Return to mimeTeX.js CVS log

Up to [LON-CAPA] / loncom / html / adm / jsMath / plugins

- jsmath 3.3

    1: /*
    2:  *  mimeTeX.js
    3:  *  
    4:  *  Part of the jsMath package for mathematics on the web.
    5:  *
    6:  *  This file makes jsMath more compatible with the mimeTeX program.
    7:  *  It does not make everything work, but it goes a long way.
    8:  *
    9:  *  ---------------------------------------------------------------------
   10:  *
   11:  *  Copyright 2004-2006 by Davide P. Cervone
   12:  * 
   13:  *  Licensed under the Apache License, Version 2.0 (the "License");
   14:  *  you may not use this file except in compliance with the License.
   15:  *  You may obtain a copy of the License at
   16:  * 
   17:  *      http://www.apache.org/licenses/LICENSE-2.0
   18:  * 
   19:  *  Unless required by applicable law or agreed to in writing, software
   20:  *  distributed under the License is distributed on an "AS IS" BASIS,
   21:  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   22:  *  See the License for the specific language governing permissions and
   23:  *  limitations under the License.
   24:  */
   25: 
   26: 
   27: /*
   28:  *  Treat ~ as space
   29:  */
   30: jsMath.Parser.prototype.nextIsSpace = function () {
   31:   return this.string.charAt(this.i) == ' ' ||
   32:          this.string.charAt(this.i) == '~';
   33: }
   34: jsMath.Parser.prototype.special['~'] = 'Space';
   35: 
   36: /*
   37:  *  Implement \[ ... \], \( ... \), etc.
   38:  */
   39: jsMath.Macro('[','\\left[');  jsMath.Macro(']','\\right]');
   40: jsMath.Macro('(','\\left(');  jsMath.Macro(')','\\right)');
   41: jsMath.Macro('<','\\left<');  jsMath.Macro('>','\\right>');
   42: // can't do \. in a reasonable way
   43: jsMath.Parser.prototype.macros['|'] = ['HandleLR','|','|'];
   44: jsMath.Parser.prototype.macros['='] = ['HandleLR','\\|','\\|'];
   45: 
   46: /*
   47:  *  Make non-standard \left{ and \right} work
   48:  */
   49: jsMath.Parser.prototype.delimiter['}'] = [5,2,0x67,3,0x09];
   50: jsMath.Parser.prototype.delimiter['{'] = [4,2,0x66,3,0x08];
   51: 
   52: 
   53: /*
   54:  *  Immitate mimeTeX \big... and \Big... ops
   55:  */
   56: 
   57: // make the normal ones in text mode
   58: jsMath.Macro('int','\\intop\\nolimits');
   59: jsMath.Macro('oint','\\ointop\\nolimits');
   60: jsMath.Macro('sum','\\sumop\\nolimits');
   61: jsMath.Macro('prod','\\prodop\\nolimits');
   62: jsMath.Macro('coprod','\\coprodop\\nolimits');
   63: 
   64: jsMath.Macro('bigint','\\bigintop\\nolimits'); 
   65: jsMath.Macro('bigoint','\\bigointop\\nolimits');
   66: jsMath.Macro('bigsum','\\bigsumop\\nolimits');
   67: jsMath.Macro('bigprod','\\bigprodop\\nolimits');
   68: jsMath.Macro('bigcoprod','\\bigcoprodop\\nolimits');
   69: 
   70: jsMath.Macro('Bigint','\\bigintop\\limits');
   71: jsMath.Macro('Bigoint','\\bigointop\\limits');
   72: jsMath.Macro('Bigsum','\\bigsumop\\limits');
   73: jsMath.Macro('Bigprod','\\bigprodop\\limits');
   74: jsMath.Macro('Bigcoprod','\\bigcoprod\\limits');
   75: 
   76: /*
   77:  *  The characters needed for the macros above
   78:  */
   79: jsMath.Parser.prototype.mathchardef['coprodop'] = [1,3,0x60];
   80: jsMath.Parser.prototype.mathchardef['prodop']   = [1,3,0x51];
   81: jsMath.Parser.prototype.mathchardef['sumop']    = [1,3,0x50];
   82: 
   83: jsMath.Parser.prototype.mathchardef['bigintop']    = [1,3,0x5A];
   84: jsMath.Parser.prototype.mathchardef['bigointop']   = [1,3,0x49];
   85: jsMath.Parser.prototype.mathchardef['bigcoprodop'] = [1,3,0x61];
   86: jsMath.Parser.prototype.mathchardef['bigprodop']   = [1,3,0x59];
   87: jsMath.Parser.prototype.mathchardef['bigsumop']    = [1,3,0x58];
   88: 
   89: /*
   90:  * Unlink the small versions so they don't enlarge in display mode
   91:  */
   92: jsMath.TeX['cmex10'][0x48].n = null;
   93: jsMath.TeX['cmex10'][0x50].n = null;
   94: jsMath.TeX['cmex10'][0x51].n = null;
   95: jsMath.TeX['cmex10'][0x52].n = null;
   96: jsMath.TeX['cmex10'][0x60].n = null;
   97: 
   98: 
   99: /*
  100:  *  Some other missing items
  101:  */
  102: jsMath.Macro('/','{}'); // insert an empty box \/
  103: jsMath.Macro('raisebox','\\raise #1px ',1); // convert to \raise
  104: jsMath.Macro('hfill','\\quad ',1); // punt
  105: jsMath.Macro('fbox','\\oldfbox{$#1$}',1); // do fbox in math mode
  106: 
  107: /*
  108:  *  These get new JavaScript routines
  109:  */
  110: jsMath.Parser.prototype.macros['unitlength'] = 'unitlength';
  111: jsMath.Parser.prototype.macros['hspace']     = 'hspace';
  112: jsMath.Parser.prototype.macros['fs']         = 'fs';
  113: jsMath.Parser.prototype.macros['oldfbox']    = 'FBox';
  114: 
  115: /*
  116:  *  Add some JavaScript functions to the parser
  117:  */
  118: jsMath.Package(jsMath.Parser,{
  119:   
  120:   /*
  121:    *  Implement \left x ... \right x
  122:    */
  123:   HandleLR: function (name,data) {
  124:     var arg = this.GetUpto(name,name); if (this.error) return;
  125:     this.string = '\\left'+data[0]+arg+'\\right'+data[1];
  126:     this.i = 0;
  127:   },
  128: 
  129:   /*
  130:    *  Hold the unit length in mlist.data
  131:    */
  132:   unitlength: function (name) {
  133:     var n = this.GetArgument(this.cmd+name); if (this.error) return;
  134:     if (!n.match(/^-?(\d+(\.\d*)?|\.\d+)$/)) {
  135:       this.Error("Argument for "+this.cmd+name+" must be a number");
  136:       return;
  137:     }
  138:     this.mlist.data['unitlength'] = n;
  139:   },
  140: 
  141:   /*
  142:    *  Get the length (converted to ems) and multiply by the unit length
  143:    */
  144:   hspace: function (name) {
  145:     var w = this.GetArgument(this.cmd+name); if (this.error) return;
  146:     if (!w.match(/^-?(\d+(\.\d*)?|\.\d+)$/)) {
  147:       this.Error("Argument for "+this.cmd+name+" must be a number");
  148:       return;
  149:     }
  150:     w /= jsMath.em
  151:     if (this.mlist.data['unitlength']) {w *= this.mlist.data['unitlength']}
  152:     this.mlist.Add(jsMath.mItem.Space(w));
  153:   },
  154:   
  155:   /*
  156:    *  Implement \fs{...} for font-size changing
  157:    */
  158:   fs: function (name) {
  159:     var n = this.GetArgument(this.cmd+name); if (this.error) return;
  160:     if (!n.match(/^[-+]?\d+$/)) {
  161:       this.Error("Argument for "+this.cmd+name+" must be an integer");
  162:       return;
  163:     }
  164:     if (n.match(/[-+]/)) {n = n - 0; n += this.mlist.data.size}
  165:     this.mlist.data.size = n = Math.max(0,Math.min(9,n));
  166:     this.mlist.Add(new jsMath.mItem('size',{size: n}));
  167:   },
  168: 
  169:   /*
  170:    *  Repalce the Array function by one that accepts an optional
  171:    *  parameter for the column types, and that handle's mimeTeX's
  172:    *  "preamble" format.
  173:    */
  174:   Array: function (name,delim) {
  175:     var columns = delim[2]; var cspacing = delim[3];
  176:     if (!columns && this.GetNext() == '{') {
  177:       columns = this.GetArgument(this.cmd+'begin{'+name+'}');
  178:       if (this.error) return;
  179:     } else {
  180:       columns = '';
  181:     }
  182:     columns = columns.replace(/[^clr]/g,'');
  183:     columns = columns.split('');
  184:     var data = this.mlist.data; var style = delim[5] || 'T';
  185:     var arg = this.GetEnd(name); if (this.error) return;
  186:     if (arg.match(/\$/)) {arg = arg.replace(/^([^$]*)\$/,''); columns = RegExp.$1}
  187:     var parse = new jsMath.Parser(arg+this.cmd+'\\',null,data.size,style);
  188:     parse.matrix = name; parse.row = []; parse.table = []; parse.rspacing = [];
  189:     parse.Parse(); if (parse.error) {this.Error(parse); return}
  190:     parse.HandleRow(name,1);  // be sure the last row is recorded
  191:     var box = jsMath.Box.Layout(data.size,parse.table,columns,cspacing,parse.rspacing,delim[4]||null);
  192:     // Add parentheses, if needed
  193:     if (delim[0] && delim[1]) {
  194:       var left  = jsMath.Box.Delimiter(box.h+box.d-jsMath.hd/4,this.delimiter[delim[0]],'T');
  195:       var right = jsMath.Box.Delimiter(box.h+box.d-jsMath.hd/4,this.delimiter[delim[1]],'T');
  196:       box = jsMath.Box.SetList([left,box,right],data.style,data.size);
  197:     }
  198:     this.mlist.Add(jsMath.mItem.Atom((delim[0]? 'inner': 'ord'),box));
  199:   },
  200: 
  201:   /*
  202:    *  Similarly for Matrix (used by \matrix and \array)
  203:    */
  204:   Matrix: function (name,delim) {
  205:     var data = this.mlist.data;
  206:     var arg = this.GetArgument(this.cmd+name); if (this.error) return;
  207:     if (arg.match(/\$/)) {arg = arg.replace(/^([^$]*)\$/,''); delim[2] = RegExp.$1}
  208:     var parse = new jsMath.Parser(arg+this.cmd+'\\',null,data.size,delim[5] || 'T');
  209:     parse.matrix = name; parse.row = []; parse.table = []; parse.rspacing = [];
  210:     parse.Parse(); if (parse.error) {this.Error(parse); return}
  211:     parse.HandleRow(name,1);  // be sure the last row is recorded
  212:     var box = jsMath.Box.Layout(data.size,parse.table,delim[2]||null,delim[3]||null,parse.rspacing,delim[4]||null);
  213:     // Add parentheses, if needed
  214:     if (delim[0] && delim[1]) {
  215:       var left  = jsMath.Box.Delimiter(box.h+box.d-jsMath.hd/4,this.delimiter[delim[0]],'T');
  216:       var right = jsMath.Box.Delimiter(box.h+box.d-jsMath.hd/4,this.delimiter[delim[1]],'T');
  217:       box = jsMath.Box.SetList([left,box,right],data.style,data.size);
  218:     }
  219:     this.mlist.Add(jsMath.mItem.Atom((delim[0]? 'inner': 'ord'),box));
  220:   }
  221: });