      1 /*
      2     Copyright 2008-2025
      3         Matthias Ehmann,
      4         Michael Gerhaeuser,
      5         Carsten Miller,
      6         Bianca Valentin,
      7         Alfred Wassermann,
      8         Peter Wilfahrt
      9
     10     This file is part of JSXGraph.
     11
     12     JSXGraph is free software dual licensed under the GNU LGPL or MIT License.
     13
     14     You can redistribute it and/or modify it under the terms of the
     15
     16       * GNU Lesser General Public License as published by
     17         the Free Software Foundation, either version 3 of the License, or
     18         (at your option) any later version
     19       OR
     20       * MIT License: https://github.com/jsxgraph/jsxgraph/blob/master/LICENSE.MIT
     21
     22     JSXGraph is distributed in the hope that it will be useful,
     23     but WITHOUT ANY WARRANTY; without even the implied warranty of
     24     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     25     GNU Lesser General Public License for more details.
     26
     27     You should have received a copy of the GNU Lesser General Public License and
     28     the MIT License along with JSXGraph. If not, see <https://www.gnu.org/licenses/>
     29     and <https://opensource.org/licenses/MIT/>.
     30  */
     31
     32 /*global JXG: true, define: true, AMprocessNode: true, MathJax: true, document: true */
     33 /*jslint nomen: true, plusplus: true, newcap:true*/
     34
     35 import JXG from "../jxg.js";
     36 import AbstractRenderer from "./abstract.js";
     37 import Const from "../base/constants.js";
     38 import Type from "../utils/type.js";
     39 import Color from "../utils/color.js";
     40 import Mat from "../math/math.js";
     41 import Numerics from "../math/numerics.js";
     42
     43 /**
     44  * Uses VML to implement the rendering methods defined in {@link JXG.AbstractRenderer}.
     45  * VML was used in very old Internet Explorer versions upto IE 8.
     46  *
     47  *
     48  * @class JXG.VMLRenderer
     49  * @augments JXG.AbstractRenderer
     50  * @param {Node} container Reference to a DOM node containing the board.
     51  * @see JXG.AbstractRenderer
     52  * @deprecated
     53  */
     54 JXG.VMLRenderer = function (container) {
     55     this.type = "vml";
     56
     57     this.container = container;
     58     this.container.style.overflow = "hidden";
     59     if (this.container.style.position === "") {
     60         this.container.style.position = "relative";
     61     }
     62     this.container.onselectstart = function () {
     63         return false;
     64     };
     65
     66     this.resolution = 10; // Paths are drawn with a resolution of this.resolution/pixel.
     67
     68     // Add VML includes and namespace
     69     // Original: IE <=7
     70     //container.ownerDocument.createStyleSheet().addRule("v\\:*", "behavior: url(#default#VML);");
     71     if (!Type.exists(JXG.vmlStylesheet)) {
     72         container.ownerDocument.namespaces.add("jxgvml", "urn:schemas-microsoft-com:vml");
     73         JXG.vmlStylesheet = this.container.ownerDocument.createStyleSheet();
     74         JXG.vmlStylesheet.addRule(".jxgvml", "behavior:url(#default#VML)");
     75     }
     76
     77     try {
     78         if (!container.ownerDocument.namespaces.jxgvml) {
     79             container.ownerDocument.namespaces.add("jxgvml", "urn:schemas-microsoft-com:vml");
     80         }
     81
     82         this.createNode = function (tagName) {
     83             return container.ownerDocument.createElement(
     84                 "<jxgvml:" + tagName + ' class="jxgvml">'
     85             );
     86         };
     87     } catch (e) {
     88         this.createNode = function (tagName) {
     89             return container.ownerDocument.createElement(
     90                 "<" + tagName + ' xmlns="urn:schemas-microsoft.com:vml" class="jxgvml">'
     91             );
     92         };
     93     }
     94
     95     // dash styles
     96     this.dashArray = [
     97         "Solid",
     98         "1 1",
     99         "ShortDash",
    100         "Dash",
    101         "LongDash",
    102         "ShortDashDot",
    103         "LongDashDot"
    104     ];
    105 };
    106
    107 JXG.VMLRenderer.prototype = new AbstractRenderer();
    108
    109 JXG.extend(
    110     JXG.VMLRenderer.prototype,
    111     /** @lends JXG.VMLRenderer.prototype */ {
    112         /**
    113          * Sets attribute <tt>key</tt> of node <tt>node</tt> to <tt>value</tt>.
    114          * @param {Node} node A DOM node.
    115          * @param {String} key Name of the attribute.
    116          * @param {String} val New value of the attribute.
    117          * @param {Boolean} [iFlag=false] If false, the attribute's name is case insensitive.
    118          */
    119         _setAttr: function (node, key, val, iFlag) {
    120             try {
    121                 if (this.container.ownerDocument.documentMode === 8) {
    122                     node[key] = val;
    123                 } else {
    124                     node.setAttribute(key, val, iFlag);
    125                 }
    126             } catch (e) {
    127                 JXG.debug("_setAttr:" /*node.id*/ + " " + key + " " + val + "<br>\n");
    128             }
    129         },
    130
    131         /* ******************************** *
    132          *  This renderer does not need to
    133          *  override draw/update* methods
    134          *  since it provides draw/update*Prim
    135          *  methods.
    136          * ******************************** */
    137
    138         /* **************************
    139          *    Lines
    140          * **************************/
    141
    142         // documented in AbstractRenderer
    143         updateTicks: function (ticks) {
    144             var i,
    145                 len,
    146                 c,
    147                 x,
    148                 y,
    149                 r = this.resolution,
    150                 tickArr = [];
    151
    152             len = ticks.ticks.length;
    153             for (i = 0; i < len; i++) {
    154                 c = ticks.ticks[i];
    155                 x = c[0];
    156                 y = c[1];
    157
    158                 if (Type.isNumber(x[0]) && Type.isNumber(x[1])) {
    159                     tickArr.push(
    160                         " m " +
    161                             Math.round(r * x[0]) +
    162                             ", " +
    163                             Math.round(r * y[0]) +
    164                             " l " +
    165                             Math.round(r * x[1]) +
    166                             ", " +
    167                             Math.round(r * y[1]) +
    168                             " "
    169                     );
    170                 }
    171             }
    172
    173             if (!Type.exists(ticks.rendNode)) {
    174                 ticks.rendNode = this.createPrim("path", ticks.id);
    175                 this.appendChildPrim(ticks.rendNode, ticks.evalVisProp('layer'));
    176             }
    177
    178             this._setAttr(ticks.rendNode, "stroked", "true");
    179             this._setAttr(
    180                 ticks.rendNode,
    181                 "strokecolor",
    182                 ticks.evalVisProp('strokecolor'),
    183                 1
    184             );
    185             this._setAttr(
    186                 ticks.rendNode,
    187                 "strokeweight",
    188                 ticks.evalVisProp('strokewidth')
    189             );
    190             this._setAttr(
    191                 ticks.rendNodeStroke,
    192                 "opacity",
    193                 ticks.evalVisProp('strokeopacity') * 100 + "%"
    194             );
    195             this.updatePathPrim(ticks.rendNode, tickArr, ticks.board);
    196         },
    197
    198         /* **************************
    199          *    Text related stuff
    200          * **************************/
    201
    202         // Already documented in JXG.AbstractRenderer
    203         displayCopyright: function (str, fontsize) {
    204             var node, t;
    205
    206             node = this.createNode("textbox");
    207             node.style.position = "absolute";
    208             this._setAttr(node, "id", this.container.id + "_" + "licenseText");
    209
    210             node.style.left = 20;
    211             node.style.top = 2;
    212             node.style.fontSize = fontsize;
    213             node.style.color = "#356AA0";
    214             node.style.fontFamily = "Arial,Helvetica,sans-serif";
    215             this._setAttr(node, "opacity", "30%");
    216             node.style.filter =
    217                 "progid:DXImageTransform.Microsoft.Matrix(M11='1.0', sizingMethod='auto expand', enabled = false) progid:DXImageTransform.Microsoft.Alpha(opacity = 30, enabled = true)";
    218
    219             t = this.container.ownerDocument.createTextNode(str);
    220             node.appendChild(t);
    221             this.appendChildPrim(node, 0);
    222         },
    223
    224         // documented in AbstractRenderer
    225         drawInternalText: function (el) {
    226             var node;
    227             node = this.createNode("textbox");
    228             node.style.position = "absolute";
    229             el.rendNodeText = this.container.ownerDocument.createTextNode("");
    230             node.appendChild(el.rendNodeText);
    231             this.appendChildPrim(node, 9);
    232             node.style.filter =
    233                 "progid:DXImageTransform.Microsoft.Matrix(M11='1.0', sizingMethod='auto expand', enabled = false) progid:DXImageTransform.Microsoft.Alpha(opacity = 100, enabled = false)";
    234
    235             return node;
    236         },
    237
    238         // documented in AbstractRenderer
    239         updateInternalText: function (el) {
    240             var v,
    241                 content = el.plaintext,
    242                 m = this.joinTransforms(el, el.transformations),
    243                 offset = [0, 0],
    244                 maxX,
    245                 maxY,
    246                 minX,
    247                 minY,
    248                 i,
    249                 node = el.rendNode,
    250                 p = [],
    251                 ev_ax = el.getAnchorX(),
    252                 ev_ay = el.getAnchorY();
    253
    254             if (!isNaN(el.coords.scrCoords[1] + el.coords.scrCoords[2])) {
    255                 // Horizontal
    256                 if (ev_ax === "right") {
    257                     offset[0] = 1;
    258                 } else if (ev_ax === "middle") {
    259                     offset[0] = 0.5;
    260                 } // default (ev_ax === 'left') offset[0] = 0;
    261
    262                 // Vertical
    263                 if (ev_ay === "bottom") {
    264                     offset[1] = 1;
    265                 } else if (ev_ay === "middle") {
    266                     offset[1] = 0.5;
    267                 } // default (ev_ay === 'top') offset[1] = 0;
    268
    269                 // Compute maxX, maxY, minX, minY
    270                 p[0] = Mat.matVecMult(m, [
    271                     1,
    272                     el.coords.scrCoords[1] - offset[0] * el.size[0],
    273                     el.coords.scrCoords[2] + (1 - offset[1]) * el.size[1] + this.vOffsetText
    274                 ]);
    275                 p[0][1] /= p[0][0];
    276                 p[0][2] /= p[0][0];
    277                 p[1] = Mat.matVecMult(m, [
    278                     1,
    279                     el.coords.scrCoords[1] + (1 - offset[0]) * el.size[0],
    280                     el.coords.scrCoords[2] + (1 - offset[1]) * el.size[1] + this.vOffsetText
    281                 ]);
    282                 p[1][1] /= p[1][0];
    283                 p[1][2] /= p[1][0];
    284                 p[2] = Mat.matVecMult(m, [
    285                     1,
    286                     el.coords.scrCoords[1] + (1 - offset[0]) * el.size[0],
    287                     el.coords.scrCoords[2] - offset[1] * el.size[1] + this.vOffsetText
    288                 ]);
    289                 p[2][1] /= p[2][0];
    290                 p[2][2] /= p[2][0];
    291                 p[3] = Mat.matVecMult(m, [
    292                     1,
    293                     el.coords.scrCoords[1] - offset[0] * el.size[0],
    294                     el.coords.scrCoords[2] - offset[1] * el.size[1] + this.vOffsetText
    295                 ]);
    296                 p[3][1] /= p[3][0];
    297                 p[3][2] /= p[3][0];
    298                 maxX = p[0][1];
    299                 minX = p[0][1];
    300                 maxY = p[0][2];
    301                 minY = p[0][2];
    302
    303                 for (i = 1; i < 4; i++) {
    304                     maxX = Math.max(maxX, p[i][1]);
    305                     minX = Math.min(minX, p[i][1]);
    306                     maxY = Math.max(maxY, p[i][2]);
    307                     minY = Math.min(minY, p[i][2]);
    308                 }
    309
    310                 // Horizontal
    311                 v =
    312                     offset[0] === 1
    313                         ? Math.floor(el.board.canvasWidth - maxX)
    314                         : Math.floor(minX);
    315                 if (el.visPropOld.left !== ev_ax + v) {
    316                     if (offset[0] === 1) {
    317                         el.rendNode.style.right = v + "px";
    318                         el.rendNode.style.left = "auto";
    319                     } else {
    320                         el.rendNode.style.left = v + "px";
    321                         el.rendNode.style.right = "auto";
    322                     }
    323                     el.visPropOld.left = ev_ax + v;
    324                 }
    325
    326                 // Vertical
    327                 v =
    328                     offset[1] === 1
    329                         ? Math.floor(el.board.canvasHeight - maxY)
    330                         : Math.floor(minY);
    331                 if (el.visPropOld.top !== ev_ay + v) {
    332                     if (offset[1] === 1) {
    333                         el.rendNode.style.bottom = v + "px";
    334                         el.rendNode.style.top = "auto";
    335                     } else {
    336                         el.rendNode.style.top = v + "px";
    337                         el.rendNode.style.bottom = "auto";
    338                     }
    339                     el.visPropOld.top = ev_ay + v;
    340                 }
    341             }
    342
    343             if (el.htmlStr !== content) {
    344                 el.rendNodeText.data = content;
    345                 el.htmlStr = content;
    346             }
    347
    348             //this.transformRect(el, el.transformations);
    349             node.filters.item(0).M11 = m[1][1];
    350             node.filters.item(0).M12 = m[1][2];
    351             node.filters.item(0).M21 = m[2][1];
    352             node.filters.item(0).M22 = m[2][2];
    353             node.filters.item(0).enabled = true;
    354         },
    355
    356         /* **************************
    357          *    Image related stuff
    358          * **************************/
    359
    360         // Already documented in JXG.AbstractRenderer
    361         drawImage: function (el) {
    362             // IE 8: Bilder ueber data URIs werden bis 32kB unterstuetzt.
    363             var node;
    364
    365             node = this.container.ownerDocument.createElement("img");
    366             node.style.position = "absolute";
    367             this._setAttr(node, "id", this.container.id + "_" + el.id);
    368
    369             this.container.appendChild(node);
    370             this.appendChildPrim(node, el.evalVisProp('layer'));
    371
    372             // Adding the rotation filter. This is always filter item 0:
    373             // node.filters.item(0), see transformRect
    374             // Also add the alpha filter. This is always filter item 1
    375             // node.filters.item(1), see setObjectFillColor and setObjectSTrokeColor
    376             //node.style.filter = node.style['-ms-filter'] = "progid:DXImageTransform.Microsoft.Matrix(M11='1.0', sizingMethod='auto expand')";
    377             node.style.filter =
    378                 "progid:DXImageTransform.Microsoft.Matrix(M11='1.0', sizingMethod='auto expand') progid:DXImageTransform.Microsoft.Alpha(opacity = 100, enabled = false)";
    379             el.rendNode = node;
    380             this.updateImage(el);
    381         },
    382
    383         // Already documented in JXG.AbstractRenderer
    384         transformRect: function (el, t) {
    385             var m,
    386                 maxX,
    387                 maxY,
    388                 minX,
    389                 minY,
    390                 i,
    391                 node = el.rendNode,
    392                 p = [],
    393                 len = t.length;
    394
    395             if (len > 0) {
    396                 /*
    397                 nt = el.rendNode.style.filter.toString();
    398                 if (!nt.match(/DXImageTransform/)) {
    399                     node.style.filter = "progid:DXImageTransform.Microsoft.Matrix(M11='1.0', sizingMethod='auto expand') " + nt;
    400                 }
    401                 */
    402
    403                 m = this.joinTransforms(el, t);
    404                 p[0] = Mat.matVecMult(m, el.coords.scrCoords);
    405                 p[0][1] /= p[0][0];
    406                 p[0][2] /= p[0][0];
    407                 p[1] = Mat.matVecMult(m, [
    408                     1,
    409                     el.coords.scrCoords[1] + el.size[0],
    410                     el.coords.scrCoords[2]
    411                 ]);
    412                 p[1][1] /= p[1][0];
    413                 p[1][2] /= p[1][0];
    414                 p[2] = Mat.matVecMult(m, [
    415                     1,
    416                     el.coords.scrCoords[1] + el.size[0],
    417                     el.coords.scrCoords[2] - el.size[1]
    418                 ]);
    419                 p[2][1] /= p[2][0];
    420                 p[2][2] /= p[2][0];
    421                 p[3] = Mat.matVecMult(m, [
    422                     1,
    423                     el.coords.scrCoords[1],
    424                     el.coords.scrCoords[2] - el.size[1]
    425                 ]);
    426                 p[3][1] /= p[3][0];
    427                 p[3][2] /= p[3][0];
    428                 maxX = p[0][1];
    429                 minX = p[0][1];
    430                 maxY = p[0][2];
    431                 minY = p[0][2];
    432
    433                 for (i = 1; i < 4; i++) {
    434                     maxX = Math.max(maxX, p[i][1]);
    435                     minX = Math.min(minX, p[i][1]);
    436                     maxY = Math.max(maxY, p[i][2]);
    437                     minY = Math.min(minY, p[i][2]);
    438                 }
    439                 node.style.left = Math.floor(minX) + "px";
    440                 node.style.top = Math.floor(minY) + "px";
    441
    442                 node.filters.item(0).M11 = m[1][1];
    443                 node.filters.item(0).M12 = m[1][2];
    444                 node.filters.item(0).M21 = m[2][1];
    445                 node.filters.item(0).M22 = m[2][2];
    446                 node.filters.item(0).enabled = true;
    447             }
    448         },
    449
    450         // Already documented in JXG.AbstractRenderer
    451         updateImageURL: function (el) {
    452             var url = el.eval(el.url);
    453
    454             this._setAttr(el.rendNode, "src", url);
    455         },
    456
    457         /* **************************
    458          * Render primitive objects
    459          * **************************/
    460
    461         // Already documented in JXG.AbstractRenderer
    462         appendChildPrim: function (node, level) {
    463             // For trace nodes
    464             if (!Type.exists(level)) {
    465                 level = 0;
    466             }
    467
    468             node.style.zIndex = level;
    469             this.container.appendChild(node);
    470
    471             return node;
    472         },
    473
    474         // Already documented in JXG.AbstractRenderer
    475         appendNodesToElement: function (el, type) {
    476             if (type === "shape" || type === "path" || type === "polygon") {
    477                 el.rendNodePath = this.getElementById(el.id + "_path");
    478             }
    479             el.rendNodeFill = this.getElementById(el.id + "_fill");
    480             el.rendNodeStroke = this.getElementById(el.id + "_stroke");
    481             el.rendNodeShadow = this.getElementById(el.id + "_shadow");
    482             el.rendNode = this.getElementById(el.id);
    483         },
    484
    485         // Already documented in JXG.AbstractRenderer
    486         createPrim: function (type, id) {
    487             var node,
    488                 pathNode,
    489                 fillNode = this.createNode("fill"),
    490                 strokeNode = this.createNode("stroke"),
    491                 shadowNode = this.createNode("shadow");
    492
    493             this._setAttr(fillNode, "id", this.container.id + "_" + id + "_fill");
    494             this._setAttr(strokeNode, "id", this.container.id + "_" + id + "_stroke");
    495             this._setAttr(shadowNode, "id", this.container.id + "_" + id + "_shadow");
    496
    497             if (type === "circle" || type === "ellipse") {
    498                 node = this.createNode("oval");
    499                 node.appendChild(fillNode);
    500                 node.appendChild(strokeNode);
    501                 node.appendChild(shadowNode);
    502             } else if (
    503                 type === "polygon" ||
    504                 type === "path" ||
    505                 type === "shape" ||
    506                 type === "line"
    507             ) {
    508                 node = this.createNode("shape");
    509                 node.appendChild(fillNode);
    510                 node.appendChild(strokeNode);
    511                 node.appendChild(shadowNode);
    512                 pathNode = this.createNode("path");
    513                 this._setAttr(pathNode, "id", this.container.id + "_" + id + "_path");
    514                 node.appendChild(pathNode);
    515             } else {
    516                 node = this.createNode(type);
    517                 node.appendChild(fillNode);
    518                 node.appendChild(strokeNode);
    519                 node.appendChild(shadowNode);
    520             }
    521
    522             node.style.position = "absolute";
    523             node.style.left = "0px";
    524             node.style.top = "0px";
    525             this._setAttr(node, "id", this.container.id + "_" + id);
    526
    527             return node;
    528         },
    529
    530         // Already documented in JXG.AbstractRenderer
    531         remove: function (node) {
    532             if (Type.exists(node)) {
    533                 node.removeNode(true);
    534             }
    535         },
    536
    537         // Already documented in JXG.AbstractRenderer
    538         makeArrows: function (el) {
    539             var nodeStroke,
    540                 ev_fa = el.evalVisProp('firstarrow'),
    541                 ev_la = el.evalVisProp('lastarrow');
    542
    543             if (el.visPropOld.firstarrow === ev_fa && el.visPropOld.lastarrow === ev_la) {
    544                 return;
    545             }
    546
    547             if (ev_fa) {
    548                 nodeStroke = el.rendNodeStroke;
    549                 this._setAttr(nodeStroke, "startarrow", "block");
    550                 this._setAttr(nodeStroke, "startarrowlength", "long");
    551             } else {
    552                 nodeStroke = el.rendNodeStroke;
    553                 if (Type.exists(nodeStroke)) {
    554                     this._setAttr(nodeStroke, "startarrow", "none");
    555                 }
    556             }
    557
    558             if (ev_la) {
    559                 nodeStroke = el.rendNodeStroke;
    560                 this._setAttr(nodeStroke, "id", this.container.id + "_" + el.id + "stroke");
    561                 this._setAttr(nodeStroke, "endarrow", "block");
    562                 this._setAttr(nodeStroke, "endarrowlength", "long");
    563             } else {
    564                 nodeStroke = el.rendNodeStroke;
    565                 if (Type.exists(nodeStroke)) {
    566                     this._setAttr(nodeStroke, "endarrow", "none");
    567                 }
    568             }
    569             el.visPropOld.firstarrow = ev_fa;
    570             el.visPropOld.lastarrow = ev_la;
    571         },
    572
    573         // Already documented in JXG.AbstractRenderer
    574         updateEllipsePrim: function (node, x, y, rx, ry) {
    575             node.style.left = Math.floor(x - rx) + "px";
    576             node.style.top = Math.floor(y - ry) + "px";
    577             node.style.width = Math.floor(Math.abs(rx) * 2) + "px";
    578             node.style.height = Math.floor(Math.abs(ry) * 2) + "px";
    579         },
    580
    581         // Already documented in JXG.AbstractRenderer
    582         updateLinePrim: function (node, p1x, p1y, p2x, p2y, board) {
    583             var s,
    584                 r = this.resolution;
    585
    586             if (!isNaN(p1x + p1y + p2x + p2y)) {
    587                 s = [
    588                     "m ",
    589                     Math.floor(r * p1x),
    590                     ", ",
    591                     Math.floor(r * p1y),
    592                     " l ",
    593                     Math.floor(r * p2x),
    594                     ", ",
    595                     Math.floor(r * p2y)
    596                 ];
    597                 this.updatePathPrim(node, s, board);
    598             }
    599         },
    600
    601         // Already documented in JXG.AbstractRenderer
    602         updatePathPrim: function (node, pointString, board) {
    603             var x = board.canvasWidth,
    604                 y = board.canvasHeight;
    605             if (pointString.length <= 0) {
    606                 pointString = ["m 0,0"];
    607             }
    608             node.style.width = x;
    609             node.style.height = y;
    610             this._setAttr(
    611                 node,
    612                 "coordsize",
    613                 [Math.floor(this.resolution * x), Math.floor(this.resolution * y)].join(",")
    614             );
    615             this._setAttr(node, "path", pointString.join(""));
    616         },
    617
    618         // Already documented in JXG.AbstractRenderer
    619         updatePathStringPoint: function (el, size, type) {
    620             var s = [],
    621                 mround = Math.round,
    622                 scr = el.coords.scrCoords,
    623                 sqrt32 = size * Math.sqrt(3) * 0.5,
    624                 s05 = size * 0.5,
    625                 r = this.resolution;
    626
    627             if (type === "x") {
    628                 s.push(
    629                     [
    630                         " m ",
    631                         mround(r * (scr[1] - size)),
    632                         ", ",
    633                         mround(r * (scr[2] - size)),
    634                         " l ",
    635                         mround(r * (scr[1] + size)),
    636                         ", ",
    637                         mround(r * (scr[2] + size)),
    638                         " m ",
    639                         mround(r * (scr[1] + size)),
    640                         ", ",
    641                         mround(r * (scr[2] - size)),
    642                         " l ",
    643                         mround(r * (scr[1] - size)),
    644                         ", ",
    645                         mround(r * (scr[2] + size))
    646                     ].join("")
    647                 );
    648             } else if (type === "+") {
    649                 s.push(
    650                     [
    651                         " m ",
    652                         mround(r * (scr[1] - size)),
    653                         ", ",
    654                         mround(r * scr[2]),
    655                         " l ",
    656                         mround(r * (scr[1] + size)),
    657                         ", ",
    658                         mround(r * scr[2]),
    659                         " m ",
    660                         mround(r * scr[1]),
    661                         ", ",
    662                         mround(r * (scr[2] - size)),
    663                         " l ",
    664                         mround(r * scr[1]),
    665                         ", ",
    666                         mround(r * (scr[2] + size))
    667                     ].join("")
    668                 );
    669             } else if (type === "<>" || type === "<<>>") {
    670                 if (type === "<<>>") {
    671                     size *= 1.41;
    672                 }
    673                 s.push(
    674                     [
    675                         " m ",
    676                         mround(r * (scr[1] - size)),
    677                         ", ",
    678                         mround(r * scr[2]),
    679                         " l ",
    680                         mround(r * scr[1]),
    681                         ", ",
    682                         mround(r * (scr[2] + size)),
    683                         " l ",
    684                         mround(r * (scr[1] + size)),
    685                         ", ",
    686                         mround(r * scr[2]),
    687                         " l ",
    688                         mround(r * scr[1]),
    689                         ", ",
    690                         mround(r * (scr[2] - size)),
    691                         " x e "
    692                     ].join("")
    693                 );
    694             } else if (type === "^") {
    695                 s.push(
    696                     [
    697                         " m ",
    698                         mround(r * scr[1]),
    699                         ", ",
    700                         mround(r * (scr[2] - size)),
    701                         " l ",
    702                         mround(r * (scr[1] - sqrt32)),
    703                         ", ",
    704                         mround(r * (scr[2] + s05)),
    705                         " l ",
    706                         mround(r * (scr[1] + sqrt32)),
    707                         ", ",
    708                         mround(r * (scr[2] + s05)),
    709                         " x e "
    710                     ].join("")
    711                 );
    712             } else if (type === "v") {
    713                 s.push(
    714                     [
    715                         " m ",
    716                         mround(r * scr[1]),
    717                         ", ",
    718                         mround(r * (scr[2] + size)),
    719                         " l ",
    720                         mround(r * (scr[1] - sqrt32)),
    721                         ", ",
    722                         mround(r * (scr[2] - s05)),
    723                         " l ",
    724                         mround(r * (scr[1] + sqrt32)),
    725                         ", ",
    726                         mround(r * (scr[2] - s05)),
    727                         " x e "
    728                     ].join("")
    729                 );
    730             } else if (type === ">") {
    731                 s.push(
    732                     [
    733                         " m ",
    734                         mround(r * (scr[1] + size)),
    735                         ", ",
    736                         mround(r * scr[2]),
    737                         " l ",
    738                         mround(r * (scr[1] - s05)),
    739                         ", ",
    740                         mround(r * (scr[2] - sqrt32)),
    741                         " l ",
    742                         mround(r * (scr[1] - s05)),
    743                         ", ",
    744                         mround(r * (scr[2] + sqrt32)),
    745                         " l ",
    746                         mround(r * (scr[1] + size)),
    747                         ", ",
    748                         mround(r * scr[2])
    749                     ].join("")
    750                 );
    751             } else if (type === "<") {
    752                 s.push(
    753                     [
    754                         " m ",
    755                         mround(r * (scr[1] - size)),
    756                         ", ",
    757                         mround(r * scr[2]),
    758                         " l ",
    759                         mround(r * (scr[1] + s05)),
    760                         ", ",
    761                         mround(r * (scr[2] - sqrt32)),
    762                         " l ",
    763                         mround(r * (scr[1] + s05)),
    764                         ", ",
    765                         mround(r * (scr[2] + sqrt32)),
    766                         " x e "
    767                     ].join("")
    768                 );
    769             }
    770
    771             return s;
    772         },
    773
    774         // Already documented in JXG.AbstractRenderer
    775         updatePathStringPrim: function (el) {
    776             var i,
    777                 scr,
    778                 pStr = [],
    779                 r = this.resolution,
    780                 mround = Math.round,
    781                 symbm = " m ",
    782                 symbl = " l ",
    783                 symbc = " c ",
    784                 nextSymb = symbm,
    785                 len = Math.min(el.numberPoints, 8192); // otherwise IE 7 crashes in hilbert.html
    786
    787             if (el.numberPoints <= 0) {
    788                 return "";
    789             }
    790             len = Math.min(len, el.points.length);
    791
    792             if (el.bezierDegree === 1) {
    793                 /*
    794                 if (isNotPlot && el.board.options.curve.RDPsmoothing) {
    795                     el.points = Numerics.RamerDouglasPeucker(el.points, 1.0);
    796                 }
    797                 */
    798
    799                 for (i = 0; i < len; i++) {
    800                     scr = el.points[i].scrCoords;
    801                     if (isNaN(scr[1]) || isNaN(scr[2])) {
    802                         // PenUp
    803                         nextSymb = symbm;
    804                     } else {
    805                         // IE has problems with values  being too far away.
    806                         if (scr[1] > 20000.0) {
    807                             scr[1] = 20000.0;
    808                         } else if (scr[1] < -20000.0) {
    809                             scr[1] = -20000.0;
    810                         }
    811
    812                         if (scr[2] > 20000.0) {
    813                             scr[2] = 20000.0;
    814                         } else if (scr[2] < -20000.0) {
    815                             scr[2] = -20000.0;
    816                         }
    817
    818                         pStr.push(
    819                             [nextSymb, mround(r * scr[1]), ", ", mround(r * scr[2])].join("")
    820                         );
    821                         nextSymb = symbl;
    822                     }
    823                 }
    824             } else if (el.bezierDegree === 3) {
    825                 i = 0;
    826                 while (i < len) {
    827                     scr = el.points[i].scrCoords;
    828                     if (isNaN(scr[1]) || isNaN(scr[2])) {
    829                         // PenUp
    830                         nextSymb = symbm;
    831                     } else {
    832                         pStr.push(
    833                             [nextSymb, mround(r * scr[1]), ", ", mround(r * scr[2])].join("")
    834                         );
    835                         if (nextSymb === symbc) {
    836                             i += 1;
    837                             scr = el.points[i].scrCoords;
    838                             pStr.push(
    839                                 [" ", mround(r * scr[1]), ", ", mround(r * scr[2])].join("")
    840                             );
    841                             i += 1;
    842                             scr = el.points[i].scrCoords;
    843                             pStr.push(
    844                                 [" ", mround(r * scr[1]), ", ", mround(r * scr[2])].join("")
    845                             );
    846                         }
    847                         nextSymb = symbc;
    848                     }
    849                     i += 1;
    850                 }
    851             }
    852             pStr.push(" e");
    853             return pStr;
    854         },
    855
    856         // Already documented in JXG.AbstractRenderer
    857         updatePathStringBezierPrim: function (el) {
    858             var i,
    859                 j,
    860                 k,
    861                 scr,
    862                 lx,
    863                 ly,
    864                 pStr = [],
    865                 f = el.evalVisProp('strokewidth'),
    866                 r = this.resolution,
    867                 mround = Math.round,
    868                 symbm = " m ",
    869                 symbl = " c ",
    870                 nextSymb = symbm,
    871                 isNoPlot = el.evalVisProp('curvetype') !== "plot",
    872                 len = Math.min(el.numberPoints, 8192); // otherwise IE 7 crashes in hilbert.html
    873
    874             if (el.numberPoints <= 0) {
    875                 return "";
    876             }
    877             if (isNoPlot && el.board.options.curve.RDPsmoothing) {
    878                 el.points = Numerics.RamerDouglasPeucker(el.points, 1.0);
    879             }
    880             len = Math.min(len, el.points.length);
    881
    882             for (j = 1; j < 3; j++) {
    883                 nextSymb = symbm;
    884                 for (i = 0; i < len; i++) {
    885                     scr = el.points[i].scrCoords;
    886                     if (isNaN(scr[1]) || isNaN(scr[2])) {
    887                         // PenUp
    888                         nextSymb = symbm;
    889                     } else {
    890                         // IE has problems with values  being too far away.
    891                         if (scr[1] > 20000.0) {
    892                             scr[1] = 20000.0;
    893                         } else if (scr[1] < -20000.0) {
    894                             scr[1] = -20000.0;
    895                         }
    896
    897                         if (scr[2] > 20000.0) {
    898                             scr[2] = 20000.0;
    899                         } else if (scr[2] < -20000.0) {
    900                             scr[2] = -20000.0;
    901                         }
    902
    903                         if (nextSymb === symbm) {
    904                             pStr.push(
    905                                 [nextSymb, mround(r * scr[1]), " ", mround(r * scr[2])].join("")
    906                             );
    907                         } else {
    908                             k = 2 * j;
    909                             pStr.push(
    910                                 [
    911                                     nextSymb,
    912                                     mround(
    913                                         r *
    914                                             (lx +
    915                                                 (scr[1] - lx) * 0.333 +
    916                                                 f * (k * Math.random() - j))
    917                                     ),
    918                                     " ",
    919                                     mround(
    920                                         r *
    921                                             (ly +
    922                                                 (scr[2] - ly) * 0.333 +
    923                                                 f * (k * Math.random() - j))
    924                                     ),
    925                                     " ",
    926                                     mround(
    927                                         r *
    928                                             (lx +
    929                                                 (scr[1] - lx) * 0.666 +
    930                                                 f * (k * Math.random() - j))
    931                                     ),
    932                                     " ",
    933                                     mround(
    934                                         r *
    935                                             (ly +
    936                                                 (scr[2] - ly) * 0.666 +
    937                                                 f * (k * Math.random() - j))
    938                                     ),
    939                                     " ",
    940                                     mround(r * scr[1]),
    941                                     " ",
    942                                     mround(r * scr[2])
    943                                 ].join("")
    944                             );
    945                         }
    946                         nextSymb = symbl;
    947                         lx = scr[1];
    948                         ly = scr[2];
    949                     }
    950                 }
    951             }
    952             pStr.push(" e");
    953             return pStr;
    954         },
    955
    956         // Already documented in JXG.AbstractRenderer
    957         updatePolygonPrim: function (node, el) {
    958             var i,
    959                 len = el.vertices.length,
    960                 r = this.resolution,
    961                 scr,
    962                 pStr = [];
    963
    964             this._setAttr(node, "stroked", "false");
    965             scr = el.vertices[0].coords.scrCoords;
    966
    967             if (isNaN(scr[1] + scr[2])) {
    968                 return;
    969             }
    970
    971             pStr.push(
    972                 ["m ", Math.floor(r * scr[1]), ",", Math.floor(r * scr[2]), " l "].join("")
    973             );
    974
    975             for (i = 1; i < len - 1; i++) {
    976                 if (el.vertices[i].isReal) {
    977                     scr = el.vertices[i].coords.scrCoords;
    978
    979                     if (isNaN(scr[1] + scr[2])) {
    980                         return;
    981                     }
    982
    983                     pStr.push(Math.floor(r * scr[1]) + "," + Math.floor(r * scr[2]));
    984                 } else {
    985                     this.updatePathPrim(node, "", el.board);
    986                     return;
    987                 }
    988                 if (i < len - 2) {
    989                     pStr.push(", ");
    990                 }
    991             }
    992             pStr.push(" x e");
    993             this.updatePathPrim(node, pStr, el.board);
    994         },
    995
    996         // Already documented in JXG.AbstractRenderer
    997         updateRectPrim: function (node, x, y, w, h) {
    998             node.style.left = Math.floor(x) + "px";
    999             node.style.top = Math.floor(y) + "px";
    1000
    1001             if (w >= 0) {
    1002                 node.style.width = w + "px";
    1003             }
    1004
    1005             if (h >= 0) {
    1006                 node.style.height = h + "px";
    1007             }
    1008         },
    1009
    1010         /* **************************
    1011          *  Set Attributes
    1012          * **************************/
    1013
    1014         // Already documented in JXG.AbstractRenderer
    1015         setPropertyPrim: function (node, key, val) {
    1016             var keyVml = "",
    1017                 v;
    1018
    1019             switch (key) {
    1020                 case "stroke":
    1021                     keyVml = "strokecolor";
    1022                     break;
    1023                 case "stroke-width":
    1024                     keyVml = "strokeweight";
    1025                     break;
    1026                 case "stroke-dasharray":
    1027                     keyVml = "dashstyle";
    1028                     break;
    1029             }
    1030
    1031             if (keyVml !== "") {
    1032                 v = val;
    1033                 this._setAttr(node, keyVml, v);
    1034             }
    1035         },
    1036
    1037         // Already documented in JXG.AbstractRenderer
    1038         display: function (el, val) {
    1039             if (el && el.rendNode) {
    1040                 el.visPropOld.visible = val;
    1041                 if (val) {
    1042                     el.rendNode.style.visibility = "inherit";
    1043                 } else {
    1044                     el.rendNode.style.visibility = "hidden";
    1045                 }
    1046             }
    1047         },
    1048
    1049         // Already documented in JXG.AbstractRenderer
    1050         show: function (el) {
    1051             JXG.deprecated("Board.renderer.show()", "Board.renderer.display()");
    1052
    1053             if (el && el.rendNode) {
    1054                 el.rendNode.style.visibility = "inherit";
    1055             }
    1056         },
    1057
    1058         // Already documented in JXG.AbstractRenderer
    1059         hide: function (el) {
    1060             JXG.deprecated("Board.renderer.hide()", "Board.renderer.display()");
    1061
    1062             if (el && el.rendNode) {
    1063                 el.rendNode.style.visibility = "hidden";
    1064             }
    1065         },
    1066
    1067         // Already documented in JXG.AbstractRenderer
    1068         setDashStyle: function (el, visProp) {
    1069             var node;
    1070             if (visProp.dash >= 0) {
    1071                 node = el.rendNodeStroke;
    1072                 this._setAttr(node, "dashstyle", this.dashArray[visProp.dash]);
    1073             }
    1074         },
    1075
    1076         // Already documented in JXG.AbstractRenderer
    1077         setGradient: function (el) {
    1078             var nodeFill = el.rendNodeFill,
    1079                 ev_g = el.evalVisProp('gradient');
    1080
    1081             if (ev_g === "linear") {
    1082                 this._setAttr(nodeFill, "type", "gradient");
    1083                 this._setAttr(
    1084                     nodeFill,
    1085                     "color2",
    1086                     el.evalVisProp('gradientsecondcolor')
    1087                 );
    1088                 this._setAttr(
    1089                     nodeFill,
    1090                     "opacity2",
    1091                     el.evalVisProp('gradientsecondopacity')
    1092                 );
    1093                 this._setAttr(nodeFill, "angle", el.evalVisProp('gradientangle'));
    1094             } else if (ev_g === "radial") {
    1095                 this._setAttr(nodeFill, "type", "gradientradial");
    1096                 this._setAttr(
    1097                     nodeFill,
    1098                     "color2",
    1099                     el.evalVisProp('gradientsecondcolor')
    1100                 );
    1101                 this._setAttr(
    1102                     nodeFill,
    1103                     "opacity2",
    1104                     el.evalVisProp('gradientsecondopacity')
    1105                 );
    1106                 this._setAttr(
    1107                     nodeFill,
    1108                     "focusposition",
    1109                     el.evalVisProp('gradientpositionx') * 100 +
    1110                         "%," +
    1111                         el.evalVisProp('gradientpositiony') * 100 +
    1112                         "%"
    1113                 );
    1114                 this._setAttr(nodeFill, "focussize", "0,0");
    1115             } else {
    1116                 this._setAttr(nodeFill, "type", "solid");
    1117             }
    1118         },
    1119
    1120         // Already documented in JXG.AbstractRenderer
    1121         setObjectFillColor: function (el, color, opacity) {
    1122             var rgba = color,
    1123                 c,
    1124                 rgbo,
    1125                 o = opacity,
    1126                 oo,
    1127                 node = el.rendNode;
    1128
    1129             o = o > 0 ? o : 0;
    1130
    1131             if (el.visPropOld.fillcolor === rgba && el.visPropOld.fillopacity === o) {
    1132                 return;
    1133             }
    1134
    1135             if (Type.exists(rgba) && rgba !== false) {
    1136                 // RGB, not RGBA
    1137                 if (rgba.length !== 9) {
    1138                     c = rgba;
    1139                     oo = o;
    1140                     // True RGBA, not RGB
    1141                 } else {
    1142                     rgbo = Color.rgba2rgbo(rgba);
    1143                     c = rgbo[0];
    1144                     oo = o * rgbo[1];
    1145                 }
    1146                 if (c === "none" || c === false) {
    1147                     this._setAttr(el.rendNode, "filled", "false");
    1148                 } else {
    1149                     this._setAttr(el.rendNode, "filled", "true");
    1150                     this._setAttr(el.rendNode, "fillcolor", c);
    1151
    1152                     if (Type.exists(oo) && el.rendNodeFill) {
    1153                         this._setAttr(el.rendNodeFill, "opacity", oo * 100 + "%");
    1154                     }
    1155                 }
    1156                 if (el.type === Const.OBJECT_TYPE_IMAGE) {
    1157                     /*
    1158                     t = el.rendNode.style.filter.toString();
    1159                     if (t.match(/alpha/)) {
    1160                         el.rendNode.style.filter = t.replace(/alpha\(opacity *= *[0-9\.]+\)/, 'alpha(opacity = ' + (oo * 100) + ')');
    1161                     } else {
    1162                         el.rendNode.style.filter += ' alpha(opacity = ' + (oo * 100) + ')';
    1163                     }
    1164                     */
    1165                     if (node.filters.length > 1) {
    1166                         // Why am I sometimes seeing node.filters.length==0 here when I move the pointer around near [0,0]?
    1167                         // Setting axes:true shows text labels!
    1168                         node.filters.item(1).opacity = Math.round(oo * 100); // Why does setObjectFillColor not use Math.round?
    1169                         node.filters.item(1).enabled = true;
    1170                     }
    1171                 }
    1172             }
    1173             el.visPropOld.fillcolor = rgba;
    1174             el.visPropOld.fillopacity = o;
    1175         },
    1176
    1177         // Already documented in JXG.AbstractRenderer
    1178         setObjectStrokeColor: function (el, color, opacity) {
    1179             var rgba = color,
    1180                 c,
    1181                 rgbo,
    1182                 o = opacity,
    1183                 oo,
    1184                 node = el.rendNode,
    1185                 nodeStroke;
    1186
    1187             o = o > 0 ? o : 0;
    1188
    1189             if (el.visPropOld.strokecolor === rgba && el.visPropOld.strokeopacity === o) {
    1190                 return;
    1191             }
    1192
    1193             // this looks like it could be merged with parts of VMLRenderer.setObjectFillColor
    1194
    1195             if (Type.exists(rgba) && rgba !== false) {
    1196                 // RGB, not RGBA
    1197                 if (rgba.length !== 9) {
    1198                     c = rgba;
    1199                     oo = o;
    1200                     // True RGBA, not RGB
    1201                 } else {
    1202                     rgbo = color.rgba2rgbo(rgba);
    1203                     c = rgbo[0];
    1204                     oo = o * rgbo[1];
    1205                 }
    1206                 if (el.elementClass === Const.OBJECT_CLASS_TEXT) {
    1207                     //node.style.filter = ' alpha(opacity = ' + oo + ')';
    1208                     /*
    1209                     t = node.style.filter.toString();
    1210                     if (t.match(/alpha/)) {
    1211                         node.style.filter =
    1212                         t.replace(/alpha\(opacity *= *[0-9\.]+\)/, 'alpha(opacity = ' + oo + ')');
    1213                     } else {
    1214                         node.style.filter += ' alpha(opacity = ' + oo + ')';
    1215                     }
    1216                     */
    1217                     if (node.filters.length > 1) {
    1218                         // Why am I sometimes seeing node.filters.length==0 here when I move the pointer around near [0,0]?
    1219                         // Setting axes:true shows text labels!
    1220                         node.filters.item(1).opacity = Math.round(oo * 100);
    1221                         node.filters.item(1).enabled = true;
    1222                     }
    1223
    1224                     node.style.color = c;
    1225                 } else {
    1226                     if (c !== false) {
    1227                         this._setAttr(node, "stroked", "true");
    1228                         this._setAttr(node, "strokecolor", c);
    1229                     }
    1230
    1231                     nodeStroke = el.rendNodeStroke;
    1232                     if (Type.exists(oo) && el.type !== Const.OBJECT_TYPE_IMAGE) {
    1233                         this._setAttr(nodeStroke, "opacity", oo * 100 + "%");
    1234                     }
    1235                 }
    1236             }
    1237             el.visPropOld.strokecolor = rgba;
    1238             el.visPropOld.strokeopacity = o;
    1239         },
    1240
    1241         // Already documented in JXG.AbstractRenderer
    1242         setObjectStrokeWidth: function (el, width) {
    1243             var w = Type.evaluate(width),
    1244                 node;
    1245
    1246             if (isNaN(w) || el.visPropOld.strokewidth === w) {
    1247                 return;
    1248             }
    1249
    1250             node = el.rendNode;
    1251             this.setPropertyPrim(node, "stroked", "true");
    1252
    1253             if (Type.exists(w)) {
    1254                 this.setPropertyPrim(node, "stroke-width", w);
    1255                 if (w === 0 && Type.exists(el.rendNodeStroke)) {
    1256                     this._setAttr(node, "stroked", "false");
    1257                 }
    1258             }
    1259
    1260             el.visPropOld.strokewidth = w;
    1261         },
    1262
    1263         // Already documented in JXG.AbstractRenderer
    1264         setShadow: function (el) {
    1265             var nodeShadow = el.rendNodeShadow,
    1266                 ev_s = el.evalVisProp('shadow');
    1267
    1268             if (!nodeShadow || el.visPropOld.shadow === ev_s) {
    1269                 return;
    1270             }
    1271
    1272             if (ev_s) {
    1273                 this._setAttr(nodeShadow, "On", "True");
    1274                 this._setAttr(nodeShadow, "Offset", "3pt,3pt");
    1275                 this._setAttr(nodeShadow, "Opacity", "60%");
    1276                 this._setAttr(nodeShadow, "Color", "#aaaaaa");
    1277             } else {
    1278                 this._setAttr(nodeShadow, "On", "False");
    1279             }
    1280
    1281             el.visPropOld.shadow = ev_s;
    1282         },
    1283
    1284         /* **************************
    1285          * renderer control
    1286          * **************************/
    1287
    1288         // Already documented in JXG.AbstractRenderer
    1289         suspendRedraw: function () {
    1290             this.container.style.display = "none";
    1291         },
    1292
    1293         // Already documented in JXG.AbstractRenderer
    1294         unsuspendRedraw: function () {
    1295             this.container.style.display = "";
    1296         }
    1297     }
    1298 );
    1299
    1300 export default JXG.VMLRenderer;
    1301