Re: Re: fontconfig support to exclude glyphs from fonts

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

 



Keith, Simos,

Both of you thought it would be useful to have a method to specify that a font has poor support for a particular language. This poor support for the language would cause other fonts with support for the language lower in the list to be selected in preference, but if no other font exists with support for the language, then the one with poor support would be selected. The attached patch solves this problem.

The following is an example of how to modify fonts.conf to use the path:

<alias>
   <family>Sans-serif</family>
   <poor>
      <family>DejaVu Sans</family>
      <lang>ar</lang>
   </poor>
<alias>

If a request for a font is made with one of the languages specified in the poor list, the match value for the font based on language is modified from a 0 for exact match, or 1 for same language different county to a 1.5. This indicates that it is worse than either of the two matching values, but better than a 2 which is language not present. This way, any font with better language matching values will be chosen first, but the 1.5 value still provides better support than fonts with a 2.

Let me know if there are other changes you would like or need.

Thanks,

Jay


Jay Hobson wrote:

Keith Packard wrote:

On Thu, 2006-06-29 at 10:43 -0700, Jay Hobson wrote:
Keith,

While I can see the need for a ban on unicode codepoint sets, I think many end users will find that horribly difficult to use and set up. With the patch that I am providing, you can accomplish the same basic goal without nearly as much hardship. I suspect it is easier to look up what languages a font supports, than what the unicode codepoint set is.


That's a good point. Having the ability to *also* edit the language set
offered by a font makes good sense.

I think what I was focused on was the notion that we should (finally)
look at editing the data about the available fonts instead of trying to
work around broken data during the match phase.

Additionally, if you ban an entire language from a font, then the language will be displayed with a different font and have a better chance of looking consistent. If you ban a codepoint set, unless you get the entire language coverage, you run the risk of having two fonts display your text, which would likely look bad.


Right. Let's work on a font pattern editing mechanism and then do both
code point and language editing. That should fix both problems nicely.

The main reason for a code point ban is to elide latin glyphs from
non-latin fonts -- TrueType nearly insists that all fonts include latin
glyphs, which makes no sense for many non-latin fonts, and which often
results in really ugly latin glyphs being included.
One interesting twist to this, and the reason that I designed the patch the way that I did, is that some of these same fonts that include Latin glyphs can have latin characters that are matched nicely to the other languages contained in the font (not often). IE: size, thickness, etc. However, the latin only contains either Serif or Sans-Serif glyphs, and the other language is often needed for both Sans and Serif coverage. This leaves a latin that might be nice to have in one instance, and not in the other. Hence the reason that you would want to dynamically enable and disable languages from a font. For one alias it would be good, for the other, it would be bad. Right now, there is no mechanism for detailing language coverage by alias. The patch includes such a mechanism which adds some additional value to fontconfig.

The language ban will work better where multiple languages share the
same code point range.

Good ideas; let's see what we can manage.




--- fccfg.c.orig        Tue Jun 13 10:28:46 2006
+++ fccfg.c     Tue Jun 27 10:51:54 2006
@@ -117,6 +117,9 @@

     config->rescanTime = time(0);
     config->rescanInterval = 30;
+#ifdef HIDE
+    config->hideFont = NULL;
+#endif

     return config;

@@ -243,6 +246,9 @@
     for (set = FcSetSystem; set <= FcSetApplication; set++)
        if (config->fonts[set])
            FcFontSetDestroy (config->fonts[set]);
+#ifdef HIDE
+    FcHideDestroy (config->hideFont);
+#endif

     free (config);
     FcMemFree (FC_MEM_CONFIG, sizeof (FcConfig));
--- fcint.h.orig        Tue Jun 13 10:29:50 2006
+++ fcint.h     Thu Aug  3 12:04:23 2006
@@ -369,6 +369,23 @@
     FcChar32   *blanks;
 };

