Mirrors_UI_SDK/fltk
1
0
Fork 0
mirror of https://github.com/fltk/fltk.git synced 2026-05-24 08:16:04 +08:00
Code Issues Actions 1 Packages Projects Releases Wiki Activity

STR #1012 (Xft): added provided Xft code and cleaned it

Browse Source 
up a little. Event though the author mentions a few flaws,
this is far better than what we had in here before and 
makes the Xft support actually usable.



git-svn-id: file:///fltk/svn/fltk/branches/branch-1.1@4592 ea41ed52-d2ee-0310-a9c1-e6b18d33e121
This commit is contained in:
Matthias Melcher
2005-10-13 13:51:59 +00:00
parent 405b80784a
commit 55f6d7673d
1 changed files with 258 additions and 25 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/fl_set_fonts_xft.cxx
+258 -25
View File
@@ -26,6 +26,8 @@
//
#include <X11/Xft/Xft.h>
#include <string.h>
#include <ctype.h>
// This function fills in the fltk font table with all the fonts that
// are found on the X server. It tries to place the fonts into families
@@ -50,6 +52,9 @@ const char* Fl::get_font_name(Fl_Font fnum, int* ap) {
case 'P': type = FL_BOLD | FL_ITALIC; break;
default: type = 0; break;
}
// NOTE: This can cause duplications in fonts that already have Bold or Italic in
// their "name". Maybe we need to find a cleverer way?
strlcpy(f->fontname, p+1, ENDOFBUFFER);
if (type & FL_BOLD) strlcat(f->fontname, " bold", ENDOFBUFFER);
if (type & FL_ITALIC) strlcat(f->fontname, " italic", ENDOFBUFFER);
@@ -59,32 +64,260 @@ const char* Fl::get_font_name(Fl_Font fnum, int* ap) {
return f->fontname;
}
#if 0
///////////////////////////////////////////////////////////
#define LOCAL_RAW_NAME_MAX 256
extern "C" {
static int sort_function(const void *aa, const void *bb) {
const char* name_a = (*(Fl_Fontdesc**)aa)->name;
const char* name_b = (*(Fl_Fontdesc**)bb)->name;
int ret = strcasecmp(name_a+1, name_b+1); if (ret) return ret;
return name_a[0]-name_b[0]; // sort by attribute
}
}
static Fl_Fontdesc* make_a_font(char attrib, const char* name) {
Fl_Fontdesc* newfont = new Fl_Fontdesc;
char *n = new char[strlen(name)+2];
n[0] = attrib;
strcpy(n+1, name);
newfont->name = n;
newfont->first = 0;
return newfont;
}
#endif // 0
// sort returned fontconfig font names
static int name_sort(const void *aa, const void *bb) {
// What should we do here? Just do a string compare for now...
// NOTE: This yeilds some oddities - in particular a Blah Bold font will be
// listed before Blah...
// Also - the fontconfig listing returns some faces that are effectively duplicates
// as far as fltk is concerned, e.g. where there are ko or ja variants that we
// can't distinguish (since we are not yet fully UTF-*) - should we strip them here?
return strcasecmp(*(char**)aa, *(char**)bb);
} // end of name_sort
} // end of extern C section
Fl_Font Fl::set_fonts(const char* xstarname) {
// TODO: implement this for Xft...
return FL_FREE_FONT;
}
// Read the "pretty" name we have derived from fontconfig then convert
// it into the format fltk uses internally for Xft names...
// This is just a mess - I should have tokenised the strings and gone from there,
// but I really thought this would be easier!
static void make_raw_name(char *raw, char *pretty)
{
// Input name will be "Some Name:style = Bold Italic" or whatever
// The plan is this:
// - the first char in the "raw" name becomes either I, B, P or " " for
// italic, bold, bold italic or normal - this seems to be the fltk way...
char *style = strchr(pretty, ':');
char *last = style + strlen(style) - 2;
if (style)
{
*style = 0; // Terminate "name" string
style ++; // point to start of style section
}
raw[0] = ' '; raw[1] = 0; // Default start of "raw name" text
strncat(raw, pretty, LOCAL_RAW_NAME_MAX);
// At this point, the name is "marked" as regular...
if (style)
{
#define PLAIN 0
#define BOLD 1
#define ITALIC 2
#define BITALIC (BOLD | ITALIC)
int mods = PLAIN;
// Now try and parse the style string - look for the "=" sign
style = strchr(style, '=');
while ((style) && (style < last))
{
int type;
while ((*style == '=') || (*style == ' ') || (*style == '\t'))
{
style++; // Start of Style string
if ((style >= last) || (*style == 0)) continue;
}
type = toupper(style[0]);
switch (type)
{
// Things we might see: Regular Normal Bold Italic Oblique (??what??) Medium
// Roman Light Demi Sans SemiCondensed SuperBold Book... etc...
// Things we actually care about: Bold Italic Oblique SuperBold - Others???
case 'I':
if (strncasecmp(style, "Italic", 6) == 0)
{
mods |= ITALIC;
}
goto NEXT_STYLE;
case 'B':
if (strncasecmp(style, "Bold", 4) == 0)
{
mods |= BOLD;
}
goto NEXT_STYLE;
case 'O':
if (strncasecmp(style, "Oblique", 7) == 0)
{
mods |= ITALIC;
}
goto NEXT_STYLE;
case 's':
if (strncasecmp(style, "SuperBold", 9) == 0)
{
mods |= BOLD;
}
goto NEXT_STYLE;
default: // find the next gap
goto NEXT_STYLE;
} // switch end
NEXT_STYLE:
while ((*style != ' ') && (*style != '\t'))
{
style++;
if ((style >= last) || (*style == 0)) goto STYLE_DONE;
}
}
STYLE_DONE:
// Set the "modifier" character in the raw string
switch(mods)
{
case BOLD: raw[0] = 'B';
break;
case ITALIC: raw[0] = 'I';
break;
case BITALIC: raw[0] = 'P';
break;
default: raw[0] = ' ';
break;
}
}
} // make_raw_name
///////////////////////////////////////////////////////////
static int fl_free_font = FL_FREE_FONT;
// Uses the fontconfig lib to construct a list of all installed fonts.
// I tried using XftListFonts for this, but the API is tricky - and when I looked
// at the XftList* code, it calls the Fc* functions anyway... so...
// Also, for now I'm ignoring the "pattern_name" and just getting everything...
// AND I don't try and skip the fonts we've already loaded in the defaults.
// Blimey! What a hack!
Fl_Font Fl::set_fonts(const char* pattern_name)
{
FcFontSet *fnt_set; // Will hold the list of fonts we find
FcPattern *fnt_pattern; // Holds the generic "match all names" pattern
FcObjectSet *fnt_obj_set = 0; // Holds the generic "match all objects"
int j; // loop iterator variable
int font_count; // Total number of fonts found to process
char **full_list; // The list of font names we build
if (fl_free_font > FL_FREE_FONT) // already been here
return (Fl_Font)fl_free_font;
fl_open_display(); // Just in case...
// Make sure fontconfig is ready... is this necessary? The docs say it is
// safe to call it multiple times, so just go for it anyway!
if (!FcInit ())
{
// What to do? Just return defaults...
return FL_FREE_FONT;
}
// Create a search pattern that will match every font name - I think this does the
// Right Thing... but am not certain...
// This could possibly be "enhanced" to pay attention to the requested "pattern_name"?
fnt_pattern = FcPatternCreate ();
fnt_obj_set = FcObjectSetBuild (FC_FAMILY, FC_STYLE, 0);
// Hopefully, this is a set of all the fonts...
fnt_set = FcFontList (0, fnt_pattern, fnt_obj_set);
// We don't need the fnt_pattern any more, release it
FcPatternDestroy (fnt_pattern);
// Now, if we got any fonts, iterate through them...
if (fnt_set)
{
char *stop;
char *start;
char *first;
font_count = fnt_set->nfont; // How many fonts?
// Allocate array of char*'s to hold the name strings
full_list = (char **)malloc(sizeof(char *) * font_count);
// iterate through all the font patterns and get the names out...
for (j = 0; j < font_count; j++)
{
// NOTE: FcChar8 is a typedef of "unsigned char"...
FcChar8 *font; // String to hold the font's name
// Convert from fontconfig internal pattern to human readable name
// NOTE: This WILL malloc storage, so we need to free it later...
font = FcNameUnparse (fnt_set->fonts[j]);
// The returned strings look like this...
// Century Schoolbook:style=Bold Italic,fed kursiv,Fett Kursiv,...
// So the bit we want is up to the first comma - BUT some strings have
// more than one name, separated by, guess what?, a comma...
stop = start = first = 0;
stop = strchr((const char *)font, ',');
start = strchr((const char *)font, ':');
if ((stop) && (start) && (stop < start))
{
first = stop + 1; // discard first version of name
// find first comma *after* the end of the name
stop = strchr((const char *)start, ',');
}
else
{
first = (char *)font; // name is just what was returned
}
// Truncate the name after the (english) modifiers description
if (stop)
{
*stop = 0; // Terminate the string at the first comma, if there is one
}
// Copy the font description into our list
if (first == (char *)font)
{ // The listed name is still OK
full_list[j] = (char *)font;
}
else
{ // The listed name has been modified
full_list[j] = strdup(first);
// Free the font name storage
free (font);
}
// replace "style=Regular" so strcmp sorts it first
if (start) {
char *reg = strstr(full_list[j], "=Regular");
if (reg) reg[1]='.';
}
}
// Release the fnt_set - we don't need it any more
FcFontSetDestroy (fnt_set);
// Sort the list into alphabetic order
qsort(full_list, font_count, sizeof(*full_list), name_sort);
// Now let us add the names we got to fltk's font list...
for (j = 0; j < font_count; j++)
{
if (full_list[j])
{
char xft_name[LOCAL_RAW_NAME_MAX];
char *stored_name;
// Parse the strings into FLTK-XFT style..
make_raw_name(xft_name, full_list[j]);
// NOTE: This just adds on AFTER the default fonts - no attempt is made
// to identify already loaded fonts. Is this bad?
stored_name = strdup(xft_name);
Fl::set_font((Fl_Font)(j + FL_FREE_FONT), stored_name);
fl_free_font ++;
free(full_list[j]); // release that name from our internal array
}
}
// Now we are done with the list, release it fully
free (full_list);
}
return (Fl_Font)fl_free_font;
} // ::set_fonts
////////////////////////////////////////////////////////////////
extern "C" {
@@ -104,8 +337,8 @@ int Fl::get_font_sizes(Fl_Font fnum, int*& sizep) {
fl_open_display();
XftFontSet* fs = XftListFonts(fl_display, fl_screen,
XFT_FAMILY, XftTypeString, s->name+1, 0,
XFT_PIXEL_SIZE, 0);
XFT_FAMILY, XftTypeString, s->name+1, 0,
XFT_PIXEL_SIZE, 0);
static int* array = 0;
static int array_size = 0;
if (fs->nfont >= array_size) {