From 0cf717d0c8ba3d766acb45c3adfcc0de1f3b79db Mon Sep 17 00:00:00 2001 From: Dekel Tsur Date: Thu, 30 Aug 2001 22:42:26 +0000 Subject: [PATCH] More fonts in mathed. Please test. git-svn-id: svn://svn.lyx.org/lyx/lyx-devel/trunk@2632 a592a061-630c-0410-9148-cb99ea01b6c8 --- development/tools/generate_symbols_list.py | 114 ++++++++ development/tools/x-font | 106 ++++++++ src/ChangeLog | 9 + src/FontInfo.C | 4 +- src/FontLoader.C | 52 +++- src/FontLoader.h | 7 +- src/Painter.C | 2 +- src/font.C | 2 +- src/lyxfont.C | 13 +- src/lyxfont.h | 30 +++ src/mathed/ChangeLog | 5 + src/mathed/math_charinset.C | 15 ++ src/mathed/math_decorationinset.C | 3 +- src/mathed/math_defs.h | 14 +- src/mathed/math_factory.C | 75 +++--- src/mathed/math_hash.C | 299 +++++++-------------- src/mathed/math_macrotable.C | 53 ++-- src/mathed/math_parser.h | 21 +- src/mathed/math_symbolinset.C | 58 +++- src/mathed/math_symbolinset.h | 7 + src/mathed/support.C | 165 +++++++----- src/mathed/support.h | 3 +- 22 files changed, 706 insertions(+), 351 deletions(-) create mode 100644 development/tools/generate_symbols_list.py create mode 100644 development/tools/x-font diff --git a/development/tools/generate_symbols_list.py b/development/tools/generate_symbols_list.py new file mode 100644 index 0000000000..ee9b3abbf0 --- /dev/null +++ b/development/tools/generate_symbols_list.py @@ -0,0 +1,114 @@ +#!/usr/bin/python +import sys,string,re,os + +def is_prefix(a, b): + return a[:len(b)] == b + +def get_code(code, font): + if code < 10: + return code+161 + elif code < 32: + return code+163 + else: + return code + +font_names = {} +symbols = {} +xsymbols = {} + +ignore_list = ["not", "braceld", "bracerd", "bracelu", "braceru", + "lmoustache", "rmoustache", "lgroup", "rgroup", "bracevert"] + +def process(file): + fh = open(file) + lines = fh.readlines() + fh.close() + + n = len(lines) + for i in xrange(n): + line = lines[i] + next_line = "" + if i+1 < n: + next_line = lines[i+1] + + # some entries are spread over two lines so we join the next line + # to the current one, (if current line contains a comment, we remove it) + line = string.split(line,'%')[0]+next_line + + mo = re.match(r'.*\\DeclareSymbolFont\s*\{(.*?)\}\s*\{(.*?)\}\s*\{(.*?)\}.*', line) + if mo != None: + font_names[mo.group(1)] = mo.group(3) + + mo = re.match(r'.*\\DeclareMath(Symbol|Delimiter)\s*\{?\\(\w*?)\}?\s*\{?\\(.*?)\}?\s*\{(.*?)\}\s*\{"(.*?)\}.*', line) + if mo != None: + symbol = mo.group(2) + type = mo.group(3) + font = mo.group(4) + code = mo.group(5) + else: + mo = re.match(r'.*\\edef\\(\w*?)\{.*?\{\\hexnumber@\\sym(.*?)\}(.*?)\}', line) + if mo != None: + symbol = mo.group(1) + type = "mathord" + font = mo.group(2) + code = mo.group(3) + + if mo != None and symbol not in ignore_list: + mo2 = re.match(r'\s*\\def\\(.*?)\{', next_line) + if mo2 != None and is_prefix(symbol,mo2.group(1)): + sys.stderr.write("%s -> %s\n" % (symbol, mo2.group(1))) + symbol = mo2.group(1) + + if font_names.has_key(font): + font = font_names[font] + + code = get_code(string.atoi(code, 16), font) + if code == 0: + continue + + xcode = 0 + if xsymbols.has_key(symbol): + xcode = xsymbols[symbol] + del xsymbols[symbol] + + if symbols.has_key(symbol): + sys.stderr.write(symbol+ " exists\n") + if code != symbols[symbol]: + sys.stderr.write("code is not equal!!!\n") + else: + symbols[symbol] = code + print "%-18s %-4s %3d %3d %-6s" % (symbol,font,code,xcode,type) + + +path = os.path.split(sys.argv[0])[0] +fh = open(os.path.join(path, "x-font")) +lines = fh.readlines() +fh.close() +for line in lines: + x = string.split(line) + symbol = x[0] + code = string.atoi(x[1],16) + xsymbols[symbol] = code + +for file in sys.argv[1:]: + print "# Generated from " + os.path.basename(file) + "\n" + process(file) + print + +exceptions = [ + ("neq", "none", 0, 185, "mathrel"), + ("textdegree", "none", 0, 176, "mathord"), + ("cong", "none", 0, 64, "mathrel"), + ("surd", "note", 0, 214, "mathord") +] + +if xsymbols.has_key("leq"): + sys.exit(0) + +for x in exceptions: + print "%-18s %-4s %3d %3d %-6s" % x + if xsymbols.has_key(x[0]): + del xsymbols[x[0]] + +for symbol in xsymbols.keys(): + sys.stderr.write(symbol+"\n") diff --git a/development/tools/x-font b/development/tools/x-font new file mode 100644 index 0000000000..43bdef7890 --- /dev/null +++ b/development/tools/x-font @@ -0,0 +1,106 @@ +forall 22 +sharp 23 +exists 24 +ni 27 +cong 40 +Delta 44 +Phi 46 +Gamma 47 +vartheta 4a +Lambda 4c +Pi 50 +Theta 51 +Sigma 53 +varsigma 56 +Omega 57 +Xi 58 +Psi 59 +therefore 5c +bot 5e +alpha 61 +beta 62 +chi 63 +delta 64 +varepsilon 65 +phi 66 +gamma 67 +eta 68 +iota 69 +varphi 6a +kappa 6b +lambda 6c +mu 6d +nu 6e +pi 70 +theta 71 +rho 72 +sigma 73 +tau 74 +upsilon 75 +varpi 76 +omega 77 +xi 78 +psi 79 +zeta 7a +mid 7c +sim 7e +Upsilon a1 +prime a2 +leq a3 +infty a5 +clubsuit a7 +diamondsuit a8 +heartsuit a9 +spadesuit aa +leftrightarrow ab +leftarrow ac +uparrow ad +rightarrow ae +downarrow af +textdegree b0 +pm b1 +geq b3 +times b4 +propto b5 +partial b6 +bullet b7 +div b8 +neq b9 +equiv ba +approx bb +aleph c0 +Im c1 +Re c2 +wp c3 +otimes c4 +oplus c5 +oslash c6 +cap c7 +cup c8 +supset c9 +supseteq ca +subset cc +subseteq cd +in ce +angle d0 +nabla d1 +prod d5 +surd d6 +cdot d7 +neg d8 +wedge d9 +vee da +Leftrightarrow db +Leftarrow dc +Uparrow dd +Rightarrow de +Downarrow df +diamond e0 +langle e1 +sum e5 +lceil e9 +lfloor eb +rangle f1 +int f2 +rceil f9 +rfloor fb diff --git a/src/ChangeLog b/src/ChangeLog index aed3547761..fb236df1ae 100644 --- a/src/ChangeLog +++ b/src/ChangeLog @@ -1,3 +1,12 @@ +2001-08-31 Dekel Tsur + + * FontLoader.C (getFontinfo): Handle latex symbol fonts. + (available): New method. + + * FontInfo.C (getFontname): Use scalable fonts even when + lyxrc.use_scalable_fonts is false, if no non-scalable fonts was + found. + 2001-08-23 Angus Leeming * converter.C (Formats::view): reverted! Incorrect fix. diff --git a/src/FontInfo.C b/src/FontInfo.C index b27ed69246..03e00a7d40 100644 --- a/src/FontInfo.C +++ b/src/FontInfo.C @@ -50,7 +50,7 @@ string const FontInfo::getFontname(int size) } } - if (scalable && lyxrc.use_scalable_fonts) { + if (scalable && (lyxrc.use_scalable_fonts || closestind == -1)) { // We can use scalable string const font = resize(strings[scaleindex], size); lyxerr[Debug::FONT] << "Using scalable font to get\n" @@ -60,7 +60,7 @@ string const FontInfo::getFontname(int size) // Did any fonts get close? if (closestind == -1) { - // No, and we are not allowed to use scalables, so... + // No, so... return string(); } diff --git a/src/FontLoader.C b/src/FontLoader.C index bdc47763ff..760013b63a 100644 --- a/src/FontLoader.C +++ b/src/FontLoader.C @@ -60,7 +60,7 @@ void FontLoader::update() void FontLoader::reset() { // Clear font infos, font structs and font metrics - for (int i1 = 0; i1 < 4; ++i1) + for (int i1 = 0; i1 < 9; ++i1) for (int i2 = 0; i2 < 2; ++i2) for (int i3 = 0; i3 < 4; ++i3) { fontinfo[i1][i2][i3] = 0; @@ -75,7 +75,7 @@ void FontLoader::reset() void FontLoader::unload() { // Unload all fonts - for (int i1 = 0; i1 < 4; ++i1) + for (int i1 = 0; i1 < 9; ++i1) for (int i2 = 0; i2 < 2; ++i2) for (int i3 = 0; i3 < 4; ++i3) { if (fontinfo[i1][i2][i3]) { @@ -103,11 +103,43 @@ void FontLoader::getFontinfo(LyXFont::FONT_FAMILY family, if (fontinfo[family][series][shape] != 0) return; - // Special code for the symbol family - if (family == LyXFont::SYMBOL_FAMILY){ - fontinfo[family][series][shape] = new FontInfo("-*-symbol-*"); - return; + // Special fonts + switch (family) + { + case LyXFont::SYMBOL_FAMILY: + fontinfo[family][series][shape] = + new FontInfo("-*-symbol-*-*-*-*-*-*-*-*-*-*-*-*"); + return; + + case LyXFont::CMSY_FAMILY: + fontinfo[family][series][shape] = + new FontInfo("-*-cmsy-*-*-*-*-*-*-*-*-*-*-*-*"); + return; + + case LyXFont::CMM_FAMILY: + fontinfo[family][series][shape] = + new FontInfo("-*-cmmi-medium-*-*-*-*-*-*-*-*-*-*-*"); + return; + + case LyXFont::CMEX_FAMILY: + fontinfo[family][series][shape] = + new FontInfo("-*-cmex-*-*-*-*-*-*-*-*-*-*-*-*"); + return; + + case LyXFont::MSA_FAMILY: + fontinfo[family][series][shape] = + new FontInfo("-*-msam-*-*-*-*-*-*-*-*-*-*-*-*"); + return; + + case LyXFont::MSB_FAMILY: + fontinfo[family][series][shape] = + new FontInfo("-*-msbm-*-*-*-*-*-*-*-*-*-*-*-*"); + return; + + default: + break; } + // Normal font. Let's search for an existing name that matches. string ffamily; @@ -282,3 +314,11 @@ XFontStruct * FontLoader::doLoad(LyXFont::FONT_FAMILY family, fontstruct[family][series][shape][size] = fs; return fs; } + + +bool FontLoader::available(LyXFont const & f) +{ + load(f.family(), f.series(), f.realShape(), f.size()); + return fontinfo[f.family()][f.series()][f.realShape()] + ->getFontname(f.size()).size(); +} diff --git a/src/FontLoader.h b/src/FontLoader.h index 0b5b2b09b3..9ddd8e1f3a 100644 --- a/src/FontLoader.h +++ b/src/FontLoader.h @@ -48,12 +48,15 @@ public: else return doLoad(family, series, shape, size); }; + /// Do we have anything matching? + bool available(LyXFont const & f); + private: /// Array of font structs - XFontStruct * fontstruct[4][2][4][10]; + XFontStruct * fontstruct[9][2][4][10]; /// Array of font infos - FontInfo * fontinfo[4][2][4]; + FontInfo * fontinfo[9][2][4]; /// Reset font handler void reset(); diff --git a/src/Painter.C b/src/Painter.C index 6c0b271bfe..7726af8365 100644 --- a/src/Painter.C +++ b/src/Painter.C @@ -284,7 +284,7 @@ PainterBase & Painter::text(int x, int y, char const * s, size_t ls, XChar2b * xs = new XChar2b[ls]; Encoding const * encoding = f.language()->encoding(); LyXFont font(f); - if (f.family() == LyXFont::SYMBOL_FAMILY) { + if (f.isSymbolFont()) { #ifdef USE_UNICODE_FOR_SYMBOLS font.setFamily(LyXFont::ROMAN_FAMILY); font.setShape(LyXFont::UP_SHAPE); diff --git a/src/font.C b/src/font.C index ef93daa5f9..c2cb085c08 100644 --- a/src/font.C +++ b/src/font.C @@ -114,7 +114,7 @@ int lyxfont::width(char const * s, size_t n, LyXFont const & f) Encoding const * encoding = f.language()->encoding(); //LyXFont const * font = &f; LyXFont font(f); - if (f.family() == LyXFont::SYMBOL_FAMILY) { + if (f.isSymbolFont()) { #ifdef USE_UNICODE_FOR_SYMBOLS //LyXFont font2 = f; font.setFamily(LyXFont::ROMAN_FAMILY); diff --git a/src/lyxfont.C b/src/lyxfont.C index c8502ea064..e00f1d004b 100644 --- a/src/lyxfont.C +++ b/src/lyxfont.C @@ -33,16 +33,16 @@ using std::endl; using std::strlen; #endif - // // Names for the GUI // namespace { -char const * GUIFamilyNames[6] = -{ N_("Roman"), N_("Sans serif"), N_("Typewriter"), N_("Symbol"), N_("Inherit"), - N_("Ignore") }; +char const * GUIFamilyNames[11] = +{ N_("Roman"), N_("Sans serif"), N_("Typewriter"), N_("Symbol"), + "cmsy", "cmm", "cmex", "msa", "msb", + N_("Inherit"), N_("Ignore") }; char const * GUISeriesNames[4] = { N_("Medium"), N_("Bold"), N_("Inherit"), N_("Ignore") }; @@ -63,8 +63,9 @@ char const * GUIMiscNames[5] = // // Strings used to read and write .lyx format files // -char const * LyXFamilyNames[6] = -{ "roman", "sans", "typewriter", "symbol", "default", "error" }; +char const * LyXFamilyNames[12] = +{ "roman", "sans", "typewriter", "symbol", "symbol2", "symbol3", + "symbolex", "fraktur", "mathscr", "mathbb", "default", "error" }; char const * LyXSeriesNames[4] = { "medium", "bold", "default", "error" }; diff --git a/src/lyxfont.h b/src/lyxfont.h index 034d4e484f..d230cfa6b4 100644 --- a/src/lyxfont.h +++ b/src/lyxfont.h @@ -45,6 +45,16 @@ public: /// SYMBOL_FAMILY, /// + CMSY_FAMILY, + /// + CMM_FAMILY, + /// + CMEX_FAMILY, + /// + MSA_FAMILY, + /// + MSB_FAMILY, + /// INHERIT_FAMILY, /// IGNORE_FAMILY @@ -200,6 +210,9 @@ public: /// bool isVisibleRightToLeft() const; + + /// + bool isSymbolFont() const; /// LyXFont & setFamily(LyXFont::FONT_FAMILY f); @@ -403,6 +416,23 @@ LyXFont::FONT_MISC_STATE LyXFont::noun() const } +inline +bool LyXFont::isSymbolFont() const +{ + switch(family()) { + case LyXFont::SYMBOL_FAMILY: + case LyXFont::CMSY_FAMILY: + case LyXFont::CMM_FAMILY: + case LyXFont::CMEX_FAMILY: + case LyXFont::MSA_FAMILY: + case LyXFont::MSB_FAMILY: + return true; + default: + return false; + } + return false; +} + /// std::ostream & operator<<(std::ostream &, LyXFont::FONT_MISC_STATE); diff --git a/src/mathed/ChangeLog b/src/mathed/ChangeLog index 4a12615a4d..5008d127e9 100644 --- a/src/mathed/ChangeLog +++ b/src/mathed/ChangeLog @@ -1,3 +1,8 @@ +2001-08-31 Dekel Tsur + + * math_hash.C: Read symbols information from external file + many files: Add support for latex symbol fonts + 2001-08-18 Dekel Tsur * math_parser.C (Parser): Eat spaces after \end_inset diff --git a/src/mathed/math_charinset.C b/src/mathed/math_charinset.C index 353f60e9e5..898868b9a3 100644 --- a/src/mathed/math_charinset.C +++ b/src/mathed/math_charinset.C @@ -13,6 +13,21 @@ #include "debug.h" +namespace { + +char const * math_font_name[] = { + "mathrm", + "mathcal", + "mathbf", + "mathsf", + "mathtt", + "mathit", + "textrm" +}; + +} + + MathCharInset::MathCharInset(char c) : char_(c), code_(nativeCode(c)) { diff --git a/src/mathed/math_decorationinset.C b/src/mathed/math_decorationinset.C index f6c7333525..11d5ff0f34 100644 --- a/src/mathed/math_decorationinset.C +++ b/src/mathed/math_decorationinset.C @@ -76,10 +76,9 @@ void MathDecorationInset::draw(Painter & pain, int x, int y) const void MathDecorationInset::write(ostream & os, bool fragile) const { - string name = key_->name; if (fragile && protect()) os << "\\protect"; - os << '\\' << name; + os << '\\' << key_->name; if (key_->id == LM_not) os << ' '; diff --git a/src/mathed/math_defs.h b/src/mathed/math_defs.h index 3ed2b92ac6..c42578fa0a 100644 --- a/src/mathed/math_defs.h +++ b/src/mathed/math_defs.h @@ -81,9 +81,19 @@ enum MathTextCodes { LM_TC_GREEK1, /// Internal code for symbols LM_TC_SYMB, - /// Internal code for symbols that get bigger in displayed math + /// internal code for symbols that get bigger in displayed math LM_TC_BSYM, /// + LM_TC_CMSY, + /// + LM_TC_CMM, + /// + LM_TC_CMEX, + /// + LM_TC_MSA, + /// + LM_TC_MSB, + /// LM_FONT_END, /// This must be < 32 @@ -124,7 +134,7 @@ enum MathInsetTypes { /// -enum MathBinaryTypes { +enum MathSymbolTypes { /// LMB_NONE = 0, /// diff --git a/src/mathed/math_factory.C b/src/mathed/math_factory.C index 4078da8ed3..fae6732e92 100644 --- a/src/mathed/math_factory.C +++ b/src/mathed/math_factory.C @@ -24,41 +24,46 @@ MathInset * createMathInset(latexkeys const * l) { switch (l->token) { - case LM_TK_NOGLYPH: - case LM_TK_NOGLYPHB: - return new MathNoglyphInset(l); - case LM_TK_BIGSYM: - return new MathBigopInset(l); - case LM_TK_FUNCLIM: - return new MathFuncLimInset(l); - case LM_TK_SPECIAL: - return new MathSpecialCharInset(l->id); - case LM_TK_SYM: - return new MathSymbolInset(l); - case LM_TK_STACK: - return new MathStackrelInset; - case LM_TK_KERN: - return new MathKernInset; - case LM_TK_BINOM: - case LM_TK_CHOOSE: - return new MathBinomInset; - case LM_TK_OVER: - case LM_TK_FRAC: - return new MathFracInset; - case LM_TK_ATOP: - return new MathFracInset(true); - case LM_TK_NOT: - return new MathNotInset; - case LM_TK_SQRT: - return new MathSqrtInset; - case LM_TK_ROOT: - return new MathRootInset; - case LM_TK_DECORATION: - return new MathDecorationInset(l); - case LM_TK_SPACE: - return new MathSpaceInset(l->id); - case LM_TK_DOTS: - return new MathDotsInset(l); + case LM_TK_NOGLYPH: + case LM_TK_NOGLYPHB: + return new MathNoglyphInset(l); + case LM_TK_BIGSYM: + return new MathBigopInset(l); + case LM_TK_FUNCLIM: + return new MathFuncLimInset(l); + case LM_TK_SPECIAL: + return new MathSpecialCharInset(l->id); + case LM_TK_SYM: + case LM_TK_CMSY: + case LM_TK_CMM: + case LM_TK_CMEX: + case LM_TK_MSA: + case LM_TK_MSB: + return new MathSymbolInset(l); + case LM_TK_STACK: + return new MathStackrelInset; + case LM_TK_KERN: + return new MathKernInset; + case LM_TK_BINOM: + case LM_TK_CHOOSE: + return new MathBinomInset; + case LM_TK_OVER: + case LM_TK_FRAC: + return new MathFracInset; + case LM_TK_ATOP: + return new MathFracInset(true); + case LM_TK_NOT: + return new MathNotInset; + case LM_TK_SQRT: + return new MathSqrtInset; + case LM_TK_ROOT: + return new MathRootInset; + case LM_TK_DECORATION: + return new MathDecorationInset(l); + case LM_TK_SPACE: + return new MathSpaceInset(l->id); + case LM_TK_DOTS: + return new MathDotsInset(l); } return new MathFuncInset(l->name); } diff --git a/src/mathed/math_hash.C b/src/mathed/math_hash.C index 140231b76c..0404da1515 100644 --- a/src/mathed/math_hash.C +++ b/src/mathed/math_hash.C @@ -1,6 +1,12 @@ #include #include "math_parser.h" +#include "lyxlex.h" +#include "debug.h" +#include "support/filetools.h" // LibFileSearch +#include "support/lyxfunctional.h" + +#include #include @@ -13,10 +19,19 @@ namespace { // This lists needs to remain sorted all the time! -latexkeys wordlist[] = +struct latexkeys_a { + /// + char const * name; + /// + short token; + /// + unsigned int id; + /// + MathSymbolTypes type; +}; + +latexkeys_a wordlist_array[] = { - //{"oint", LM_TK_BIGSYM, LM_oint, LMB_NONE}, - //{"pmod", LM_TK_SYM, 0, LMB_NONE}, {"!", LM_TK_SPACE, 0, LMB_NONE}, {"#", LM_TK_SPECIAL, '#', LMB_NONE}, {"$", LM_TK_SPECIAL, '$', LMB_NONE}, @@ -28,144 +43,52 @@ latexkeys wordlist[] = {".", LM_TK_SPECIAL, '.', LMB_NONE}, {":", LM_TK_SPACE, 2, LMB_NONE}, {";", LM_TK_SPACE, 3, LMB_NONE}, - {"Delta", LM_TK_SYM, LM_Delta, LMB_NONE}, - {"Downarrow", LM_TK_SYM, LM_Downarrow, LMB_NONE}, - {"Gamma", LM_TK_SYM, LM_Gamma, LMB_NONE}, - {"Im", LM_TK_SYM, LM_Im, LMB_NONE}, - {"Lambda", LM_TK_SYM, LM_Lambda, LMB_NONE}, - {"Leftarrow", LM_TK_SYM, LM_Leftarrow, LMB_NONE}, - {"Leftrightarrow", LM_TK_SYM, LM_Leftrightarrow, LMB_NONE}, - {"Longleftarrow", LM_TK_NOGLYPH, 0, LMB_NONE}, - {"Longleftrightarrow", LM_TK_NOGLYPH, 0, LMB_NONE}, - {"Longrightarrow", LM_TK_NOGLYPH, 0, LMB_NONE}, - {"Omega", LM_TK_SYM, LM_Omega, LMB_NONE}, - {"Phi", LM_TK_SYM, LM_Phi, LMB_NONE}, - {"Pi", LM_TK_SYM, LM_Pi, LMB_NONE}, {"Pr", LM_TK_FUNCLIM, 0, LMB_NONE}, - {"Psi", LM_TK_SYM, LM_Psi, LMB_NONE}, - {"Re", LM_TK_SYM, LM_Re, LMB_NONE}, - {"Rightarrow", LM_TK_SYM, LM_Rightarrow, LMB_NONE}, - {"Sigma", LM_TK_SYM, LM_Sigma, LMB_NONE}, - {"Theta", LM_TK_SYM, LM_Theta, LMB_NONE}, - {"Uparrow", LM_TK_SYM, LM_Uparrow, LMB_NONE}, - {"Updownarrow", LM_TK_NOGLYPH, LM_Updownarrow, LMB_NONE}, - {"Upsilon", LM_TK_SYM, LM_Upsilon, LMB_NONE}, - {"Vert", LM_TK_NOGLYPH, LM_Vert, LMB_NONE}, - {"Xi", LM_TK_SYM, LM_Xi, LMB_NONE}, {"[", LM_TK_BEGIN, LM_OT_EQUATION, LMB_NONE}, {"\\", LM_TK_NEWLINE, static_cast(-1), LMB_NONE}, // -1 needed in mathed_parse_lines! {"]", LM_TK_END, LM_OT_EQUATION, LMB_NONE}, {"_", LM_TK_SPECIAL, '_', LMB_NONE}, {"acute", LM_TK_DECORATION, LM_acute, LMB_NONE}, - {"aleph", LM_TK_SYM, LM_aleph, LMB_NONE}, - {"alpha", LM_TK_SYM, LM_alpha, LMB_NONE}, - {"amalg", LM_TK_NOGLYPH, 0, LMB_OPERATOR}, - {"angle", LM_TK_SYM, LM_angle, LMB_NONE}, - {"approx", LM_TK_SYM, LM_approx, LMB_RELATION}, {"arccos", LM_TK_FUNC, 0, LMB_NONE}, {"arcsin", LM_TK_FUNC, 0, LMB_NONE}, {"arctan", LM_TK_FUNC, 0, LMB_NONE}, {"arg", LM_TK_FUNC, 0, LMB_NONE}, - {"asymp", LM_TK_NOGLYPH, 0, LMB_RELATION}, {"atop", LM_TK_ATOP, 0, LMB_NONE}, {"backslash", LM_TK_SPECIAL, '\\', LMB_NONE}, {"bar", LM_TK_DECORATION, LM_bar, LMB_NONE}, {"begin", LM_TK_BEGIN, 0, LMB_NONE}, - {"beta", LM_TK_SYM, LM_beta, LMB_NONE}, - {"bigcap", LM_TK_NOGLYPHB, 0, LMB_NONE}, - {"bigcirc", LM_TK_NOGLYPH, 0, LMB_OPERATOR}, - {"bigcup", LM_TK_NOGLYPHB, 0, LMB_NONE}, - {"bigodot", LM_TK_NOGLYPHB, 0, LMB_NONE}, - {"bigoplus", LM_TK_NOGLYPHB, 0, LMB_NONE}, - {"bigotimes", LM_TK_NOGLYPHB, 0, LMB_NONE}, - {"bigsqcup", LM_TK_NOGLYPHB, 0, LMB_NONE}, - {"bigtriangledown", LM_TK_NOGLYPH, 0, LMB_OPERATOR}, - {"bigtriangleup", LM_TK_NOGLYPH, 0, LMB_OPERATOR}, - {"biguplus", LM_TK_NOGLYPHB, 0, LMB_NONE}, - {"bigvee", LM_TK_NOGLYPHB, 0, LMB_NONE}, - {"bigwedge", LM_TK_NOGLYPHB, 0, LMB_NONE}, {"binom", LM_TK_BINOM, 0, LMB_NONE}, {"bmod", LM_TK_FUNC, 0, LMB_NONE}, - {"bot", LM_TK_SYM, LM_bot, LMB_NONE}, - {"bowtie", LM_TK_NOGLYPH, 0, LMB_RELATION}, {"breve", LM_TK_DECORATION, LM_breve, LMB_NONE}, - {"bullet", LM_TK_SYM, LM_bullet, LMB_OPERATOR}, {"cal", LM_TK_OLDFONT, LM_TC_CAL, LMB_OPERATOR}, - {"cap", LM_TK_SYM, LM_cap, LMB_OPERATOR}, - {"cdot", LM_TK_SYM, LM_cdot, LMB_OPERATOR}, {"cdots", LM_TK_DOTS, LM_cdots, LMB_NONE}, {"check", LM_TK_DECORATION, LM_check, LMB_NONE}, - {"chi", LM_TK_SYM, LM_chi, LMB_NONE}, {"choose", LM_TK_CHOOSE, 0, LMB_NONE}, - {"circ", LM_TK_NOGLYPH, 0, LMB_OPERATOR}, - {"clubsuit", LM_TK_SYM, LM_clubsuit, LMB_NONE}, - {"cong", LM_TK_SYM, LM_cong, LMB_RELATION}, - {"coprod", LM_TK_NOGLYPHB, 0, LMB_NONE}, {"cos", LM_TK_FUNC, 0, LMB_NONE}, {"cosh", LM_TK_FUNC, 0, LMB_NONE}, {"cot", LM_TK_FUNC, 0, LMB_NONE}, {"coth", LM_TK_FUNC, 0, LMB_NONE}, {"csc", LM_TK_FUNC, 0, LMB_NONE}, - {"cup", LM_TK_SYM, LM_cup, LMB_OPERATOR}, - {"dagger", LM_TK_NOGLYPH, 0, LMB_OPERATOR}, - {"dashv", LM_TK_NOGLYPH, 0, LMB_RELATION}, - {"ddagger", LM_TK_NOGLYPH, 0, LMB_OPERATOR}, {"ddot", LM_TK_DECORATION, LM_ddot, LMB_NONE}, {"ddots", LM_TK_DOTS, LM_ddots, LMB_NONE}, {"deg", LM_TK_FUNC, 0, LMB_NONE}, - {"delta", LM_TK_SYM, LM_delta, LMB_NONE}, {"det", LM_TK_FUNCLIM, 0, LMB_NONE}, - {"diamond", LM_TK_SYM, LM_diamond, LMB_OPERATOR}, - {"diamondsuit", LM_TK_SYM, LM_diamondsuit, LMB_NONE}, {"dim", LM_TK_FUNC, 0, LMB_NONE}, //{"displaystyle", LM_TK_STY, LM_ST_DISPLAY, LMB_NONE}, - {"div", LM_TK_SYM, LM_div, LMB_OPERATOR}, {"dot", LM_TK_DECORATION, LM_dot, LMB_NONE}, - {"doteq", LM_TK_NOGLYPH, 0, LMB_RELATION}, - {"downarrow", LM_TK_SYM, LM_downarrow, LMB_NONE}, - {"ell", LM_TK_NOGLYPH, 0, LMB_NONE}, {"end", LM_TK_END, 0, LMB_NONE}, - {"epsilon", LM_TK_NOGLYPH, 0, LMB_NONE}, - {"equiv", LM_TK_SYM, LM_equiv, LMB_RELATION}, - {"eta", LM_TK_SYM, LM_eta, LMB_NONE}, - {"exists", LM_TK_SYM, LM_exists, LMB_NONE}, {"exp", LM_TK_FUNC, 0, LMB_NONE}, - {"flat", LM_TK_NOGLYPH, 0, LMB_NONE}, - {"forall", LM_TK_SYM, LM_forall, LMB_NONE}, {"frac", LM_TK_FRAC, 0, LMB_NONE}, - {"frown", LM_TK_NOGLYPH, 0, LMB_RELATION}, - {"gamma", LM_TK_SYM, LM_gamma, LMB_NONE}, {"gcd", LM_TK_FUNCLIM, 0, LMB_NONE}, - {"geq", LM_TK_SYM, LM_geq, LMB_RELATION}, {"grave", LM_TK_DECORATION, LM_grave, LMB_NONE}, {"hat", LM_TK_DECORATION, LM_hat, LMB_NONE}, - {"hbar", LM_TK_NOGLYPH, 0, LMB_NONE}, - {"heartsuit", LM_TK_SYM, LM_heartsuit, LMB_NONE}, {"hom", LM_TK_FUNC, 0, LMB_NONE}, - {"hookleftarrow", LM_TK_NOGLYPH, 0, LMB_NONE}, - {"hookrightarrow", LM_TK_NOGLYPH, 0, LMB_NONE}, - {"imath", LM_TK_NOGLYPH, 0, LMB_NONE}, - {"in", LM_TK_SYM, LM_in, LMB_RELATION}, {"inf", LM_TK_FUNCLIM, 0, LMB_NONE}, - {"infty", LM_TK_SYM, LM_infty, LMB_NONE}, - {"int", LM_TK_BIGSYM, LM_int, LMB_NONE}, - {"iota", LM_TK_SYM, LM_iota, LMB_NONE}, - {"jmath", LM_TK_NOGLYPH, 0, LMB_NONE}, - {"kappa", LM_TK_SYM, LM_kappa, LMB_NONE}, {"ker", LM_TK_FUNC, 0, LMB_NONE}, {"kern", LM_TK_KERN, 0, LMB_NONE}, {"label", LM_TK_LABEL, 0, LMB_NONE}, - {"lambda", LM_TK_SYM, LM_lambda, LMB_NONE}, - {"langle", LM_TK_SYM, LM_langle, LMB_NONE}, - {"lceil", LM_TK_SYM, LM_lceil, LMB_NONE}, {"ldots", LM_TK_DOTS, LM_ldots, LMB_NONE}, {"left", LM_TK_LEFT, 0, LMB_NONE}, - {"leftarrow", LM_TK_SYM, LM_leftarrow, LMB_NONE}, - {"leftharpoondown", LM_TK_NOGLYPH, 0, LMB_NONE}, - {"leftharpoonup", LM_TK_NOGLYPH, 0, LMB_NONE}, - {"leftrightarrow", LM_TK_SYM, LM_leftrightarrow, LMB_NONE}, - {"leq", LM_TK_SYM, LM_leq, LMB_RELATION}, - {"lfloor", LM_TK_SYM, LM_lfloor, LMB_NONE}, {"lg", LM_TK_FUNC, 0, LMB_NONE}, {"lim", LM_TK_FUNCLIM, 0, LMB_NONE}, {"liminf", LM_TK_FUNCLIM, 0, LMB_NONE}, @@ -173,11 +96,6 @@ latexkeys wordlist[] = {"limsup", LM_TK_FUNCLIM, 0, LMB_NONE}, {"ln", LM_TK_FUNC, 0, LMB_NONE}, {"log", LM_TK_FUNC, 0, LMB_NONE}, - {"longleftarrow", LM_TK_NOGLYPH, 0, LMB_NONE}, - {"longleftrightarrow", LM_TK_NOGLYPH, 0, LMB_NONE}, - {"longmapsto", LM_TK_NOGLYPH, 0, LMB_NONE}, - {"longrightarrow", LM_TK_NOGLYPH, 0, LMB_NONE}, - {"mapsto", LM_TK_NOGLYPH, 0, LMB_NONE}, {"mathbf", LM_TK_FONT, LM_TC_BF, LMB_NONE}, {"mathcal", LM_TK_FONT, LM_TC_CAL, LMB_NONE}, {"mathit", LM_TK_FONT, LM_TC_IT, LMB_NONE}, @@ -186,153 +104,128 @@ latexkeys wordlist[] = {"mathsf", LM_TK_FONT, LM_TC_SF, LMB_NONE}, {"mathtt", LM_TK_FONT, LM_TC_TT, LMB_NONE}, {"max", LM_TK_FUNCLIM, 0, LMB_NONE}, - {"mid", LM_TK_SYM, LM_mid, LMB_RELATION}, {"min", LM_TK_FUNCLIM, 0, LMB_NONE}, - {"models", LM_TK_NOGLYPH, 0, LMB_RELATION}, - {"mp", LM_TK_NOGLYPH, 0, LMB_OPERATOR}, - {"mu", LM_TK_SYM, LM_mu, LMB_NONE}, - {"nabla", LM_TK_SYM, LM_nabla, LMB_NONE}, - {"natural", LM_TK_NOGLYPH, 0, LMB_NONE}, - {"nearrow", LM_TK_NOGLYPH, 0, LMB_NONE}, - {"neg", LM_TK_SYM, LM_neg, LMB_NONE}, - {"neq", LM_TK_SYM, LM_neq, LMB_RELATION}, {"newcommand", LM_TK_NEWCOMMAND, 0 , LMB_NONE}, - {"ni", LM_TK_SYM, LM_ni, LMB_RELATION}, {"nolimits", LM_TK_LIMIT, static_cast(-1), LMB_NONE}, {"nonumber", LM_TK_NONUM, 0, LMB_NONE}, {"not", LM_TK_NOT, LM_not, LMB_NONE}, - {"nu", LM_TK_SYM, LM_nu, LMB_NONE}, - {"nwarrow", LM_TK_NOGLYPH, 0, LMB_NONE}, - {"odot", LM_TK_NOGLYPH, 0, LMB_OPERATOR}, - {"omega", LM_TK_SYM, LM_omega, LMB_NONE}, - {"ominus", LM_TK_NOGLYPH, 0, LMB_OPERATOR}, - {"oplus", LM_TK_SYM, LM_oplus, LMB_OPERATOR}, - {"oslash", LM_TK_SYM, LM_oslash, LMB_OPERATOR}, - {"otimes", LM_TK_SYM, LM_otimes, LMB_OPERATOR}, {"over", LM_TK_OVER, 0, LMB_NONE}, {"overbrace", LM_TK_DECORATION, LM_overbrace, LMB_NONE}, {"overleftarrow", LM_TK_DECORATION, LM_overleftarrow, LMB_NONE}, {"overline", LM_TK_DECORATION, LM_overline, LMB_NONE}, {"overrightarrow", LM_TK_DECORATION, LM_overightarrow, LMB_NONE}, - {"parallel", LM_TK_NOGLYPH, 0, LMB_RELATION}, - {"partial", LM_TK_SYM, LM_partial, LMB_NONE}, - {"phi", LM_TK_SYM, LM_phi, LMB_NONE}, - {"pi", LM_TK_SYM, LM_pi, LMB_NONE}, - {"pm", LM_TK_SYM, LM_pm, LMB_OPERATOR}, - {"prec", LM_TK_NOGLYPH, 0, LMB_RELATION}, - {"preceq", LM_TK_NOGLYPH, 0, LMB_RELATION}, - {"prime", LM_TK_SYM, LM_prime, LMB_NONE}, - {"prod", LM_TK_BIGSYM, LM_prod, LMB_NONE}, - {"propto", LM_TK_SYM, LM_propto, LMB_RELATION}, {"protect", LM_TK_PROTECT, 0, LMB_RELATION}, - {"psi", LM_TK_SYM, LM_psi, LMB_NONE}, {"qquad", LM_TK_SPACE, 5, LMB_NONE}, {"quad", LM_TK_SPACE, 4, LMB_NONE}, - {"rangle", LM_TK_SYM, LM_rangle, LMB_NONE}, - {"rceil", LM_TK_SYM, LM_rceil, LMB_NONE}, - {"rfloor", LM_TK_SYM, LM_rfloor, LMB_NONE}, - {"rho", LM_TK_SYM, LM_rho, LMB_NONE}, {"right", LM_TK_RIGHT, 0, LMB_NONE}, - {"rightarrow", LM_TK_SYM, LM_rightarrow, LMB_NONE}, - {"rightharpoondown", LM_TK_NOGLYPH, 0, LMB_NONE}, - {"rightharpoonup", LM_TK_NOGLYPH, 0, LMB_NONE}, - {"rightleftharpoons", LM_TK_NOGLYPH, 0, LMB_NONE}, {"root", LM_TK_ROOT, 0, LMB_NONE}, //{"scriptscriptstyle", LM_TK_STY, LM_ST_SCRIPTSCRIPT, LMB_NONE}, //{"scriptstyle", LM_TK_STY, LM_ST_SCRIPT, LMB_NONE}, - {"searrow", LM_TK_NOGLYPH, 0, LMB_NONE}, {"sec", LM_TK_FUNC, 0, LMB_NONE}, - {"setminus", LM_TK_NOGLYPH, 0, LMB_OPERATOR}, - {"sharp", LM_TK_SYM, LM_sharp, LMB_NONE}, - {"sigma", LM_TK_SYM, LM_sigma, LMB_NONE}, - {"sim", LM_TK_SYM, LM_sim, LMB_RELATION}, - {"simeq", LM_TK_NOGLYPH, 0, LMB_RELATION}, {"sin", LM_TK_FUNC, 0, LMB_NONE}, {"sinh", LM_TK_FUNC, 0, LMB_NONE}, - {"smile", LM_TK_NOGLYPH, 0, LMB_RELATION}, - {"spadesuit", LM_TK_SYM, LM_spadesuit, LMB_NONE}, - {"sqcap", LM_TK_NOGLYPH, 0, LMB_OPERATOR}, - {"sqcup", LM_TK_NOGLYPH, 0, LMB_OPERATOR}, {"sqrt", LM_TK_SQRT, 0, LMB_NONE}, - {"sqsubseteq", LM_TK_NOGLYPH, 0, LMB_RELATION}, - {"sqsupseteq", LM_TK_NOGLYPH, 0, LMB_RELATION}, {"stackrel", LM_TK_STACK, 0, LMB_NONE}, - {"star", LM_TK_NOGLYPH, 0, LMB_OPERATOR}, - {"subset", LM_TK_SYM, LM_subset, LMB_RELATION}, - {"subseteq", LM_TK_SYM, LM_subseteq, LMB_RELATION}, - {"succ", LM_TK_NOGLYPH, 0, LMB_RELATION}, - {"succeq", LM_TK_NOGLYPH, 0, LMB_RELATION}, - {"sum", LM_TK_BIGSYM, LM_sum, LMB_NONE}, {"sup", LM_TK_FUNCLIM, 0, LMB_NONE}, - {"supset", LM_TK_SYM, LM_supset, LMB_RELATION}, - {"supseteq", LM_TK_SYM, LM_supseteq, LMB_RELATION}, - {"surd", LM_TK_SYM, LM_surd, LMB_NONE}, - {"swarrow", LM_TK_NOGLYPH, 0, LMB_NONE}, {"tan", LM_TK_FUNC, 0, LMB_NONE}, {"tanh", LM_TK_FUNC, 0, LMB_NONE}, - {"tau", LM_TK_SYM, LM_tau, LMB_NONE}, {"textrm", LM_TK_FONT, LM_TC_TEXTRM, LMB_NONE}, - {"textdegree", LM_TK_SYM, LM_textdegree, LMB_NONE}, //{"textstyle", LM_TK_STY, LM_ST_TEXT, LMB_NONE}, - {"therefore", LM_TK_SYM, LM_therefore, LMB_NONE}, - {"theta", LM_TK_SYM, LM_theta, LMB_NONE}, {"tilde", LM_TK_DECORATION, LM_tilde, LMB_NONE}, - {"times", LM_TK_SYM, LM_times, LMB_OPERATOR}, - {"top", LM_TK_NOGLYPH, 0, LMB_NONE}, - {"triangle", LM_TK_NOGLYPH, 0, LMB_NONE}, - {"triangleleft", LM_TK_NOGLYPH, 0, LMB_OPERATOR}, - {"triangleright", LM_TK_NOGLYPH, 0, LMB_OPERATOR}, {"underbrace", LM_TK_DECORATION, LM_underbrace, LMB_NONE}, {"underline", LM_TK_DECORATION, LM_underline, LMB_NONE}, - {"uparrow", LM_TK_SYM, LM_uparrow, LMB_NONE}, - {"updownarrow", LM_TK_NOGLYPH, LM_updownarrow, LMB_NONE}, - {"uplus", LM_TK_NOGLYPH, 0, LMB_OPERATOR}, - {"upsilon", LM_TK_SYM, LM_upsilon, LMB_NONE}, - {"varepsilon", LM_TK_SYM, LM_varepsilon, LMB_NONE}, - {"varphi", LM_TK_SYM, LM_varphi, LMB_NONE}, - {"varpi", LM_TK_SYM, LM_varpi, LMB_NONE}, - {"varsigma", LM_TK_SYM, LM_varsigma, LMB_NONE}, - {"vartheta", LM_TK_SYM, LM_vartheta, LMB_NONE}, - {"vdash", LM_TK_NOGLYPH, 0, LMB_RELATION}, {"vdots", LM_TK_DOTS, LM_vdots, LMB_NONE}, {"vec", LM_TK_DECORATION, LM_vec, LMB_NONE}, - {"vee", LM_TK_SYM, LM_vee, LMB_OPERATOR}, - {"wedge", LM_TK_SYM, LM_wedge, LMB_OPERATOR}, {"widehat", LM_TK_DECORATION, LM_widehat, LMB_NONE}, {"widetilde", LM_TK_DECORATION, LM_widetilde, LMB_NONE}, - {"wp", LM_TK_SYM, LM_wp, LMB_NONE}, - {"wr", LM_TK_NOGLYPH, 0, LMB_OPERATOR}, - {"xi", LM_TK_SYM, LM_xi, LMB_NONE}, - {"zeta", LM_TK_SYM, LM_zeta, LMB_NONE}, {"{", LM_TK_SPECIAL, '{', LMB_NONE}, {"|", LM_TK_UNDEF, '|', LMB_NONE}, - {"}", LM_TK_SPECIAL, '}', LMB_NONE} + {"}", LM_TK_SPECIAL, '}', LMB_NONE}, + {"", LM_TK_SPECIAL, 0, LMB_NONE} + }; -// the "Initializer": Its default constructor is executed on loading and -// sorts the list. Not exactly needed as long as the list is kept sorted -// but who knows... +std::vector wordlist; -struct init { - init() { - std::sort(wordlist, wordlist + sizeof(wordlist)/sizeof(wordlist[0])); - } -}; - -static init dummy; +bool initialized = false; } // namespace anon +void ReadSymbols(string const & filename) +{ + for(latexkeys_a * p = wordlist_array; !string(p->name).empty(); ++p) { + latexkeys tmp; + tmp.name = p->name; + tmp.token = p->token; + tmp.id = p->id; + tmp.latex_font_id = 0; + tmp.type = p->type; + wordlist.push_back(tmp); + } + + LyXLex lex(0, 0); + lex.setFile(filename); + while (lex.isOK()) { + latexkeys tmp; + string font; + string type; + + if (lex.next()) + tmp.name = lex.getString(); + else + break; + + if (lex.next()) + font = lex.getString(); + if (lex.next()) + tmp.latex_font_id = lex.getInteger(); + if (lex.next()) + tmp.id = lex.getInteger(); + if (lex.next()) + type = lex.getString(); + + if (font == "cmsy") + tmp.token = LM_TK_CMSY; + else if (font == "cmm") + tmp.token = LM_TK_CMM; + else if (font == "cmex") + tmp.token = LM_TK_CMEX; + else if (font == "msa") + tmp.token = LM_TK_MSA; + else if (font == "msb") + tmp.token = LM_TK_MSB; + else + tmp.token = LM_TK_SYM; + + if (type == "mathrel") + tmp.type = LMB_RELATION; + else if (type == "mathbin") + tmp.type = LMB_OPERATOR; + else + tmp.type = LMB_NONE; + + wordlist.push_back(tmp); + } + + std::sort(wordlist.begin(), wordlist.end()); +} + latexkeys const * in_word_set(string const & str) { -#ifdef WITH_WARNINGS -#warning Not nice yet... -#endif - latexkeys tmp; - tmp.name = str.c_str(); - int const n = sizeof(wordlist)/sizeof(wordlist[0]); - latexkeys const * pos = std::lower_bound(wordlist, wordlist + n, tmp); - return (string(pos->name) == str) ? pos : 0; + if (!initialized) { + lyxerr[Debug::MATHED] << "Reading symbols file" << endl; + string const file = LibFileSearch(string(), "symbols"); + if (file.empty()) + lyxerr << "Could not find symbols file" << endl; + else + ReadSymbols(file); + initialized = true; + } + + std::vector::iterator it = + std::find_if(wordlist.begin(), wordlist.end(), + lyx::compare_memfun(&latexkeys::Name, str)); + return (it != wordlist.end()) ? &(*it) : 0; } diff --git a/src/mathed/math_macrotable.C b/src/mathed/math_macrotable.C index 596b19f294..167b8fb809 100644 --- a/src/mathed/math_macrotable.C +++ b/src/mathed/math_macrotable.C @@ -85,23 +85,44 @@ void MathMacroTable::builtinMacros() built = true; //lyxerr[Debug::MATHED] << "Building macros\n"; - createTemplate("emptyset", 0, "\\not0"); - createTemplate("ne", 0, "\\not="); - createTemplate("ge", 0, "\\geq"); - createTemplate("gets", 0, "\\leftarrow"); - createTemplate("land", 0, "\\wedge"); - createTemplate("le", 0, "\\leq"); - createTemplate("lor", 0, "\\vee"); + //createTemplate("emptyset", 0, "\\not0"); createTemplate("notin", 0, "\\not\\in"); - createTemplate("perp", 0, "\\bot"); + + // fontmath.ltx + + createTemplate("lnot", 0, "\\neg"); + createTemplate("land", 0, "\\wedge"); + createTemplate("lor", 0, "\\vee"); + createTemplate("ne", 0, "\\neq"); + createTemplate("le", 0, "\\leq"); + createTemplate("ge", 0, "\\geq"); createTemplate("owns", 0, "\\ni"); + createTemplate("gets", 0, "\\leftarrow"); createTemplate("to", 0, "\\rightarrow"); -#ifdef WITH_WARNINGS -#warning 9em looks like too much but it is somehow working on screen.. -#endif - createTemplate("ll", 0, "<\\kern-9em<"); - createTemplate("gg", 0, ">\\kern-9em>"); - //createTemplate("lint", 4, "\\int_#1^#2#3 d#4"); - //createTemplate("silentmult", 0, "\\cdot"); - //createTemplate("binom", 2, "\\left(\\frac#1#2\\right)"); + + //amsfonts.sty + + createTemplate("dasharrow", 0, "\\dashrightarrow"); + createTemplate("Box", 0, "\\square"); + createTemplate("Diamond", 0, "\\lozenge"); + createTemplate("leadsto", 0, "\\rightsquigarrow"); + + // amssymb.sty + + createTemplate("restriction", 0, "\\upharpoonright"); + createTemplate("Doteq", 0, "\\doteqdot"); + createTemplate("doublecup", 0, "\\Cup"); + createTemplate("doublecap", 0, "\\Cap"); + createTemplate("llless", 0, "\\lll"); + createTemplate("gggtr", 0, "\\ggg"); + +// #ifdef WITH_WARNINGS +// #warning 9em looks like too much but it is somehow working on screen.. +// #endif WITH_WARNINGS +// createTemplate("ll", 0, "<\\kern-9em<"); +// createTemplate("gg", 0, ">\\kern-9em>"); + + //createTemplate("lint", 4, "\\int_#1^#2#3 d#4"); + //createTemplate("silentmult", 0, "\\cdot"); + //createTemplate("binom", 2, "\\left(\\frac#1#2\\right)"); } diff --git a/src/mathed/math_parser.h b/src/mathed/math_parser.h index 469a97f290..27f647ead4 100644 --- a/src/mathed/math_parser.h +++ b/src/mathed/math_parser.h @@ -81,6 +81,16 @@ enum MathTokenEnum /// LM_TK_NOGLYPHB, /// + LM_TK_CMSY, + /// + LM_TK_CMM, + /// + LM_TK_CMEX, + /// + LM_TK_MSA, + /// + LM_TK_MSB, + /// LM_TK_LABEL, /// LM_TK_NONUM, @@ -114,19 +124,26 @@ enum MathTokenEnum /// struct latexkeys { /// - char const * name; + string name; /// short token; /// unsigned int id; /// - int numargs; + unsigned char latex_font_id; + /// + MathSymbolTypes type; + /// + string const & Name() const { return name;} }; /// latexkeys const * in_word_set(string const & str); +/// +void ReadSymbols(string const & file); + MathMatrixInset * mathed_parse_normal(string const &); MathMatrixInset * mathed_parse_normal(std::istream &); MathMatrixInset * mathed_parse_normal(LyXLex &); diff --git a/src/mathed/math_symbolinset.C b/src/mathed/math_symbolinset.C index 6a1648ea17..9983df5dd6 100644 --- a/src/mathed/math_symbolinset.C +++ b/src/mathed/math_symbolinset.C @@ -7,8 +7,7 @@ using std::ostream; MathSymbolInset::MathSymbolInset(const latexkeys * l) - : sym_(l) -{} + : sym_(l), h_(0) {} MathInset * MathSymbolInset::clone() const @@ -29,10 +28,43 @@ void MathSymbolInset::writeNormal(ostream & os) const } +MathTextCodes MathSymbolInset::code() const +{ + switch(sym_->token) { + case LM_TK_CMSY: + return LM_TC_CMSY; + case LM_TK_CMM: + return LM_TC_CMM; + case LM_TK_CMEX: + return LM_TC_CMEX; + case LM_TK_MSA: + return LM_TC_MSA; + case LM_TK_MSB: + return LM_TC_MSB; + default: + return LM_TC_SYMB; + } +} + void MathSymbolInset::metrics(MathStyles st) const { - size(st); - mathed_char_dim(LM_TC_SYMB, size_, sym_->id, ascent_, descent_, width_); + size_ = st; + MathTextCodes Code = code(); + if (sym_->latex_font_id > 0 && math_font_available(Code)) { + mathed_char_dim(Code, size_, sym_->latex_font_id, + ascent_, descent_, width_); + if (Code == LM_TC_CMEX) { + h_ = 4*descent_/5; + ascent_ += h_; + descent_ -= h_; + } + } else if (sym_->id > 0 && sym_->id < 255 && + math_font_available(LM_TC_SYMB)) { + mathed_char_dim(LM_TC_SYMB, size_, sym_->id, + ascent_, descent_, width_); + } else { + mathed_string_dim(LM_TC_TEX, size_, sym_->name, ascent_, descent_, width_); + } } @@ -40,12 +72,24 @@ void MathSymbolInset::draw(Painter & pain, int x, int y) const { xo(x); yo(y); - - drawChar(pain, LM_TC_SYMB, size_, x, y, sym_->id); + MathTextCodes Code = code(); + if (sym_->latex_font_id > 0 && math_font_available(Code)) + drawChar(pain, Code, size_, x, y - h_, sym_->latex_font_id); + else if (sym_->id > 0 && sym_->id < 255 && + math_font_available(LM_TC_SYMB)) + drawChar(pain, LM_TC_SYMB, size_, x, y, sym_->id); + else + drawStr(pain, LM_TC_TEX, size_, x, y, sym_->name); } bool MathSymbolInset::isRelOp() const { - return sym_->id == LM_leq || sym_->id == LM_geq; + return sym_->type == LMB_RELATION; +} + + +bool MathSymbolInset::isScriptable() const +{ + return sym_->token == LM_TK_CMEX; } diff --git a/src/mathed/math_symbolinset.h b/src/mathed/math_symbolinset.h index 29254c7b0f..bd3b7b55b9 100644 --- a/src/mathed/math_symbolinset.h +++ b/src/mathed/math_symbolinset.h @@ -25,9 +25,16 @@ public: void draw(Painter &, int x, int y) const; /// bool isRelOp() const; + /// + bool isScriptable() const; private: + /// + MathTextCodes code() const; + /// latexkeys const * sym_; + /// + mutable int h_; }; #endif diff --git a/src/mathed/support.C b/src/mathed/support.C index 91528084e2..e9c587e8e6 100644 --- a/src/mathed/support.C +++ b/src/mathed/support.C @@ -4,6 +4,7 @@ #include "mathed/support.h" #include "lyxfont.h" +#include "FontLoader.h" #include "font.h" #include "math_defs.h" #include "math_parser.h" @@ -16,9 +17,9 @@ using std::endl; using std::max; -bool isBinaryOp(char c) +bool isBinaryOp(char c, MathTextCodes type) { - return strchr("+-<>=/*", c); + return type < LM_TC_SYMB && strchr("+-<>=/*", c); } @@ -98,88 +99,109 @@ void Matrix::transform(float xp, float yp, float & x, float & y) namespace { -LyXFont * Math_Fonts = 0; +LyXFont * MathFonts = 0; +bool font_available[LM_FONT_END]; +bool font_available_initialized[LM_FONT_END]; void mathed_init_fonts() { - Math_Fonts = new LyXFont[8]; //DEC cxx cannot initialize all fonts + MathFonts = new LyXFont[13]; //DEC cxx cannot initialize all fonts //at once (JMarc) rc - for (int i = 0 ; i < 8 ; ++i) { - Math_Fonts[i] = LyXFont(LyXFont::ALL_SANE); + for (int i = 0 ; i < 13 ; ++i) { + MathFonts[i] = LyXFont(LyXFont::ALL_SANE); } - Math_Fonts[0].setShape(LyXFont::ITALIC_SHAPE); + MathFonts[0].setShape(LyXFont::ITALIC_SHAPE); - Math_Fonts[1].setFamily(LyXFont::SYMBOL_FAMILY); + MathFonts[1].setFamily(LyXFont::SYMBOL_FAMILY); - Math_Fonts[2].setFamily(LyXFont::SYMBOL_FAMILY); - Math_Fonts[2].setShape(LyXFont::ITALIC_SHAPE); + MathFonts[2].setFamily(LyXFont::SYMBOL_FAMILY); + MathFonts[2].setShape(LyXFont::ITALIC_SHAPE); - Math_Fonts[3].setSeries(LyXFont::BOLD_SERIES); + MathFonts[3].setSeries(LyXFont::BOLD_SERIES); - Math_Fonts[4].setFamily(LyXFont::SANS_FAMILY); - Math_Fonts[4].setShape(LyXFont::ITALIC_SHAPE); + MathFonts[4].setFamily(LyXFont::SANS_FAMILY); + MathFonts[4].setShape(LyXFont::ITALIC_SHAPE); - Math_Fonts[5].setFamily(LyXFont::TYPEWRITER_FAMILY); + MathFonts[5].setFamily(LyXFont::TYPEWRITER_FAMILY); - Math_Fonts[6].setFamily(LyXFont::ROMAN_FAMILY); + MathFonts[6].setFamily(LyXFont::ROMAN_FAMILY); - Math_Fonts[7].setFamily(LyXFont::SANS_FAMILY); + MathFonts[7].setFamily(LyXFont::SANS_FAMILY); + + MathFonts[8].setFamily(LyXFont::CMSY_FAMILY); + MathFonts[9].setFamily(LyXFont::CMM_FAMILY); + MathFonts[10].setFamily(LyXFont::CMEX_FAMILY); + MathFonts[11].setFamily(LyXFont::MSA_FAMILY); + MathFonts[12].setFamily(LyXFont::MSB_FAMILY); + + for (int i = 0; i < LM_FONT_END; ++i) + font_available_initialized[i] = false; } -} // namespace - -LyXFont WhichFont(MathTextCodes type, MathStyles size) +LyXFont const & whichFontBase(MathTextCodes type) { - LyXFont f; - - if (!Math_Fonts) + if (!MathFonts) mathed_init_fonts(); switch (type) { case LM_TC_SYMB: case LM_TC_BSYM: - f = Math_Fonts[2]; - break; + return MathFonts[2]; case LM_TC_VAR: case LM_TC_IT: - f = Math_Fonts[0]; - break; + return MathFonts[0]; case LM_TC_BF: - f = Math_Fonts[3]; - break; - - case LM_TC_SF: - f = Math_Fonts[7]; - break; + return MathFonts[3]; case LM_TC_CAL: - f = Math_Fonts[4]; - break; + return MathFonts[4]; case LM_TC_TT: - f = Math_Fonts[5]; - break; + return MathFonts[5]; case LM_TC_TEXTRM: case LM_TC_CONST: case LM_TC_TEX: case LM_TC_RM: - f = Math_Fonts[6]; - break; + return MathFonts[6]; + + case LM_TC_SF: + return MathFonts[7]; + + case LM_TC_CMSY: + return MathFonts[8]; + + case LM_TC_CMM: + return MathFonts[9]; + + case LM_TC_CMEX: + return MathFonts[10]; + + case LM_TC_MSA: + return MathFonts[11]; + + case LM_TC_MSB: + return MathFonts[12]; default: - f = Math_Fonts[1]; break; } + return MathFonts[1]; +} + + +LyXFont whichFont(MathTextCodes type, MathStyles size) +{ + LyXFont f = whichFontBase(type); switch (size) { case LM_ST_DISPLAY: - if (type == LM_TC_BSYM) { + if (type == LM_TC_BSYM || type == LM_TC_CMEX) { f.incSize(); f.incSize(); } @@ -213,15 +235,18 @@ LyXFont WhichFont(MathTextCodes type, MathStyles size) return f; } -char const * math_font_name[] = { - "mathrm", - "mathcal", - "mathbf", - "mathsf", - "mathtt", - "mathit", - "textrm" -}; +} // namespace + + +bool math_font_available(MathTextCodes type) +{ + if (!font_available_initialized[type]) { + font_available_initialized[type] = true; + font_available[type] = + fontloader.available(whichFontBase(type)); + } + return font_available[type]; +} namespace { @@ -500,7 +525,7 @@ deco_struct const * search_deco(int code) void mathed_char_dim(MathTextCodes type, MathStyles size, unsigned char c, int & asc, int & des, int & wid) { - LyXFont const font = WhichFont(type, size); + LyXFont const font = whichFont(type, size); des = lyxfont::descent(c, font); asc = lyxfont::ascent(c, font); wid = mathed_char_width(type, size, c); @@ -510,7 +535,7 @@ void mathed_char_dim(MathTextCodes type, MathStyles size, unsigned char c, int mathed_char_height(MathTextCodes type, MathStyles size, unsigned char c, int & asc, int & des) { - LyXFont const font = WhichFont(type, size); + LyXFont const font = whichFont(type, size); des = lyxfont::descent(c, font); asc = lyxfont::ascent(c, font); return asc + des; @@ -524,23 +549,28 @@ int mathed_char_height(MathTextCodes type, MathStyles size, unsigned char c) return mathed_char_height(type, size, c, asc, des); } + int mathed_char_ascent(MathTextCodes type, MathStyles size, unsigned char c) { - LyXFont const font = WhichFont(type, size); + LyXFont const font = whichFont(type, size); return lyxfont::ascent(c, font); } + int mathed_char_descent(MathTextCodes type, MathStyles size, unsigned char c) { - LyXFont const font = WhichFont(type, size); + LyXFont const font = whichFont(type, size); return lyxfont::descent(c, font); } + int mathed_char_width(MathTextCodes type, MathStyles size, unsigned char c) { - LyXFont const font = WhichFont(type, size); - if (isBinaryOp(c)) - return lyxfont::width(c, font) + 2 * lyxfont::width(' ', font); + LyXFont const font = whichFont(type, size); + LyXFont const f1 = whichFont(LM_TC_TEXTRM, size); +#warning why f1 is used ? + if (isBinaryOp(c, type)) + return lyxfont::width(c, font) + 2 * lyxfont::width(' ', f1); else return lyxfont::width(c, font); } @@ -553,10 +583,11 @@ void mathed_string_dim(MathTextCodes type, MathStyles size, string const & s, wid = mathed_string_width(type, size, s); } + int mathed_string_height(MathTextCodes type, MathStyles size, string const & s, int & asc, int & des) { - LyXFont const font = WhichFont(type, size); + LyXFont const font = whichFont(type, size); asc = des = 0; for (string::const_iterator it = s.begin(); it != s.end(); ++it) { des = max(des, lyxfont::descent(*it, font)); @@ -565,9 +596,10 @@ int mathed_string_height(MathTextCodes type, MathStyles size, string const & s, return asc + des; } + int mathed_string_width(MathTextCodes type, MathStyles size, string const & s) { - return lyxfont::width(s, WhichFont(type, size)); + return lyxfont::width(s, whichFont(type, size)); } @@ -577,7 +609,7 @@ void mathed_draw_deco(Painter & pain, int x, int y, int w, int h, Matrix mt; Matrix sqmt; int i = 0; - string name = l->name; + string const & name = l->name; int code = (name.size() > 1) ? l->id : name[0]; if (name == ".") { @@ -589,7 +621,7 @@ void mathed_draw_deco(Painter & pain, int x, int y, int w, int h, deco_struct const * mds = search_deco(code); if (!mds) { lyxerr << "Deco was not found. Programming error?\n"; - lyxerr << "name: '" << l->name << "', code: " << code << "\n"; + lyxerr << "name: '" << name << "', code: " << code << "\n"; return; } @@ -661,11 +693,11 @@ void mathed_draw_deco(Painter & pain, int x, int y, int w, int h, } -// In a near future maybe we use a better fonts renderer +// In the future maybe we use a better fonts renderer void drawStr(Painter & pain, MathTextCodes type, MathStyles siz, int x, int y, string const & s) { - pain.text(x, y, s, WhichFont(type, siz)); + pain.text(x, y, s, whichFont(type, siz)); } @@ -673,14 +705,15 @@ void drawChar (Painter & pain, MathTextCodes type, MathStyles siz, int x, int y, char c) { string s; - if (isBinaryOp(c)) + if (isBinaryOp(c, type)) s += ' '; s += c; - if (isBinaryOp(c)) + if (isBinaryOp(c, type)) s += ' '; drawStr(pain, type, siz, x, y, s); } + // decrease math size for super- and subscripts MathStyles smallerStyleScript(MathStyles st) { @@ -692,6 +725,7 @@ MathStyles smallerStyleScript(MathStyles st) return st; } + // decrease math size for fractions MathStyles smallerStyleFrac(MathStyles st) { @@ -706,11 +740,12 @@ MathStyles smallerStyleFrac(MathStyles st) void math_font_max_dim(MathTextCodes code, MathStyles siz, int & asc, int & des) { - LyXFont font = WhichFont(code, siz); + LyXFont font = whichFont(code, siz); asc = lyxfont::maxAscent(font); des = lyxfont::maxDescent(font); } + char const * latex_mathspace[] = { "!", ",", ":", ";", "quad", "qquad" }; diff --git a/src/mathed/support.h b/src/mathed/support.h index 79248d90a7..046f285c9c 100644 --- a/src/mathed/support.h +++ b/src/mathed/support.h @@ -9,7 +9,6 @@ class Painter; class latexkeys; -extern char const * math_font_name[]; extern char const * latex_mathspace[]; int mathed_char_height(MathTextCodes type, MathStyles size, unsigned char c, @@ -40,4 +39,6 @@ void drawChar(Painter & pain, MathTextCodes type, MathStyles siz, void math_font_max_dim (MathTextCodes code, MathStyles siz, int & asc, int & desc); +bool math_font_available(MathTextCodes code); + #endif