anne/lyx_mirror
1
0
Fork 0
mirror of https://git.lyx.org/repos/lyx.git synced 2024-12-24 21:55:29 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Clean up LaTeX font handling (#4999)

Browse Source 
The LaTeX font information are now centralized and outsourced. This removes a lot of hardcoding and duplication and makes it easier to support new LaTeX fonts.
This commit is contained in:
Juergen Spitzmueller 2012-08-16 13:23:39 +02:00
parent 4f1fb3f6d1
commit 869b84aef9
13 changed files with 923 additions and 241 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
development/qmake/lyx.pro
View File

@ -91,6 +91,7 @@ SOURCES += \
../../src/Language.cpp \
../../src/LaTeX.cpp \
../../src/LaTeXFeatures.cpp \
../../src/LaTeXFonts.cpp \
../../src/Layout.cpp \
../../src/LayoutFile.cpp \
../../src/LayoutModuleList.cpp \
@ -439,6 +440,7 @@ HEADERS += \
../../src/KeySequence.h \
../../src/Language.h \
../../src/LaTeXFeatures.h \
../../src/LaTeXFonts.h \
../../src/LaTeX.h \
../../src/LayoutEnums.h \
../../src/LayoutFile.h \

2
lib/Makefile.am
View File

@ -5,7 +5,7 @@ SUBDIRS = doc lyx2lyx
CHMOD = chmod
dist_pkgdata_DATA = CREDITS autocorrect chkconfig.ltx external_templates \
encodings layouttranslations languages symbols syntax.default \
encodings layouttranslations languages latexfonts symbols syntax.default \
unicodesymbols
nodist_pkgdata_DATA = installed_translations

242
lib/latexfonts Normal file
View File

@ -0,0 +1,242 @@
##########################################################################
#
# LaTeX fonts natively supported by LyX.
#
# Syntax:
#
# Font <name>
# GuiName "<Gui Name>"
# Family <rm|sf|tt>
# SwitchDefault <0|1>
# Package <LaTeX package to be loaded>
# Requires <LaTeX package to test for>
# AltPackages <alternative packages (comma-separated)>
# OT1Package <alternative package specifically for OT1 encoding>
# CompletePackage <alternative package for the complete family>
# OsfOption <option for oldstyle figure support>
# ScOption <option for true smallcaps support>
# OsfScOption <option for combined osf and true smallcaps support>
# ScaleOption <option for font scaling>
# EndFont
#
#
# NOTES:
#
# * Adding a new font results in a FILE FORMAT CHANGE. So if a new font
# is added for the LyX distribution, the according changes need to be
# done.
# * "SwitchDefault 1" makes the font to be loaded by switching the default
# family to <name> (e.g., \renewcommand{\rmdefault}{cmr}), whereas
# Package <package> loads it via \usepackage{package}. Normally, only
# one of these options is used per font.
# * If AltPackages are defined, LyX will try to load them in the defined
# order if the main package is not available. So
# Package mathptmx
# AltPackages mathptm,times
# will try to load mathptm if mathptmx is not available and then times
# if mathptm is not available either.
# * If Requires is set, LyX will check for this. If not, it will check
# for Package and AltPackages.
# * OT1Package will load the defined package instead of the default
# package if the font encoding is OT1. This is necessary since some
# newer packages for a font do not support this encoding.
# The value "none" tells LyX not to load a package in OT1 encoding.
# * CompletePackage is a package that is loaded if the current font is
# selected as rm and both sf and tt are set to "default" (this allows
# f. ex. to load "bera" as opposed to "beraserif").
# * OsfScOption overrides any OsfOption and ScOption if both features
# are selected.
# * ScaleOption supports the placeholder $$val for the scale value.
#
##########################################################################
#
# Roman fonts
#
Font cmr
GuiName "Computer Modern Roman"
Family rm
SwitchDefault 1
OsfPackage eco
EndFont
Font lmodern
GuiName "Latin Modern Roman"
Family rm
Package lmodern
EndFont
Font ae
GuiName "AE (Almost European)"
Family rm
Package "ae,aecompl"
OT1Package none
Requires ae
EndFont
Font times
GuiName "Times Roman"
Family rm
Package mathptmx
AltPackages "mathptm,times"
Requires psnfss
EndFont
Font palatino
GuiName "Palatino"
Family rm
OsfOption osf
ScOption sc
OsfScOption osf
Package mathpazo
AltPackages "mathpple,palatino"
Requires psnfss
EndFont
Font charter
GuiName "Bitstream Charter"
Family rm
Package charter
EndFont
Font newcent
GuiName "New Century Schoolbook"
Family rm
Package newcent
EndFont
Font bookman
GuiName "Bookman"
Family rm
Package bookman
EndFont
# fourier supersedes utopia.sty, but does
# not work with OT1 encoding.
Font utopia
GuiName "Utopia"
Family rm
OsfOption oldstyle
ScOption expert
Package fourier
AltPackages utopia
OT1Package utopia
EndFont
Font beraserif
GuiName "Bera Serif"
Family rm
Package beraserif
CompletePackage bera
Requires bera
EndFont
Font ccfonts
GuiName "Concrete Roman"
Family rm
Package ccfonts
EndFont
Font chancery
GuiName "Zapf Chancery"
Family rm
Package chancery
EndFont
#
# SansSerif fonts
#
Font cmss
GuiName "Computer Modern Sans"
Family sf
SwitchDefault 1
EndFont
Font lmss
GuiName "Latin Modern Sans"
Family sf
SwitchDefault 1
Requires lmodern
EndFont
Font helvet
GuiName "Helvetica"
Family sf
ScaleOption scaled=$$val
Package helvet
Requires psnfss
EndFont
Font avant
GuiName "Avant Garde"
Family sf
Package avant
EndFont
Font berasans
GuiName "Bera Sans"
Family sf
ScaleOption scaled=$$val
Package berasans
Requires bera
EndFont
Font cmbr
GuiName "CM Bright"
Family sf
SwitchDefault 1
Requires cmbright
EndFont
#
# Monospaced fonts
#
Font cmtt
GuiName "Computer Modern Typewriter"
Family tt
SwitchDefault 1
EndFont
Font lmtt
GuiName "Latin Modern Typewriter"
Family tt
SwitchDefault 1
Requires lmodern
EndFont
Font courier
GuiName "Courier"
Family tt
Package courier
Requires psnfss
EndFont
Font beramono
GuiName "Bera Mono"
Family tt
ScaleOption scaled=$$val
Package beramono
Requires bera
EndFont
Font luximono
GuiName "LuxiMono"
Family tt
ScaleOption scaled=$$val
Package luximono
EndFont
Font cmtl
GuiName "CM Typewriter Light"
Family tt
SwitchDefault 1
Requires cmbright
EndFont

