src/frontends/xforms/MathsSymbols.C

   1 /**
   2  * \file MathsSymbols.C
   3  * Copyright 2001 the LyX Team
   4  * Read the file COPYING
   5  *
   6  * \author Alejandro Aguilar Sierra
   7  * \author John Levon
   8  */
   9
  10 #include <config.h>
  11 #include <algorithm>
  12
  13 #include XPM_H_LOCATION
  14
  15 #ifdef __GNUG__
  16 #pragma implementation
  17 #endif
  18
  19 #include "support/LAssert.h"
  20 #include "support/lstrings.h"
  21 #include "debug.h"
  22 #include "MathsSymbols.h"
  23 #include "FormMathsPanel.h"
  24
  25 using std::max;
  26 using std::endl;
  27 using std::ostream;
  28
  29 #ifndef CXX_GLOBAL_CSTD
  30 using std::strstr;
  31 #endif
  32
  33
  34 /* Latex code for those bitmaps */
  35
  36 #include "greek.xbm"
  37 #include "arrows.xbm"
  38 #include "brel.xbm"
  39 #include "bop.xbm"
  40 #include "misc.xbm"
  41 #include "varsz.xbm"
  42 #include "dots.xbm"
  43 #include "mathed/math_parser.h"
  44 #include "frac.xpm"
  45 #include "sub.xpm"
  46 #include "super.xpm"
  47 #include "style.xpm"
  48 #include "sqrt.xpm"
  49 #include "delim.xbm"
  50 #include "delim.xpm"
  51 #include "deco.xbm"
  52 #include "deco.xpm"
  53 #include "space.xpm"
  54 #include "matrix.xpm"
  55 #include "equation.xpm"
  56
  57 char const * function_names[] = {
  58         "arccos", "arcsin", "arctan", "arg", "bmod",
  59         "cos", "cosh", "cot", "coth", "csc", "deg",
  60         "det", "dim", "exp", "gcd", "hom", "inf", "ker",
  61         "lg", "lim", "liminf", "limsup", "ln", "log",
  62         "max", "min", "sec", "sin", "sinh", "sup",
  63         "tan", "tanh"
  64 };
  65
  66 int const nr_function_names = sizeof(function_names) /
  67                                      sizeof(char const *);
  68
  69 char const * latex_arrow[] = {
  70         "downarrow", "leftarrow", "Downarrow", "Leftarrow",
  71         "hookleftarrow", "rightarrow", "uparrow", "Rightarrow", "Uparrow",
  72         "hookrightarrow", "updownarrow", "Leftrightarrow", "leftharpoonup",
  73         "rightharpoonup", "rightleftharpoons", "leftrightarrow", "Updownarrow",
  74         "leftharpoondown", "rightharpoondown", "mapsto",
  75         "Longleftarrow", "Longrightarrow", "Longleftrightarrow",
  76         "longleftrightarrow", "longleftarrow", "longrightarrow", "longmapsto",
  77         "nwarrow", "nearrow", "swarrow", "searrow",  "",
  78 };
  79
  80 int const nr_latex_arrow = sizeof(latex_arrow) / sizeof(char const *);
  81
  82 char const * latex_bop[] = {
  83         "pm", "cap", "diamond", "oplus",
  84         "mp", "cup", "bigtriangleup", "ominus",
  85         "times", "uplus", "bigtriangledown", "otimes",
  86         "div", "sqcap", "triangleright", "oslash",
  87         "cdot", "sqcup", "triangleleft", "odot",
  88         "star", "vee", "amalg", "bigcirc",
  89         "setminus", "wedge", "dagger", "circ",
  90         "bullet", "wr", "ddagger", ""
  91 };
  92
  93 int const nr_latex_bop = sizeof(latex_bop) / sizeof(char const *);
  94
  95 char const * latex_brel[] = {
  96         "leq", "geq", "equiv", "models",
  97         "prec", "succ", "sim", "perp",
  98         "preceq", "succeq", "simeq", "mid",
  99         "ll", "gg", "asymp", "parallel",
 100         "subset", "supset", "approx", "smile",
 101         "subseteq", "supseteq", "cong", "frown",
 102         "sqsubseteq", "sqsupseteq", "doteq", "neq",
 103         "in", "ni", "propto", "notin",
 104         "vdash", "dashv", "bowtie", ""
 105 };
 106
 107 int const nr_latex_brel = sizeof(latex_brel) / sizeof(char const *);
 108
 109 char const * latex_dots[] = {
 110         "ldots", "cdots", "vdots", "ddots"
 111 };
 112
 113 int const nr_latex_dots = sizeof(latex_dots) / sizeof(char const *);
 114
 115 char const * latex_greek[] = {
 116         "Gamma", "Delta", "Theta", "Lambda", "Xi", "Pi",
 117         "Sigma", "Upsilon", "Phi", "Psi", "Omega",
 118         "alpha", "beta", "gamma", "delta", "epsilon", "varepsilon", "zeta",
 119         "eta", "theta", "vartheta", "iota", "kappa", "lambda", "mu",
 120         "nu", "xi", "pi", "varpi", "rho", "sigma", "varsigma",
 121         "tau", "upsilon", "phi", "varphi", "chi", "psi", "omega", ""
 122 };
 123
 124 int const nr_latex_greek = sizeof(latex_greek) / sizeof(char const *);
 125
 126 char const * latex_misc[] = {
 127         "nabla", "partial", "infty", "prime", "ell",
 128         "emptyset", "exists", "forall", "imath",  "jmath",
 129         "Re", "Im", "aleph", "wp", "hbar",
 130         "angle", "top", "bot", "Vert", "neg",
 131         "flat", "natural", "sharp", "surd", "triangle",
 132         "diamondsuit", "heartsuit", "clubsuit", "spadesuit",
 133         "mathbb N", "mathbb Z", "mathbb Q",
 134         "mathbb R", "mathbb C", "mathbb H",
 135         "mathcal F", "mathcal L",
 136         "mathcal H", "mathcal O",""
 137 };
 138
 139 int const nr_latex_misc = sizeof(latex_misc) / sizeof(char const *);
 140
 141 char const * latex_varsz[] = {
 142         "sum", "int", "oint",
 143         "prod", "coprod", "bigsqcup",
 144         "bigotimes", "bigodot", "bigoplus",
 145         "bigcap", "bigcup", "biguplus",
 146         "bigvee", "bigwedge", ""
 147 };
 148
 149 int const nr_latex_varsz = sizeof(latex_varsz) / sizeof(char const *);
 150
 151 static char const ** mathed_get_pixmap_from_icon(int d)
 152 {
 153         switch (d) {
 154                 case MM_FRAC: return frac;
 155                 case MM_SQRT: return sqrt_xpm;
 156                 case MM_SUPER: return super_xpm;
 157                 case MM_SUB: return sub_xpm;
 158                 case MM_STYLE: return style_xpm;
 159                 case MM_DELIM: return delim;
 160                 case MM_MATRIX: return matrix;
 161                 case MM_EQU: return equation;
 162                 case MM_DECO: return deco;
 163                 case MM_SPACE: return space_xpm;
 164                 default: return 0;
 165         }
 166 }
 167
 168 static char const ** pixmapFromBitmapData(char const * s, int wx, int hx)
 169 {
 170         char const ** data = 0;
 171
 172         int id = -1;
 173
 174         int i = 0;
 175         for (; i < 6; ++i) {
 176                 char const ** latex_str = 0;
 177                 switch (i) {
 178                 case 0: latex_str = latex_greek; break;
 179                 case 1: latex_str = latex_bop; break;
 180                 case 2: latex_str = latex_brel; break;
 181                 case 3: latex_str = latex_arrow; break;
 182                 case 4: latex_str = latex_varsz; break;
 183                 case 5: latex_str = latex_misc; break;
 184                 }
 185
 186                 for (int k = 0; latex_str[k][0] > ' '; ++k) {
 187                         if (compare(latex_str[k], s) == 0) {
 188                                 id = k;
 189                                 break;
 190                         }
 191                 }
 192                 if (id >= 0) break;
 193         }
 194         if (i < 6 && id >= 0) {
 195                 unsigned char const * bdata = 0;
 196                 int w = 0;
 197                 int h = 0;
 198                 int dw = 0;
 199                 int dh = 0;
 200
 201                 lyxerr[Debug::MATHED] << "Imando " << i << ", " << id << endl;
 202                 switch (i) {
 203                 case 0:
 204                         if (id <= 10) {
 205                                 w = Greek_width;
 206                                 h = Greek_height;
 207                                 bdata = Greek_bits;
 208                                 dw = 6;
 209                                 dh = 2;
 210                         } else {
 211                                 w = greek_width;
 212                                 h = greek_height;
 213                                 bdata = greek_bits;
 214                                 dw = 7;
 215                                 dh = 4;
 216                                 id -= 11;
 217                         }
 218                         break;
 219                 case 1:
 220                         w = bop_width;
 221                         h = bop_height;
 222                         bdata = bop_bits;
 223                         dw = 4;
 224                         dh = 8;
 225                         break;
 226                 case 2:
 227                         w = brel_width;
 228                         h = brel_height;
 229                         bdata = brel_bits;
 230                         dw = 4;
 231                         dh = 9;
 232                         break;
 233                 case 3:
 234                         if (id < 20) {
 235                                 w = arrow_width;
 236                                 h = arrow_height;
 237                                 bdata = arrow_bits;
 238                                 dw = 5;
 239                                 dh = 4;
 240                         } else if (id > 28) {
 241                                 w = darrow_width;
 242                                 h = darrow_height;
 243                                 bdata = darrow_bits;
 244                                 dw = 2;
 245                                 dh = 2;
 246                                 id -= 29;
 247                         } else {
 248                                 w = larrow_width;
 249                                 h = larrow_height;
 250                                 bdata = larrow_bits;
 251                                 dw = 2;
 252                                 dh = 4;
 253                                 id -= 20;
 254                         }
 255                         break;
 256                 case 4:
 257                         w = varsz_width;
 258                         h = varsz_height;
 259                         bdata = varsz_bits;
 260                         dw = 3;
 261                         dh = 5;
 262                         break;
 263                 case 5:
 264                         if (id < 29) {
 265                                 w = misc_width;
 266                                 h = misc_height;
 267                                 bdata = misc_bits;
 268                                 dw = 5;
 269                                 dh = 6;
 270                         } else if (id > 36) {
 271                                 w = misc3_width;
 272                                 h = misc3_height;
 273                                 bdata = misc3_bits;
 274                                 dw = 3;
 275                                 dh = 2;
 276                                 id -= 37;
 277                         } else {
 278                                 w = misc2_width;
 279                                 h = misc2_height;
 280                                 bdata = misc2_bits;
 281                                 dw = 2;
 282                                 dh = 2;
 283                                 id -= 29;
 284                         }
 285                         break;
 286                 }
 287                 int ww = w / dw;
 288                 int hh = h / dh;
 289                 XImage * xima = XCreateImage(fl_get_display(), 0, 1, XYBitmap, 0,
 290                                              const_cast<char*>(reinterpret_cast<char const *>(bdata)), w, h, 8, 0);
 291                 xima->byte_order = LSBFirst;
 292                 xima->bitmap_bit_order = LSBFirst;
 293                 int x = (id % dw) * ww;
 294                 int y = (id/dw) * hh;
 295                 if (ww > wx) ww = wx;
 296                 if (hh > hx) hh = hx;
 297                 XImage * sbima = XSubImage(xima, x, y, ww, hh);
 298                 XpmCreateDataFromImage(fl_get_display(), const_cast<char***>(&data), sbima, sbima, 0);
 299
 300                 // Dirty hack to get blue symbols quickly
 301                 char * sx = const_cast<char*>(strstr(data[2], "FFFFFFFF"));
 302                 if (sx) {
 303                         for (int k = 0; k < 8; ++k) sx[k] = '0';
 304                 }
 305
 306 //      XDestroyImage(xima);
 307         }
 308
 309         return data;
 310 }
 311
 312
 313 char const ** get_pixmap_from_symbol(char const * arg, int wx, int hx)
 314 {
 315         lyx::Assert(arg);
 316
 317         char const ** data = 0;
 318         latexkeys const * l = in_word_set(arg);
 319         if (!l)
 320                 return 0;
 321
 322         switch (l->token) {
 323         case LM_TK_FRAC:
 324                 data = mathed_get_pixmap_from_icon(MM_FRAC);
 325                 break;
 326         case LM_TK_SQRT:
 327                 data = mathed_get_pixmap_from_icon(MM_SQRT);
 328                 break;
 329         case LM_TK_SYM:
 330         case LM_TK_CMR:
 331         case LM_TK_CMSY:
 332         case LM_TK_CMEX:
 333         case LM_TK_CMM:
 334         case LM_TK_MSA:
 335         case LM_TK_MSB:
 336                 // I have to use directly the bitmap data since the
 337                 // bitmap tables are not yet created when this
 338                 // function is called.
 339                 data = pixmapFromBitmapData(arg, wx, hx);
 340                 break;
 341         default:
 342                 break;
 343         }
 344
 345         return data;
 346 }