src/LaTeXFonts.cpp

   1 /**
   2  * \file LaTeXFonts.cpp
   3  * This file is part of LyX, the document processor.
   4  * Licence details can be found in the file COPYING.
   5  *
   6  * \author Jürgen Spitzmüller
   7  *
   8  * Full author contact details are available in file CREDITS.
   9  */
  10
  11 #include <config.h>
  12
  13 #include "LaTeXFonts.h"
  14
  15 #include "LaTeXFeatures.h"
  16 #include "Lexer.h"
  17
  18 #include "frontends/alert.h"
  19
  20 #include "support/convert.h"
  21 #include "support/debug.h"
  22 #include "support/FileName.h"
  23 #include "support/filetools.h"
  24 #include "support/gettext.h"
  25 #include "support/lstrings.h"
  26
  27
  28 using namespace std;
  29 using namespace lyx::support;
  30
  31
  32 namespace lyx {
  33
  34 LaTeXFonts latexfonts;
  35
  36
  37 LaTeXFont LaTeXFont::altFont(docstring const & name)
  38 {
  39         return theLaTeXFonts().getAltFont(name);
  40 }
  41
  42
  43 bool LaTeXFont::available(bool ot1, bool nomath)
  44 {
  45         if (nomath && !nomathfont_.empty())
  46                 return altFont(nomathfont_).available(ot1, nomath);
  47         else if (ot1 && !ot1font_.empty())
  48                 return (ot1font_ == "none") ?
  49                         true : altFont(ot1font_).available(ot1, nomath);
  50         else if (requires_.empty() && package_.empty())
  51                 return true;
  52         else if (!requires_.empty()
  53                 && LaTeXFeatures::isAvailable(to_ascii(requires_)))
  54                 return true;
  55         else if (requires_.empty() && !package_.empty()
  56                 && LaTeXFeatures::isAvailable(to_ascii(package_)))
  57                 return true;
  58         else if (!altfonts_.empty()) {
  59                 for (size_t i = 0; i < altfonts_.size(); ++i) {
  60                         if (altFont(altfonts_[i]).available(ot1, nomath))
  61                                 return true;
  62                 }
  63         }
  64         return false;
  65 }
  66
  67
  68 bool LaTeXFont::providesNoMath(bool ot1, bool complete)
  69 {
  70         docstring const usedfont = getUsedFont(ot1, complete, false);
  71
  72         if (usedfont.empty())
  73                 return false;
  74         else if (usedfont != name_)
  75                 return altFont(usedfont).providesNoMath(ot1, complete);
  76
  77         return (!nomathfont_.empty() && available(ot1, true));
  78 }
  79
  80
  81 bool LaTeXFont::providesOSF(bool ot1, bool complete, bool nomath)
  82 {
  83         docstring const usedfont = getUsedFont(ot1, complete, nomath);
  84
  85         if (usedfont.empty())
  86                 return false;
  87         else if (usedfont != name_)
  88                 return altFont(usedfont).providesOSF(ot1, complete, nomath);
  89         else if (!osffont_.empty())
  90                 return altFont(osffont_).available(ot1, nomath);
  91         else if (!available(ot1, nomath))
  92                 return false;
  93
  94         return (!osfoption_.empty() || !osfscoption_.empty());
  95 }
  96
  97
  98 bool LaTeXFont::providesSC(bool ot1, bool complete, bool nomath)
  99 {
 100         docstring const usedfont = getUsedFont(ot1, complete, nomath);
 101
 102         if (usedfont.empty())
 103                 return false;
 104         else if (usedfont != name_)
 105                 return altFont(usedfont).providesSC(ot1, complete, nomath);
 106         else if (!available(ot1, nomath))
 107                 return false;
 108
 109         return (!scoption_.empty() || !osfscoption_.empty());
 110 }
 111
 112
 113 bool LaTeXFont::hasMonolithicExpertSet(bool ot1, bool complete, bool nomath)
 114 {
 115         docstring const usedfont = getUsedFont(ot1, complete, nomath);
 116
 117         if (usedfont.empty())
 118                 return false;
 119         else if (usedfont != name_)
 120                 return altFont(usedfont).hasMonolithicExpertSet(ot1, complete, nomath);
 121         return (!osfoption_.empty() && !scoption_.empty() && osfoption_ == scoption_)
 122                 || (osfoption_.empty() && scoption_.empty() && !osfscoption_.empty());
 123 }
 124
 125
 126 bool LaTeXFont::providesScale(bool ot1, bool complete, bool nomath)
 127 {
 128         docstring const usedfont = getUsedFont(ot1, complete, nomath);
 129
 130         if (usedfont.empty())
 131                 return false;
 132         else if (usedfont != name_)
 133                 return altFont(usedfont).providesScale(ot1, complete, nomath);
 134         else if (!available(ot1, nomath))
 135                 return false;
 136         return (!scaleoption_.empty());
 137 }
 138
 139 bool LaTeXFont::provides(std::string const & name, bool ot1, bool complete, bool nomath)
 140 {
 141         docstring const usedfont = getUsedFont(ot1, complete, nomath);
 142
 143         if (usedfont.empty())
 144                 return false;
 145         else if (usedfont != name_)
 146                 return altFont(usedfont).provides(name, ot1, complete, nomath);
 147         else if (provides_.empty())
 148                 return false;
 149
 150         for (size_t i = 0; i < provides_.size(); ++i) {
 151                 if (provides_[i] == name)
 152                         return true;
 153         }
 154         return false;
 155 }
 156
 157
 158 docstring const LaTeXFont::getUsedFont(bool ot1, bool complete, bool nomath)
 159 {
 160         if (nomath && !nomathfont_.empty() && available(ot1, true))
 161                 return nomathfont_;
 162         else if (ot1 && !ot1font_.empty())
 163                 return (ot1font_ == "none") ? docstring() : ot1font_;
 164         else if (family_ == "rm" && complete && !completefont_.empty()
 165                  && altFont(completefont_).available(ot1, nomath))
 166                         return completefont_;
 167         else if (switchdefault_) {
 168                 if (requires_.empty()
 169                     || (!requires_.empty()
 170                         && LaTeXFeatures::isAvailable(to_ascii(requires_))))
 171                         return name_;
 172         }
 173         else if (!requires_.empty()
 174                 && LaTeXFeatures::isAvailable(to_ascii(requires_)))
 175                         return name_;
 176         else if (!package_.empty()
 177                 && LaTeXFeatures::isAvailable(to_ascii(package_)))
 178                         return name_;
 179         else if (!preamble_.empty() && package_.empty()
 180                  && requires_.empty() && !switchdefault_
 181                  && altfonts_.empty()) {
 182                         return name_;
 183         }
 184         else if (!altfonts_.empty()) {
 185                 for (size_t i = 0; i < altfonts_.size(); ++i) {
 186                         LaTeXFont altf = altFont(altfonts_[i]);
 187                         if (altf.available(ot1, nomath))
 188                                 return altf.getUsedFont(ot1, complete, nomath);
 189                 }
 190         }
 191
 192         return docstring();
 193 }
 194
 195
 196 string const LaTeXFont::getAvailablePackage(bool dryrun)
 197 {
 198         if (package_.empty())
 199                 return string();
 200
 201         string const package = to_ascii(package_);
 202         if (!requires_.empty() && LaTeXFeatures::isAvailable(to_ascii(requires_)))
 203                 return package;
 204         else if (LaTeXFeatures::isAvailable(package))
 205                 return package;
 206         // Output unavailable packages in source preview
 207         else if (dryrun)
 208                 return package;
 209
 210         docstring const req = requires_.empty() ? package_ : requires_;
 211         frontend::Alert::warning(_("Font not available"),
 212                         bformat(_("The LaTeX package `%1$s' needed for the font `%2$s'\n"
 213                                   "is not available on your system. LyX will fall back to the default font."),
 214                                 req, guiname_), true);
 215
 216         return string();
 217 }
 218
 219
 220 string const LaTeXFont::getPackageOptions(bool ot1, bool complete, bool sc, bool osf,
 221                                           int scale, bool nomath)
 222 {
 223         ostringstream os;
 224         bool const needosfopt = (osf != osfdefault_);
 225         bool const has_osf = providesOSF(ot1, complete, nomath);
 226         bool const has_sc = providesSC(ot1, complete, nomath);
 227
 228         if (!packageoption_.empty())
 229                 os << to_ascii(packageoption_);
 230
 231         if (sc && needosfopt && has_osf && has_sc) {
 232                 if (!os.str().empty())
 233                         os << ',';
 234                 if (!osfscoption_.empty())
 235                         os << to_ascii(osfscoption_);
 236                 else
 237                         os << to_ascii(osfoption_)
 238                            << ',' << to_ascii(scoption_);
 239         } else if (needosfopt && has_osf) {
 240                 if (!os.str().empty())
 241                         os << ',';
 242                 os << to_ascii(osfoption_);
 243         } else if (sc && has_sc) {
 244                 if (!os.str().empty())
 245                         os << ',';
 246                 os << to_ascii(scoption_);
 247         }
 248
 249         if (scale != 100 && !scaleoption_.empty()
 250             && providesScale(ot1, complete, nomath)) {
 251                 if (!os.str().empty())
 252                         os << ',';
 253                 os << subst(to_ascii(scaleoption_), "$$val",
 254                             convert<std::string>(float(scale) / 100));
 255         }
 256         return os.str();
 257 }
 258
 259
 260 string const LaTeXFont::getLaTeXCode(bool dryrun, bool ot1, bool complete, bool sc,
 261                                      bool osf, bool nomath, int const & scale)
 262 {
 263         ostringstream os;
 264
 265         docstring const usedfont = getUsedFont(ot1, complete, nomath);
 266         if (usedfont.empty())
 267                 return string();
 268         else if (usedfont != name_)
 269                 return altFont(usedfont).getLaTeXCode(dryrun, ot1, complete, sc, osf, nomath, scale);
 270
 271         if (switchdefault_) {
 272                 if (family_.empty()) {
 273                         LYXERR0("Error: Font `" << name_ << "' has no family defined!");
 274                         return string();
 275                 }
 276                 if (available(ot1, nomath) || dryrun)
 277                         os << "\\renewcommand{\\" << to_ascii(family_) << "default}{"
 278                            << to_ascii(name_) << "}\n";
 279                 else
 280                         frontend::Alert::warning(_("Font not available"),
 281                                         bformat(_("The LaTeX package `%1$s' needed for the font `%2$s'\n"
 282                                                   "is not available on your system. LyX will fall back to the default font."),
 283                                                 requires_, guiname_), true);
 284         } else {
 285                 string const package =
 286                         getAvailablePackage(dryrun);
 287                 string const packageopts = getPackageOptions(ot1, complete, sc, osf, scale, nomath);
 288                 if (packageopts.empty() && !package.empty())
 289                         os << "\\usepackage{" << package << "}\n";
 290                 else if (!packageopts.empty() && !package.empty())
 291                         os << "\\usepackage[" << packageopts << "]{" << package << "}\n";
 292         }
 293         if (osf && providesOSF(ot1, complete, nomath) && !osffont_.empty())
 294                 os << altFont(osffont_).getLaTeXCode(dryrun, ot1, complete, sc, osf, nomath, scale);
 295
 296         if (!preamble_.empty())
 297                 os << preamble_;
 298
 299         return os.str();
 300 }
 301
 302
 303 bool LaTeXFont::readFont(Lexer & lex)
 304 {
 305         enum LaTeXFontTags {
 306                 LF_ALT_FONTS = 1,
 307                 LF_COMPLETE_FONT,
 308                 LF_END,
 309                 LF_FAMILY,
 310                 LF_GUINAME,
 311                 LF_NOMATHFONT,
 312                 LF_OSFDEFAULT,
 313                 LF_OSFFONT,
 314                 LF_OSFOPTION,
 315                 LF_OSFSCOPTION,
 316                 LF_OT1_FONT,
 317                 LF_PACKAGE,
 318                 LF_PACKAGEOPTION,
 319                 LF_PREAMBLE,
 320                 LF_PROVIDES,
 321                 LF_REQUIRES,
 322                 LF_SCALEOPTION,
 323                 LF_SCOPTION,
 324                 LF_SWITCHDEFAULT
 325         };
 326
 327         // Keep these sorted alphabetically!
 328         LexerKeyword latexFontTags[] = {
 329                 { "altfonts",             LF_ALT_FONTS },
 330                 { "completefont",         LF_COMPLETE_FONT },
 331                 { "endfont",              LF_END },
 332                 { "family",               LF_FAMILY },
 333                 { "guiname",              LF_GUINAME },
 334                 { "nomathfont",           LF_NOMATHFONT },
 335                 { "osfdefault",           LF_OSFDEFAULT },
 336                 { "osffont",              LF_OSFFONT },
 337                 { "osfoption",            LF_OSFOPTION },
 338                 { "osfscoption",          LF_OSFSCOPTION },
 339                 { "ot1font",              LF_OT1_FONT },
 340                 { "package",              LF_PACKAGE },
 341                 { "packageoption",        LF_PACKAGEOPTION },
 342                 { "preamble",             LF_PREAMBLE },
 343                 { "provides",             LF_PROVIDES },
 344                 { "requires",             LF_REQUIRES },
 345                 { "scaleoption",          LF_SCALEOPTION },
 346                 { "scoption",             LF_SCOPTION },
 347                 { "switchdefault",        LF_SWITCHDEFAULT }
 348         };
 349
 350         bool error = false;
 351         bool finished = false;
 352         lex.pushTable(latexFontTags);
 353         // parse style section
 354         while (!finished && lex.isOK() && !error) {
 355                 int le = lex.lex();
 356                 // See comment in LyXRC.cpp.
 357                 switch (le) {
 358                 case Lexer::LEX_FEOF:
 359                         continue;
 360
 361                 case Lexer::LEX_UNDEF: // parse error
 362                         lex.printError("Unknown LaTeXFont tag `$$Token'");
 363                         error = true;
 364                         continue;
 365
 366                 default:
 367                         break;
 368                 }
 369                 switch (static_cast<LaTeXFontTags>(le)) {
 370                 case LF_END: // end of structure
 371                         finished = true;
 372                         break;
 373                 case LF_ALT_FONTS: {
 374                         lex.eatLine();
 375                         docstring altp = lex.getDocString();
 376                         altfonts_ = getVectorFromString(altp);
 377                         break;
 378                 }
 379                 case LF_COMPLETE_FONT:
 380                         lex >> completefont_;
 381                         break;
 382                 case LF_FAMILY:
 383                         lex >> family_;
 384                         break;
 385                 case LF_GUINAME:
 386                         lex >> guiname_;
 387                         break;
 388                 case LF_NOMATHFONT:
 389                         lex >> nomathfont_;
 390                         break;
 391                 case LF_OSFOPTION:
 392                         lex >> osfoption_;
 393                         break;
 394                 case LF_OSFFONT:
 395                         lex >> osffont_;
 396                         break;
 397                 case LF_OSFDEFAULT:
 398                         lex >> osfdefault_;
 399                         break;
 400                 case LF_OSFSCOPTION:
 401                         lex >> osfscoption_;
 402                         break;
 403                 case LF_OT1_FONT:
 404                         lex >> ot1font_;
 405                         break;
 406                 case LF_PACKAGE:
 407                         lex >> package_;
 408                         break;
 409                 case LF_PACKAGEOPTION:
 410                         lex >> packageoption_;
 411                         break;
 412                 case LF_PREAMBLE:
 413                         preamble_ = lex.getLongString("EndPreamble");
 414                         break;
 415                 case LF_PROVIDES: {
 416                         lex.eatLine();
 417                         string features = lex.getString();
 418                         provides_ = getVectorFromString(features);
 419                         break;
 420                 }
 421                 case LF_REQUIRES:
 422                         lex >> requires_;
 423                         break;
 424                 case LF_SCALEOPTION:
 425                         lex >> scaleoption_;
 426                         break;
 427                 case LF_SCOPTION:
 428                         lex >> scoption_;
 429                         break;
 430                 case LF_SWITCHDEFAULT:
 431                         lex >> switchdefault_;
 432                         break;
 433                 }
 434         }
 435         if (!finished) {
 436                 lex.printError("No End tag found for LaTeXFont tag `$$Token'");
 437                 return false;
 438         }
 439         lex.popTable();
 440         return finished && !error;
 441 }
 442
 443
 444 bool LaTeXFont::read(Lexer & lex)
 445 {
 446         switchdefault_ = 0;
 447         osfdefault_ = 0;
 448
 449         if (!lex.next()) {
 450                 lex.printError("No name given for LaTeX font: `$$Token'.");
 451                 return false;
 452         }
 453
 454         name_ = lex.getDocString();
 455         LYXERR(Debug::INFO, "Reading LaTeX font " << name_);
 456         if (!readFont(lex)) {
 457                 LYXERR0("Error parsing LaTeX font `" << name_ << '\'');
 458                 return false;
 459         }
 460
 461         return true;
 462 }
 463
 464
 465 void LaTeXFonts::readLaTeXFonts()
 466 {
 467         // Read latexfonts file
 468         FileName filename = libFileSearch(string(), "latexfonts");
 469         if (filename.empty()) {
 470                 LYXERR0("Error: latexfonts file not found!");
 471                 return;
 472         }
 473         Lexer lex;
 474         lex.setFile(filename);
 475         lex.setContext("LaTeXFeatures::readLaTeXFonts");
 476         while (lex.isOK()) {
 477                 int le = lex.lex();
 478                 switch (le) {
 479                 case Lexer::LEX_FEOF:
 480                         continue;
 481
 482                 default:
 483                         break;
 484                 }
 485                 string const type = lex.getString();
 486                 if (type != "Font" && type != "AltFont") {
 487                         lex.printError("Unknown LaTeXFont tag `$$Token'");
 488                         continue;
 489                 }
 490                 LaTeXFont f;
 491                 f.read(lex);
 492                 if (!lex)
 493                         break;
 494
 495                 if (type == "AltFont")
 496                         texaltfontmap_[f.name()] = f;
 497                 else
 498                         texfontmap_[f.name()] = f;
 499         }
 500 }
 501
 502
 503 LaTeXFonts::TexFontMap LaTeXFonts::getLaTeXFonts()
 504 {
 505         if (texfontmap_.empty())
 506                 readLaTeXFonts();
 507         return texfontmap_;
 508 }
 509
 510
 511 LaTeXFont LaTeXFonts::getLaTeXFont(docstring const & name)
 512 {
 513         if (name == "default" || name == "auto")
 514                 return LaTeXFont();
 515         if (texfontmap_.empty())
 516                 readLaTeXFonts();
 517         if (texfontmap_.find(name) == texfontmap_.end()) {
 518                 LYXERR0("LaTeXFonts::getLaTeXFont: font '" << name << "' not found!");
 519                 return LaTeXFont();
 520         }
 521         return texfontmap_[name];
 522 }
 523
 524
 525 LaTeXFont LaTeXFonts::getAltFont(docstring const & name)
 526 {
 527         if (name == "default" || name == "auto")
 528                 return LaTeXFont();
 529         if (texaltfontmap_.empty())
 530                 readLaTeXFonts();
 531         if (texaltfontmap_.find(name) == texaltfontmap_.end()) {
 532                 LYXERR0("LaTeXFonts::getAltFont: alternative font '" << name << "' not found!");
 533                 return LaTeXFont();
 534         }
 535         return texaltfontmap_[name];
 536 }
 537
 538
 539 } // namespace lyx