/* This file is part of Zutty. * Copyright (C) 2020 Tom Szilagyi * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * See the file LICENSE for the full license. */ #include "fontpack.h"#include "log.h" #include <ftw.h>//#include <stdio.h> // DEBUG#include <string.h>#include <strings.h> namespace{   struct SearchState   {      // input      const char* fontname = nullptr;      size_t fontnamelen = 0;       // output      int level = 0;      std::string ext;      std::string regular;      std::string bold;      std::string italic;      std::string boldItalic;   };   SearchState sstate;    int   saveCandidate (const char* fpath, const char* ext, int level,                  const char* variant, std::string& dest)   {      logT << variant << ": " << fpath << std::endl;      if (sstate.ext != "" && sstate.ext != ext)      {         logT << "Rejecting candidate because its extension: '" << ext              << "' does not match the other(s): '" << sstate.ext << "'"              << std::endl;         return 1;      }      dest = fpath;      sstate.ext = ext;      sstate.level = level;      return 0;   }    int   fontFileFilter (const char* fpath, const struct stat* sb,                   int tflag, struct FTW* ftwbuf)   {      // If we have just emerged from a directory where fonts were found,      // time to call it a day.      if (tflag == FTW_D &&          sstate.level > 0 && ftwbuf->level == sstate.level - 1 &&          sstate.regular.size () > 0)         return 1;       // In a less ideal case, where some candidates were found in this dir,      // but no regular variant, clear partial results and proceed.      if (tflag == FTW_D && sstate.level > 0)      {         logT << "Some candidates found but no regular variant; continuing"              << std::endl;         sstate.level = 0;         sstate.ext = "";         sstate.regular = "";         sstate.bold = "";         sstate.italic = "";         sstate.boldItalic = "";         return 0;      }       // Filter by file type - only regular files and symlinks      if (tflag != FTW_F && tflag != FTW_SL)         return 0;       // Filter by extension      const char* fname = fpath + ftwbuf->base;      const char* ext = strrchr (fname, '.');      if (!ext)         return 0;      if (strcasecmp (ext, ".gz") == 0 && ext > fname)         do            --ext;         while (ext > fname && ext [0] != '.');       if (strcasecmp (ext, ".ttc") != 0 &&          strcasecmp (ext, ".ttf") != 0 &&          strcasecmp (ext, ".otf") != 0 &&          strcasecmp (ext, ".pcf") != 0 &&          strcasecmp (ext, ".pcf.gz") != 0)         return 0;       // Filter by font name      if (strncasecmp (fname, sstate.fontname, sstate.fontnamelen) != 0)         return 0;       // At this point we only need to consider the mid part between font name      // and extension. This is either matched to one of the face variants,      // or we reject the file.      const char* mid = fname + sstate.fontnamelen;      size_t midlen = ext - mid;       // Discard optional hyphen, underscore or space between name and midpart      if (midlen > 0 &&          (mid [0] == '-' || mid [0] == '_' || mid [0] == ' '))      {         ++mid;         --midlen;      }       // Apply some simple heuristics to identify font variants      if (midlen == 0 ||          strncasecmp (mid, "R", midlen) == 0 ||          strncasecmp (mid, "Regular", midlen) == 0)      {         if (saveCandidate (fpath, ext, ftwbuf->level,                            "Regular", sstate.regular))            return 0;      }      else if (strncasecmp (mid, "B", midlen) == 0 ||               strncasecmp (mid, "Bold", midlen) == 0)      {         if (saveCandidate (fpath, ext, ftwbuf->level,                            "Bold", sstate.bold))            return 0;      }      else if (strncasecmp (mid, "I", midlen) == 0 ||               strncasecmp (mid, "It", midlen) == 0 ||               strncasecmp (mid, "Italic", midlen) == 0 ||               strncasecmp (mid, "O", midlen) == 0 ||               strncasecmp (mid, "Ob", midlen) == 0 ||               strncasecmp (mid, "Oblique", midlen) == 0)      {         if (saveCandidate (fpath, ext, ftwbuf->level,                            "Italic", sstate.italic))            return 0;      }      else if (strncasecmp (mid, "BI", midlen) == 0 ||               strncasecmp (mid, "BoldIt", midlen) == 0 ||               strncasecmp (mid, "BoldItalic", midlen) == 0)      {         if (saveCandidate (fpath, ext, ftwbuf->level,                            "BoldItalic", sstate.boldItalic))            return 0;      }    #if 0      // TODO remove the below printouts along with the include of stdio.h      printf("%-3s %2d ",             (tflag == FTW_D) ?   "d"   : (tflag == FTW_DNR) ? "dnr" :             (tflag == FTW_DP) ?  "dp"  : (tflag == FTW_F) ?   "f" :             (tflag == FTW_NS) ?  "ns"  : (tflag == FTW_SL) ?  "sl" :             (tflag == FTW_SLN) ? "sln" : "???",             ftwbuf->level);       if (tflag == FTW_NS)         printf("-------");      else         printf("%7jd", (intmax_t) sb->st_size);       printf("   %-40s %d %s\n",             fpath, ftwbuf->base, fpath + ftwbuf->base);   #endif      return 0;   } } // namespace namespace zutty{   Fontpack::Fontpack (const std::string& fontpath,                       const std::string& fontname,                       const std::string& dwfontname)   {      logT << "Fontpack: fontpath=" << fontpath           << "; fontname=" << fontname           << "; dwfontname=" << dwfontname           << std::endl;       // Look for & initialize the regular font (with variants)       sstate.fontname = fontname.data ();      sstate.fontnamelen = fontname.size ();       size_t pos = 0;      size_t nextpos = 0;      do      {         nextpos = fontpath.find (':', pos);         size_t len = (nextpos == std::string::npos)                    ? std::string::npos                    : nextpos - pos;          std::string fontpath1 = fontpath.substr (pos, len);         logT << "Looking for candidates under " << fontpath1 << std::endl;         pos = nextpos + 1;          int flags = FTW_DEPTH;         if (nftw (fontpath1.c_str (), fontFileFilter, 32, flags) == -1)         {            SYS_WARN ("Cannot walk file tree at ", fontpath1);         }       } while (!sstate.regular.size () && nextpos != std::string::npos);       if (! sstate.regular.size ())      {         logE << "No Regular variant of the requested font '" << fontname              << "' could be identified." << std::endl;         throw std::runtime_error (std::string ("No suitable files for '") +                                   fontname + "' found!");      }       fontRegular = std::make_unique <Font> (sstate.regular);      px = fontRegular->getPx ();      py = fontRegular->getPy ();       try      {         if (sstate.bold.size ())            fontBold = std::make_unique <Font> (               sstate.bold, * fontRegular.get (), Font::Overlay);      }      catch (const std::runtime_error& e)      {         fontBold = nullptr;         logW << "Failed to load bold variant: " << e.what () << std::endl;      }       try      {         if (sstate.italic.size ())            fontItalic = std::make_unique <Font> (               sstate.italic, * fontRegular.get (), Font::Overlay);      }      catch (const std::runtime_error& e)      {         fontItalic = nullptr;         logW << "Failed to load italic variant: " << e.what () << std::endl;      }       try      {         if (sstate.boldItalic.size ())            fontBoldItalic = std::make_unique <Font> (               sstate.boldItalic, * fontRegular.get (), Font::Overlay);      }      catch (const std::runtime_error& e)      {         fontBoldItalic = nullptr;         logW << "Failed to load boldItalic variant: " << e.what () << std::endl;      }       // Initialize the underline metrics       ulMetrics [0] = getRegular().getUlTop ();      ulMetrics [1] = getRegular().getUlThick ();      ulMetrics [2] = getBold().getUlTop ();      ulMetrics [3] = getBold().getUlThick ();      ulMetrics [4] = getItalic().getUlTop ();      ulMetrics [5] = getItalic().getUlThick ();      ulMetrics [6] = getBoldItalic().getUlTop ();      ulMetrics [7] = getBoldItalic().getUlThick ();       // Look for & initialize the double-width font       sstate.level = 0;      sstate.ext = "";      sstate.regular = "";      sstate.bold = "";      sstate.italic = "";      sstate.boldItalic = "";       sstate.fontname = dwfontname.data ();      sstate.fontnamelen = dwfontname.size ();       pos = 0;      nextpos = 0;      do      {         nextpos = fontpath.find (':', pos);         size_t len = (nextpos == std::string::npos)                    ? std::string::npos                    : nextpos - pos;          std::string fontpath1 = fontpath.substr (pos, len);         logT << "Looking for double-width candidates under " << fontpath1              << std::endl;         pos = nextpos + 1;          int flags = FTW_DEPTH;         if (nftw (fontpath1.c_str (), fontFileFilter, 32, flags) == -1)         {            SYS_WARN ("Cannot walk file tree at ", fontpath1);         }       } while (!sstate.regular.size () && nextpos != std::string::npos);       try      {         if (sstate.regular.size ())            fontDoubleWidth = std::make_unique <Font> (               sstate.regular, * fontRegular.get (), Font::DoubleWidth);         else if (dwfontname != "")         {            logW << "Failed to locate requested double-width font: "                 << dwfontname << std::endl;         }      }      catch (const std::runtime_error& e)      {         fontDoubleWidth = nullptr;         logW << "Failed to load double-width font: " << e.what () << std::endl;      }   } } // namespace zutty