3
po/Rules-lyx
View File

@ -38,6 +38,9 @@ $(top_srcdir)/lib/layouttranslations: $(POFILES) $(top_srcdir)/lib/layouts/*.lay
languages_l10n.pot: $(top_srcdir)/lib/languages
$(PYTHON) $(srcdir)/lyx_pot.py -b $(top_srcdir) -o $@ -t languages ${top_srcdir}/lib/languages
latexfonts_l10n.pot: $(top_srcdir)/lib/latexfonts
$(PYTHON) $(srcdir)/lyx_pot.py -b $(top_srcdir) -o $@ -t latexfonts ${top_srcdir}/lib/latexfonts
encodings_l10n.pot: $(top_srcdir)/lib/encodings
$(PYTHON) $(srcdir)/lyx_pot.py -b $(top_srcdir) -o $@ -t encodings ${top_srcdir}/lib/encodings

25
po/lyx_pot.py
View File

@ -435,6 +435,26 @@ def languages_l10n(input_files, output, base):
out.close()
def latexfonts_l10n(input_files, output, base):
'''Generate pot file from lib/latexfonts'''
out = open(output, 'w')
GuiName = re.compile(r'^[^#]*GuiName\s+(.*)', re.IGNORECASE)
for src in input_files:
descStartLine = -1
descLines = []
lineno = 0
for line in open(src).readlines():
lineno += 1
res = GuiName.search(line)
if res != None:
string = res.group(1)
writeString(out, src, base, lineno, string)
continue
out.close()
def external_l10n(input_files, output, base):
'''Generate pot file from lib/external_templates'''
output = open(output, 'w')
@ -553,6 +573,7 @@ where
layouttranslations: create lib/layouttranslations from po/*.po and lib/layouts/*
qt4: qt4 ui files
languages: file lib/languages
latexfonts: file lib/latexfonts
encodings: file lib/encodings
external: external templates file
formats: formats predefined in lib/configure.py
@ -579,7 +600,7 @@ if __name__ == '__main__':
elif opt in ['-s', '--src_file']:
input_files = [f.strip() for f in open(value)]
if input_type not in ['ui', 'layouts', 'layouttranslations', 'qt4', 'languages', 'encodings', 'external', 'formats'] or output is None:
if input_type not in ['ui', 'layouts', 'layouttranslations', 'qt4', 'languages', 'latexfonts', 'encodings', 'external', 'formats'] or output is None:
print 'Wrong input type or output filename.'
sys.exit(1)
@ -587,6 +608,8 @@ if __name__ == '__main__':
if input_type == 'ui':
ui_l10n(input_files, output, base)
elif input_type == 'latexfonts':
latexfonts_l10n(input_files, output, base)
elif input_type == 'layouts':
layouts_l10n(input_files, output, base, False)
elif input_type == 'layouttranslations':

140
src/BufferParams.cpp
View File

@ -30,6 +30,7 @@
#include "IndicesList.h"
#include "Language.h"
#include "LaTeXFeatures.h"
#include "LaTeXFonts.h"
#include "ModuleList.h"
#include "Font.h"
#include "Lexer.h"
@ -2856,115 +2857,50 @@ string const BufferParams::loadFonts(string const & rm,
return os.str();
}
// Tex Fonts
bool const ot1 = (font_encoding() == "default" || font_encoding() == "OT1");
// ROMAN FONTS
// Computer Modern (must be explicitly selectable -- there might be classes
// that define a different default font!
if (rm == "cmr") {
os << "\\renewcommand{\\rmdefault}{cmr}\n";
// osf for Computer Modern needs eco.sty
if (osf)
os << "\\usepackage{eco}\n";
LaTeXFont roman = theLaTeXFonts().getLaTeXFont(from_ascii(rm));
if (roman.switchdefault())
os << "\\renewcommand{\\rmdefault}{" << to_ascii(roman.name()) << "}\n";
else {
bool const complete = (sf == "default" && tt == "default");
string const package = roman.getAvailablePackage(ot1, complete);
string const packageopts = roman.getPackageOptions(ot1, sc, osf);
if (packageopts.empty() && !package.empty())
os << "\\usepackage{" << package << "}\n";
else if (!packageopts.empty() && !package.empty())
os << "\\usepackage[" << packageopts << "]{" << package << "}\n";
}
// Latin Modern Roman
else if (rm == "lmodern")
os << "\\usepackage{lmodern}\n";
// AE
else if (rm == "ae") {
// not needed when using OT1 font encoding.
if (font_encoding() != "default")
os << "\\usepackage{ae,aecompl}\n";
}
// Times
else if (rm == "times") {
// try to load the best available package
if (LaTeXFeatures::isAvailable("mathptmx"))
os << "\\usepackage{mathptmx}\n";
else if (LaTeXFeatures::isAvailable("mathptm"))
os << "\\usepackage{mathptm}\n";
else
os << "\\usepackage{times}\n";
}
// Palatino
else if (rm == "palatino") {
// try to load the best available package
if (LaTeXFeatures::isAvailable("mathpazo")) {
os << "\\usepackage";
if (osf || sc) {
os << '[';
if (!osf)
os << "sc";
else
// "osf" includes "sc"!
os << "osf";
os << ']';
}
os << "{mathpazo}\n";
}
else if (LaTeXFeatures::isAvailable("mathpple"))
os << "\\usepackage{mathpple}\n";
else
os << "\\usepackage{palatino}\n";
}
// Utopia
else if (rm == "utopia") {
// fourier supersedes utopia.sty, but does
// not work with OT1 encoding.
if (LaTeXFeatures::isAvailable("fourier")
&& font_encoding() != "default") {
os << "\\usepackage";
if (osf || sc) {
os << '[';
if (sc)
os << "expert";
if (osf && sc)
os << ',';
if (osf)
os << "oldstyle";
os << ']';
}
os << "{fourier}\n";
}
else
os << "\\usepackage{utopia}\n";
}
// Bera (complete fontset)
else if (rm == "bera" && sf == "default" && tt == "default")
os << "\\usepackage{bera}\n";
// everything else
else if (rm != "default")
os << "\\usepackage" << "{" << rm << "}\n";
if (osf && roman.providesOSF(ot1) && !roman.osfpackage().empty())
os << "\\usepackage{" << to_ascii(roman.osfpackage()) << "}\n";
// SANS SERIF
// Helvetica, Bera Sans
if (sf == "helvet" || sf == "berasans") {
if (sfscale != 100)
os << "\\usepackage[scaled=" << float(sfscale) / 100
<< "]{" << sf << "}\n";
else
os << "\\usepackage{" << sf << "}\n";
LaTeXFont sans = theLaTeXFonts().getLaTeXFont(from_ascii(sf));
if (sans.switchdefault())
os << "\\renewcommand{\\sfdefault}{" << to_ascii(sans.name()) << "}\n";
else {
string const package = sans.getAvailablePackage(ot1);
string const packageopts = sans.getPackageOptions(ot1, sc, osf, sfscale);
if (packageopts.empty() && !package.empty())
os << "\\usepackage{" << package << "}\n";
else if (!packageopts.empty() && !package.empty())
os << "\\usepackage[" << packageopts << "]{" << package << "}\n";
}
// Avant Garde
else if (sf == "avant")
os << "\\usepackage{" << sf << "}\n";
// Computer Modern, Latin Modern, CM Bright
else if (sf != "default")
os << "\\renewcommand{\\sfdefault}{" << sf << "}\n";
// monospaced/typewriter
// Courier, LuxiMono
if (tt == "luximono" || tt == "beramono") {
if (ttscale != 100)
os << "\\usepackage[scaled=" << float(ttscale) / 100
<< "]{" << tt << "}\n";
else
os << "\\usepackage{" << tt << "}\n";
// MONOSPACED/TYPEWRITER
LaTeXFont mono = theLaTeXFonts().getLaTeXFont(from_ascii(tt));
if (mono.switchdefault())
os << "\\renewcommand{\\ttdefault}{" << to_ascii(mono.name()) << "}\n";
else {
string const package = mono.getAvailablePackage(ot1);
string const packageopts = mono.getPackageOptions(ot1, sc, osf, ttscale);
if (packageopts.empty() && !package.empty())
os << "\\usepackage{" << package << "}\n";
else if (!packageopts.empty() && !package.empty())
os << "\\usepackage[" << packageopts << "]{" << package << "}\n";
}
// Courier
else if (tt == "courier" )
os << "\\usepackage{" << tt << "}\n";
// Computer Modern, Latin Modern, CM Bright
else if (tt != "default")
os << "\\renewcommand{\\ttdefault}{" << tt << "}\n";
return os.str();
}

335
src/LaTeXFonts.cpp Normal file
View File

@ -0,0 +1,335 @@
/**
* \file LaTeXFonts.cpp
* This file is part of LyX, the document processor.
* Licence details can be found in the file COPYING.
*
* \author Jürgen Spitzmüller
*
* Full author contact details are available in file CREDITS.
*/
#include <config.h>
#include "LaTeXFonts.h"
#include "LaTeXFeatures.h"
#include "Lexer.h"
#include "support/convert.h"
#include "support/debug.h"
#include "support/FileName.h"
#include "support/filetools.h"
#include "support/lstrings.h"
using namespace std;
using namespace lyx::support;
namespace lyx {
LaTeXFonts latexfonts;
bool LaTeXFont::available(bool ot1) const
{
return ot1 ? available_ot1_ : available_;
}
bool LaTeXFont::providesOSF(bool ot1) const
{
if (!osfpackage_.empty())
return LaTeXFeatures::isAvailable(to_ascii(osfpackage_));
if (ot1 && !ot1package_.empty() && ot1package_ != "none")
return false;
if (!package_.empty() && !LaTeXFeatures::isAvailable(to_ascii(package_)))
return false;
return (!osfoption_.empty() || !osfscoption_.empty());
}
bool LaTeXFont::providesSC(bool ot1) const
{
if (ot1 && !ot1package_.empty() && ot1package_ != "none")
return false;
if (!package_.empty() && !LaTeXFeatures::isAvailable(to_ascii(package_)))
return false;
return (!scoption_.empty() || !osfscoption_.empty());
}
bool LaTeXFont::providesScale(bool ot1) const
{
if (ot1 && !ot1package_.empty() && ot1package_ != "none")
return false;
if (!package_.empty() && !LaTeXFeatures::isAvailable(to_ascii(package_)))
return false;
return (!scaleoption_.empty());
}
string const LaTeXFont::getAvailablePackage(bool ot1, bool complete)
{
if (ot1 && !ot1package_.empty()) {
if (ot1package_ != "none" && LaTeXFeatures::isAvailable(to_ascii(ot1package_)))
return to_ascii(ot1package_);
return string();
}
if (complete && !completepackage_.empty()) {
if (LaTeXFeatures::isAvailable(to_ascii(completepackage_)))
return to_ascii(completepackage_);
}
if (!package_.empty()) {
if (!requires_.empty() && LaTeXFeatures::isAvailable(to_ascii(requires_)))
return to_ascii(package_);
if (LaTeXFeatures::isAvailable(to_ascii(package_)))
return to_ascii(package_);
else if (!altpackages_.empty()) {
for (size_t i = 0; i < altpackages_.size(); ++i) {
if (LaTeXFeatures::isAvailable(to_ascii(altpackages_[i])))
return to_ascii(altpackages_[i]);
}
}
}
return string();
}
string const LaTeXFont::getPackageOptions(bool const & ot1, bool const & sc,
bool const & osf, int const & scale)
{
if (ot1 && !ot1package_.empty())
return string();
ostringstream os;
if (sc && osf && providesOSF() && providesSC()) {
if (!osfscoption_.empty())
os << to_ascii(osfscoption_);
else
os << to_ascii(osfoption_) << ',' << to_ascii(scoption_);
} else if (osf && providesOSF())
os << to_ascii(osfoption_);
else if (sc && providesSC())
os << to_ascii(scoption_);
if (scale != 100 && !scaleoption_.empty()) {
if (!os.str().empty())
os << ',';
os << subst(to_ascii(scaleoption_), "$$val",
convert<std::string>(float(scale) / 100));
}
return os.str();
}
bool LaTeXFont::readFont(Lexer & lex)
{
enum LaTeXFontTags {
LF_ALT_PACKAGES = 1,
LF_COMPLETE_PACKAGE,
LF_END,
LF_FAMILY,
LF_GUINAME,
LF_OSFOPTION,
LF_OSFPACKAGE,
LF_OSFSCOPTION,
LF_OT1_PACKAGE,
LF_PACKAGE,
LF_REQUIRES,
LF_SCALEOPTION,
LF_SCOPTION,
LF_SWITCHDEFAULT
};
// Keep these sorted alphabetically!
LexerKeyword latexFontTags[] = {
{ "altpackages", LF_ALT_PACKAGES },
{ "completepackage", LF_COMPLETE_PACKAGE },
{ "endfont", LF_END },
{ "family", LF_FAMILY },
{ "guiname", LF_GUINAME },
{ "osfoption", LF_OSFOPTION },
{ "osfpackage", LF_OSFPACKAGE },
{ "osfscoption", LF_OSFSCOPTION },
{ "ot1package", LF_OT1_PACKAGE },
{ "package", LF_PACKAGE },
{ "requires", LF_REQUIRES },
{ "scaleoption", LF_SCALEOPTION },
{ "scoption", LF_SCOPTION },
{ "switchdefault", LF_SWITCHDEFAULT }
};
bool error = false;
bool finished = false;
lex.pushTable(latexFontTags);
// parse style section
while (!finished && lex.isOK() && !error) {
int le = lex.lex();
// See comment in LyXRC.cpp.
switch (le) {
case Lexer::LEX_FEOF:
continue;
case Lexer::LEX_UNDEF: // parse error
lex.printError("Unknown LaTeXFont tag `$$Token'");
error = true;
continue;
default:
break;
}
switch (static_cast<LaTeXFontTags>(le)) {
case LF_END: // end of structure
finished = true;
break;
case LF_ALT_PACKAGES: {
docstring altp;
lex >> altp;
altpackages_ = getVectorFromString(altp);
break;
}
case LF_COMPLETE_PACKAGE:
lex >> completepackage_;
break;
case LF_FAMILY:
lex >> family_;
break;
case LF_GUINAME:
lex >> guiname_;
break;
case LF_OSFOPTION:
lex >> osfoption_;
break;
case LF_OSFPACKAGE:
lex >> osfpackage_;
break;
case LF_OSFSCOPTION:
lex >> osfscoption_;
break;
case LF_OT1_PACKAGE:
lex >> ot1package_;
break;
case LF_PACKAGE:
lex >> package_;
break;
case LF_REQUIRES:
lex >> requires_;
break;
case LF_SCALEOPTION:
lex >> scaleoption_;
break;
case LF_SCOPTION:
lex >> scoption_;
break;
case LF_SWITCHDEFAULT:
lex >> switchdefault_;
break;
}
}
if (!finished) {
lex.printError("No End tag found for LaTeXFont tag `$$Token'");
return false;
}
lex.popTable();
return finished && !error;
}
bool LaTeXFont::read(Lexer & lex)
{
switchdefault_ = 0;
if (!lex.next()) {
lex.printError("No name given for LaTeX font: `$$Token'.");
return false;
}
name_ = lex.getDocString();
LYXERR(Debug::INFO, "Reading LaTeX font " << name_);
if (!readFont(lex)) {
LYXERR0("Error parsing LaTeX font `" << name_ << '\'');
return false;
}
bool available = true;
if (!requires_.empty())
available = LaTeXFeatures::isAvailable(to_ascii(requires_));
else if (!package_.empty()) {
available = LaTeXFeatures::isAvailable(to_ascii(package_));
if (!available && !altpackages_.empty()) {
for (size_t i = 0; i < altpackages_.size(); ++i) {
available = LaTeXFeatures::isAvailable(to_ascii(altpackages_[i]));
if (available)
break;
}
}
}
available_ = available;
if (!ot1package_.empty() && ot1package_ != "none")
available_ot1_ = LaTeXFeatures::isAvailable(to_ascii(ot1package_));
else
available_ot1_ = available;
return true;
}
void LaTeXFonts::readLaTeXFonts()
{
// Read latexfonts file
FileName filename = libFileSearch(string(), "latexfonts");
if (filename.empty()) {
LYXERR0("Error: latexfonts file not found!");
return;
}
Lexer lex;
lex.setFile(filename);
lex.setContext("LaTeXFeatures::readLaTeXFonts");
while (lex.isOK()) {
int le = lex.lex();
switch (le) {
case Lexer::LEX_FEOF:
continue;
default:
break;
}
if (lex.getString() != "Font") {
lex.printError("Unknown LaTeXFont tag `$$Token'");
continue;
}
LaTeXFont f;
f.read(lex);
if (!lex)
break;
texfontmap_[f.name()] = f;
}
}
LaTeXFonts::TexFontMap LaTeXFonts::getLaTeXFonts()
{
if (texfontmap_.empty())
readLaTeXFonts();
return texfontmap_;
}
LaTeXFont LaTeXFonts::getLaTeXFont(docstring const & name)
{
if (texfontmap_.empty())
readLaTeXFonts();
return texfontmap_[name];
}
} // namespace lyx