+#ifdef HIDE
+typedef struct _FcFontLang {
+    FcChar8             *family;        /* Name of font family */
+    FcStrSet            *hides;         /* list of hidden languages */
+    FcStrSet            *only;          /* list of only allowed languages */
+    FcStrSet            *poor;         /* list of poor quality languages */
+    struct _FcFontLang  *next;          /* Next font family */
+} FcFontLang;
+
+typedef struct _FcHide {
+    FcChar8         *alias;         /* Name of alias Sans/Serif */
+    FcFontLang      *family;        /* Hidden languages struct */
+    FcFontLang      *az[26];        /* Quick pointers */
+    struct _FcHide  *next;          /* Next alias */
+} FcHide;
+#endif
+
 struct _FcConfig {
     /*
      * File names loaded from the configuration -- saved here as the
@@ -423,6 +440,16 @@
      */
     time_t     rescanTime;         /* last time information was scanned */
     int                rescanInterval;     /* interval between scans */
+#ifdef HIDE
+    /*
+     * Languages can be selectively turned off for some fonts to allow
+     * fonts to be used for specific languages only even if the font
+     * supports the language. This allows best fonts to be used per
+     * language where two fonts that both support the same language
+     * cannot be placed in the preference list appropriately.
+     */
+    FcHide *hideFont;
+#endif
 };

 extern FcConfig        *_fcConfig;
@@ -747,6 +774,11 @@
 void
 FcEditDestroy (FcEdit *e);

+#ifdef HIDE
+void
+FcHideDestroy ( FcHide *r );
+#endif
+
 /* fcinit.c */

 void
@@ -778,6 +810,14 @@
 FcBool
 FcNameUnparseLangSet (FcStrBuf *buf, const FcLangSet *ls);

+#ifdef HIDE
+FcBool
+FcLangSetRemove (FcLangSet *ls, const FcChar8 *lang);
+
+FcBool
+FcLangSetRemoveLangs (FcLangSet *ls, FcStrSet *langs);
+#endif
+
 void
 FcLangSetNewBank (void);

--- fclang.c.orig       Tue Jun 13 10:28:40 2006
+++ fclang.c    Tue Jun 27 10:55:02 2006
@@ -43,6 +43,9 @@

 #define FcLangSetBitSet(ls, id)        ((ls)->map[(id)>>5] |= ((FcChar32) 1 << ((id) & 0x1f)))
 #define FcLangSetBitGet(ls, id) (((ls)->map[(id)>>5] >> ((id) & 0x1f)) & 1)
+#ifdef HIDE
+#define FcLangSetBitUnset(ls, id)       ((ls)->map[(id)>>5] &= ~((FcChar32) 1 << ((id) & 0x1f)))
+#endif

 static FcBool langsets_populated = FcFalse;

@@ -355,6 +358,36 @@
     return FcStrSetAdd (ls->extra, lang);
 }

+#ifdef HIDE
+FcBool
+FcLangSetRemove (FcLangSet *ls, const FcChar8 *lang)
+{
+    int id;
+
+    id = FcLangSetIndex (lang);
+    if (id >= 0)
+    {
+        FcLangSetBitUnset (ls, id);
+        return FcTrue;
+    }
+    if (ls->extra)
+        return FcStrSetDel (ls->extra, lang);
+    return FcFalse;
+}
+
+FcBool
+FcLangSetRemoveLangs (FcLangSet *ls, FcStrSet *langs)
+{
+    int i;
+
+    for ( i = 0; i < langs->num; i++ )
+    {
+        FcLangSetRemove ( ls, langs->strs[i] );
+    }
+    return FcTrue;
+}
+#endif
+
 FcLangResult
 FcLangSetHasLang (const FcLangSet *ls, const FcChar8 *lang)
 {
--- fcmatch.c.orig      Tue Jun 13 10:28:35 2006
+++ fcmatch.c   Thu Aug  3 12:05:04 2006
@@ -465,7 +465,7 @@
     FcPatternElt    *fe, *pe;
     FcValue        v;
     FcResult       result;
-
+
     new = FcPatternCreate ();
     if (!new)
        return 0;
@@ -502,6 +502,158 @@
     return new;
 }

