Apply Font2 patch (with working color emoji support)

Patch Homepage: https://st.suckless.org/patches/font2/
Patch Link: https://st.suckless.org/patches/font2/st-font2-20190416-ba72400.diff

Additional notes:
This patch involved multiple steps:
+ libXft needs to be patched to avoid instant crash of st. The patch was
  submitted as a PR here
  (https://gitlab.freedesktop.org/xorg/lib/libxft/-/merge_requests/1)
  and here for the patch file
  (https://gitlab.freedesktop.org/xorg/lib/libxft/-/merge_requests/1/diffs.patch).
  Gentoo x11-libs/libXft package can be easily patched following the
  instructions here (https://wiki.gentoo.org/wiki//etc/portage/patches).
  A patched package is available in the AUR for ArchLinux users
  (https://aur.archlinux.org/packages/libxft-bgra/);
+ Install a font supporting colored emoji. In this case I prefer the
  Twitter Color Emoji font buy Joy Pixels (formerly EmojiOne) has been
  tested and works as well.
  Follow the instructions here to install the font
  (https://github.com/eosrei/twemoji-color-font#manual-install-on-any-linux).
  They also suggest to install Bitstream Vera font to use for
  serif/sans/sans serif fonts due to its (almost absent) coverage of
  emojis, which won't interfere with the emoji font.
  The installation script also deploys a fontconfig file to properly
  setup fonts. From initial tests seems to work out of the box;
+ Apply patch (manually)

1 files changed, 102 insertions, 0 deletions

diff --git a/x.c b/x.c
index 48a6676..be1d3d0 100644
--- a/x.c
+++ b/x.c
@@ -157,6 +157,8 @@ static void xhints(void);
 static int xloadcolor(int, const char *, Color *);
 static int xloadfont(Font *, FcPattern *);
 static void xloadfonts(char *, double);
+static int xloadsparefont(FcPattern *, int);
+static void xloadsparefonts(void);
 static void xunloadfont(Font *);
 static void xunloadfonts(void);
 static void xsetenv(void);
@@ -305,6 +307,7 @@ zoomabs(const Arg *arg)
 {
         xunloadfonts();
         xloadfonts(usedfont, arg->f);
+        xloadsparefonts();
         cresize(0, 0);
         redraw();
         xhints();
@@ -1004,6 +1007,102 @@ xloadfonts(char *fontstr, double fontsize)
         FcPatternDestroy(pattern);
 }
 
+int
+xloadsparefont(FcPattern *pattern, int flags)
+{
+        FcPattern *match;
+        FcResult result;
+        
+        match = FcFontMatch(NULL, pattern, &result);
+        if (!match) {
+                return 1;
+        }
+
+        if (!(frc[frclen].font = XftFontOpenPattern(xw.dpy, match))) {
+                FcPatternDestroy(match);
+                return 1;
+        }
+
+        frc[frclen].flags = flags;
+        /* Believe U+0000 glyph will present in each default font */
+        frc[frclen].unicodep = 0;
+        frclen++;
+
+        return 0;
+}
+
+void
+xloadsparefonts(void)
+{
+        FcPattern *pattern;
+        double sizeshift, fontval;
+        int fc;
+        char **fp;
+
+        if (frclen != 0)
+                die("can't embed spare fonts. cache isn't empty");
+
+        /* Calculate count of spare fonts */
+        fc = sizeof(font2) / sizeof(*font2);
+        if (fc == 0)
+                return;
+
+        /* Allocate memory for cache entries. */
+        if (frccap < 4 * fc) {
+                frccap += 4 * fc - frccap;
+                frc = xrealloc(frc, frccap * sizeof(Fontcache));
+        }
+
+        for (fp = font2; fp - font2 < fc; ++fp) {
+        
+                if (**fp == '-')
+                        pattern = XftXlfdParse(*fp, False, False);
+                else
+                        pattern = FcNameParse((FcChar8 *)*fp);
+        
+                if (!pattern)
+                        die("can't open spare font %s\n", *fp);
+                        
+                if (defaultfontsize > 0) {
+                        sizeshift = usedfontsize - defaultfontsize;
+                        if (sizeshift != 0 &&
+                                        FcPatternGetDouble(pattern, FC_PIXEL_SIZE, 0, &fontval) ==
+                                        FcResultMatch) {        
+                                fontval += sizeshift;
+                                FcPatternDel(pattern, FC_PIXEL_SIZE);
+                                FcPatternDel(pattern, FC_SIZE);
+                                FcPatternAddDouble(pattern, FC_PIXEL_SIZE, fontval);
+                        }
+                }
+        
+                FcPatternAddBool(pattern, FC_SCALABLE, 1);
+        
+                FcConfigSubstitute(NULL, pattern, FcMatchPattern);
+                XftDefaultSubstitute(xw.dpy, xw.scr, pattern);
+        
+                if (xloadsparefont(pattern, FRC_NORMAL))
+                        die("can't open spare font %s\n", *fp);
+        
+                FcPatternDel(pattern, FC_SLANT);
+                FcPatternAddInteger(pattern, FC_SLANT, FC_SLANT_ITALIC);
+                if (xloadsparefont(pattern, FRC_ITALIC))
+                        die("can't open spare font %s\n", *fp);
+                        
+                FcPatternDel(pattern, FC_WEIGHT);
+                FcPatternAddInteger(pattern, FC_WEIGHT, FC_WEIGHT_BOLD);
+                if (xloadsparefont(pattern, FRC_ITALICBOLD))
+                        die("can't open spare font %s\n", *fp);
+        
+                FcPatternDel(pattern, FC_SLANT);
+                FcPatternAddInteger(pattern, FC_SLANT, FC_SLANT_ROMAN);
+                if (xloadsparefont(pattern, FRC_BOLD))
+                        die("can't open spare font %s\n", *fp);
+        
+                FcPatternDestroy(pattern);
+        }
+}
+
+
 void
 xunloadfont(Font *f)
 {
@@ -1101,6 +1200,9 @@ xinit(int cols, int rows)
         usedfont = (opt_font == NULL)? font : opt_font;
         xloadfonts(usedfont, 0);
 
+        /* spare fonts */
+        xloadsparefonts();
+
         /* colors */
         xw.cmap = XDefaultColormap(xw.dpy, xw.scr);
         xloadcols();