136
src/LaTeXFonts.h Normal file
View File

@ -0,0 +1,136 @@
// -*- C++ -*-
/**
* \file LaTeXFonts.h
* This file is part of LyX, the document processor.
* Licence details can be found in the file COPYING.
*
* \author Jürgen Spitzmüller
*
* Full author contact details are available in file CREDITS.
*/
#ifndef LATEXFONTS_H
#define LATEXFONTS_H
#include "support/docstring.h"
#include <map>
#include <vector>
namespace lyx {
class Lexer;
/// LaTeX Font definition
class LaTeXFont {
public:
/// TeX font
LaTeXFont() : switchdefault_(false) {}
/// The font name
docstring const & name() { return name_; }
/// The name to appear in the document dialog
docstring const & guiname() { return guiname_; }
/// Font family (rm, sf, tt)
docstring const & family() { return family_; }
/// The package that provides this font
docstring const & package() { return package_; }
/// Alternative packages if package() is not available
std::vector<docstring> const & altpackages() { return altpackages_; }
/// A package that provides all families
docstring const & completepackage() { return completepackage_; }
/// A package specifically needed for OT1 font encoding
docstring const & ot1package() { return ot1package_; }
/// A package that provides Old Style Figures for this font
docstring const & osfpackage() { return osfpackage_; }
/// A package option for Old Style Figures
docstring const & osfoption() { return osfoption_; }
/// A package option for true SmallCaps
docstring const & scoption() { return scoption_; }
/// A package option for both Old Style Figures and SmallCaps
docstring const & osfscoption() { return osfscoption_; }
/// A package option for font scaling
docstring const & scaleoption() { return scaleoption_; }
/// Alternative requirement to test for
docstring const & requires() { return requires_; }
/// Issue the familydefault switch
bool switchdefault() const { return switchdefault_; }
/// Is this font available?
bool available(bool ot1 = false) const;
/// Does this font provide Old Style Figures?
bool providesOSF(bool ot1 = false) const;
/// Does this font provide optional true SmallCaps?
bool providesSC(bool ot1 = false) const;
/// Does this font provide scaling?
bool providesScale(bool ot1 = false) const;
/// Return the preferred available package
std::string const getAvailablePackage(bool ot1 = false, bool complete = false);
/// Return the package options
std::string const getPackageOptions(bool const & ot1,
bool const & sc,
bool const & osf,
int const & scale = 100);
///
bool read(Lexer & lex);
///
bool readFont(Lexer & lex);
private:
///
docstring name_;
///
docstring guiname_;
///
docstring family_;
///
docstring package_;
///
std::vector<docstring> altpackages_;
///
docstring completepackage_;
///
docstring ot1package_;
///
docstring osfpackage_;
///
docstring osfoption_;
///
docstring scoption_;
///
docstring osfscoption_;
///
docstring scaleoption_;
///
docstring requires_;
///
bool switchdefault_;
///
bool available_;
///
bool available_ot1_;
};
/** The list of available LaTeX fonts
*/
class LaTeXFonts {
public:
///
typedef std::map<docstring, LaTeXFont> TexFontMap;
/// Get all LaTeXFonts
TexFontMap getLaTeXFonts();
/// Get a specific LaTeXFont \p name
LaTeXFont getLaTeXFont(docstring const & name);
private:
///
void readLaTeXFonts();
///
TexFontMap texfontmap_;
};
/// Implementation is in LyX.cpp
extern LaTeXFonts & theLaTeXFonts();
} // namespace lyx
#endif