+#ifdef HIDE
+static FcHide *
+FcHideGetList (FcConfig *config, FcPattern *p)
+{
+    FcHide *r = NULL;
+
+    if ( config->hideFont )
+    {
+        FcPatternElt *pe    = FcPatternFindElt (p, "family");
+
+        r = config->hideFont;
+
+        /*
+         * Find the base family (alias) and see if it is in the
+         * hide list
+         */
+        if ( pe )
+        {
+            FcValueListPtr v1;
+            FcValueList   *v1_ptrU;
+           int            found = 0;
+
+           while ( r )
+           {
+                for ( v1 = pe->values, v1_ptrU = FcValueListPtrU(v1);
+                      v1_ptrU;
+                      v1 = v1_ptrU->next, v1_ptrU = FcValueListPtrU(v1))
+               {
+                   const FcChar8* v1_string = fc_value_string ( &(v1_ptrU->value) );
+                    if ( !strcasecmp ( (char *)r->alias, (char *)v1_string ))
+                        found = 1;
+               }
+
+               if ( !found )
+                    r = r->next;
+               else
+                   break;
+           }
+        }
+
+        /*
+         * At this point, we have the list of hidden fonts
+         * for the alias. We now need to check and see if the
+         * font we are comparing is on the hide list.
+         */
+    }
+    return r;
+}
+
+static FcPattern *
+FcHideFont (FcHide *r, FcPatternElt *pe, FcPattern *fnt, FcLangSet **ls)
+{
+    FcPattern  *new = NULL;
+    FcFontLang *fl;
+
+    if ( r && pe )
+    {
+        FcValueListPtr ev        = pe->values;
+        FcValueList   *ev_ptrU   = FcValueListPtrU(ev);
+       const FcChar8 *ev_string = fc_value_string(& (ev_ptrU->value) );
+        int            pos       = (int)(FcToLower(*ev_string)) - (int)'a';
+
+        fl = r->az[pos];
+
+       /*
+        * Check to see if the family is in the hide list for this alias
+        */
+        while ( fl )
+        {
+            int cmp = strcasecmp ( (char *)fl->family, (char *)ev_string );
+
+            if ( !cmp )
+                break;
+            else if ( cmp > 0 )
+                fl = NULL;
+            else
+                fl = fl->next;
+        }
+
+       /*
+        * If the family is to be language restricted, then copy the pattern
+        * and modify the language support list
+        */
+        if ( fl )
+        {
+            FcPatternElt *ppe;
+
+           new = FcPatternDuplicate (fnt);
+           if ( new )
+           {
+               ppe = FcPatternFindElt (new, "lang");
+                if ( ppe )
+                {
+                   FcValueList *fv_ptrU = FcValueListPtrU(ppe->values);
+                    if ( fv_ptrU->value.type == FcTypeLangSet )
+                    {
+                        int i;
+                       if ( fl->hides )
+                       {
+                            FcLangSetRemoveLangs ( (FcLangSet *)fv_ptrU->value.u.l, fl->hides );
+                       }
+                       if ( fl->only )
+                       {
+                           FcLangSetDestroy ( (FcLangSet *)fv_ptrU->value.u.l );
+                           fv_ptrU->value.u.l = FcLangSetCreate ();
+                           for ( i = 0; i < fl->only->num; i++ )
+                               FcLangSetAdd ( (FcLangSet *)fv_ptrU->value.u.l,
+                                               fl->only->strs[i] );
+                       }
+                       if ( fl->poor )
+                       {
+                           *ls = FcLangSetCreate ();
+                           for ( i = 0; i < fl->poor->num; i++ )
+                               FcLangSetAdd ( (FcLangSet *)*ls,
+                                               fl->poor->strs[i] );
+                       }
+                    }
+                    else
+                    {
+                       /*
+                        * Don't know what to do with this yet
+                        */
+                    }
+                }
+               else
+               {
+                   FcPatternDestroy (new);
+                   new = NULL;
+               }
+           }
+        }
+    }
+
+    return new;
+}
+
+static double
+FcHidePoorLangs ( FcValue *value, FcLangSet *ls )
+{
+    double v = 0;
+    switch (value->type) {
+    case FcTypeLangSet:
+       v = FcLangSetCompare (ls, value->u.l);
+       break;
+    case FcTypeString:
+       v = FcLangSetHasLang (ls, value->u.s);
+       break;
+    }
+    return ( v != 2.0 ) * 1.5;
+}
+#endif
+
 FcPattern *
 FcFontSetMatch (FcConfig    *config,
                FcFontSet   **sets,
@@ -526,7 +678,11 @@
     int                    pat_elt;
     int                    *match_blocked;
     int                    block_start;
+#ifdef HIDE
+    FcHide          *r = NULL;
+#endif

+
     if (!nsets || !sets || !p)
     {
        *result = FcResultNoMatch;
@@ -548,6 +704,10 @@
        }
     }

