src/frontends/controllers/ControlMath.C

   1 /**
   2  * \file ControlMath.C
   3  * This file is part of LyX, the document processor.
   4  * Licence details can be found in the file COPYING.
   5  *
   6  * \author Angus Leeming
   7  *
   8  * Full author contact details are available in file CREDITS.
   9  */
  10
  11 #include <config.h>
  12
  13 #include "ControlMath.h"
  14 #include "debug.h"
  15 #include "funcrequest.h"
  16
  17 #include "support/lyxalgo.h" // sorted
  18 #include "support/lstrings.h"
  19 #include "support/filetools.h"
  20
  21 #include <functional>
  22
  23 using std::string;
  24
  25 namespace lyx {
  26
  27 using support::compare;
  28 using support::libFileSearch;
  29 using support::subst;
  30
  31 namespace frontend {
  32
  33 ControlMath::ControlMath(Dialog & dialog)
  34         : Dialog::Controller(dialog)
  35 {}
  36
  37
  38 void ControlMath::dispatchFunc(kb_action action, string const & arg) const
  39 {
  40         kernel().dispatch(FuncRequest(action, arg));
  41 }
  42
  43
  44 void ControlMath::dispatchInsert(string const & name) const
  45 {
  46         dispatchFunc(LFUN_MATH_INSERT, '\\' + name);
  47 }
  48
  49
  50 void ControlMath::dispatchSubscript() const
  51 {
  52         dispatchFunc(LFUN_MATH_INSERT, "_");
  53 }
  54
  55
  56 void ControlMath::dispatchSuperscript() const
  57 {
  58         dispatchFunc(LFUN_MATH_INSERT, "^");
  59 }
  60
  61
  62 void ControlMath::dispatchCubeRoot() const
  63 {
  64         dispatchFunc(LFUN_MATH_INSERT, "\\root");
  65         dispatchFunc(LFUN_SELF_INSERT, "3");
  66         dispatchFunc(LFUN_CHAR_FORWARD);
  67 }
  68
  69
  70 void ControlMath::dispatchMatrix(string const & str) const
  71 {
  72         dispatchFunc(LFUN_MATH_MATRIX, str);
  73 }
  74
  75
  76 void ControlMath::dispatchDelim(string const & str) const
  77 {
  78         dispatchFunc(LFUN_MATH_DELIM, str);
  79 }
  80
  81
  82 void ControlMath::dispatchBigDelim(string const & str) const
  83 {
  84         dispatchFunc(LFUN_MATH_BIGDELIM, str);
  85 }
  86
  87
  88 void ControlMath::dispatchToggleDisplay() const
  89 {
  90         dispatchFunc(LFUN_MATH_DISPLAY);
  91 }
  92
  93
  94 void ControlMath::showDialog(string const & name) const
  95 {
  96         dispatchFunc(LFUN_DIALOG_SHOW, name);
  97 }
  98
  99
 100 char const * function_names[] = {
 101         "arccos", "arcsin", "arctan", "arg", "bmod",
 102         "cos", "cosh", "cot", "coth", "csc", "deg",
 103         "det", "dim", "exp", "gcd", "hom", "inf", "ker",
 104         "lg", "lim", "liminf", "limsup", "ln", "log",
 105         "max", "min", "sec", "sin", "sinh", "sup",
 106         "tan", "tanh", "Pr", ""
 107 };
 108
 109 int const nr_function_names = sizeof(function_names) / sizeof(char const *) - 1;
 110
 111 char const * latex_dots[] = {
 112         "ldots", "cdots", "vdots", "ddots", ""
 113 };
 114
 115 int const nr_latex_dots = sizeof(latex_dots) / sizeof(char const *) - 1;
 116
 117 char const * latex_deco[] = {
 118         "widehat", "widetilde", "overbrace", "overleftarrow", "overrightarrow",
 119         "overline", "underbrace", "underline", "underleftarrow", "underrightarrow",
 120         "underleftrightarrow", "overleftrightarrow",
 121         "hat", "acute", "bar", "dot",
 122         "check", "grave", "vec", "ddot",
 123         "breve", "tilde", "overset", "underset", ""
 124 };
 125
 126 int const nr_latex_deco = sizeof(latex_deco) / sizeof(char const *) - 1;
 127
 128 char const * latex_arrow[] = {
 129         "downarrow", "leftarrow", "Downarrow", "Leftarrow",
 130         "hookleftarrow", "rightarrow", "uparrow", "Rightarrow", "Uparrow",
 131         "hookrightarrow", "updownarrow", "Leftrightarrow", "leftharpoonup",
 132         "rightharpoonup", "rightleftharpoons", "leftrightarrow", "Updownarrow",
 133         "leftharpoondown", "rightharpoondown", "mapsto",
 134         "Longleftarrow", "Longrightarrow", "Longleftrightarrow",
 135         "longleftrightarrow", "longleftarrow", "longrightarrow", "longmapsto",
 136         "nwarrow", "nearrow", "swarrow", "searrow",  "",
 137 };
 138
 139 int const nr_latex_arrow = sizeof(latex_arrow) / sizeof(char const *);
 140
 141 char const * latex_bop[] = {
 142         "pm", "cap", "diamond", "oplus",
 143         "mp", "cup", "bigtriangleup", "ominus",
 144         "times", "uplus", "bigtriangledown", "otimes",
 145         "div", "sqcap", "triangleright", "oslash",
 146         "cdot", "sqcup", "triangleleft", "odot",
 147         "star", "vee", "amalg", "bigcirc",
 148         "setminus", "wedge", "dagger", "circ",
 149         "bullet", "wr", "ddagger", ""
 150 };
 151
 152 int const nr_latex_bop = sizeof(latex_bop) / sizeof(char const *);
 153
 154 char const * latex_brel[] = {
 155         "leq", "geq", "equiv", "models",
 156         "prec", "succ", "sim", "perp",
 157         "preceq", "succeq", "simeq", "mid",
 158         "ll", "gg", "asymp", "parallel",
 159         "subset", "supset", "approx", "smile",
 160         "subseteq", "supseteq", "cong", "frown",
 161         "sqsubseteq", "sqsupseteq", "doteq", "neq",
 162         "in", "ni", "propto", "notin",
 163         "vdash", "dashv", "bowtie", ""
 164 };
 165
 166 int const nr_latex_brel = sizeof(latex_brel) / sizeof(char const *);
 167
 168 char const * latex_greek[] = {
 169         "Gamma", "Delta", "Theta", "Lambda", "Xi", "Pi",
 170         "Sigma", "Upsilon", "Phi", "Psi", "Omega",
 171         "alpha", "beta", "gamma", "delta", "epsilon", "varepsilon", "zeta",
 172         "eta", "theta", "vartheta", "iota", "kappa", "lambda", "mu",
 173         "nu", "xi", "pi", "varpi", "rho", "sigma", "varsigma",
 174         "tau", "upsilon", "phi", "varphi", "chi", "psi", "omega", ""
 175 };
 176
 177 int const nr_latex_greek = sizeof(latex_greek) / sizeof(char const *);
 178
 179 char const * latex_misc[] = {
 180         "nabla", "partial", "infty", "prime", "ell",
 181         "emptyset", "exists", "forall", "imath",  "jmath",
 182         "Re", "Im", "aleph", "wp", "hbar",
 183         "angle", "top", "bot", "Vert", "neg",
 184         "flat", "natural", "sharp", "surd", "triangle",
 185         "diamondsuit", "heartsuit", "clubsuit", "spadesuit",
 186         "textrm \\AA", "textrm \\O", "mathcircumflex", "_",
 187         "mathrm T",
 188         "mathbb N", "mathbb Z", "mathbb Q",
 189         "mathbb R", "mathbb C", "mathbb H",
 190         "mathcal F", "mathcal L",
 191         "mathcal H", "mathcal O", ""
 192 };
 193
 194 int const nr_latex_misc = sizeof(latex_misc) / sizeof(char const *);
 195
 196 char const * latex_varsz[] = {
 197         "sum", "int", "oint",
 198         "prod", "coprod", "bigsqcup",
 199         "bigotimes", "bigodot", "bigoplus",
 200         "bigcap", "bigcup", "biguplus",
 201         "bigvee", "bigwedge", ""
 202 };
 203
 204 int const nr_latex_varsz = sizeof(latex_varsz) / sizeof(char const *);
 205
 206 char const * latex_ams_misc[] = {
 207         "digamma", "varkappa", "beth", "daleth", "gimel",
 208         "ulcorner", "urcorner", "llcorner", "lrcorner",
 209         "hbar", "hslash", "vartriangle",
 210         "triangledown", "square", "lozenge",
 211         "circledS", "angle", "measuredangle",
 212         "nexists", "mho", "Finv",
 213         "Game", "Bbbk", "backprime",
 214         "varnothing", "blacktriangle", "blacktriangledown",
 215         "blacksquare", "blacklozenge", "bigstar",
 216         "sphericalangle", "complement", "eth",
 217         "diagup", "diagdown", ""
 218 };
 219
 220 int const nr_latex_ams_misc = sizeof(latex_ams_misc) / sizeof(char const *);
 221
 222 char const * latex_ams_arrows[] = {
 223         "dashrightarrow", "dashleftarrow", "leftleftarrows",
 224         "leftrightarrows", "Lleftarrow", "twoheadleftarrow",
 225         "leftarrowtail", "looparrowleft", "leftrightharpoons",
 226         "curvearrowleft", "circlearrowleft", "Lsh",
 227         "upuparrows", "upharpoonleft", "downharpoonleft",
 228         "multimap", "leftrightsquigarrow", "rightrightarrows",
 229         "rightleftarrows", "rightrightarrows", "rightleftarrows",
 230         "twoheadrightarrow", "rightarrowtail", "looparrowright",
 231         "rightleftharpoons", "curvearrowright", "circlearrowright",
 232         "Rsh", "downdownarrows", "upharpoonright",
 233         "downharpoonright", "rightsquigarrow",
 234         "nleftarrow", "nrightarrow", "nLeftarrow",
 235         "nRightarrow", "nleftrightarrow", "nLeftrightarrow", ""
 236 };
 237
 238 int const nr_latex_ams_arrows = sizeof(latex_ams_arrows) / sizeof(char const *);
 239
 240 char const * latex_ams_rel[] = {
 241         "leqq", "leqslant", "eqslantless", "eqslantgtr", "gtrsim", "gtrapprox",
 242         "lesssim", "lessapprox", "approxeq", "gtrdot", "ggg", "gtrless",
 243         "lessdot", "lll", "lessgtr", "gtreqless", "gtreqqless", "eqcirc",
 244         "lesseqgtr", "lesseqqgtr", "doteqdot", "circeq", "triangleq", "thicksim",
 245         "risingdotseq", "fallingdotseq", "backsim", "thickapprox", "supseteqq", "Supset",
 246         "backsimeq", "subseteqq", "Subset", "sqsupset", "succcurlyeq", "curlyeqsucc",
 247         "sqsubset", "preccurlyeq", "curlyeqprec", "succsim", "succapprox", "vartriangleright",
 248         "precsim", "precapprox", "vartriangleleft", "trianglerighteq", "Vdash", "shortmid",
 249         "trianglelefteq", "vDash", "Vvdash", "shortparallel", "between", "pitchfork",
 250         "smallsmile", "smallfrown", "bumpeq", "varpropto", "blacktriangleleft", "therefore",
 251         "Bumpeq", "geqq", "geqslant", "backepsilon", "blacktriangleright", "because", ""
 252 };
 253
 254 int const nr_latex_ams_rel = sizeof(latex_ams_rel) / sizeof(char const *);
 255
 256 char const * latex_ams_nrel[] = {
 257         "nless", "nleq", "nleqslant", "ngeqslant", "ngeqq", "gneq",
 258         "nleqq", "lneq", "lneqq", "gneqq", "gvertneqq", "gnsim",
 259         "lvertneqq", "lnsim", "lnapprox", "gnapprox", "nsucc", "nsucceq",
 260         "nprec", "npreceq", "precnsim","succnsim", "succnapprox", "ncong",
 261         "precnapprox", "nsim", "nshortmid", "nshortparallel", "nparallel", "nvDash",
 262
 263         "nmid", "nvdash", "nvDash", "nVDash", "ntriangleright", "ntrianglerighteq",
 264         "ntriangleleft", "ntrianglelefteq", "nsubseteq", "nsupseteq", "nsupseteqq", "supsetneq",
 265         "subsetneq", "varsubsetneq", "subsetneqq", "varsupsetneq", "supsetneqq", "varsupsetneqq",
 266         "varsubsetneqq", "ngtr", "ngeq", "", "", ""
 267 };
 268
 269 int const nr_latex_ams_nrel = sizeof(latex_ams_nrel) / sizeof(char const *);
 270
 271
 272 char const * latex_ams_ops[] = {
 273         "dotplus", "smallsetminus", "Cap",
 274         "Cup", "barwedge", "veebar",
 275         "doublebarwedge", "boxminus", "boxtimes",
 276         "boxdot", "boxplus", "divideontimes",
 277         "ltimes", "rtimes", "leftthreetimes",
 278         "rightthreetimes", "curlywedge", "curlyvee",
 279         "circleddash", "circledast", "circledcirc",
 280         "centerdot", "intercal", ""
 281 };
 282
 283 int const nr_latex_ams_ops = sizeof(latex_ams_ops) / sizeof(char const *);
 284
 285
 286 namespace {
 287
 288 struct XPMmap {
 289         char const * key;
 290         char const * value;
 291 };
 292
 293
 294 bool operator<(XPMmap const & lhs, XPMmap const & rhs)
 295 {
 296                 return compare(lhs.key, rhs.key) < 0;
 297 }
 298
 299
 300 class CompareKey : public std::unary_function<XPMmap, bool> {
 301 public:
 302         CompareKey(string const & name) : name_(name) {}
 303         bool operator()(XPMmap const & other) const {
 304                 return other.key == name_;
 305         }
 306 private:
 307         string const name_;
 308 };
 309
 310
 311 XPMmap sorted_xpm_map[] = {
 312         { "Bumpeq", "bumpeq2" },
 313         { "Cap", "cap2" },
 314         { "Cup", "cup2" },
 315         { "Delta", "delta2" },
 316         { "Downarrow", "downarrow2" },
 317         { "Gamma", "gamma2" },
 318         { "Lambda", "lambda2" },
 319         { "Leftarrow", "leftarrow2" },
 320         { "Leftrightarrow", "leftrightarrow2" },
 321         { "Longleftarrow", "longleftarrow2" },
 322         { "Longleftrightarrow", "longleftrightarrow2" },
 323         { "Longrightarrow", "longrightarrow2" },
 324         { "Omega", "omega2" },
 325         { "Phi", "phi2" },
 326         { "Pi", "pi2" },
 327         { "Psi", "psi2" },
 328         { "Rightarrow", "rightarrow2" },
 329         { "Sigma", "sigma2" },
 330         { "Subset", "subset2" },
 331         { "Supset", "supset2" },
 332         { "Theta", "theta2" },
 333         { "Uparrow", "uparrow2" },
 334         { "Updownarrow", "updownarrow2" },
 335         { "Upsilon", "upsilon2" },
 336         { "Vdash", "vdash3" },
 337         { "Xi", "xi2" },
 338         { "nLeftarrow", "nleftarrow2" },
 339         { "nLeftrightarrow", "nleftrightarrow2" },
 340         { "nRightarrow", "nrightarrow2" },
 341         { "nVDash", "nvdash3" },
 342         { "nvDash", "nvdash2" },
 343         { "textrm \\AA", "textrm_AA"},
 344         { "textrm \\O", "textrm_Oe"},
 345         { "vDash", "vdash2" }
 346 };
 347
 348 size_t const nr_sorted_xpm_map = sizeof(sorted_xpm_map) / sizeof(XPMmap);
 349
 350 } // namespace anon
 351
 352
 353 string const find_xpm(string const & name)
 354 {
 355         XPMmap const * const begin = sorted_xpm_map;
 356         XPMmap const * const end = begin + nr_sorted_xpm_map;
 357         BOOST_ASSERT(sorted(begin, end));
 358
 359         XPMmap const * const it =
 360                 std::find_if(begin, end, CompareKey(name));
 361
 362         string xpm_name;
 363         if (it != end)
 364                 xpm_name = it->value;
 365         else {
 366                 xpm_name = subst(name, "_", "underscore");
 367                 xpm_name = subst(xpm_name, ' ', '_');
 368
 369                 // This way we can have "math-delim { }" on the toolbar.
 370                 xpm_name = subst(xpm_name, "(", "lparen");
 371                 xpm_name = subst(xpm_name, ")", "rparen");
 372                 xpm_name = subst(xpm_name, "[", "lbracket");
 373                 xpm_name = subst(xpm_name, "]", "rbracket");
 374                 xpm_name = subst(xpm_name, "{", "lbrace");
 375                 xpm_name = subst(xpm_name, "}", "rbrace");
 376                 xpm_name = subst(xpm_name, "|", "bars");
 377         }
 378
 379         lyxerr[Debug::GUI] << "find_xpm(" << name << ")\n"
 380                            << "Looking for math XPM called \""
 381                            << xpm_name << '"' << std::endl;
 382
 383         return libFileSearch("images/math/", xpm_name, "xpm");
 384 }
 385
 386 } // namespace frontend
 387 } // namespace lyx