You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@openmeetings.apache.org by so...@apache.org on 2017/12/25 13:35:27 UTC
[1/3] openmeetings git commit: [OPENMEETINGS-1783] missing MathJs
files are added
Repository: openmeetings
Updated Branches:
refs/heads/4.0.x fce7f3b9d -> b4060659c
http://git-wip-us.apache.org/repos/asf/openmeetings/blob/9d341f1b/openmeetings-web/src/main/java/org/apache/openmeetings/web/room/wb/MathJax.js
----------------------------------------------------------------------
diff --git a/openmeetings-web/src/main/java/org/apache/openmeetings/web/room/wb/MathJax.js b/openmeetings-web/src/main/java/org/apache/openmeetings/web/room/wb/MathJax.js
index f8f6f38..cd7d507 100644
--- a/openmeetings-web/src/main/java/org/apache/openmeetings/web/room/wb/MathJax.js
+++ b/openmeetings-web/src/main/java/org/apache/openmeetings/web/room/wb/MathJax.js
@@ -3289,7 +3289,25 @@ MathJax.Hub.Startup = {
MathJax.Ajax.Preloading(
"[MathJax]/jax/element/mml/jax.js",
+"[MathJax]/jax/element/mml/optable/Arrows.js",
+"[MathJax]/jax/element/mml/optable/MiscMathSymbolsA.js",
+"[MathJax]/jax/element/mml/optable/Dingbats.js",
+"[MathJax]/jax/element/mml/optable/GeneralPunctuation.js",
+"[MathJax]/jax/element/mml/optable/SpacingModLetters.js",
+"[MathJax]/jax/element/mml/optable/MiscTechnical.js",
+"[MathJax]/jax/element/mml/optable/SupplementalArrowsA.js",
+"[MathJax]/jax/element/mml/optable/GreekAndCoptic.js",
+"[MathJax]/jax/element/mml/optable/LetterlikeSymbols.js",
+"[MathJax]/jax/element/mml/optable/SupplementalArrowsB.js",
"[MathJax]/jax/element/mml/optable/BasicLatin.js",
+"[MathJax]/jax/element/mml/optable/MiscSymbolsAndArrows.js",
+"[MathJax]/jax/element/mml/optable/CombDiacritMarks.js",
+"[MathJax]/jax/element/mml/optable/GeometricShapes.js",
+"[MathJax]/jax/element/mml/optable/MathOperators.js",
+"[MathJax]/jax/element/mml/optable/MiscMathSymbolsB.js",
+"[MathJax]/jax/element/mml/optable/SuppMathOperators.js",
+"[MathJax]/jax/element/mml/optable/CombDiactForSymbols.js",
+"[MathJax]/jax/element/mml/optable/Latin1Supplement.js",
"[MathJax]/extensions/MathEvents.js",
"[MathJax]/extensions/tex2jax.js",
"[MathJax]/jax/input/TeX/config.js",
@@ -3307,8 +3325,34 @@ MathJax.Ajax.Preloading(
"[MathJax]/jax/output/SVG/fonts/TeX/fontdata.js",
"[MathJax]/jax/output/SVG/fonts/TeX/fontdata-extra.js",
"[MathJax]/jax/output/SVG/fonts/TeX/AMS/Regular/Main.js",
+"[MathJax]/jax/output/SVG/fonts/TeX/AMS/Regular/Arrows.js",
+"[MathJax]/jax/output/SVG/fonts/TeX/AMS/Regular/BoxDrawing.js",
+"[MathJax]/jax/output/SVG/fonts/TeX/AMS/Regular/CombDiacritMarks.js",
+"[MathJax]/jax/output/SVG/fonts/TeX/AMS/Regular/Dingbats.js",
+"[MathJax]/jax/output/SVG/fonts/TeX/AMS/Regular/EnclosedAlphanum.js",
+"[MathJax]/jax/output/SVG/fonts/TeX/AMS/Regular/GeneralPunctuation.js",
+"[MathJax]/jax/output/SVG/fonts/TeX/AMS/Regular/GeometricShapes.js",
+"[MathJax]/jax/output/SVG/fonts/TeX/AMS/Regular/GreekAndCoptic.js",
+"[MathJax]/jax/output/SVG/fonts/TeX/AMS/Regular/Latin1Supplement.js",
+"[MathJax]/jax/output/SVG/fonts/TeX/AMS/Regular/LatinExtendedA.js",
+"[MathJax]/jax/output/SVG/fonts/TeX/AMS/Regular/LetterlikeSymbols.js",
+"[MathJax]/jax/output/SVG/fonts/TeX/AMS/Regular/MathOperators.js",
+"[MathJax]/jax/output/SVG/fonts/TeX/AMS/Regular/MiscMathSymbolsB.js",
+"[MathJax]/jax/output/SVG/fonts/TeX/AMS/Regular/MiscSymbols.js",
"[MathJax]/jax/output/SVG/fonts/TeX/AMS/Regular/MiscTechnical.js",
+"[MathJax]/jax/output/SVG/fonts/TeX/AMS/Regular/PUA.js",
+"[MathJax]/jax/output/SVG/fonts/TeX/AMS/Regular/SpacingModLetters.js",
+"[MathJax]/jax/output/SVG/fonts/TeX/AMS/Regular/SuppMathOperators.js",
"[MathJax]/jax/output/SVG/fonts/TeX/Main/Regular/BasicLatin.js",
+"[MathJax]/jax/output/SVG/fonts/TeX/Main/Regular/CombDiacritMarks.js",
+"[MathJax]/jax/output/SVG/fonts/TeX/Main/Regular/GeometricShapes.js",
+"[MathJax]/jax/output/SVG/fonts/TeX/Main/Regular/GreekAndCoptic.js",
+"[MathJax]/jax/output/SVG/fonts/TeX/Main/Regular/LatinExtendedA.js",
+"[MathJax]/jax/output/SVG/fonts/TeX/Main/Regular/LatinExtendedB.js",
+"[MathJax]/jax/output/SVG/fonts/TeX/Main/Regular/LetterlikeSymbols.js",
+"[MathJax]/jax/output/SVG/fonts/TeX/Main/Regular/MiscSymbols.js",
+"[MathJax]/jax/output/SVG/fonts/TeX/Main/Regular/SpacingModLetters.js",
+"[MathJax]/jax/output/SVG/fonts/TeX/Main/Regular/SuppMathOperators.js",
"[MathJax]/jax/output/SVG/fonts/TeX/Size1/Regular/Main.js",
"[MathJax]/jax/output/SVG/fonts/TeX/Size2/Regular/Main.js",
"[MathJax]/jax/output/SVG/fonts/TeX/Size3/Regular/Main.js",
@@ -5136,7 +5180,7 @@ MathJax.ElementJax.mml.loadComplete("jax.js");
/*************************************************************
*
- * MathJax/jax/output/HTML-CSS/optable/BasicLatin.js
+ * MathJax/jax/output/HTML-CSS/optable/Arrows.js
*
* Copyright (c) 2010-2017 The MathJax Consortium
*
@@ -5160,5779 +5204,4907 @@ MathJax.ElementJax.mml.loadComplete("jax.js");
MathJax.Hub.Insert(MML.mo.prototype,{
OPTABLE: {
- prefix: {
- '||': [0,0,TEXCLASS.BIN,{fence: true, stretchy: true, symmetric: true}], // multiple character operator: ||
- '|||': [0,0,TEXCLASS.ORD,{fence: true, stretchy: true, symmetric: true}] // multiple character operator: |||
- },
- postfix: {
- '!!': [1,0,TEXCLASS.BIN], // multiple character operator: !!
- '\'': MO.ACCENT, // apostrophe
- '++': [0,0,TEXCLASS.BIN], // multiple character operator: ++
- '--': [0,0,TEXCLASS.BIN], // multiple character operator: --
- '..': [0,0,TEXCLASS.BIN], // multiple character operator: ..
- '...': MO.ORD, // multiple character operator: ...
- '||': [0,0,TEXCLASS.BIN,{fence: true, stretchy: true, symmetric: true}], // multiple character operator: ||
- '|||': [0,0,TEXCLASS.ORD,{fence: true, stretchy: true, symmetric: true}] // multiple character operator: |||
- },
infix: {
- '!=': MO.BIN4, // multiple character operator: !=
- '&&': MO.BIN4, // multiple character operator: &&
- '**': [1,1,TEXCLASS.BIN], // multiple character operator: **
- '*=': MO.BIN4, // multiple character operator: *=
- '+=': MO.BIN4, // multiple character operator: +=
- '-=': MO.BIN4, // multiple character operator: -=
- '->': MO.BIN5, // multiple character operator: ->
- '//': [1,1,TEXCLASS.BIN], // multiple character operator: //
- '/=': MO.BIN4, // multiple character operator: /=
- ':=': MO.BIN4, // multiple character operator: :=
- '<=': MO.BIN5, // multiple character operator: <=
- '<>': [1,1,TEXCLASS.BIN], // multiple character operator: <>
- '==': MO.BIN4, // multiple character operator: ==
- '>=': MO.BIN5, // multiple character operator: >=
- '@': MO.ORD11, // commercial at
- '||': [2,2,TEXCLASS.BIN,{fence: true, stretchy: true, symmetric: true}], // multiple character operator: ||
- '|||': [2,2,TEXCLASS.ORD,{fence: true, stretchy: true, symmetric: true}] // multiple character operator: |||
+ '\u219A': MO.RELACCENT, // leftwards arrow with stroke
+ '\u219B': MO.RELACCENT, // rightwards arrow with stroke
+ '\u219C': MO.WIDEREL, // leftwards wave arrow
+ '\u219D': MO.WIDEREL, // rightwards wave arrow
+ '\u219E': MO.WIDEREL, // leftwards two headed arrow
+ '\u219F': MO.WIDEREL, // upwards two headed arrow
+ '\u21A0': MO.WIDEREL, // rightwards two headed arrow
+ '\u21A1': MO.RELSTRETCH, // downwards two headed arrow
+ '\u21A2': MO.WIDEREL, // leftwards arrow with tail
+ '\u21A3': MO.WIDEREL, // rightwards arrow with tail
+ '\u21A4': MO.WIDEREL, // leftwards arrow from bar
+ '\u21A5': MO.RELSTRETCH, // upwards arrow from bar
+ '\u21A7': MO.RELSTRETCH, // downwards arrow from bar
+ '\u21A8': MO.RELSTRETCH, // up down arrow with base
+ '\u21AB': MO.WIDEREL, // leftwards arrow with loop
+ '\u21AC': MO.WIDEREL, // rightwards arrow with loop
+ '\u21AD': MO.WIDEREL, // left right wave arrow
+ '\u21AE': MO.RELACCENT, // left right arrow with stroke
+ '\u21AF': MO.RELSTRETCH, // downwards zigzag arrow
+ '\u21B0': MO.RELSTRETCH, // upwards arrow with tip leftwards
+ '\u21B1': MO.RELSTRETCH, // upwards arrow with tip rightwards
+ '\u21B2': MO.RELSTRETCH, // downwards arrow with tip leftwards
+ '\u21B3': MO.RELSTRETCH, // downwards arrow with tip rightwards
+ '\u21B4': MO.RELSTRETCH, // rightwards arrow with corner downwards
+ '\u21B5': MO.RELSTRETCH, // downwards arrow with corner leftwards
+ '\u21B6': MO.RELACCENT, // anticlockwise top semicircle arrow
+ '\u21B7': MO.RELACCENT, // clockwise top semicircle arrow
+ '\u21B8': MO.REL, // north west arrow to long bar
+ '\u21B9': MO.WIDEREL, // leftwards arrow to bar over rightwards arrow to bar
+ '\u21BA': MO.REL, // anticlockwise open circle arrow
+ '\u21BB': MO.REL, // clockwise open circle arrow
+ '\u21BE': MO.RELSTRETCH, // upwards harpoon with barb rightwards
+ '\u21BF': MO.RELSTRETCH, // upwards harpoon with barb leftwards
+ '\u21C2': MO.RELSTRETCH, // downwards harpoon with barb rightwards
+ '\u21C3': MO.RELSTRETCH, // downwards harpoon with barb leftwards
+ '\u21C4': MO.WIDEREL, // rightwards arrow over leftwards arrow
+ '\u21C5': MO.RELSTRETCH, // upwards arrow leftwards of downwards arrow
+ '\u21C6': MO.WIDEREL, // leftwards arrow over rightwards arrow
+ '\u21C7': MO.WIDEREL, // leftwards paired arrows
+ '\u21C8': MO.RELSTRETCH, // upwards paired arrows
+ '\u21C9': MO.WIDEREL, // rightwards paired arrows
+ '\u21CA': MO.RELSTRETCH, // downwards paired arrows
+ '\u21CB': MO.WIDEREL, // leftwards harpoon over rightwards harpoon
+ '\u21CD': MO.RELACCENT, // leftwards double arrow with stroke
+ '\u21CE': MO.RELACCENT, // left right double arrow with stroke
+ '\u21CF': MO.RELACCENT, // rightwards double arrow with stroke
+ '\u21D6': MO.RELSTRETCH, // north west double arrow
+ '\u21D7': MO.RELSTRETCH, // north east double arrow
+ '\u21D8': MO.RELSTRETCH, // south east double arrow
+ '\u21D9': MO.RELSTRETCH, // south west double arrow
+ '\u21DA': MO.WIDEREL, // leftwards triple arrow
+ '\u21DB': MO.WIDEREL, // rightwards triple arrow
+ '\u21DC': MO.WIDEREL, // leftwards squiggle arrow
+ '\u21DD': MO.WIDEREL, // rightwards squiggle arrow
+ '\u21DE': MO.REL, // upwards arrow with double stroke
+ '\u21DF': MO.REL, // downwards arrow with double stroke
+ '\u21E0': MO.WIDEREL, // leftwards dashed arrow
+ '\u21E1': MO.RELSTRETCH, // upwards dashed arrow
+ '\u21E2': MO.WIDEREL, // rightwards dashed arrow
+ '\u21E3': MO.RELSTRETCH, // downwards dashed arrow
+ '\u21E4': MO.WIDEREL, // leftwards arrow to bar
+ '\u21E5': MO.WIDEREL, // rightwards arrow to bar
+ '\u21E6': MO.WIDEREL, // leftwards white arrow
+ '\u21E7': MO.RELSTRETCH, // upwards white arrow
+ '\u21E8': MO.WIDEREL, // rightwards white arrow
+ '\u21E9': MO.RELSTRETCH, // downwards white arrow
+ '\u21EA': MO.RELSTRETCH, // upwards white arrow from bar
+ '\u21EB': MO.RELSTRETCH, // upwards white arrow on pedestal
+ '\u21EC': MO.RELSTRETCH, // upwards white arrow on pedestal with horizontal bar
+ '\u21ED': MO.RELSTRETCH, // upwards white arrow on pedestal with vertical bar
+ '\u21EE': MO.RELSTRETCH, // upwards white double arrow
+ '\u21EF': MO.RELSTRETCH, // upwards white double arrow on pedestal
+ '\u21F0': MO.WIDEREL, // rightwards white arrow from wall
+ '\u21F1': MO.REL, // north west arrow to corner
+ '\u21F2': MO.REL, // south east arrow to corner
+ '\u21F3': MO.RELSTRETCH, // up down white arrow
+ '\u21F4': MO.RELACCENT, // right arrow with small circle
+ '\u21F5': MO.RELSTRETCH, // downwards arrow leftwards of upwards arrow
+ '\u21F6': MO.WIDEREL, // three rightwards arrows
+ '\u21F7': MO.RELACCENT, // leftwards arrow with vertical stroke
+ '\u21F8': MO.RELACCENT, // rightwards arrow with vertical stroke
+ '\u21F9': MO.RELACCENT, // left right arrow with vertical stroke
+ '\u21FA': MO.RELACCENT, // leftwards arrow with double vertical stroke
+ '\u21FB': MO.RELACCENT, // rightwards arrow with double vertical stroke
+ '\u21FC': MO.RELACCENT, // left right arrow with double vertical stroke
+ '\u21FD': MO.WIDEREL, // leftwards open-headed arrow
+ '\u21FE': MO.WIDEREL, // rightwards open-headed arrow
+ '\u21FF': MO.WIDEREL // left right open-headed arrow
}
}
});
- MathJax.Ajax.loadComplete(MML.optableDir+"/BasicLatin.js");
+ MathJax.Ajax.loadComplete(MML.optableDir+"/Arrows.js");
})(MathJax.ElementJax.mml);
-/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
-/* vim: set ts=2 et sw=2 tw=80: */
-
/*************************************************************
*
- * MathJax/extensions/MathEvents.js
- *
- * Implements the event handlers needed by the output jax to perform
- * menu, hover, and other events.
- *
- * ---------------------------------------------------------------------
+ * MathJax/jax/output/HTML-CSS/optable/MiscMathSymbolsA.js
*
- * Copyright (c) 2011-2017 The MathJax Consortium
+ * Copyright (c) 2010-2017 The MathJax Consortium
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
- * http://www.apache.org/licenses/LICENSE-2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
+ *
*/
-(function (HUB,HTML,AJAX,CALLBACK,LOCALE,OUTPUT,INPUT) {
- var VERSION = "2.7.2";
-
- var EXTENSION = MathJax.Extension;
- var ME = EXTENSION.MathEvents = {version: VERSION};
+(function (MML) {
+ var MO = MML.mo.OPTYPES;
+ var TEXCLASS = MML.TEXCLASS;
- var SETTINGS = HUB.config.menuSettings;
+ MathJax.Hub.Insert(MML.mo.prototype,{
+ OPTABLE: {
+ prefix: {
+ '\u27E6': MO.OPEN, // mathematical left white square bracket
+ '\u27EA': MO.OPEN, // mathematical left double angle bracket
+ '\u27EC': MO.OPEN // mathematical left white tortoise shell bracket
+ },
+ postfix: {
+ '\u27E7': MO.CLOSE, // mathematical right white square bracket
+ '\u27EB': MO.CLOSE, // mathematical right double angle bracket
+ '\u27ED': MO.CLOSE // mathematical right white tortoise shell bracket
+ }
+ }
+ });
- var CONFIG = {
- hover: 500, // time required to be considered a hover
- frame: {
- x: 3.5, y: 5, // frame padding and
- bwidth: 1, // frame border width (in pixels)
- bcolor: "#A6D", // frame border color
- hwidth: "15px", // haze width
- hcolor: "#83A" // haze color
- },
- button: {
- x: -6, y: -3, // menu button offsets
- wx: -2 // button offset for full-width equations
- },
- fadeinInc: .2, // increment for fade-in
- fadeoutInc: .05, // increment for fade-out
- fadeDelay: 50, // delay between fade-in or fade-out steps
- fadeoutStart: 400, // delay before fade-out after mouseout
- fadeoutDelay: 15*1000, // delay before automatic fade-out
+ MathJax.Ajax.loadComplete(MML.optableDir+"/MiscMathSymbolsA.js");
- styles: {
- ".MathJax_Hover_Frame": {
- "border-radius": ".25em", // Opera 10.5 and IE9
- "-webkit-border-radius": ".25em", // Safari and Chrome
- "-moz-border-radius": ".25em", // Firefox
- "-khtml-border-radius": ".25em", // Konqueror
+})(MathJax.ElementJax.mml);
- "box-shadow": "0px 0px 15px #83A", // Opera 10.5 and IE9
- "-webkit-box-shadow": "0px 0px 15px #83A", // Safari and Chrome
- "-moz-box-shadow": "0px 0px 15px #83A", // Forefox
- "-khtml-box-shadow": "0px 0px 15px #83A", // Konqueror
+/*************************************************************
+ *
+ * MathJax/jax/output/HTML-CSS/optable/Dingbats.js
+ *
+ * Copyright (c) 2010-2017 The MathJax Consortium
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
- border: "1px solid #A6D ! important",
- display: "inline-block", position:"absolute"
- },
+(function (MML) {
+ var MO = MML.mo.OPTYPES;
+ var TEXCLASS = MML.TEXCLASS;
- ".MathJax_Menu_Button .MathJax_Hover_Arrow": {
- position:"absolute",
- cursor:"pointer",
- display:"inline-block",
- border:"2px solid #AAA",
- "border-radius":"4px",
- "-webkit-border-radius": "4px", // Safari and Chrome
- "-moz-border-radius": "4px", // Firefox
- "-khtml-border-radius": "4px", // Konqueror
- "font-family":"'Courier New',Courier",
- "font-size":"9px",
- color:"#F0F0F0"
- },
- ".MathJax_Menu_Button .MathJax_Hover_Arrow span": {
- display:"block",
- "background-color":"#AAA",
- border:"1px solid",
- "border-radius":"3px",
- "line-height":0,
- padding:"4px"
- },
- ".MathJax_Hover_Arrow:hover": {
- color:"white!important",
- border:"2px solid #CCC!important"
+ MathJax.Hub.Insert(MML.mo.prototype,{
+ OPTABLE: {
+ prefix: {
+ '\u2772': MO.OPEN // light left tortoise shell bracket ornament
},
- ".MathJax_Hover_Arrow:hover span": {
- "background-color":"#CCC!important"
+ postfix: {
+ '\u2773': MO.CLOSE // light right tortoise shell bracket ornament
}
}
- };
-
-
- //
- // Common event-handling code
- //
- var EVENT = ME.Event = {
+ });
- LEFTBUTTON: 0, // the event.button value for left button
- RIGHTBUTTON: 2, // the event.button value for right button
- MENUKEY: "altKey", // the event value for alternate context menu
+ MathJax.Ajax.loadComplete(MML.optableDir+"/Dingbats.js");
- /*************************************************************/
- /*
- * Enum element for key codes.
- */
- KEY: {
- RETURN: 13,
- ESCAPE: 27,
- SPACE: 32,
- LEFT: 37,
- UP: 38,
- RIGHT: 39,
- DOWN: 40
- },
+})(MathJax.ElementJax.mml);
- Mousedown: function (event) {return EVENT.Handler(event,"Mousedown",this)},
- Mouseup: function (event) {return EVENT.Handler(event,"Mouseup",this)},
- Mousemove: function (event) {return EVENT.Handler(event,"Mousemove",this)},
- Mouseover: function (event) {return EVENT.Handler(event,"Mouseover",this)},
- Mouseout: function (event) {return EVENT.Handler(event,"Mouseout",this)},
- Click: function (event) {return EVENT.Handler(event,"Click",this)},
- DblClick: function (event) {return EVENT.Handler(event,"DblClick",this)},
- Menu: function (event) {return EVENT.Handler(event,"ContextMenu",this)},
+/*************************************************************
+ *
+ * MathJax/jax/output/HTML-CSS/optable/GeneralPunctuation.js
+ *
+ * Copyright (c) 2010-2017 The MathJax Consortium
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
- //
- // Call the output jax's event handler or the zoom handler
- //
- Handler: function (event,type,math) {
- if (AJAX.loadingMathMenu) {return EVENT.False(event)}
- var jax = OUTPUT[math.jaxID];
- if (!event) {event = window.event}
- event.isContextMenu = (type === "ContextMenu");
- if (jax[type]) {return jax[type](event,math)}
- if (EXTENSION.MathZoom) {return EXTENSION.MathZoom.HandleEvent(event,type,math)}
- },
+(function (MML) {
+ var MO = MML.mo.OPTYPES;
+ var TEXCLASS = MML.TEXCLASS;
- //
- // Try to cancel the event in every way we can
- //
- False: function (event) {
- if (!event) {event = window.event}
- if (event) {
- if (event.preventDefault) {event.preventDefault()} else {event.returnValue = false}
- if (event.stopPropagation) {event.stopPropagation()}
- event.cancelBubble = true;
+ MathJax.Hub.Insert(MML.mo.prototype,{
+ OPTABLE: {
+ prefix: {
+ '\u2016': [0,0,TEXCLASS.ORD,{fence: true, stretchy: true}], // double vertical line
+ '\u2018': [0,0,TEXCLASS.OPEN,{fence: true}], // left single quotation mark
+ '\u201C': [0,0,TEXCLASS.OPEN,{fence: true}] // left double quotation mark
+ },
+ postfix: {
+ '\u2016': [0,0,TEXCLASS.ORD,{fence: true, stretchy: true}], // double vertical line
+ '\u2019': [0,0,TEXCLASS.CLOSE,{fence: true}], // right single quotation mark
+ '\u201D': [0,0,TEXCLASS.CLOSE,{fence: true}] // right double quotation mark
}
- return false;
- },
+ }
+ });
- //
- // Keydown event handler. Should only fire on Space key.
- //
- Keydown: function (event, math) {
- if (!event) event = window.event;
- if (event.keyCode === EVENT.KEY.SPACE) {
- EVENT.ContextMenu(event, this);
- };
- },
+ MathJax.Ajax.loadComplete(MML.optableDir+"/GeneralPunctuation.js");
- //
- // Load the contextual menu code, if needed, and post the menu
- //
- ContextMenu: function (event,math,force) {
- //
- // Check if we are showing menus
- //
- var JAX = OUTPUT[math.jaxID], jax = JAX.getJaxFromMath(math);
- var show = (JAX.config.showMathMenu != null ? JAX : HUB).config.showMathMenu;
- if (!show || (SETTINGS.context !== "MathJax" && !force)) return;
+})(MathJax.ElementJax.mml);
- //
- // Remove selections, remove hover fades
- //
- if (ME.msieEventBug) {event = window.event || event}
- EVENT.ClearSelection(); HOVER.ClearHoverTimer();
- if (jax.hover) {
- if (jax.hover.remove) {clearTimeout(jax.hover.remove); delete jax.hover.remove}
- jax.hover.nofade = true;
+/*************************************************************
+ *
+ * MathJax/jax/output/HTML-CSS/optable/SpacingModLetters.js
+ *
+ * Copyright (c) 2010-2017 The MathJax Consortium
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+(function (MML) {
+ var MO = MML.mo.OPTYPES;
+ var TEXCLASS = MML.TEXCLASS;
+
+ MathJax.Hub.Insert(MML.mo.prototype,{
+ OPTABLE: {
+ postfix: {
+ '\u02CD': MO.WIDEACCENT, // modifier letter low macron
+ '\u02DA': MO.ACCENT, // ring above
+ '\u02DD': MO.ACCENT, // double acute accent
+ '\u02F7': MO.WIDEACCENT // modifier letter low tilde
}
+ }
+ });
- //
- // If the menu code is loaded,
- // Check if localization needs loading;
- // If not, post the menu, and return.
- // Otherwise wait for the localization to load
- // Otherwse load the menu code.
- // Try again after the file is loaded.
- //
- var MENU = MathJax.Menu; var load, fn;
- if (MENU) {
- if (MENU.loadingDomain) {return EVENT.False(event)}
- load = LOCALE.loadDomain("MathMenu");
- if (!load) {
- MENU.jax = jax;
- var source = MENU.menu.Find("Show Math As").submenu;
- source.items[0].name = jax.sourceMenuTitle;
- source.items[0].format = (jax.sourceMenuFormat||"MathML");
- source.items[1].name = INPUT[jax.inputJax].sourceMenuTitle;
- source.items[5].disabled = !INPUT[jax.inputJax].annotationEncoding;
+ MathJax.Ajax.loadComplete(MML.optableDir+"/SpacingModLetters.js");
- //
- // Try and find each known annotation format and enable the menu
- // items accordingly.
- //
- var annotations = source.items[2]; annotations.disabled = true;
- var annotationItems = annotations.submenu.items;
- annotationList = MathJax.Hub.Config.semanticsAnnotations;
- for (var i = 0, m = annotationItems.length; i < m; i++) {
- var name = annotationItems[i].name[1]
- if (jax.root && jax.root.getAnnotation(name) !== null) {
- annotations.disabled = false;
- annotationItems[i].hidden = false;
- } else {
- annotationItems[i].hidden = true;
- }
- }
+})(MathJax.ElementJax.mml);
- var MathPlayer = MENU.menu.Find("Math Settings","MathPlayer");
- MathPlayer.hidden = !(jax.outputJax === "NativeMML" && HUB.Browser.hasMathPlayer);
- return MENU.menu.Post(event);
- }
- MENU.loadingDomain = true;
- fn = function () {delete MENU.loadingDomain};
- } else {
- if (AJAX.loadingMathMenu) {return EVENT.False(event)}
- AJAX.loadingMathMenu = true;
- load = AJAX.Require("[MathJax]/extensions/MathMenu.js");
- fn = function () {
- delete AJAX.loadingMathMenu;
- if (!MathJax.Menu) {MathJax.Menu = {}}
- }
- }
- var ev = {
- pageX:event.pageX, pageY:event.pageY,
- clientX:event.clientX, clientY:event.clientY
- };
- CALLBACK.Queue(
- load, fn, // load the file and delete the marker when done
- ["ContextMenu",EVENT,ev,math,force] // call this function again
- );
- return EVENT.False(event);
- },
+/*************************************************************
+ *
+ * MathJax/jax/output/HTML-CSS/optable/MiscTechnical.js
+ *
+ * Copyright (c) 2010-2017 The MathJax Consortium
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
- //
- // Mousedown handler for alternate means of accessing menu
- //
- AltContextMenu: function (event,math) {
- var JAX = OUTPUT[math.jaxID];
- var show = (JAX.config.showMathMenu != null ? JAX : HUB).config.showMathMenu;
- if (show) {
- show = (JAX.config.showMathMenuMSIE != null ? JAX : HUB).config.showMathMenuMSIE;
- if (SETTINGS.context === "MathJax" && !SETTINGS.mpContext && show) {
- if (!ME.noContextMenuBug || event.button !== EVENT.RIGHTBUTTON) return;
- } else {
- if (!event[EVENT.MENUKEY] || event.button !== EVENT.LEFTBUTTON) return;
- }
- return JAX.ContextMenu(event,math,true);
+(function (MML) {
+ var MO = MML.mo.OPTYPES;
+ var TEXCLASS = MML.TEXCLASS;
+
+ MathJax.Hub.Insert(MML.mo.prototype,{
+ OPTABLE: {
+ postfix: {
+ '\u23B4': MO.WIDEACCENT, // top square bracket
+ '\u23B5': MO.WIDEACCENT, // bottom square bracket
+ '\u23DC': MO.WIDEACCENT, // top parenthesis
+ '\u23DD': MO.WIDEACCENT, // bottom parenthesis
+ '\u23E0': MO.WIDEACCENT, // top tortoise shell bracket
+ '\u23E1': MO.WIDEACCENT // bottom tortoise shell bracket
}
- },
+ }
+ });
- ClearSelection: function () {
- if (ME.safariContextMenuBug) {setTimeout("window.getSelection().empty()",0)}
- if (document.selection) {setTimeout("document.selection.empty()",0)}
- },
+ MathJax.Ajax.loadComplete(MML.optableDir+"/MiscTechnical.js");
- getBBox: function (span) {
- span.appendChild(ME.topImg);
- var h = ME.topImg.offsetTop, d = span.offsetHeight-h, w = span.offsetWidth;
- span.removeChild(ME.topImg);
- return {w:w, h:h, d:d};
- }
+})(MathJax.ElementJax.mml);
- };
+/*************************************************************
+ *
+ * MathJax/jax/output/HTML-CSS/optable/SupplementalArrowsA.js
+ *
+ * Copyright (c) 2010-2017 The MathJax Consortium
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
- //
- // Handle hover "discoverability"
- //
- var HOVER = ME.Hover = {
+(function (MML) {
+ var MO = MML.mo.OPTYPES;
+ var TEXCLASS = MML.TEXCLASS;
- //
- // Check if we are moving from a non-MathJax element to a MathJax one
- // and either start fading in again (if it is fading out) or start the
- // timer for the hover
- //
- Mouseover: function (event,math) {
- if (SETTINGS.discoverable || SETTINGS.zoom === "Hover") {
- var from = event.fromElement || event.relatedTarget,
- to = event.toElement || event.target;
- if (from && to && (HUB.isMathJaxNode(from) !== HUB.isMathJaxNode(to) ||
- HUB.getJaxFor(from) !== HUB.getJaxFor(to))) {
- var jax = this.getJaxFromMath(math);
- if (jax.hover) {HOVER.ReHover(jax)} else {HOVER.HoverTimer(jax,math)}
- return EVENT.False(event);
- }
- }
- },
- //
- // Check if we are moving from a MathJax element to a non-MathJax one
- // and either start fading out, or clear the timer if we haven't
- // hovered yet
- //
- Mouseout: function (event,math) {
- if (SETTINGS.discoverable || SETTINGS.zoom === "Hover") {
- var from = event.fromElement || event.relatedTarget,
- to = event.toElement || event.target;
- if (from && to && (HUB.isMathJaxNode(from) !== HUB.isMathJaxNode(to) ||
- HUB.getJaxFor(from) !== HUB.getJaxFor(to))) {
- var jax = this.getJaxFromMath(math);
- if (jax.hover) {HOVER.UnHover(jax)} else {HOVER.ClearHoverTimer()}
- return EVENT.False(event);
- }
- }
- },
- //
- // Restart hover timer if the mouse moves
- //
- Mousemove: function (event,math) {
- if (SETTINGS.discoverable || SETTINGS.zoom === "Hover") {
- var jax = this.getJaxFromMath(math); if (jax.hover) return;
- if (HOVER.lastX == event.clientX && HOVER.lastY == event.clientY) return;
- HOVER.lastX = event.clientX; HOVER.lastY = event.clientY;
- HOVER.HoverTimer(jax,math);
- return EVENT.False(event);
+ MathJax.Hub.Insert(MML.mo.prototype,{
+ OPTABLE: {
+ infix: {
+ '\u27F0': MO.RELSTRETCH, // upwards quadruple arrow
+ '\u27F1': MO.RELSTRETCH, // downwards quadruple arrow
+ '\u27FB': MO.WIDEREL, // long leftwards arrow from bar
+ '\u27FD': MO.WIDEREL, // long leftwards double arrow from bar
+ '\u27FE': MO.WIDEREL, // long rightwards double arrow from bar
+ '\u27FF': MO.WIDEREL // long rightwards squiggle arrow
}
- },
+ }
+ });
- //
- // Clear the old timer and start a new one
- //
- HoverTimer: function (jax,math) {
- this.ClearHoverTimer();
- this.hoverTimer = setTimeout(CALLBACK(["Hover",this,jax,math]),CONFIG.hover);
- },
- ClearHoverTimer: function () {
- if (this.hoverTimer) {clearTimeout(this.hoverTimer); delete this.hoverTimer}
- },
+ MathJax.Ajax.loadComplete(MML.optableDir+"/SupplementalArrowsA.js");
- //
- // Handle putting up the hover frame
- //
- Hover: function (jax,math) {
- //
- // Check if Zoom handles the hover event
- //
- if (EXTENSION.MathZoom && EXTENSION.MathZoom.Hover({},math)) return;
- //
- // Get the hover data
- //
- var JAX = OUTPUT[jax.outputJax],
- span = JAX.getHoverSpan(jax,math),
- bbox = JAX.getHoverBBox(jax,span,math),
- show = (JAX.config.showMathMenu != null ? JAX : HUB).config.showMathMenu;
- var dx = CONFIG.frame.x, dy = CONFIG.frame.y, dd = CONFIG.frame.bwidth; // frame size
- if (ME.msieBorderWidthBug) {dd = 0}
- jax.hover = {opacity:0, id:jax.inputID+"-Hover"};
- //
- // The frame and menu button
- //
- var frame = HTML.Element("span",{
- id:jax.hover.id, isMathJax: true,
- style:{display:"inline-block", width:0, height:0, position:"relative"}
- },[["span",{
- className:"MathJax_Hover_Frame", isMathJax: true,
- style:{
- display:"inline-block", position:"absolute",
- top:this.Px(-bbox.h-dy-dd-(bbox.y||0)), left:this.Px(-dx-dd+(bbox.x||0)),
- width:this.Px(bbox.w+2*dx), height:this.Px(bbox.h+bbox.d+2*dy),
- opacity:0, filter:"alpha(opacity=0)"
- }}
- ]]
- );
- var button = HTML.Element("span",{
- isMathJax: true, id:jax.hover.id+"Menu", className:"MathJax_Menu_Button",
- style:{display:"inline-block", "z-index": 1, width:0, height:0, position:"relative"}
- },[["span",{
- className: "MathJax_Hover_Arrow", isMathJax: true, math: math,
- onclick: this.HoverMenu, jax:JAX.id,
- style: {
- left:this.Px(bbox.w+dx+dd+(bbox.x||0)+CONFIG.button.x),
- top:this.Px(-bbox.h-dy-dd-(bbox.y||0)-CONFIG.button.y),
- opacity:0, filter:"alpha(opacity=0)"
- }
- },[["span",{isMathJax:true},"\u25BC"]]]]
- );
- if (bbox.width) {
- frame.style.width = button.style.width = bbox.width;
- frame.style.marginRight = button.style.marginRight = "-"+bbox.width;
- frame.firstChild.style.width = bbox.width;
- button.firstChild.style.left = "";
- button.firstChild.style.right = this.Px(CONFIG.button.wx);
- }
- //
- // Add the frame and button
- //
- span.parentNode.insertBefore(frame,span);
- if (show) {span.parentNode.insertBefore(button,span)}
- if (span.style) {span.style.position = "relative"} // so math is on top of hover frame
- //
- // Start the hover fade-in
- //
- this.ReHover(jax);
- },
- //
- // Restart the hover fade in and fade-out timers
- //
- ReHover: function (jax) {
- if (jax.hover.remove) {clearTimeout(jax.hover.remove)}
- jax.hover.remove = setTimeout(CALLBACK(["UnHover",this,jax]),CONFIG.fadeoutDelay);
- this.HoverFadeTimer(jax,CONFIG.fadeinInc);
- },
- //
- // Start the fade-out
- //
- UnHover: function (jax) {
- if (!jax.hover.nofade) {this.HoverFadeTimer(jax,-CONFIG.fadeoutInc,CONFIG.fadeoutStart)}
- },
- //
- // Handle the fade-in and fade-out
- //
- HoverFade: function (jax) {
- delete jax.hover.timer;
- jax.hover.opacity = Math.max(0,Math.min(1,jax.hover.opacity + jax.hover.inc));
- jax.hover.opacity = Math.floor(1000*jax.hover.opacity)/1000;
- var frame = document.getElementById(jax.hover.id),
- button = document.getElementById(jax.hover.id+"Menu");
- frame.firstChild.style.opacity = jax.hover.opacity;
- frame.firstChild.style.filter = "alpha(opacity="+Math.floor(100*jax.hover.opacity)+")";
- if (button) {
- button.firstChild.style.opacity = jax.hover.opacity;
- button.firstChild.style.filter = frame.style.filter;
- }
- if (jax.hover.opacity === 1) {return}
- if (jax.hover.opacity > 0) {this.HoverFadeTimer(jax,jax.hover.inc); return}
- frame.parentNode.removeChild(frame);
- if (button) {button.parentNode.removeChild(button)}
- if (jax.hover.remove) {clearTimeout(jax.hover.remove)}
- delete jax.hover;
- },
- //
- // Set the fade to in or out (via inc) and start the timer, if needed
- //
- HoverFadeTimer: function (jax,inc,delay) {
- jax.hover.inc = inc;
- if (!jax.hover.timer) {
- jax.hover.timer = setTimeout(CALLBACK(["HoverFade",this,jax]),(delay||CONFIG.fadeDelay));
+})(MathJax.ElementJax.mml);
+
+/*************************************************************
+ *
+ * MathJax/jax/output/HTML-CSS/optable/GreekAndCoptic.js
+ *
+ * Copyright (c) 2010-2017 The MathJax Consortium
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+(function (MML) {
+ var MO = MML.mo.OPTYPES;
+ var TEXCLASS = MML.TEXCLASS;
+
+ MathJax.Hub.Insert(MML.mo.prototype,{
+ OPTABLE: {
+ infix: {
+ '\u03F6': MO.REL // greek reversed lunate epsilon symbol
}
- },
+ }
+ });
- //
- // Handle a click on the menu button
- //
- HoverMenu: function (event) {
- if (!event) {event = window.event}
- return OUTPUT[this.jax].ContextMenu(event,this.math,true);
- },
+ MathJax.Ajax.loadComplete(MML.optableDir+"/GreekAndCoptic.js");
- //
- // Clear all hover timers
- //
- ClearHover: function (jax) {
- if (jax.hover.remove) {clearTimeout(jax.hover.remove)}
- if (jax.hover.timer) {clearTimeout(jax.hover.timer)}
- HOVER.ClearHoverTimer();
- delete jax.hover;
- },
+})(MathJax.ElementJax.mml);
- //
- // Make a measurement in pixels
- //
- Px: function (m) {
- if (Math.abs(m) < .006) {return "0px"}
- return m.toFixed(2).replace(/\.?0+$/,"") + "px";
- },
+/*************************************************************
+ *
+ * MathJax/jax/output/HTML-CSS/optable/LetterlikeSymbols.js
+ *
+ * Copyright (c) 2010-2017 The MathJax Consortium
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
- //
- // Preload images so they show up with the menu
- //
- getImages: function () {
- if (SETTINGS.discoverable) {
- var menu = new Image();
- menu.src = CONFIG.button.src;
+(function (MML) {
+ var MO = MML.mo.OPTYPES;
+ var TEXCLASS = MML.TEXCLASS;
+
+ MathJax.Hub.Insert(MML.mo.prototype,{
+ OPTABLE: {
+ prefix: {
+ '\u2145': MO.ORD21, // double-struck italic capital d
+ '\u2146': [2,0,TEXCLASS.ORD] // double-struck italic small d
}
}
+ });
- };
+ MathJax.Ajax.loadComplete(MML.optableDir+"/LetterlikeSymbols.js");
- //
- // Handle touch events.
- //
- // Use double-tap-and-hold as a replacement for context menu event.
- // Use double-tap as a replacement for double click.
- //
- var TOUCH = ME.Touch = {
+})(MathJax.ElementJax.mml);
- last: 0, // time of last tap event
- delay: 500, // delay time for double-click
+/*************************************************************
+ *
+ * MathJax/jax/output/HTML-CSS/optable/SupplementalArrowsB.js
+ *
+ * Copyright (c) 2010-2017 The MathJax Consortium
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
- //
- // Check if this is a double-tap, and if so, start the timer
- // for the double-tap and hold (to trigger the contextual menu)
- //
- start: function (event) {
- var now = new Date().getTime();
- var dblTap = (now - TOUCH.last < TOUCH.delay && TOUCH.up);
- TOUCH.last = now; TOUCH.up = false;
- if (dblTap) {
- TOUCH.timeout = setTimeout(TOUCH.menu,TOUCH.delay,event,this);
- event.preventDefault();
- }
- },
+(function (MML) {
+ var MO = MML.mo.OPTYPES;
+ var TEXCLASS = MML.TEXCLASS;
- //
- // Check if there is a timeout pending, i.e., we have a
- // double-tap and were waiting to see if it is held long
- // enough for the menu. Since we got the end before the
- // timeout, it is a double-click, not a double-tap-and-hold.
- // Prevent the default action and issue a double click.
- //
- end: function (event) {
- var now = new Date().getTime();
- TOUCH.up = (now - TOUCH.last < TOUCH.delay);
- if (TOUCH.timeout) {
- clearTimeout(TOUCH.timeout);
- delete TOUCH.timeout; TOUCH.last = 0; TOUCH.up = false;
- event.preventDefault();
- return EVENT.Handler((event.touches[0]||event.touch),"DblClick",this);
+ MathJax.Hub.Insert(MML.mo.prototype,{
+ OPTABLE: {
+ infix: {
+ '\u2900': MO.RELACCENT, // rightwards two-headed arrow with vertical stroke
+ '\u2901': MO.RELACCENT, // rightwards two-headed arrow with double vertical stroke
+ '\u2902': MO.RELACCENT, // leftwards double arrow with vertical stroke
+ '\u2903': MO.RELACCENT, // rightwards double arrow with vertical stroke
+ '\u2904': MO.RELACCENT, // left right double arrow with vertical stroke
+ '\u2905': MO.RELACCENT, // rightwards two-headed arrow from bar
+ '\u2906': MO.RELACCENT, // leftwards double arrow from bar
+ '\u2907': MO.RELACCENT, // rightwards double arrow from bar
+ '\u2908': MO.REL, // downwards arrow with horizontal stroke
+ '\u2909': MO.REL, // upwards arrow with horizontal stroke
+ '\u290A': MO.RELSTRETCH, // upwards triple arrow
+ '\u290B': MO.RELSTRETCH, // downwards triple arrow
+ '\u290C': MO.WIDEREL, // leftwards double dash arrow
+ '\u290D': MO.WIDEREL, // rightwards double dash arrow
+ '\u290E': MO.WIDEREL, // leftwards triple dash arrow
+ '\u290F': MO.WIDEREL, // rightwards triple dash arrow
+ '\u2910': MO.WIDEREL, // rightwards two-headed triple dash arrow
+ '\u2911': MO.RELACCENT, // rightwards arrow with dotted stem
+ '\u2912': MO.RELSTRETCH, // upwards arrow to bar
+ '\u2913': MO.RELSTRETCH, // downwards arrow to bar
+ '\u2914': MO.RELACCENT, // rightwards arrow with tail with vertical stroke
+ '\u2915': MO.RELACCENT, // rightwards arrow with tail with double vertical stroke
+ '\u2916': MO.RELACCENT, // rightwards two-headed arrow with tail
+ '\u2917': MO.RELACCENT, // rightwards two-headed arrow with tail with vertical stroke
+ '\u2918': MO.RELACCENT, // rightwards two-headed arrow with tail with double vertical stroke
+ '\u2919': MO.RELACCENT, // leftwards arrow-tail
+ '\u291A': MO.RELACCENT, // rightwards arrow-tail
+ '\u291B': MO.RELACCENT, // leftwards double arrow-tail
+ '\u291C': MO.RELACCENT, // rightwards double arrow-tail
+ '\u291D': MO.RELACCENT, // leftwards arrow to black diamond
+ '\u291E': MO.RELACCENT, // rightwards arrow to black diamond
+ '\u291F': MO.RELACCENT, // leftwards arrow from bar to black diamond
+ '\u2920': MO.RELACCENT, // rightwards arrow from bar to black diamond
+ '\u2921': MO.RELSTRETCH, // north west and south east arrow
+ '\u2922': MO.RELSTRETCH, // north east and south west arrow
+ '\u2923': MO.REL, // north west arrow with hook
+ '\u2924': MO.REL, // north east arrow with hook
+ '\u2925': MO.REL, // south east arrow with hook
+ '\u2926': MO.REL, // south west arrow with hook
+ '\u2927': MO.REL, // north west arrow and north east arrow
+ '\u2928': MO.REL, // north east arrow and south east arrow
+ '\u2929': MO.REL, // south east arrow and south west arrow
+ '\u292A': MO.REL, // south west arrow and north west arrow
+ '\u292B': MO.REL, // rising diagonal crossing falling diagonal
+ '\u292C': MO.REL, // falling diagonal crossing rising diagonal
+ '\u292D': MO.REL, // south east arrow crossing north east arrow
+ '\u292E': MO.REL, // north east arrow crossing south east arrow
+ '\u292F': MO.REL, // falling diagonal crossing north east arrow
+ '\u2930': MO.REL, // rising diagonal crossing south east arrow
+ '\u2931': MO.REL, // north east arrow crossing north west arrow
+ '\u2932': MO.REL, // north west arrow crossing north east arrow
+ '\u2933': MO.RELACCENT, // wave arrow pointing directly right
+ '\u2934': MO.REL, // arrow pointing rightwards then curving upwards
+ '\u2935': MO.REL, // arrow pointing rightwards then curving downwards
+ '\u2936': MO.REL, // arrow pointing downwards then curving leftwards
+ '\u2937': MO.REL, // arrow pointing downwards then curving rightwards
+ '\u2938': MO.REL, // right-side arc clockwise arrow
+ '\u2939': MO.REL, // left-side arc anticlockwise arrow
+ '\u293A': MO.RELACCENT, // top arc anticlockwise arrow
+ '\u293B': MO.RELACCENT, // bottom arc anticlockwise arrow
+ '\u293C': MO.RELACCENT, // top arc clockwise arrow with minus
+ '\u293D': MO.RELACCENT, // top arc anticlockwise arrow with plus
+ '\u293E': MO.REL, // lower right semicircular clockwise arrow
+ '\u293F': MO.REL, // lower left semicircular anticlockwise arrow
+ '\u2940': MO.REL, // anticlockwise closed circle arrow
+ '\u2941': MO.REL, // clockwise closed circle arrow
+ '\u2942': MO.RELACCENT, // rightwards arrow above short leftwards arrow
+ '\u2943': MO.RELACCENT, // leftwards arrow above short rightwards arrow
+ '\u2944': MO.RELACCENT, // short rightwards arrow above leftwards arrow
+ '\u2945': MO.RELACCENT, // rightwards arrow with plus below
+ '\u2946': MO.RELACCENT, // leftwards arrow with plus below
+ '\u2947': MO.RELACCENT, // rightwards arrow through x
+ '\u2948': MO.RELACCENT, // left right arrow through small circle
+ '\u2949': MO.REL, // upwards two-headed arrow from small circle
+ '\u294A': MO.RELACCENT, // left barb up right barb down harpoon
+ '\u294B': MO.RELACCENT, // left barb down right barb up harpoon
+ '\u294C': MO.REL, // up barb right down barb left harpoon
+ '\u294D': MO.REL, // up barb left down barb right harpoon
+ '\u294E': MO.WIDEREL, // left barb up right barb up harpoon
+ '\u294F': MO.RELSTRETCH, // up barb right down barb right harpoon
+ '\u2950': MO.WIDEREL, // left barb down right barb down harpoon
+ '\u2951': MO.RELSTRETCH, // up barb left down barb left harpoon
+ '\u2952': MO.WIDEREL, // leftwards harpoon with barb up to bar
+ '\u2953': MO.WIDEREL, // rightwards harpoon with barb up to bar
+ '\u2954': MO.RELSTRETCH, // upwards harpoon with barb right to bar
+ '\u2955': MO.RELSTRETCH, // downwards harpoon with barb right to bar
+ '\u2956': MO.RELSTRETCH, // leftwards harpoon with barb down to bar
+ '\u2957': MO.RELSTRETCH, // rightwards harpoon with barb down to bar
+ '\u2958': MO.RELSTRETCH, // upwards harpoon with barb left to bar
+ '\u2959': MO.RELSTRETCH, // downwards harpoon with barb left to bar
+ '\u295A': MO.WIDEREL, // leftwards harpoon with barb up from bar
+ '\u295B': MO.WIDEREL, // rightwards harpoon with barb up from bar
+ '\u295C': MO.RELSTRETCH, // upwards harpoon with barb right from bar
+ '\u295D': MO.RELSTRETCH, // downwards harpoon with barb right from bar
+ '\u295E': MO.WIDEREL, // leftwards harpoon with barb down from bar
+ '\u295F': MO.WIDEREL, // rightwards harpoon with barb down from bar
+ '\u2960': MO.RELSTRETCH, // upwards harpoon with barb left from bar
+ '\u2961': MO.RELSTRETCH, // downwards harpoon with barb left from bar
+ '\u2962': MO.RELACCENT, // leftwards harpoon with barb up above leftwards harpoon with barb down
+ '\u2963': MO.REL, // upwards harpoon with barb left beside upwards harpoon with barb right
+ '\u2964': MO.RELACCENT, // rightwards harpoon with barb up above rightwards harpoon with barb down
+ '\u2965': MO.REL, // downwards harpoon with barb left beside downwards harpoon with barb right
+ '\u2966': MO.RELACCENT, // leftwards harpoon with barb up above rightwards harpoon with barb up
+ '\u2967': MO.RELACCENT, // leftwards harpoon with barb down above rightwards harpoon with barb down
+ '\u2968': MO.RELACCENT, // rightwards harpoon with barb up above leftwards harpoon with barb up
+ '\u2969': MO.RELACCENT, // rightwards harpoon with barb down above leftwards harpoon with barb down
+ '\u296A': MO.RELACCENT, // leftwards harpoon with barb up above long dash
+ '\u296B': MO.RELACCENT, // leftwards harpoon with barb down below long dash
+ '\u296C': MO.RELACCENT, // rightwards harpoon with barb up above long dash
+ '\u296D': MO.RELACCENT, // rightwards harpoon with barb down below long dash
+ '\u296E': MO.RELSTRETCH, // upwards harpoon with barb left beside downwards harpoon with barb right
+ '\u296F': MO.RELSTRETCH, // downwards harpoon with barb left beside upwards harpoon with barb right
+ '\u2970': MO.RELACCENT, // right double arrow with rounded head
+ '\u2971': MO.RELACCENT, // equals sign above rightwards arrow
+ '\u2972': MO.RELACCENT, // tilde operator above rightwards arrow
+ '\u2973': MO.RELACCENT, // leftwards arrow above tilde operator
+ '\u2974': MO.RELACCENT, // rightwards arrow above tilde operator
+ '\u2975': MO.RELACCENT, // rightwards arrow above almost equal to
+ '\u2976': MO.RELACCENT, // less-than above leftwards arrow
+ '\u2977': MO.RELACCENT, // leftwards arrow through less-than
+ '\u2978': MO.RELACCENT, // greater-than above rightwards arrow
+ '\u2979': MO.RELACCENT, // subset above rightwards arrow
+ '\u297A': MO.RELACCENT, // leftwards arrow through subset
+ '\u297B': MO.RELACCENT, // superset above leftwards arrow
+ '\u297C': MO.RELACCENT, // left fish tail
+ '\u297D': MO.RELACCENT, // right fish tail
+ '\u297E': MO.REL, // up fish tail
+ '\u297F': MO.REL // down fish tail
}
- },
-
- //
- // If the timeout passes without an end event, we issue
- // the contextual menu event.
- //
- menu: function (event,math) {
- delete TOUCH.timeout; TOUCH.last = 0; TOUCH.up = false;
- return EVENT.Handler((event.touches[0]||event.touch),"ContextMenu",math);
}
+ });
- };
+ MathJax.Ajax.loadComplete(MML.optableDir+"/SupplementalArrowsB.js");
- /*
- * //
- * // Mobile screens are small, so use larger version of arrow
- * //
- * if (HUB.Browser.isMobile) {
- * var arrow = CONFIG.styles[".MathJax_Hover_Arrow"];
- * arrow.width = "25px"; arrow.height = "18px";
- * CONFIG.button.x = -6;
- * }
- */
+})(MathJax.ElementJax.mml);
- //
- // Set up browser-specific values
- //
- HUB.Browser.Select({
- MSIE: function (browser) {
- var mode = (document.documentMode || 0);
- var isIE8 = browser.versionAtLeast("8.0");
- ME.msieBorderWidthBug = (document.compatMode === "BackCompat"); // borders are inside offsetWidth/Height
- ME.msieEventBug = browser.isIE9; // must get event from window even though event is passed
- ME.msieAlignBug = (!isIE8 || mode < 8); // inline-block spans don't rest on baseline
- if (mode < 9) {EVENT.LEFTBUTTON = 1} // IE < 9 has wrong event.button values
- },
- Safari: function (browser) {
- ME.safariContextMenuBug = true; // selection can be started by contextmenu event
- },
- Opera: function (browser) {
- ME.operaPositionBug = true; // position is wrong unless border is used
- },
- Konqueror: function (browser) {
- ME.noContextMenuBug = true; // doesn't produce contextmenu event
+/*************************************************************
+ *
+ * MathJax/jax/output/HTML-CSS/optable/BasicLatin.js
+ *
+ * Copyright (c) 2010-2017 The MathJax Consortium
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+(function (MML) {
+ var MO = MML.mo.OPTYPES;
+ var TEXCLASS = MML.TEXCLASS;
+
+ MathJax.Hub.Insert(MML.mo.prototype,{
+ OPTABLE: {
+ prefix: {
+ '||': [0,0,TEXCLASS.BIN,{fence: true, stretchy: true, symmetric: true}], // multiple character operator: ||
+ '|||': [0,0,TEXCLASS.ORD,{fence: true, stretchy: true, symmetric: true}] // multiple character operator: |||
+ },
+ postfix: {
+ '!!': [1,0,TEXCLASS.BIN], // multiple character operator: !!
+ '\'': MO.ACCENT, // apostrophe
+ '++': [0,0,TEXCLASS.BIN], // multiple character operator: ++
+ '--': [0,0,TEXCLASS.BIN], // multiple character operator: --
+ '..': [0,0,TEXCLASS.BIN], // multiple character operator: ..
+ '...': MO.ORD, // multiple character operator: ...
+ '||': [0,0,TEXCLASS.BIN,{fence: true, stretchy: true, symmetric: true}], // multiple character operator: ||
+ '|||': [0,0,TEXCLASS.ORD,{fence: true, stretchy: true, symmetric: true}] // multiple character operator: |||
+ },
+ infix: {
+ '!=': MO.BIN4, // multiple character operator: !=
+ '&&': MO.BIN4, // multiple character operator: &&
+ '**': [1,1,TEXCLASS.BIN], // multiple character operator: **
+ '*=': MO.BIN4, // multiple character operator: *=
+ '+=': MO.BIN4, // multiple character operator: +=
+ '-=': MO.BIN4, // multiple character operator: -=
+ '->': MO.BIN5, // multiple character operator: ->
+ '//': [1,1,TEXCLASS.BIN], // multiple character operator: //
+ '/=': MO.BIN4, // multiple character operator: /=
+ ':=': MO.BIN4, // multiple character operator: :=
+ '<=': MO.BIN5, // multiple character operator: <=
+ '<>': [1,1,TEXCLASS.BIN], // multiple character operator: <>
+ '==': MO.BIN4, // multiple character operator: ==
+ '>=': MO.BIN5, // multiple character operator: >=
+ '@': MO.ORD11, // commercial at
+ '||': [2,2,TEXCLASS.BIN,{fence: true, stretchy: true, symmetric: true}], // multiple character operator: ||
+ '|||': [2,2,TEXCLASS.ORD,{fence: true, stretchy: true, symmetric: true}] // multiple character operator: |||
+ }
}
});
- //
- // Used in measuring zoom and hover positions
- //
- ME.topImg = (ME.msieAlignBug ?
- HTML.Element("img",{style:{width:0,height:0,position:"relative"},src:"about:blank"}) :
- HTML.Element("span",{style:{width:0,height:0,display:"inline-block"}})
- );
- if (ME.operaPositionBug) {ME.topImg.style.border="1px solid"}
+ MathJax.Ajax.loadComplete(MML.optableDir+"/BasicLatin.js");
- //
- // Get configuration from user
- //
- ME.config = CONFIG = HUB.CombineConfig("MathEvents",CONFIG);
- var SETFRAME = function () {
- var haze = CONFIG.styles[".MathJax_Hover_Frame"];
- haze.border = CONFIG.frame.bwidth+"px solid "+CONFIG.frame.bcolor+" ! important";
- haze["box-shadow"] = haze["-webkit-box-shadow"] =
- haze["-moz-box-shadow"] = haze["-khtml-box-shadow"] =
- "0px 0px "+CONFIG.frame.hwidth+" "+CONFIG.frame.hcolor;
- };
+})(MathJax.ElementJax.mml);
- //
- // Queue the events needed for startup
- //
- CALLBACK.Queue(
- HUB.Register.StartupHook("End Config",{}), // wait until config is complete
- [SETFRAME],
- ["getImages",HOVER],
- ["Styles",AJAX,CONFIG.styles],
- ["Post",HUB.Startup.signal,"MathEvents Ready"],
- ["loadComplete",AJAX,"[MathJax]/extensions/MathEvents.js"]
- );
+/*************************************************************
+ *
+ * MathJax/jax/output/HTML-CSS/optable/MiscSymbolsAndArrows.js
+ *
+ * Copyright (c) 2010-2017 The MathJax Consortium
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
-})(MathJax.Hub,MathJax.HTML,MathJax.Ajax,MathJax.Callback,
- MathJax.Localization,MathJax.OutputJax,MathJax.InputJax);
+(function (MML) {
+ var MO = MML.mo.OPTYPES;
+ var TEXCLASS = MML.TEXCLASS;
-/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */
-/* vim: set ts=2 et sw=2 tw=80: */
+ MathJax.Hub.Insert(MML.mo.prototype,{
+ OPTABLE: {
+ infix: {
+ '\u2B45': MO.RELSTRETCH, // leftwards quadruple arrow
+ '\u2B46': MO.RELSTRETCH // rightwards quadruple arrow
+ }
+ }
+ });
+
+ MathJax.Ajax.loadComplete(MML.optableDir+"/MiscSymbolsAndArrows.js");
+
+})(MathJax.ElementJax.mml);
/*************************************************************
*
- * MathJax/extensions/tex2jax.js
- *
- * Implements the TeX to Jax preprocessor that locates TeX code
- * within the text of a document and replaces it with SCRIPT tags
- * for processing by MathJax.
+ * MathJax/jax/output/HTML-CSS/optable/CombDiacritMarks.js
+ *
+ * Copyright (c) 2010-2017 The MathJax Consortium
*
- * ---------------------------------------------------------------------
- *
- * Copyright (c) 2009-2017 The MathJax Consortium
- *
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
+ *
*/
-MathJax.Extension.tex2jax = {
- version: "2.7.2",
- config: {
- inlineMath: [ // The start/stop pairs for in-line math
-// ['$','$'], // (comment out any you don't want, or add your own, but
- ['\\(','\\)'] // be sure that you don't have an extra comma at the end)
- ],
+(function (MML) {
+ var MO = MML.mo.OPTYPES;
+ var TEXCLASS = MML.TEXCLASS;
- displayMath: [ // The start/stop pairs for display math
- ['$$','$$'], // (comment out any you don't want, or add your own, but
- ['\\[','\\]'] // be sure that you don't have an extra comma at the end)
- ],
+ MathJax.Hub.Insert(MML.mo.prototype,{
+ OPTABLE: {
+ postfix: {
+ '\u0311': MO.ACCENT // combining inverted breve
+ }
+ }
+ });
- balanceBraces: true, // determines whether tex2jax requires braces to be
- // balanced within math delimiters (allows for nested
- // dollar signs). Set to false to get pre-v2.0 compatibility.
+ MathJax.Ajax.loadComplete(MML.optableDir+"/CombDiacritMarks.js");
- skipTags: ["script","noscript","style","textarea","pre","code","annotation","annotation-xml"],
- // The names of the tags whose contents will not be
- // scanned for math delimiters
+})(MathJax.ElementJax.mml);
- ignoreClass: "tex2jax_ignore", // the class name of elements whose contents should
- // NOT be processed by tex2jax. Note that this
- // is a regular expression, so be sure to quote any
- // regexp special characters
+/*************************************************************
+ *
+ * MathJax/jax/output/HTML-CSS/optable/GeometricShapes.js
+ *
+ * Copyright (c) 2010-2017 The MathJax Consortium
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
- processClass: "tex2jax_process", // the class name of elements whose contents SHOULD
- // be processed when they appear inside ones that
- // are ignored. Note that this is a regular expression,
- // so be sure to quote any regexp special characters
+(function (MML) {
+ var MO = MML.mo.OPTYPES;
+ var TEXCLASS = MML.TEXCLASS;
- processEscapes: false, // set to true to allow \$ to produce a dollar without
- // starting in-line math mode
+ MathJax.Hub.Insert(MML.mo.prototype,{
+ OPTABLE: {
+ infix: {
+ '\u25A0': MO.BIN3, // black square
+ '\u25A1': MO.BIN3, // white square
+ '\u25AA': MO.BIN3, // black small square
+ '\u25AB': MO.BIN3, // white small square
+ '\u25AD': MO.BIN3, // white rectangle
+ '\u25AE': MO.BIN3, // black vertical rectangle
+ '\u25AF': MO.BIN3, // white vertical rectangle
+ '\u25B0': MO.BIN3, // black parallelogram
+ '\u25B1': MO.BIN3, // white parallelogram
+ '\u25B2': MO.BIN4, // black up-pointing triangle
+ '\u25B4': MO.BIN4, // black up-pointing small triangle
+ '\u25B6': MO.BIN4, // black right-pointing triangle
+ '\u25B7': MO.BIN4, // white right-pointing triangle
+ '\u25B8': MO.BIN4, // black right-pointing small triangle
+ '\u25BC': MO.BIN4, // black down-pointing triangle
+ '\u25BE': MO.BIN4, // black down-pointing small triangle
+ '\u25C0': MO.BIN4, // black left-pointing triangle
+ '\u25C1': MO.BIN4, // white left-pointing triangle
+ '\u25C2': MO.BIN4, // black left-pointing small triangle
+ '\u25C4': MO.BIN4, // black left-pointing pointer
+ '\u25C5': MO.BIN4, // white left-pointing pointer
+ '\u25C6': MO.BIN4, // black diamond
+ '\u25C7': MO.BIN4, // white diamond
+ '\u25C8': MO.BIN4, // white diamond containing black small diamond
+ '\u25C9': MO.BIN4, // fisheye
+ '\u25CC': MO.BIN4, // dotted circle
+ '\u25CD': MO.BIN4, // circle with vertical fill
+ '\u25CE': MO.BIN4, // bullseye
+ '\u25CF': MO.BIN4, // black circle
+ '\u25D6': MO.BIN4, // left half black circle
+ '\u25D7': MO.BIN4, // right half black circle
+ '\u25E6': MO.BIN4 // white bullet
+ }
+ }
+ });
- processEnvironments: true, // set to true to process \begin{xxx}...\end{xxx} outside
- // of math mode, false to prevent that
+ MathJax.Ajax.loadComplete(MML.optableDir+"/GeometricShapes.js");
- processRefs: true, // set to true to process \ref{...} outside of math mode
+})(MathJax.ElementJax.mml);
+/*************************************************************
+ *
+ * MathJax/jax/output/HTML-CSS/optable/MathOperators.js
+ *
+ * Copyright (c) 2010-2017 The MathJax Consortium
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
- preview: "TeX" // set to "none" to not insert MathJax_Preview spans
- // or set to an array specifying an HTML snippet
- // to use the same preview for every equation.
+(function (MML) {
+ var MO = MML.mo.OPTYPES;
+ var TEXCLASS = MML.TEXCLASS;
- },
-
- //
- // Tags to ignore when searching for TeX in the page
- //
- ignoreTags: {
- br: (MathJax.Hub.Browser.isMSIE && document.documentMode < 9 ? "\n" : " "),
- wbr: "",
- "#comment": ""
- },
-
- PreProcess: function (element) {
- if (!this.configured) {
- this.config = MathJax.Hub.CombineConfig("tex2jax",this.config);
- if (this.config.Augment) {MathJax.Hub.Insert(this,this.config.Augment)}
- if (typeof(this.config.previewTeX) !== "undefined" && !this.config.previewTeX)
- {this.config.preview = "none"} // backward compatibility for previewTeX parameter
- this.configured = true;
- }
- if (typeof(element) === "string") {element = document.getElementById(element)}
- if (!element) {element = document.body}
- if (this.createPatterns()) {this.scanElement(element,element.nextSibling)}
- },
-
- createPatterns: function () {
- var starts = [], parts = [], i, m, config = this.config;
- this.match = {};
- for (i = 0, m = config.inlineMath.length; i < m; i++) {
- starts.push(this.patternQuote(config.inlineMath[i][0]));
- this.match[config.inlineMath[i][0]] = {
- mode: "",
- end: config.inlineMath[i][1],
- pattern: this.endPattern(config.inlineMath[i][1])
- };
- }
- for (i = 0, m = config.displayMath.length; i < m; i++) {
- starts.push(this.patternQuote(config.displayMath[i][0]));
- this.match[config.displayMath[i][0]] = {
- mode: "; mode=display",
- end: config.displayMath[i][1],
- pattern: this.endPattern(config.displayMath[i][1])
- };
- }
- if (starts.length) {parts.push(starts.sort(this.sortLength).join("|"))}
- if (config.processEnvironments) {parts.push("\\\\begin\\{([^}]*)\\}")}
- if (config.processEscapes) {parts.push("\\\\*\\\\\\\$")}
- if (config.processRefs) {parts.push("\\\\(eq)?ref\\{[^}]*\\}")}
- this.start = new RegExp(parts.join("|"),"g");
- this.skipTags = new RegExp("^("+config.skipTags.join("|")+")$","i");
- var ignore = [];
- if (MathJax.Hub.config.preRemoveClass) {ignore.push(MathJax.Hub.config.preRemoveClass)};
- if (config.ignoreClass) {ignore.push(config.ignoreClass)}
- this.ignoreClass = (ignore.length ? new RegExp("(^| )("+ignore.join("|")+")( |$)") : /^$/);
- this.processClass = new RegExp("(^| )("+config.processClass+")( |$)");
- return (parts.length > 0);
- },
-
- patternQuote: function (s) {return s.replace(/([\^$(){}+*?\-|\[\]\:\\])/g,'\\$1')},
-
- endPattern: function (end) {
- return new RegExp(this.patternQuote(end)+"|\\\\.|[{}]","g");
- },
-
- sortLength: function (a,b) {
- if (a.length !== b.length) {return b.length - a.length}
- return (a == b ? 0 : (a < b ? -1 : 1));
- },
-
- scanElement: function (element,stop,ignore) {
- var cname, tname, ignoreChild, process;
- while (element && element != stop) {
- if (element.nodeName.toLowerCase() === '#text') {
- if (!ignore) {element = this.scanText(element)}
- } else {
- cname = (typeof(element.className) === "undefined" ? "" : element.className);
- tname = (typeof(element.tagName) === "undefined" ? "" : element.tagName);
- if (typeof(cname) !== "string") {cname = String(cname)} // jsxgraph uses non-string class names!
- process = this.processClass.exec(cname);
- if (element.firstChild && !cname.match(/(^| )MathJax/) &&
- (process || !this.skipTags.exec(tname))) {
- ignoreChild = (ignore || this.ignoreClass.exec(cname)) && !process;
- this.scanElement(element.firstChild,stop,ignoreChild);
- }
- }
- if (element) {element = element.nextSibling}
- }
- },
-
- scanText: function (element) {
- if (element.nodeValue.replace(/\s+/,'') == '') {return element}
- var match, prev;
- this.search = {start: true};
- this.pattern = this.start;
- while (element) {
- this.pattern.lastIndex = 0;
- while (element && element.nodeName.toLowerCase() === '#text' &&
- (match = this.pattern.exec(element.nodeValue))) {
- if (this.search.start) {element = this.startMatch(match,element)}
- else {element = this.endMatch(match,element)}
- }
- if (this.search.matched) {element = this.encloseMath(element)}
- if (element) {
- do {prev = element; element = element.nextSibling}
- while (element && this.ignoreTags[element.nodeName.toLowerCase()] != null);
- if (!element || element.nodeName !== '#text')
- {return (this.search.close ? this.prevEndMatch() : prev)}
- }
- }
- return element;
- },
-
- startMatch: function (match,element) {
- var delim = this.match[match[0]];
- if (delim != null) { // a start delimiter
- this.search = {
- end: delim.end, mode: delim.mode, pcount: 0,
- open: element, olen: match[0].length, opos: this.pattern.lastIndex - match[0].length
- };
- this.switchPattern(delim.pattern);
- } else if (match[0].substr(0,6) === "\\begin") { // \begin{...}
- this.search = {
- end: "\\end{"+match[1]+"}", mode: "; mode=display", pcount: 0,
- open: element, olen: 0, opos: this.pattern.lastIndex - match[0].length,
- isBeginEnd: true
- };
- this.switchPattern(this.endPattern(this.search.end));
- } else if (match[0].substr(0,4) === "\\ref" || match[0].substr(0,6) === "\\eqref") {
- this.search = {
- mode: "", end: "", open: element, pcount: 0,
- olen: 0, opos: this.pattern.lastIndex - match[0].length
- }
- return this.endMatch([""],element);
- } else { // escaped dollar signs
- // put $ in a span so it doesn't get processed again
- // split off backslashes so they don't get removed later
- var slashes = match[0].substr(0,match[0].length-1), n, span;
- if (slashes.length % 2 === 0) {span = [slashes.replace(/\\\\/g,"\\")]; n = 1}
- else {span = [slashes.substr(1).replace(/\\\\/g,"\\"),"$"]; n = 0}
- span = MathJax.HTML.Element("span",null,span);
- var text = MathJax.HTML.TextNode(element.nodeValue.substr(0,match.index));
- element.nodeValue = element.nodeValue.substr(match.index + match[0].length - n);
- element.parentNode.insertBefore(span,element);
- element.parentNode.insertBefore(text,span);
- this.pattern.lastIndex = n;
- }
- return element;
- },
-
- endMatch: function (match,element) {
- var search = this.search;
- if (match[0] == search.end) {
- if (!search.close || search.pcount === 0) {
- search.close = element;
- search.cpos = this.pattern.lastIndex;
- search.clen = (search.isBeginEnd ? 0 : match[0].length);
- }
- if (search.pcount === 0) {
- search.matched = true;
- element = this.encloseMath(element);
- this.switchPattern(this.start);
- }
- }
- else if (match[0] === "{") {search.pcount++}
- else if (match[0] === "}" && search.pcount) {search.pcount--}
- return element;
- },
- prevEndMatch: function () {
- this.search.matched = true;
- var element = this.encloseMath(this.search.close);
- this.switchPattern(this.start);
- return element;
- },
-
- switchPattern: function (pattern) {
- pattern.lastIndex = this.pattern.lastIndex;
- this.pattern = pattern;
- this.search.start = (pattern === this.start);
- },
-
- encloseMath: function (element) {
- var search = this.search, close = search.close, CLOSE, math, next;
- if (search.cpos === close.length) {close = close.nextSibling}
- else {close = close.splitText(search.cpos)}
- if (!close) {CLOSE = close = MathJax.HTML.addText(search.close.parentNode,"")}
- search.close = close;
- math = (search.opos ? search.open.splitText(search.opos) : search.open);
- while ((next = math.nextSibling) && next !== close) {
- if (next.nodeValue !== null) {
- if (next.nodeName === "#comment") {
- math.nodeValue += next.nodeValue.replace(/^\[CDATA\[((.|\n|\r)*)\]\]$/,"$1");
- } else {
- math.nodeValue += next.nodeValue;
- }
- } else {
- var ignore = this.ignoreTags[next.nodeName.toLowerCase()];
- math.nodeValue += (ignore == null ? " " : ignore);
+ MathJax.Hub.Insert(MML.mo.prototype,{
+ OPTABLE: {
+ prefix: {
+ '\u2204': MO.ORD21, // there does not exist
+ '\u221B': MO.ORD11, // cube root
+ '\u221C': MO.ORD11, // fourth root
+ '\u2221': MO.ORD, // measured angle
+ '\u2222': MO.ORD, // spherical angle
+ '\u222C': MO.INTEGRAL, // double integral
+ '\u222D': MO.INTEGRAL, // triple integral
+ '\u222F': MO.INTEGRAL, // surface integral
+ '\u2230': MO.INTEGRAL, // volume integral
+ '\u2231': MO.INTEGRAL, // clockwise integral
+ '\u2232': MO.INTEGRAL, // clockwise contour integral
+ '\u2233': MO.INTEGRAL // anticlockwise contour integral
+ },
+ infix: {
+ '\u2201': [1,2,TEXCLASS.ORD], // complement
+ '\u2206': MO.BIN3, // increment
+ '\u220A': MO.REL, // small element of
+ '\u220C': MO.REL, // does not contain as member
+ '\u220D': MO.REL, // small contains as member
+ '\u220E': MO.BIN3, // end of proof
+ '\u2214': MO.BIN4, // dot plus
+ '\u221F': MO.REL, // right angle
+ '\u2224': MO.REL, // does not divide
+ '\u2226': MO.REL, // not parallel to
+ '\u2234': MO.REL, // therefore
+ '\u2235': MO.REL, // because
+ '\u2236': MO.REL, // ratio
+ '\u2237': MO.REL, // proportion
+ '\u2238': MO.BIN4, // dot minus
+ '\u2239': MO.REL, // excess
+ '\u223A': MO.BIN4, // geometric proportion
+ '\u223B': MO.REL, // homothetic
+ '\u223D': MO.REL, // reversed tilde
+ '\u223D\u0331': MO.BIN3, // reversed tilde with underline
+ '\u223E': MO.REL, // inverted lazy s
+ '\u223F': MO.BIN3, // sine wave
+ '\u2241': MO.REL, // not tilde
+ '\u2242': MO.REL, // minus tilde
+ '\u2242\u0338': MO.REL, // minus tilde with slash
+ '\u2244': MO.REL, // not asymptotically equal to
+ '\u2246': MO.REL, // approximately but not actually equal to
+ '\u2247': MO.REL, // neither approximately nor actually equal to
+ '\u2249': MO.REL, // not almost equal to
+ '\u224A': MO.REL, // almost equal or equal to
+ '\u224B': MO.REL, // triple tilde
+ '\u224C': MO.REL, // all equal to
+ '\u224E': MO.REL, // geometrically equivalent to
+ '\u224E\u0338': MO.REL, // geometrically equivalent to with slash
+ '\u224F': MO.REL, // difference between
+ '\u224F\u0338': MO.REL, // difference between with slash
+ '\u2251': MO.REL, // geometrically equal to
+ '\u2252': MO.REL, // approximately equal to or the image of
+ '\u2253': MO.REL, // image of or approximately equal to
+ '\u2254': MO.REL, // colon equals
+ '\u2255': MO.REL, // equals colon
+ '\u2256': MO.REL, // ring in equal to
+ '\u2257': MO.REL, // ring equal to
+ '\u2258': MO.REL, // corresponds to
+ '\u2259': MO.REL, // estimates
+ '\u225A': MO.REL, // equiangular to
+ '\u225C': MO.REL, // delta equal to
+ '\u225D': MO.REL, // equal to by definition
+ '\u225E': MO.REL, // measured by
+ '\u225F': MO.REL, // questioned equal to
+ '\u2262': MO.REL, // not identical to
+ '\u2263': MO.REL, // strictly equivalent to
+ '\u2266': MO.REL, // less-than over equal to
+ '\u2266\u0338': MO.REL, // less-than over equal to with slash
+ '\u2267': MO.REL, // greater-than over equal to
+ '\u2268': MO.REL, // less-than but not equal to
+ '\u2269': MO.REL, // greater-than but not equal to
+ '\u226A\u0338': MO.REL, // much less than with slash
+ '\u226B\u0338': MO.REL, // much greater than with slash
+ '\u226C': MO.REL, // between
+ '\u226D': MO.REL, // not equivalent to
+ '\u226E': MO.REL, // not less-than
+ '\u226F': MO.REL, // not greater-than
+ '\u2270': MO.REL, // neither less-than nor equal to
+ '\u2271': MO.REL, // neither greater-than nor equal to
+ '\u2272': MO.REL, // less-than or equivalent to
+ '\u2273': MO.REL, // greater-than or equivalent to
+ '\u2274': MO.REL, // neither less-than nor equivalent to
+ '\u2275': MO.REL, // neither greater-than nor equivalent to
+ '\u2276': MO.REL, // less-than or greater-than
+ '\u2277': MO.REL, // greater-than or less-than
+ '\u2278': MO.REL, // neither less-than nor greater-than
+ '\u2279': MO.REL, // neither greater-than nor less-than
+ '\u227C': MO.REL, // precedes or equal to
+ '\u227D': MO.REL, // succeeds or equal to
+ '\u227E': MO.REL, // precedes or equivalent to
+ '\u227F': MO.REL, // succeeds or equivalent to
+ '\u227F\u0338': MO.REL, // succeeds or equivalent to with slash
+ '\u2280': MO.REL, // does not precede
+ '\u2281': MO.REL, // does not succeed
+ '\u2282\u20D2': MO.REL, // subset of with vertical line
+ '\u2283\u20D2': MO.REL, // superset of with vertical line
+ '\u2284': MO.REL, // not a subset of
+ '\u2285': MO.REL, // not a superset of
+ '\u2288': MO.REL, // neither a subset of nor equal to
+ '\u2289': MO.REL, // neither a superset of nor equal to
+ '\u228A': MO.REL, // subset of with not equal to
+ '\u228B': MO.REL, // superset of with not equal to
+ '\u228C': MO.BIN4, // multiset
+ '\u228D': MO.BIN4, // multiset multiplication
+ '\u228F': MO.REL, // square image of
+ '\u228F\u0338': MO.REL, // square image of with slash
+ '\u2290': MO.REL, // square original of
+ '\u2290\u0338': MO.REL, // square original of with slash
+ '\u229A': MO.BIN4, // circled ring operator
+ '\u229B': MO.BIN4, // circled asterisk operator
+ '\u229C': MO.BIN4, // circled equals
+ '\u229D': MO.BIN4, // circled dash
+ '\u229E': MO.BIN4, // squared plus
+ '\u229F': MO.BIN4, // squared minus
+ '\u22A0': MO.BIN4, // squared times
+ '\u22A1': MO.BIN4, // squared dot operator
+ '\u22A6': MO.REL, // assertion
+ '\u22A7': MO.REL, // models
+ '\u22A9': MO.REL, // forces
+ '\u22AA': MO.REL, // triple vertical bar right turnstile
+ '\u22AB': MO.REL, // double vertical bar double right turnstile
+ '\u22AC': MO.REL, // does not prove
+ '\u22AD': MO.REL, // not true
+ '\u22AE': MO.REL, // does not force
+ '\u22AF': MO.REL, // negated double vertical bar double right turnstile
+ '\u22B0': MO.REL, // precedes under relation
+ '\u22B1': MO.REL, // succeeds under relation
+ '\u22B2': MO.REL, // normal subgroup of
+ '\u22B3': MO.REL, // contains as normal subgroup
+ '\u22B4': MO.REL, // normal subgroup of or equal to
+ '\u22B5': MO.REL, // contains as normal subgroup or equal to
+ '\u22B6': MO.REL, // original of
+ '\u22B7': MO.REL, // image of
+ '\u22B8': MO.REL, // multimap
+ '\u22B9': MO.REL, // hermitian conjugate matrix
+ '\u22BA': MO.BIN4, // intercalate
+ '\u22BB': MO.BIN4, // xor
+ '\u22BC': MO.BIN4, // nand
+ '\u22BD': MO.BIN4, // nor
+ '\u22BE': MO.BIN3, // right angle with arc
+ '\u22BF': MO.BIN3, // right triangle
+ '\u22C7': MO.BIN4, // division times
+ '\u22C9': MO.BIN4, // left normal factor semidirect product
+ '\u22CA': MO.BIN4, // right normal factor semidirect product
+ '\u22CB': MO.BIN4, // left semidirect product
+ '\u22CC': MO.BIN4, // right semidirect product
+ '\u22CD': MO.REL, // reversed tilde equals
+ '\u22CE': MO.BIN4, // curly logical or
+ '\u22CF': MO.BIN4, // curly logical and
+ '\u22D0': MO.REL, // double subset
+ '\u22D1': MO.REL, // double superset
+ '\u22D2': MO.BIN4, // double intersection
+ '\u22D3': MO.BIN4, // double union
+ '\u22D4': MO.REL, // pitchfork
+ '\u22D5': MO.REL, // equal and parallel to
+ '\u22D6': MO.REL, // less-than with dot
+ '\u22D7': MO.REL, // greater-than with dot
+ '\u22D8': MO.REL, // very much less-than
+ '\u22D9': MO.REL, // very much greater-than
+ '\u22DA': MO.REL, // less-than equal to or greater-than
+ '\u22DB': MO.REL, // greater-than equal to or less-than
+ '\u22DC': MO.REL, // equal to or less-than
+ '\u22DD': MO.REL, // equal to or greater-than
+ '\u22DE': MO.REL, // equal to or precedes
+ '\u22DF': MO.REL, // equal to or succeeds
+ '\u22E0': MO.REL, // does not precede or equal
+ '\u22E1': MO.REL, // does not succeed or equal
+ '\u22E2': MO.REL, // not square image of or equal to
+ '\u22E3': MO.REL, // not square original of or equal to
+ '\u22E4': MO.REL, // square image of or not equal to
+ '\u22E5': MO.REL, // square original of or not equal to
+ '\u22E6': MO.REL, // less-than but not equivalent to
+ '\u22E7': MO.REL, // greater-than but not equivalent to
+ '\u22E8': MO.REL, // precedes but not equivalent to
+ '\u22E9': MO.REL, // succeeds but not equivalent to
+ '\u22EA': MO.REL, // not normal subgroup of
+ '\u22EB': MO.REL, // does not contain as normal subgroup
+ '\u22EC': MO.REL, // not normal subgroup of or equal to
+ '\u22ED': MO.REL, // does not contain as normal subgroup or equal
+ '\u22F0': MO.REL, // up right diagonal ellipsis
+ '\u22F2': MO.REL, // element of with long horizontal stroke
+ '\u22F3': MO.REL, // element of with vertical bar at end of horizontal stroke
+ '\u22F4': MO.REL, // small element of with vertical bar at end of horizontal stroke
+ '\u22F5': MO.REL, // element of with dot above
+ '\u22F6': MO.REL, // element of with overbar
+ '\u22F7': MO.REL, // small element of with overbar
+ '\u22F8': MO.REL, // element of with underbar
+ '\u22F9': MO.REL, // element of with two horizontal strokes
+ '\u22FA': MO.REL, // contains with long horizontal stroke
+ '\u22FB': MO.REL, // contains with vertical bar at end of horizontal stroke
+ '\u22FC': MO.REL, // small contains with vertical bar at end of horizontal stroke
+ '\u22FD': MO.REL, // contains with overbar
+ '\u22FE': MO.REL, // small contains with overbar
+ '\u22FF': MO.REL // z notation bag membership
}
- math.parentNode.removeChild(next);
- }
- var TeX = math.nodeValue.substr(search.olen,math.nodeValue.length-search.olen-search.clen);
- math.parentNode.removeChild(math);
- if (this.config.preview !== "none") {this.createPreview(search.mode,TeX)}
- math = this.createMathTag(search.mode,TeX);
- this.search = {}; this.pattern.lastIndex = 0;
- if (CLOSE) {CLOSE.parentNode.removeChild(CLOSE)}
- return math;
- },
-
- insertNode: function (node) {
- var search = this.search;
- search.close.parentNode.insertBefore(node,search.close);
- },
-
- createPreview: function (mode,tex) {
- var previewClass = MathJax.Hub.config.preRemoveClass;
- var preview = this.config.preview;
- if (preview === "none") return;
- if ((this.search.close.previousSibling||{}).className === previewClass) return;
- if (preview === "TeX") {preview = [this.filterPreview(tex)]}
- if (preview) {
- preview = MathJax.HTML.Element("span",{className:previewClass},preview);
- this.insertNode(prev
<TRUNCATED>
[3/3] openmeetings git commit: [OPENMEETINGS-1775] chat messages
import is fixed
Posted by so...@apache.org.
[OPENMEETINGS-1775] chat messages import is fixed
Project: http://git-wip-us.apache.org/repos/asf/openmeetings/repo
Commit: http://git-wip-us.apache.org/repos/asf/openmeetings/commit/b4060659
Tree: http://git-wip-us.apache.org/repos/asf/openmeetings/tree/b4060659
Diff: http://git-wip-us.apache.org/repos/asf/openmeetings/diff/b4060659
Branch: refs/heads/4.0.x
Commit: b4060659c7a25a59e6b5a9950085e5569b7030e8
Parents: 9d341f1
Author: Maxim Solodovnik <so...@gmail.com>
Authored: Mon Dec 25 20:35:17 2017 +0700
Committer: Maxim Solodovnik <so...@gmail.com>
Committed: Mon Dec 25 20:35:17 2017 +0700
----------------------------------------------------------------------
.../java/org/apache/openmeetings/db/dao/basic/ChatDao.java | 6 +++++-
.../main/java/org/apache/openmeetings/backup/BackupImport.java | 2 +-
2 files changed, 6 insertions(+), 2 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/openmeetings/blob/b4060659/openmeetings-db/src/main/java/org/apache/openmeetings/db/dao/basic/ChatDao.java
----------------------------------------------------------------------
diff --git a/openmeetings-db/src/main/java/org/apache/openmeetings/db/dao/basic/ChatDao.java b/openmeetings-db/src/main/java/org/apache/openmeetings/db/dao/basic/ChatDao.java
index fc374c4..0e651dc 100644
--- a/openmeetings-db/src/main/java/org/apache/openmeetings/db/dao/basic/ChatDao.java
+++ b/openmeetings-db/src/main/java/org/apache/openmeetings/db/dao/basic/ChatDao.java
@@ -84,7 +84,11 @@ public class ChatDao {
}
public ChatMessage update(ChatMessage entity) {
- entity.setSent(new Date());
+ return update(entity, null);
+ }
+
+ public ChatMessage update(ChatMessage entity, Date sent) {
+ entity.setSent(sent == null ? new Date() : sent);
if (entity.getId() == null) {
em.persist(entity);
}
http://git-wip-us.apache.org/repos/asf/openmeetings/blob/b4060659/openmeetings-install/src/main/java/org/apache/openmeetings/backup/BackupImport.java
----------------------------------------------------------------------
diff --git a/openmeetings-install/src/main/java/org/apache/openmeetings/backup/BackupImport.java b/openmeetings-install/src/main/java/org/apache/openmeetings/backup/BackupImport.java
index 494c32e..8e2c015 100644
--- a/openmeetings-install/src/main/java/org/apache/openmeetings/backup/BackupImport.java
+++ b/openmeetings-install/src/main/java/org/apache/openmeetings/backup/BackupImport.java
@@ -661,7 +661,7 @@ public class BackupImport {
if (m.getFromUser() == null || m.getFromUser().getId() == null) {
continue;
}
- chatDao.update(m);
+ chatDao.update(m, m.getSent());
}
}
[2/3] openmeetings git commit: [OPENMEETINGS-1783] missing MathJs
files are added
Posted by so...@apache.org.
[OPENMEETINGS-1783] missing MathJs files are added
Project: http://git-wip-us.apache.org/repos/asf/openmeetings/repo
Commit: http://git-wip-us.apache.org/repos/asf/openmeetings/commit/9d341f1b
Tree: http://git-wip-us.apache.org/repos/asf/openmeetings/tree/9d341f1b
Diff: http://git-wip-us.apache.org/repos/asf/openmeetings/diff/9d341f1b
Branch: refs/heads/4.0.x
Commit: 9d341f1b5f2e85d1e3b6ce6385714e20b8dcc68b
Parents: fce7f3b
Author: Maxim Solodovnik <so...@gmail.com>
Authored: Mon Dec 25 20:34:39 2017 +0700
Committer: Maxim Solodovnik <so...@gmail.com>
Committed: Mon Dec 25 20:34:39 2017 +0700
----------------------------------------------------------------------
.../apache/openmeetings/web/room/wb/MathJax.js | 19393 ++++++++++-------
1 file changed, 11230 insertions(+), 8163 deletions(-)
----------------------------------------------------------------------