+#ifdef HIDE
+    r = FcHideGetList ( config, p );
+#endif
+
     sets_offset = (int *)calloc(nsets, sizeof (int));

     nfonts = 0;
@@ -630,11 +790,24 @@
                {
                    int             cand_elt;
                    FcPatternElt    *cand_elts;
+#ifdef HIDE
+                    FcPatternElt *pe = FcPatternFindElt (s->fonts[f], "family");
+                   FcPattern    *hideFont = NULL;
+                   FcLangSet    *ls       = NULL;
+#endif

+
                    if (match_blocked[f + sets_offset[set]] == 1)
                        continue;

                    score = 1e99;
+#ifdef HIDE
+                   if ( scoring_index == MATCH_LANG_INDEX )
+                        hideFont = FcHideFont ( r, pe, s->fonts[f], &ls);
+                   if ( hideFont )
+                       cand_elts = FcPatternEltU (hideFont->elts );
+                   else
+#endif
                    cand_elts = FcPatternEltU(s->fonts[f]->elts);

                    /* Look for the appropriate element in this candidate
@@ -651,6 +824,12 @@
                                 v2 = v2_ptrU->next, v2_ptrU = FcValueListPtrU(v2))
                            {
                                double v = (matcher->compare)(&v1_ptrU->value, &v2_ptrU->value);
+#ifdef HIDE
+                               if ( ls )
+                               {
+                                   v = FcHidePoorLangs (&v1_ptrU->value, ls);
+                               }
+#endif

                                if (v < 0)
                                {
@@ -657,6 +836,12 @@
                                    *result = FcResultTypeMismatch;
                                    free (match_blocked);
                                    free (sets_offset);
+#ifdef HIDE
+                                    if ( hideFont )
+                                       FcPatternDestroy ( hideFont );
+                                   if ( ls )
+                                       FcLangSetDestroy ( ls );
+#endif
                                    return 0;
                                }

@@ -673,6 +858,13 @@
                        }
                    }

+#ifdef HIDE
+                   if ( hideFont )
+                       FcPatternDestroy ( hideFont );
+                   if ( ls )
+                       FcLangSetDestroy ( ls );
+#endif
+
                    /* We had no matching, just try the next one */
                    if (score == 1e99)
                    {
@@ -867,6 +1059,9 @@
     int                    nPatternLang;
     FcBool         *patternLangSat;
     FcValue        patternLang;
+#ifdef HIDE
+    FcHide          *r = NULL;
+#endif

     if (FcDebug () & FC_DBG_MATCH)
     {
@@ -900,6 +1095,11 @@

     new = nodes;
     nodep = nodeps;
+
+#ifdef HIDE
+    r = FcHideGetList ( config, p );
+#endif
+
     for (set = 0; set < nsets; set++)
     {
        s = sets[set];
@@ -907,14 +1107,44 @@
            continue;
        for (f = 0; f < s->nfont; f++)
        {
+#ifdef HIDE
+           FcLangSet    *ls = NULL;
+            FcPatternElt *pe = FcPatternFindElt (s->fonts[f], "family");
+            FcPattern    *hideFont = FcHideFont ( r, pe, s->fonts[f], &ls);
+           int           res = 1;
+#endif
            if (FcDebug () & FC_DBG_MATCHV)
            {
                printf ("Font %d ", f);
                FcPatternPrint (s->fonts[f]);
            }
+#ifdef HIDE
+           if ( hideFont )
+               new->pattern = hideFont;
+           else
+#endif
            new->pattern = s->fonts[f];
            if (!FcCompare (p, new->pattern, new->score, result))
+#ifdef HIDE
+                res = 0;
+
+           if ( hideFont )
+           {
+               FcPatternDestroy ( hideFont );
+               new->pattern = s->fonts[f];
+           }
+
+           if ( ls )
+           {
+               if ( FcPatternGet (p, FC_LANG, i, &patternLang) == FcResultMatch )
+                   new->score[MATCH_LANG_INDEX] = FcHidePoorLangs ( &patternLang,ls );
+               FcLangSetDestroy ( ls );
+           }
+
+            if ( !res )
+#endif
                goto bail1;
+
            if (FcDebug () & FC_DBG_MATCHV)
            {
                printf ("Score");
--- fcxml.c.orig        Tue Jun 13 10:28:29 2006
+++ fcxml.c     Thu Aug  3 12:05:30 2006
@@ -299,6 +299,13 @@
     FcElementDefault,
     FcElementFamily,

+#ifdef HIDE
+    FcElementPoor,
+    FcElementOnly,
+    FcElementHide,
+    FcElementLang,
+#endif
+
     FcElementSelectfont,
     FcElementAcceptfont,
     FcElementRejectfont,
@@ -359,6 +366,13 @@
     { "default",       FcElementDefault },
     { "family",                FcElementFamily },

+#ifdef HIDE
+    { "poor",          FcElementPoor },
+    { "only",          FcElementOnly },
+    { "hide",          FcElementHide },
+    { "lang",          FcElementLang },
+#endif
+
     { "selectfont",    FcElementSelectfont },
     { "acceptfont",    FcElementAcceptfont },
     { "rejectfont",    FcElementRejectfont },
@@ -430,6 +444,13 @@
     FcVStackPrefer,
     FcVStackAccept,
     FcVStackDefault,
+
+#ifdef HIDE
+    FcVStackPoor,
+    FcVStackOnly,
+    FcVStackHide,
+    FcVStackLang,
+#endif

     FcVStackInteger,
     FcVStackDouble,
@@ -730,6 +751,9 @@
        case FcVStackField:
        case FcVStackConstant:
        case FcVStackGlob:
+#ifdef HIDE
+        case FcVStackLang:
+#endif
            FcStrFree (vstack->u.string);
            break;
        case FcVStackPattern:
@@ -737,6 +761,11 @@
            break;
        case FcVStackInteger:
        case FcVStackDouble:
+#ifdef HIDE
+        case FcVStackPoor:
+        case FcVStackOnly:
+        case FcVStackHide:
+#endif
            break;
        case FcVStackMatrix:
            FcMatrixFree (vstack->u.matrix);
@@ -1345,7 +1374,435 @@
        FcVStackPushExpr (parse, FcVStackFamily, expr);
 }

+#ifdef HIDE
 static void
+FcParseLang (FcConfigParse *parse)
+{
+    FcChar8 *s;
+    FcExpr  *expr;
+
+    if (!parse->pstack)
+        return;
+    s = FcStrBufDone (&parse->pstack->str);
+    if (!s)
+    {
+        FcConfigMessage (parse, FcSevereError, "out of memory");
+        return;
+    }
+    expr = FcExprCreateString (s);
+    FcStrFree (s);
+    if (expr)
+        FcVStackPushExpr (parse, FcVStackLang, expr);
+}
+
+static void
+FcParseOnly (FcConfigParse *parse, FcVStackTag tag)
+{
+    FcExpr      *family = 0;
+    FcStrSet    *lang = 0;
+    FcVStack    *vstack;
+    FcFontLang  *fl = NULL;
+    FcExpr      *expr;
+
+    while ((vstack = FcVStackPop (parse)))
+    {
+        switch (vstack->tag) {
+        case FcVStackFamily:
+            if (family)
+                FcExprDestroy (family);
+            family = vstack->u.expr;
+            vstack->tag = FcVStackNone;
+            break;
+        case FcVStackLang:
+            if (!lang)
+                lang = FcStrSetCreate ();
+            FcStrSetAdd (lang, vstack->u.expr->u.sval);
+            break;
+        default:
+            FcConfigMessage (parse, FcSevereWarning, "bad alias");
+            break;
+        }
+        FcVStackDestroy (vstack);
+    }
+    if (!family)
+    {
+        FcConfigMessage (parse, FcSevereError, "missing family in only");
+    }
+    if ( lang )
+    {
+        fl = (FcFontLang *)malloc (sizeof (FcFontLang));
+
+        if ( fl )
+        {
+            int len = strlen ( (char *)family->u.sval );
+            fl->family = (FcChar8 *)malloc ( sizeof ( char ) * ( len + 1 ));
+            strncpy ( (char *)fl->family, (char *)family->u.sval, len );
+            fl->family[len] = '\0';
+            fl->hides       = NULL;
+           fl->only        = lang;
+           fl->poor        = NULL;
+            fl->next        = NULL;
+        }
+    }
+    if ( fl )
+    {
+        expr = FcExprCreateNil ();
+        if (expr)
+       {
+           expr->u.sval = (FcChar8 *)fl;
+            FcVStackPushExpr (parse, FcVStackOnly, expr);
+       }
+    }
+}
+
+static void
+FcParsePoor (FcConfigParse *parse, FcVStackTag tag)
+{
+    FcExpr      *family = 0;
+    FcStrSet    *lang = 0;
+    FcVStack    *vstack;
+    FcFontLang  *fl = NULL;
+    FcExpr      *expr;
+
+    while ((vstack = FcVStackPop (parse)))
+    {
+        switch (vstack->tag) {
+        case FcVStackFamily:
+            if (family)
+                FcExprDestroy (family);
+            family = vstack->u.expr;
+            vstack->tag = FcVStackNone;
+            break;
+        case FcVStackLang:
+            if (!lang)
+                lang = FcStrSetCreate ();
+            FcStrSetAdd (lang, vstack->u.expr->u.sval);
+            break;
+        default:
+            FcConfigMessage (parse, FcSevereWarning, "bad alias");
+            break;
+        }
+        FcVStackDestroy (vstack);
+    }
+    if (!family)
+    {
+        FcConfigMessage (parse, FcSevereError, "missing family in poor");
+    }
+    if ( lang )
+    {
+        fl = (FcFontLang *)malloc (sizeof (FcFontLang));
+
+        if ( fl )
+        {
+            int len = strlen ( (char *)family->u.sval );
+            fl->family = (FcChar8 *)malloc ( sizeof ( char ) * ( len + 1 ));
+            strncpy ( (char *)fl->family, (char *)family->u.sval, len );
+            fl->family[len] = '\0';
+            fl->hides       = NULL;
+            fl->only        = NULL;
+            fl->poor        = lang;
+            fl->next        = NULL;
+        }
+    }
+    if ( fl )
+    {
+        expr = FcExprCreateNil ();
+        if (expr)
+       {
+           expr->u.sval = (FcChar8 *)fl;
+            FcVStackPushExpr (parse, FcVStackPoor, expr);
+       }
+    }
+}
+
+static void
+FcParseHide (FcConfigParse *parse, FcVStackTag tag)
+{
+    FcExpr      *family = 0;
+    FcStrSet    *lang = 0;
+    FcVStack    *vstack;
+    FcFontLang  *fl = NULL;
+    FcExpr      *expr;
+
+    while ((vstack = FcVStackPop (parse)))
+    {
+        switch (vstack->tag) {
+        case FcVStackFamily:
+            if (family)
+                FcExprDestroy (family);
+            family = vstack->u.expr;
+            vstack->tag = FcVStackNone;
+            break;
+        case FcVStackLang:
+            if (!lang)
+                lang = FcStrSetCreate ();
+            FcStrSetAdd (lang, vstack->u.expr->u.sval);
+            break;
+        default:
+            FcConfigMessage (parse, FcSevereWarning, "bad alias");
+            break;
+        }
+        FcVStackDestroy (vstack);
+    }
+    if (!family)
+    {
+        FcConfigMessage (parse, FcSevereError, "missing family in hide");
+    }
+    if ( lang )
+    {
+        fl = (FcFontLang *)malloc (sizeof (FcFontLang));
+
+        if ( fl )
+        {
+            int len = strlen ( (char *)family->u.sval );
+            fl->family = (FcChar8 *)malloc ( sizeof ( char ) * ( len + 1 ));
+            strncpy ( (char *)fl->family, (char *)family->u.sval, len );
+            fl->family[len] = '\0';
+            fl->hides       = lang;
+            fl->only        = NULL;
+            fl->poor        = NULL;
+            fl->next        = NULL;
+        }
+    }
+    if ( fl )
+    {
+        expr = FcExprCreateNil ();
+        if (expr)
+       {
+           expr->u.sval = (FcChar8 *)fl;
+            FcVStackPushExpr (parse, FcVStackHide, expr);
+       }
+    }
+}
+
+static void
+FcFontLangDestroy(FcFontLang *fl)
+{
+    FcFontLang *cur = fl;
+
+    while (fl)
+    {
+        cur = fl;
+        fl  = fl->next;
+        free (cur->family);
+       if ( cur->hides )
+            FcStrSetDestroy (cur->hides);
+       if ( cur->only )
+            FcStrSetDestroy (cur->only);
+       if ( cur->poor )
+            FcStrSetDestroy (cur->poor);
+        free (cur);
+    }
+}
+
+void
+FcHideDestroy ( FcHide *r )
+{
+    if ( r )
+    {
+        if ( r->alias )
+            free ( r->alias );
+        FcFontLangDestroy ( r->family );
+        FcHideDestroy ( r->next );
+        free ( r );
+    }
+}
+
+void
+FcHideShowLangs ( FcFontLang *fl )
+{
+    int i;
+
+    if ( fl->hides )
+    {
+       printf ( "hides: " );
+        for ( i = 0; i < fl->hides->num; i++ )
+           printf ( " %s,", fl->hides->strs[i]);
+    }
+    if ( fl->only )
+    {
+       printf ( "only allows: " );
+       for ( i = 0; i < fl->only->num; i++ )
+           printf ( " %s", fl->only->strs[i]);
+    }
+    if ( fl->poor )
+    {
+       printf ( "poor: " );
+       for ( i = 0; i < fl->poor->num; i++ )
+           printf ( " %s", fl->poor->strs[i]);
+    }
+    printf("\n");
+}
+
+static int
+FcHideCreate(FcConfigParse *parse, FcFontLang *fl, FcExpr *family)
+{
+    FcHide *new = parse->config->hideFont;
+    int         i;
+
+    /*
+     * Check to see if user has already hidden something in this alias
+     */
+    while ( new != NULL )
+    {
+       if ( !strcasecmp ( (char *)new->alias, (char *)family->u.sval ))
+           break;
+       else
+           new = new->next;
+    }
+
+    /*
+     * If no alias hides exist, then create an FcHide structure and
+     * fill in the base values.
+     */
+    if ( !new )
+    {
+        new = (FcHide *)malloc ( sizeof ( FcHide ));
+        if ( new )
+       {
+            int len = strlen ( (char *)family->u.sval );
+            new->alias  = (FcChar8 *)malloc ( sizeof ( char ) * ( len + 1 ));
+            if ( new->alias )
+            {
+                strncpy ((char *)new->alias, (char *)family->u.sval, len);
+                new->alias[len] = '\0';
+            }
+            else
+            {
+                free (new);
+                return 0;
+            }
+            new->family = NULL;
+            new->next   = parse->config->hideFont;
+            parse->config->hideFont = new;
+       }
+       else
+           return 0;
+    }
+
+    /*
+     * Add FontLang structure in alphabetical order based on family
+     * to the hide list
+     */
+    while ( fl )
+    {
+        FcFontLang *next = fl->next;
+
+        fl->next = NULL;
+
+       /*
+        * If no hidden families exist, then just add this one
+        */
+        if ( !new->family )
+       {
+            new->family = fl;
+       }
+        else
+        {
+            FcFontLang *ptr  = new->family;
+            FcFontLang *last = NULL;
+
+           /*
+            * Check to see where to enter hidden family, or if it already
+            * exists
+            */
+            while ( ptr )
+            {
+               int cmp = strcasecmp ( (char *)fl->family, (char *)ptr->family);
+               /*
+                * Find out if new family is before current alphabetically
+                */
+                if ( cmp < 0 )
+                {
+                    fl->next = ptr;
+                    if ( !last )
+                        new->family = fl;
+                    else
+                        last->next = fl;
+                    break;
+                }
+               /*
+                * If it already exists, then just add new lang(s)
+                */
+                else if ( cmp == 0 )
+               {
+                   /*
+                    * Check to see if we have a family with only langs and
+                    * hidden langs. Return error. Otherwise, add langs to list
+                    */
+                   if (( fl->hides && ptr->only ) ||
+                       ( fl->only && ptr->hides ))
+                       return 1;
+                   if ( fl->hides )
+                   {
+                       if ( !ptr->hides )
+                           ptr->hides = FcStrSetCreate ();
+                       for ( i = 0; i < fl->hides->num; i++ )
+                       {
+                           if ( !FcStrSetMember ( ptr->hides, fl->hides->strs[i] ))
+                               FcStrSetAdd ( ptr->hides, fl->hides->strs[i] );
+                       }
+                   }
+                   if ( fl->only )
+                   {
+                       if ( !ptr->only )
+                           ptr->only = FcStrSetCreate ();
+                       for ( i = 0; i < fl->only->num; i++ )
+                       {
+                           if ( !FcStrSetMember ( ptr->only, fl->only->strs[i] ))
+                               FcStrSetAdd ( ptr->only, fl->only->strs[i] );
+                       }
+                   }
+                   if ( fl->poor )
+                   {
+                       if ( !ptr->only )
+                           ptr->poor = FcStrSetCreate ();
+                       for ( i = 0; i < fl->poor->num; i++ )
+                       {
+                           if ( !FcStrSetMember ( ptr->poor, fl->poor->strs[i] ))
+                               FcStrSetAdd ( ptr->poor, fl->poor->strs[i] );
+                       }
+                   }
+                   FcFontLangDestroy ( fl );
+                   break;
+               }
+               /*
+                * If it is after, then continue moving down the list
+                */
+               else
+                {
+                    last = ptr;
+                    ptr = ptr->next;
+
+                    if ( !ptr )
+                   {
+                        last->next = fl;
+                   }
+                }
+            }
+        }
+        fl = next;
+    }
+
+    for ( i = 0; i < 26; i++ )
+        new->az[i] = NULL;
+
+    fl = new->family;
+    while ( fl )
+    {
+        int pos = (int)(fl->family[0]) - (int)'A';
+        if ( !new->az[pos] )
+        {
+            new->az[pos] = fl;
+        }
+        fl = fl->next;
+    }
+
+    return 0;
+}
+#endif
+
+static void
 FcParseAlias (FcConfigParse *parse)
 {
     FcExpr     *family = 0, *accept = 0, *prefer = 0, *def = 0, *new = 0;
@@ -1352,6 +1809,10 @@
     FcEdit     *edit = 0, *next;
     FcVStack   *vstack;
     FcTest     *test;
+#ifdef HIDE
+    FcFontLang  *langs = NULL;
+    FcFontLang  *tmp;
+#endif

     while ((vstack = FcVStackPop (parse)))
     {
@@ -1373,6 +1834,17 @@
                vstack->tag = FcVStackNone;
            }
            break;
+#ifdef HIDE
+       case FcVStackPoor:
+       case FcVStackOnly:
+        case FcVStackHide:
+            tmp = (FcFontLang *)(vstack->u.expr->u.sval);
+            FcExprDestroy (vstack->u.expr);
+            tmp->next = langs;
+            langs = tmp;
+            vstack->tag = FcVStackNone;
+            break;
+#endif
        case FcVStackPrefer:
            if (prefer)
                FcExprDestroy (prefer);
@@ -1446,6 +1918,13 @@
        else
            FcExprDestroy (def);
     }
+#ifdef HIDE
+    if (langs)
+    {
+        if ( FcHideCreate(parse, langs, family))
+           FcConfigMessage (parse, FcSevereError, "Cannot include hide and only for same family");
+    }
+#endif
     if (edit)
     {
        test = FcTestCreate (parse, FcMatchPattern,
@@ -1473,6 +1952,9 @@
        break;
     case FcVStackString:
     case FcVStackFamily:
+#ifdef HIDE
+    case FcVStackLang:
+#endif
        expr = FcExprCreateString (vstack->u.string);
        break;
     case FcVStackField:
@@ -2099,6 +2581,20 @@
     case FcElementFamily:
        FcParseFamily (parse);
        break;
+#ifdef HIDE
+    case FcElementPoor:
+       FcParsePoor (parse, FcVStackLang);
+       break;
+    case FcElementOnly:
+       FcParseOnly (parse, FcVStackLang);
+       break;
+    case FcElementHide:
+        FcParseHide (parse, FcVStackLang);
+        break;
+    case FcElementLang:
+        FcParseLang (parse);
+        break;
+#endif

     case FcElementTest:
        FcParseTest (parse);

_______________________________________________
Fontconfig mailing list
Fontconfig@xxxxxxxxxxxxxxxxxxxxx
http://lists.freedesktop.org/mailman/listinfo/fontconfig

[Index of Archives]     [Fedora Fonts]     [Fedora Users]     [Fedora Cloud]     [Kernel]     [Fedora Packaging]     [Fedora Desktop]     [PAM]     [Gimp Graphics Editor]     [Yosemite News]

  Powered by Linux