16
src/LyX.cpp
View File

@ -34,6 +34,7 @@
#include "HunspellChecker.h"
#include "KeyMap.h"
#include "Language.h"
#include "LaTeXFonts.h"
#include "LayoutFile.h"
#include "Lexer.h"
#include "LyX.h"
@ -139,12 +140,13 @@ void reconfigureUserLyXDir()
/// The main application class private implementation.
struct LyX::Impl
{
Impl() : spell_checker_(0), apple_spell_checker_(0), aspell_checker_(0), enchant_checker_(0), hunspell_checker_(0)
Impl() : latexfonts_(0), spell_checker_(0), apple_spell_checker_(0), aspell_checker_(0), enchant_checker_(0), hunspell_checker_(0)
{
}
~Impl()
{
delete latexfonts_;
delete apple_spell_checker_;
delete aspell_checker_;
delete enchant_checker_;
@ -187,6 +189,9 @@ struct LyX::Impl
bool first_start;
/// the parsed command line batch command if any
vector<string> batch_commands;
///
LaTeXFonts * latexfonts_;
///
SpellChecker * spell_checker_;
@ -1387,6 +1392,15 @@ Session & theSession()
}
LaTeXFonts & theLaTeXFonts()
{
LASSERT(singleton_, /**/);
if (!singleton_->pimpl_->latexfonts_)
singleton_->pimpl_->latexfonts_ = new LaTeXFonts;
return *singleton_->pimpl_->latexfonts_;
}
CmdDef & theTopLevelCmdDef()
{
LASSERT(singleton_, /**/);

2
src/LyX.h
View File

@ -28,6 +28,7 @@ class ErrorItem;
class FuncRequest;
class FuncStatus;
class KeyMap;
class LaTeXFonts;
class Messages;
class Mover;
class Movers;
@ -148,6 +149,7 @@ private:
friend Movers & theSystemMovers();
friend frontend::Application * theApp();
friend Session & theSession();
friend LaTeXFonts & theLaTeXFonts();
friend CmdDef & theTopLevelCmdDef();
friend SpellChecker * theSpellChecker();
friend void setSpellChecker();

2
src/Makefile.am
View File

@ -85,6 +85,8 @@ lyx_SOURCES = \
$(ENCHANT) \
$(HUNSPELL) \
$(PWL) \
LaTeXFonts.cpp \
LaTeXFonts.h \
PrinterParams.cpp \
PrinterParams.h \
Thesaurus.cpp \

245
src/frontends/qt4/GuiDocument.cpp
View File

@ -38,6 +38,7 @@
#include "IndicesList.h"
#include "Language.h"
#include "LaTeXFeatures.h"
#include "LaTeXFonts.h"
#include "Layout.h"
#include "LayoutModuleList.h"
#include "LyXRC.h"
@ -115,51 +116,6 @@ char const * const tex_graphics_gui[] =
};
char const * const tex_fonts_roman[] =
{
"default", "cmr", "lmodern", "ae", "times", "palatino",
"charter", "newcent", "bookman", "utopia", "beraserif",
"ccfonts", "chancery", ""
};
char const * tex_fonts_roman_gui[] =
{
N_("Default"), N_("Computer Modern Roman"), N_("Latin Modern Roman"),
N_("AE (Almost European)"), N_("Times Roman"), N_("Palatino"),
N_("Bitstream Charter"), N_("New Century Schoolbook"), N_("Bookman"),
N_("Utopia"), N_("Bera Serif"), N_("Concrete Roman"), N_("Zapf Chancery"),
""
};
char const * const tex_fonts_sans[] =
{
"default", "cmss", "lmss", "helvet", "avant", "berasans", "cmbr", ""
};
char const * tex_fonts_sans_gui[] =
{
N_("Default"), N_("Computer Modern Sans"), N_("Latin Modern Sans"),
N_("Helvetica"), N_("Avant Garde"), N_("Bera Sans"), N_("CM Bright"), ""
};
char const * const tex_fonts_monospaced[] =
{
"default", "cmtt", "lmtt", "courier", "beramono", "luximono", "cmtl", ""
};
char const * tex_fonts_monospaced_gui[] =
{
N_("Default"), N_("Computer Modern Typewriter"),
N_("Latin Modern Typewriter"), N_("Courier"), N_("Bera Mono"),
N_("LuxiMono"), N_("CM Typewriter Light"), ""
};
char const * backref_opts[] =
{
"false", "section", "slide", "page", ""
@ -209,6 +165,10 @@ char const * packages_gui[][4] =
vector<string> engine_types_;
vector<pair<string, QString> > pagestyles;
QMap<QString, QString> rmfonts_;
QMap<QString, QString> sffonts_;
QMap<QString, QString> ttfonts_;
} // anonymous namespace
@ -890,9 +850,9 @@ GuiDocument::GuiDocument(GuiView & lv)
fontModule->fontsizeCO->addItem(qt_("11"));
fontModule->fontsizeCO->addItem(qt_("12"));
fontModule->fontencCO->addItem(qt_("Default"));
fontModule->fontencCO->addItem(qt_("Custom"));
fontModule->fontencCO->addItem(qt_("None (no fontenc)"));
fontModule->fontencCO->addItem(qt_("Default"), QString("global"));
fontModule->fontencCO->addItem(qt_("Custom"), QString("custom"));
fontModule->fontencCO->addItem(qt_("None (no fontenc)"), QString("default"));
for (int n = 0; GuiDocument::fontfamilies_gui[n][0]; ++n)
fontModule->fontsDefaultCO->addItem(
@ -1808,28 +1768,39 @@ void GuiDocument::osFontsChanged(bool nontexfonts)
fontModule->fontsDefaultLA->setEnabled(tex_fonts);
fontModule->cjkFontLE->setEnabled(tex_fonts);
fontModule->cjkFontLA->setEnabled(tex_fonts);
string font;
if (tex_fonts)
font = tex_fonts_sans[fontModule->fontsSansCO->currentIndex()];
bool scaleable = providesScale(font);
fontModule->scaleSansSB->setEnabled(scaleable);
fontModule->scaleSansLA->setEnabled(scaleable);
if (tex_fonts)
font = tex_fonts_monospaced[fontModule->fontsTypewriterCO->currentIndex()];
scaleable = providesScale(font);
fontModule->scaleTypewriterSB->setEnabled(scaleable);
fontModule->scaleTypewriterLA->setEnabled(scaleable);
if (tex_fonts)
font = tex_fonts_roman[fontModule->fontsRomanCO->currentIndex()];
fontModule->fontScCB->setEnabled(providesSC(font));
fontModule->fontOsfCB->setEnabled(providesOSF(font));
updateFontOptions();
fontModule->fontencLA->setEnabled(tex_fonts);
fontModule->fontencCO->setEnabled(tex_fonts);
if (!tex_fonts)
fontModule->fontencLE->setEnabled(false);
else
fontencChanged(fontModule->fontencCO->currentIndex());
fontencChanged(fontModule->fontencCO->currentIndex());
}
void GuiDocument::updateFontOptions()
{
bool const tex_fonts = !fontModule->osFontsCB->isChecked();
QString font;
if (tex_fonts)
font = fontModule->fontsSansCO->itemData(
fontModule->fontsSansCO->currentIndex()).toString();
bool scaleable = providesScale(font);
fontModule->scaleSansSB->setEnabled(scaleable);
fontModule->scaleSansLA->setEnabled(scaleable);
if (tex_fonts)
font = fontModule->fontsTypewriterCO->itemData(
fontModule->fontsTypewriterCO->currentIndex()).toString();
scaleable = providesScale(font);
fontModule->scaleTypewriterSB->setEnabled(scaleable);
fontModule->scaleTypewriterLA->setEnabled(scaleable);
if (tex_fonts)
font = fontModule->fontsRomanCO->itemData(
fontModule->fontsRomanCO->currentIndex()).toString();
fontModule->fontScCB->setEnabled(providesSC(font));
fontModule->fontOsfCB->setEnabled(providesOSF(font));
}
@ -1851,6 +1822,40 @@ void GuiDocument::updateFontsize(string const & items, string const & sel)
}
bool GuiDocument::ot1() const
{
QString const fontenc =
fontModule->fontencCO->itemData(fontModule->fontencCO->currentIndex()).toString();
return (fontenc == "default"
|| (fontenc == "global" && (lyxrc.fontenc == "default" || lyxrc.fontenc == "OT1"))
|| (fontenc == "custom" && fontModule->fontencLE->text() == "OT1"));
}
void GuiDocument::updateTexFonts()
{
LaTeXFonts::TexFontMap texfontmap = theLaTeXFonts().getLaTeXFonts();
LaTeXFonts::TexFontMap::const_iterator it = texfontmap.begin();
LaTeXFonts::TexFontMap::const_iterator end = texfontmap.end();
for (; it != end; ++it) {
LaTeXFont lf = it->second;
if (lf.name().empty())
return;
docstring const family = lf.family();
docstring guiname = translateIfPossible(lf.guiname());
if (!lf.available(ot1()))
guiname += _(" (not installed)");
if (family == "rm")
rmfonts_.insert(toqstr(guiname), toqstr(it->first));
else if (family == "sf")
sffonts_.insert(toqstr(guiname), toqstr(it->first));
else if (family == "tt")
ttfonts_.insert(toqstr(guiname), toqstr(it->first));
}
}
void GuiDocument::updateFontlist()
{
fontModule->fontsRomanCO->clear();
@ -1873,30 +1878,39 @@ void GuiDocument::updateFontlist()
return;
}
for (int n = 0; tex_fonts_roman[n][0]; ++n) {
QString font = qt_(tex_fonts_roman_gui[n]);
if (!isFontAvailable(tex_fonts_roman[n]))
font += qt_(" (not installed)");
fontModule->fontsRomanCO->addItem(font, qt_(tex_fonts_roman[n]));
if (rmfonts_.empty())
updateTexFonts();
fontModule->fontsRomanCO->addItem(qt_("Default"), QString("default"));
QMap<QString, QString>::const_iterator rmi = rmfonts_.constBegin();
while (rmi != rmfonts_.constEnd()) {
fontModule->fontsRomanCO->addItem(rmi.key(), rmi.value());
++rmi;
}
for (int n = 0; tex_fonts_sans[n][0]; ++n) {
QString font = qt_(tex_fonts_sans_gui[n]);
if (!isFontAvailable(tex_fonts_sans[n]))
font += qt_(" (not installed)");
fontModule->fontsSansCO->addItem(font, qt_(tex_fonts_sans[n]));
fontModule->fontsSansCO->addItem(qt_("Default"), QString("default"));
QMap<QString, QString>::const_iterator sfi = sffonts_.constBegin();
while (sfi != sffonts_.constEnd()) {
fontModule->fontsSansCO->addItem(sfi.key(), sfi.value());
++sfi;
}
for (int n = 0; tex_fonts_monospaced[n][0]; ++n) {
QString font = qt_(tex_fonts_monospaced_gui[n]);
if (!isFontAvailable(tex_fonts_monospaced[n]))
font += qt_(" (not installed)");
fontModule->fontsTypewriterCO->addItem(font, qt_(tex_fonts_monospaced[n]));
fontModule->fontsTypewriterCO->addItem(qt_("Default"), QString("default"));
QMap<QString, QString>::const_iterator tti = ttfonts_.constBegin();
while (tti != ttfonts_.constEnd()) {
fontModule->fontsTypewriterCO->addItem(tti.key(), tti.value());
++tti;
}
}
void GuiDocument::fontencChanged(int item)
{
fontModule->fontencLE->setEnabled(item == 1);
fontModule->fontencLE->setEnabled(
fontModule->fontencCO->itemData(item).toString() == "custom");
// The availability of TeX fonts depends on the font encoding
updateTexFonts();
updateFontOptions();
}
@ -1904,7 +1918,8 @@ void GuiDocument::romanChanged(int item)
{
if (fontModule->osFontsCB->isChecked())
return;
string const font = tex_fonts_roman[item];
QString const font =
fontModule->fontsRomanCO->itemData(item).toString();
fontModule->fontScCB->setEnabled(providesSC(font));
fontModule->fontOsfCB->setEnabled(providesOSF(font));
}
@ -1914,7 +1929,8 @@ void GuiDocument::sansChanged(int item)
{
if (fontModule->osFontsCB->isChecked())
return;
string const font = tex_fonts_sans[item];
QString const font =
fontModule->fontsSansCO->itemData(item).toString();
bool scaleable = providesScale(font);
fontModule->scaleSansSB->setEnabled(scaleable);
fontModule->scaleSansLA->setEnabled(scaleable);
@ -1925,7 +1941,8 @@ void GuiDocument::ttChanged(int item)
{
if (fontModule->osFontsCB->isChecked())
return;
string const font = tex_fonts_monospaced[item];
QString const font =
fontModule->fontsTypewriterCO->itemData(item).toString();
bool scaleable = providesScale(font);
fontModule->scaleTypewriterSB->setEnabled(scaleable);
fontModule->scaleTypewriterLA->setEnabled(scaleable);
@ -2680,12 +2697,12 @@ void GuiDocument::applyView()
fromqstr(fontModule->fontsTypewriterCO->
itemData(fontModule->fontsTypewriterCO->currentIndex()).toString());
if (fontModule->fontencCO->currentIndex() == 0)
bp_.fontenc = "global";
else if (fontModule->fontencCO->currentIndex() == 1)
QString const fontenc =
fontModule->fontencCO->itemData(fontModule->fontencCO->currentIndex()).toString();
if (fontenc == "custom")
bp_.fontenc = fromqstr(fontModule->fontencLE->text());
else if (fontModule->fontencCO->currentIndex() == 2)
bp_.fontenc = "default";
else
bp_.fontenc = fromqstr(fontenc);
bp_.fonts_cjk =
fromqstr(fontModule->cjkFontLE->text());
@ -3136,11 +3153,9 @@ void GuiDocument::paramsToDialog()
if (nn >= 0)
fontModule->fontsDefaultCO->setCurrentIndex(nn);
if (bp_.fontenc == "global") {
fontModule->fontencCO->setCurrentIndex(0);
fontModule->fontencLE->setEnabled(false);
} else if (bp_.fontenc == "default") {
fontModule->fontencCO->setCurrentIndex(2);
if (bp_.fontenc == "global" || bp_.fontenc == "default") {
fontModule->fontencCO->setCurrentIndex(
fontModule->fontencCO->findData(toqstr(bp_.fontenc)));
fontModule->fontencLE->setEnabled(false);
} else {
fontModule->fontencCO->setCurrentIndex(1);
@ -3599,61 +3614,29 @@ void GuiDocument::saveAsDefault() const
}
bool GuiDocument::isFontAvailable(string const & font) const
{
if (font == "default" || font == "cmr"
|| font == "cmss" || font == "cmtt")
// these are standard
return true;
if (font == "lmodern" || font == "lmss" || font == "lmtt")
return LaTeXFeatures::isAvailable("lmodern");
if (font == "times" || font == "palatino"
|| font == "helvet" || font == "courier")
return LaTeXFeatures::isAvailable("psnfss");
if (font == "cmbr" || font == "cmtl")
return LaTeXFeatures::isAvailable("cmbright");
if (font == "utopia")
return LaTeXFeatures::isAvailable("utopia")
|| LaTeXFeatures::isAvailable("fourier");
if (font == "beraserif" || font == "berasans"
|| font == "beramono")
return LaTeXFeatures::isAvailable("bera");
return LaTeXFeatures::isAvailable(font);
}
bool GuiDocument::providesOSF(string const & font) const
bool GuiDocument::providesOSF(QString const & font) const
{
if (fontModule->osFontsCB->isChecked())
// FIXME: we should check if the fonts really
// have OSF support. But how?
return true;
if (font == "cmr")
return isFontAvailable("eco");
if (font == "palatino")
return isFontAvailable("mathpazo");
return false;
return theLaTeXFonts().getLaTeXFont(qstring_to_ucs4(font)).providesOSF(ot1());
}
bool GuiDocument::providesSC(string const & font) const
bool GuiDocument::providesSC(QString const & font) const
{
if (fontModule->osFontsCB->isChecked())
return false;
if (font == "palatino")
return isFontAvailable("mathpazo");
if (font == "utopia")
return isFontAvailable("fourier");
return false;
return theLaTeXFonts().getLaTeXFont(qstring_to_ucs4(font)).providesSC(ot1());
}
bool GuiDocument::providesScale(string const & font) const
bool GuiDocument::providesScale(QString const & font) const
{
if (fontModule->osFontsCB->isChecked())
return true;
return font == "helvet" || font == "luximono"
|| font == "berasans" || font == "beramono";
return theLaTeXFonts().getLaTeXFont(qstring_to_ucs4(font)).providesScale(ot1());
}

14
src/frontends/qt4/GuiDocument.h
View File

@ -228,14 +228,12 @@ private:
void setLanguage() const;
///
void saveAsDefault() const;
///
bool isFontAvailable(std::string const & font) const;
/// does this font provide Old Style figures?
bool providesOSF(std::string const & font) const;
bool providesOSF(QString const & font) const;
/// does this font provide true Small Caps?
bool providesSC(std::string const & font) const;
bool providesSC(QString const & font) const;
/// does this font provide size adjustment?
bool providesScale(std::string const & font) const;
bool providesScale(QString const & font) const;
///
void executeBranchRenaming() const;
///
@ -246,6 +244,12 @@ private:
///
void updateUnknownBranches();
///
void updateTexFonts();
///
void updateFontOptions();
///
bool ot1() const;
///
BufferParams bp_;
/// List of names of available modules
std::list<modInfoStruct> moduleNames_;