      1 /*
      2     Copyright 2008-2022
      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 <http://www.gnu.org/licenses/>
     29     and <http://opensource.org/licenses/MIT/>.
     30  */
     31
     32
     33 /*global JXG: true, define: true, AMprocessNode: true, MathJax: true, document: true */
     34 /*jslint nomen: true, plusplus: true, newcap:true, unparam: true*/
     35 /*eslint no-unused-vars: "off"*/
     36
     37 /* depends:
     38  jxg
     39  renderer/abstract
     40 */
     41
     42 /**
     43  * @fileoverview JSXGraph can use various technologies to render the contents of a construction, e.g.
     44  * SVG, VML, and HTML5 Canvas. To accomplish this, The rendering and the logic and control mechanisms
     45  * are completely separated from each other. Every rendering technology has it's own class, called
     46  * Renderer, e.g. SVGRenderer for SVG, the same for VML and Canvas. The common base for all available
     47  * renderers is the class AbstractRenderer.
     48  */
     49
     50 define(['jxg', 'renderer/abstract'], function (JXG, AbstractRenderer) {
     51
     52     "use strict";
     53
     54     /**
     55      * This renderer draws nothing. It is intended to be used in environments where none of our rendering engines
     56      * are available, e.g. WebWorkers. All methods are empty.
     57      *
     58      * @class JXG.NoRenderer
     59      * @augments JXG.AbstractRenderer
     60      * @see JXG.AbstractRenderer
     61      */
     62     JXG.NoRenderer = function () {
     63         /**
     64          * If this property is set to <tt>true</tt> the visual properties of the elements are updated
     65          * on every update. Visual properties means: All the stuff stored in the
     66          * {@link JXG.GeometryElement#visProp} property won't be set if enhancedRendering is <tt>false</tt>
     67          * @type Boolean
     68          * @default true
     69          */
     70         this.enhancedRendering = false;
     71
     72         /**
     73          * This is used to easily determine which renderer we are using
     74          * @example if (board.renderer.type === 'vml') {
     75          *     // do something
     76          * }
     77          * @type String
     78          */
     79         this.type = 'no';
     80     };
     81
     82     JXG.extend(JXG.NoRenderer.prototype, /** @lends JXG.NoRenderer.prototype */ {
     83         /* ******************************** *
     84          *    Point drawing and updating    *
     85          * ******************************** */
     86
     87         /**
     88          * Draws a point on the {@link JXG.Board}.
     89          * @param {JXG.Point} element Reference to a {@link JXG.Point} object that has to be drawn.
     90          * @see Point
     91          * @see JXG.Point
     92          * @see JXG.AbstractRenderer#updatePoint
     93          * @see JXG.AbstractRenderer#changePointStyle
     94          */
     95         drawPoint: function (element) {},
     96
     97         /**
     98          * Updates visual appearance of the renderer element assigned to the given {@link JXG.Point}.
     99          * @param {JXG.Point} element Reference to a {@link JXG.Point} object, that has to be updated.
    100          * @see Point
    101          * @see JXG.Point
    102          * @see JXG.AbstractRenderer#drawPoint
    103          * @see JXG.AbstractRenderer#changePointStyle
    104          */
    105         updatePoint: function (element) { },
    106
    107         /**
    108          * Changes the style of a {@link JXG.Point}. This is required because the point styles differ in what
    109          * elements have to be drawn, e.g. if the point is marked by a "x" or a "+" two lines are drawn, if
    110          * it's marked by spot a circle is drawn. This method removes the old renderer element(s) and creates
    111          * the new one(s).
    112          * @param {JXG.Point} element Reference to a {@link JXG.Point} object, that's style is changed.
    113          * @see Point
    114          * @see JXG.Point
    115          * @see JXG.AbstractRenderer#updatePoint
    116          * @see JXG.AbstractRenderer#drawPoint
    117          */
    118         changePointStyle: function (element) { },
    119
    120         /* ******************************** *
    121          *           Lines                  *
    122          * ******************************** */
    123
    124         /**
    125          * Draws a line on the {@link JXG.Board}.
    126          * @param {JXG.Line} element Reference to a line object, that has to be drawn.
    127          * @see Line
    128          * @see JXG.Line
    129          * @see JXG.AbstractRenderer#updateLine
    130          */
    131         drawLine: function (element) { },
    132
    133         /**
    134          * Updates visual appearance of the renderer element assigned to the given {@link JXG.Line}.
    135          * @param {JXG.Line} element Reference to the {@link JXG.Line} object that has to be updated.
    136          * @see Line
    137          * @see JXG.Line
    138          * @see JXG.AbstractRenderer#drawLine
    139          */
    140         updateLine: function (element) { },
    141
    142         /**
    143          * Creates a rendering node for ticks added to a line.
    144          * @param {JXG.Line} element A arbitrary line.
    145          * @see Line
    146          * @see Ticks
    147          * @see JXG.Line
    148          * @see JXG.Ticks
    149          * @see JXG.AbstractRenderer#updateTicks
    150          */
    151         drawTicks: function (element) { },
    152
    153         /**
    154          * Update {@link Ticks} on a {@link JXG.Line}. This method is only a stub and has to be implemented
    155          * in any descendant renderer class.
    156          * @param {JXG.Line} element Reference of an line object, thats ticks have to be updated.
    157          * @see Line
    158          * @see Ticks
    159          * @see JXG.Line
    160          * @see JXG.Ticks
    161          * @see JXG.AbstractRenderer#drawTicks
    162          */
    163         updateTicks: function (element) { /* stub */ },
    164
    165         /* **************************
    166          *    Curves
    167          * **************************/
    168
    169         /**
    170          * Draws a {@link JXG.Curve} on the {@link JXG.Board}.
    171          * @param {JXG.Curve} element Reference to a graph object, that has to be plotted.
    172          * @see Curve
    173          * @see JXG.Curve
    174          * @see JXG.AbstractRenderer#updateCurve
    175          */
    176         drawCurve: function (element) { },
    177
    178         /**
    179          * Updates visual appearance of the renderer element assigned to the given {@link JXG.Curve}.
    180          * @param {JXG.Curve} element Reference to a {@link JXG.Curve} object, that has to be updated.
    181          * @see Curve
    182          * @see JXG.Curve
    183          * @see JXG.AbstractRenderer#drawCurve
    184          */
    185         updateCurve: function (element) { },
    186
    187         /* **************************
    188          *    Circle related stuff
    189          * **************************/
    190
    191         /**
    192          * Draws a {@link JXG.Circle}
    193          * @param {JXG.Circle} element Reference to a {@link JXG.Circle} object that has to be drawn.
    194          * @see Circle
    195          * @see JXG.Circle
    196          * @see JXG.AbstractRenderer#updateEllipse
    197          */
    198         drawEllipse: function (element) { },
    199
    200         /**
    201          * Updates visual appearance of a given {@link JXG.Circle} on the {@link JXG.Board}.
    202          * @param {JXG.Circle} element Reference to a {@link JXG.Circle} object, that has to be updated.
    203          * @see Circle
    204          * @see JXG.Circle
    205          * @see JXG.AbstractRenderer#drawEllipse
    206          */
    207         updateEllipse: function (element) { },
    208
    209
    210         /* **************************
    211          *   Polygon related stuff
    212          * **************************/
    213
    214         /**
    215          * Draws a {@link JXG.Polygon} on the {@link JXG.Board}.
    216          * @param {JXG.Polygon} element Reference to a Polygon object, that is to be drawn.
    217          * @see Polygon
    218          * @see JXG.Polygon
    219          * @see JXG.AbstractRenderer#updatePolygon
    220          */
    221         drawPolygon: function (element) { },
    222
    223         /**
    224          * Updates properties of a {@link JXG.Polygon}'s rendering node.
    225          * @param {JXG.Polygon} element Reference to a {@link JXG.Polygon} object, that has to be updated.
    226          * @see Polygon
    227          * @see JXG.Polygon
    228          * @see JXG.AbstractRenderer#drawPolygon
    229          */
    230         updatePolygon: function (element) { },
    231
    232         /* **************************
    233          *    Text related stuff
    234          * **************************/
    235
    236         /**
    237          * Shows a small copyright notice in the top left corner of the board.
    238          * @param {String} str The copyright notice itself
    239          * @param {Number} fontsize Size of the font the copyright notice is written in
    240          */
    241         displayCopyright: function (str, fontsize) { /* stub */ },
    242
    243         /**
    244          * An internal text is a {@link JXG.Text} element which is drawn using only
    245          * the given renderer but no HTML. This method is only a stub, the drawing
    246          * is done in the special renderers.
    247          * @param {JXG.Text} element Reference to a {@link JXG.Text} object
    248          * @see Text
    249          * @see JXG.Text
    250          * @see JXG.AbstractRenderer#updateInternalText
    251          * @see JXG.AbstractRenderer#drawText
    252          * @see JXG.AbstractRenderer#updateText
    253          * @see JXG.AbstractRenderer#updateTextStyle
    254          */
    255         drawInternalText: function (element) { /* stub */ },
    256
    257         /**
    258          * Updates visual properties of an already existing {@link JXG.Text} element.
    259          * @param {JXG.Text} element Reference to an {@link JXG.Text} object, that has to be updated.
    260          * @see Text
    261          * @see JXG.Text
    262          * @see JXG.AbstractRenderer#drawInternalText
    263          * @see JXG.AbstractRenderer#drawText
    264          * @see JXG.AbstractRenderer#updateText
    265          * @see JXG.AbstractRenderer#updateTextStyle
    266          */
    267         updateInternalText: function (element) { /* stub */ },
    268
    269         /**
    270          * Displays a {@link JXG.Text} on the {@link JXG.Board} by putting a HTML div over it.
    271          * @param {JXG.Text} element Reference to an {@link JXG.Text} object, that has to be displayed
    272          * @see Text
    273          * @see JXG.Text
    274          * @see JXG.AbstractRenderer#drawInternalText
    275          * @see JXG.AbstractRenderer#updateText
    276          * @see JXG.AbstractRenderer#updateInternalText
    277          * @see JXG.AbstractRenderer#updateTextStyle
    278          */
    279         drawText: function (element) { },
    280
    281         /**
    282          * Updates visual properties of an already existing {@link JXG.Text} element.
    283          * @param {JXG.Text} element Reference to an {@link JXG.Text} object, that has to be updated.
    284          * @see Text
    285          * @see JXG.Text
    286          * @see JXG.AbstractRenderer#drawText
    287          * @see JXG.AbstractRenderer#drawInternalText
    288          * @see JXG.AbstractRenderer#updateInternalText
    289          * @see JXG.AbstractRenderer#updateTextStyle
    290          */
    291         updateText: function (element) { },
    292
    293         /**
    294          * Updates CSS style properties of a {@link JXG.Text} node.
    295          * @param {JXG.Text} element Reference to the {@link JXG.Text} object, that has to be updated.
    296          * @param {Boolean} doHighlight
    297          * @see Text
    298          * @see JXG.Text
    299          * @see JXG.AbstractRenderer#drawText
    300          * @see JXG.AbstractRenderer#drawInternalText
    301          * @see JXG.AbstractRenderer#updateText
    302          * @see JXG.AbstractRenderer#updateInternalText
    303          */
    304         updateTextStyle: function (element, doHighlight) { },
    305
    306         /**
    307          * Set color and opacity of internal texts.
    308          * SVG needs its own version.
    309          * @private
    310          * @see JXG.AbstractRenderer#updateTextStyle
    311          * @see JXG.AbstractRenderer#updateInternalTextStyle
    312          */
    313         updateInternalTextStyle: function (element, strokeColor, strokeOpacity) { /* stub */ },
    314
    315         /* **************************
    316          *    Image related stuff
    317          * **************************/
    318
    319         /**
    320          * Draws an {@link JXG.Image} on a board; This is just a template that has to be implemented by special renderers.
    321          * @param {JXG.Image} element Reference to the image object that is to be drawn
    322          * @see Image
    323          * @see JXG.Image
    324          * @see JXG.AbstractRenderer#updateImage
    325          */
    326         drawImage: function (element) { /* stub */ },
    327
    328         /**
    329          * Updates the properties of an {@link JXG.Image} element.
    330          * @param {JXG.Image} element Reference to an {@link JXG.Image} object, that has to be updated.
    331          * @see Image
    332          * @see JXG.Image
    333          * @see JXG.AbstractRenderer#drawImage
    334          */
    335         updateImage: function (element) { },
    336
    337         /**
    338          * Applies transformations on images and text elements. This method is just a stub and has to be implemented in all
    339          * descendant classes where text and image transformations are to be supported.
    340          * @param {JXG.Image|JXG.Text} element A {@link JXG.Image} or {@link JXG.Text} object.
    341          * @param {Array} transformations An array of {@link JXG.Transformation} objects. This is usually the transformations property
    342          * of the given element <tt>el</tt>.
    343          */
    344         transformImage: function (element, transformations) { /* stub */ },
    345
    346         /**
    347          * If the URL of the image is provided by a function the URL has to be updated during updateImage()
    348          * @param {JXG.Image} element Reference to an image object.
    349          * @see JXG.AbstractRenderer#updateImage
    350          */
    351         updateImageURL: function (element) { /* stub */ },
    352
    353         /* **************************
    354          * Render primitive objects
    355          * **************************/
    356
    357         /**
    358          * Appends a node to a specific layer level. This is just an abstract method and has to be implemented
    359          * in all renderers that want to use the <tt>createPrim</tt> model to draw.
    360          * @param {Node} node A DOM tree node.
    361          * @param {Number} level The layer the node is attached to. This is the index of the layer in
    362          * {@link JXG.SVGRenderer#layer} or the <tt>z-index</tt> style property of the node in VMLRenderer.
    363          */
    364         appendChildPrim: function (node, level) { /* stub */ },
    365
    366         /**
    367          * Stores the rendering nodes. This is an abstract method which has to be implemented in all renderers that use
    368          * the <tt>createPrim</tt> method.
    369          * @param {JXG.GeometryElement} element A JSXGraph element.
    370          * @param {String} type The XML node name. Only used in VMLRenderer.
    371          */
    372         appendNodesToElement: function (element, type) { /* stub */ },
    373
    374         /**
    375          * Creates a node of a given type with a given id.
    376          * @param {String} type The type of the node to create.
    377          * @param {String} id Set the id attribute to this.
    378          * @returns {Node} Reference to the created node.
    379          */
    380         createPrim: function (type, id) {
    381             /* stub */
    382             return null;
    383         },
    384
    385         /**
    386          * Removes an element node. Just a stub.
    387          * @param {Node} node The node to remove.
    388          */
    389         remove: function (node) { /* stub */ },
    390
    391         /**
    392          * Can be used to create the nodes to display arrows. This is an abstract method which has to be implemented
    393          * in any descendant renderer.
    394          * @param {JXG.GeometryElement} element The element the arrows are to be attached to.
    395          */
    396         makeArrows: function (element) { /* stub */ },
    397
    398         /**
    399          * Updates an ellipse node primitive. This is an abstract method which has to be implemented in all renderers
    400          * that use the <tt>createPrim</tt> method.
    401          * @param {Node} node Reference to the node.
    402          * @param {Number} x Centre X coordinate
    403          * @param {Number} y Centre Y coordinate
    404          * @param {Number} rx The x-axis radius.
    405          * @param {Number} ry The y-axis radius.
    406          */
    407         updateEllipsePrim: function (node, x, y, rx, ry) { /* stub */ },
    408
    409         /**
    410          * Refreshes a line node. This is an abstract method which has to be implemented in all renderers that use
    411          * the <tt>createPrim</tt> method.
    412          * @param {Node} node The node to be refreshed.
    413          * @param {Number} p1x The first point's x coordinate.
    414          * @param {Number} p1y The first point's y coordinate.
    415          * @param {Number} p2x The second point's x coordinate.
    416          * @param {Number} p2y The second point's y coordinate.
    417          * @param {JXG.Board} board
    418          */
    419         updateLinePrim: function (node, p1x, p1y, p2x, p2y, board) { /* stub */ },
    420
    421         /**
    422          * Updates a path element. This is an abstract method which has to be implemented in all renderers that use
    423          * the <tt>createPrim</tt> method.
    424          * @param {Node} node The path node.
    425          * @param {String} pathString A string formatted like e.g. <em>'M 1,2 L 3,1 L5,5'</em>. The format of the string
    426          * depends on the rendering engine.
    427          * @param {JXG.Board} board Reference to the element's board.
    428          */
    429         updatePathPrim: function (node, pathString, board) { /* stub */ },
    430
    431         /**
    432          * Builds a path data string to draw a point with a face other than <em>rect</em> and <em>circle</em>. Since
    433          * the format of such a string usually depends on the renderer this method
    434          * is only an abstract method. Therefore, it has to be implemented in the descendant renderer itself unless
    435          * the renderer does not use the createPrim interface but the draw* interfaces to paint.
    436          * @param {JXG.Point} element The point element
    437          * @param {Number} size A positive number describing the size. Usually the half of the width and height of
    438          * the drawn point.
    439          * @param {String} type A string describing the point's face. This method only accepts the shortcut version of
    440          * each possible face: <tt>x, +, <>, ^, v, >, <
    441          */
    442         updatePathStringPoint: function (element, size, type) { /* stub */ },
    443
    444         /**
    445          * Builds a path data string from a {@link JXG.Curve} element. Since the path data strings heavily depend on the
    446          * underlying rendering technique this method is just a stub. Although such a path string is of no use for the
    447          * CanvasRenderer, this method is used there to draw a path directly.
    448          * @param element
    449          */
    450         updatePathStringPrim: function (element) { /* stub */ },
    451
    452         /**
    453          * Builds a path data string from a {@link JXG.Curve} element such that the curve looks like
    454          * hand drawn.
    455          * Since the path data strings heavily depend on the
    456          * underlying rendering technique this method is just a stub. Although such a path string is of no use for the
    457          * CanvasRenderer, this method is used there to draw a path directly.
    458          * @param element
    459          */
    460         updatePathStringBezierPrim: function (element) { /* stub */ },
    461
    462
    463         /**
    464          * Update a polygon primitive.
    465          * @param {Node} node
    466          * @param {JXG.Polygon} element A JSXGraph element of type {@link JXG.Polygon}
    467          */
    468         updatePolygonPrim: function (node, element) { /* stub */ },
    469
    470         /**
    471          * Update a rectangle primitive. This is used only for points with face of type 'rect'.
    472          * @param {Node} node The node yearning to be updated.
    473          * @param {Number} x x coordinate of the top left vertex.
    474          * @param {Number} y y coordinate of the top left vertex.
    475          * @param {Number} w Width of the rectangle.
    476          * @param {Number} h The rectangle's height.
    477          */
    478         updateRectPrim: function (node, x, y, w, h) { /* stub */ },
    479
    480         /* **************************
    481          *  Set Attributes
    482          * **************************/
    483
    484         /**
    485          * Sets a node's attribute.
    486          * @param {Node} node The node that is to be updated.
    487          * @param {String} key Name of the attribute.
    488          * @param {String} val New value for the attribute.
    489          */
    490         setPropertyPrim: function (node, key, val) { /* stub */ },
    491
    492         /**
    493          * Shows or hides an element on the canvas; Only a stub, requires implementation in the derived renderer.
    494          * @param {JXG.GeometryElement} element Reference to the object that has to appear.
    495          * @param {Boolean} value true to show the element, false to hide the element.
    496          */
    497         display: function (element, value) {
    498             if (element) {
    499                 element.visPropOld.visible = value;
    500             }
    501         },
    502
    503         /**
    504          * Shows a hidden element on the canvas; Only a stub, requires implementation in the derived renderer.
    505          *
    506          * Please use JXG.AbstractRenderer#display instead
    507          * @param {JXG.GeometryElement} element Reference to the object that has to appear.
    508          * @see JXG.AbstractRenderer#hide
    509          * @deprecated
    510          */
    511         show: function (element) { /* stub */ },
    512
    513         /**
    514          * Hides an element on the canvas; Only a stub, requires implementation in the derived renderer.
    515          *
    516          * Please use JXG.AbstractRenderer#display instead
    517          * @param {JXG.GeometryElement} element Reference to the geometry element that has to disappear.
    518          * @see JXG.AbstractRenderer#show
    519          * @deprecated
    520          */
    521         hide: function (element) { /* stub */ },
    522
    523         /**
    524          * Sets the buffering as recommended by SVGWG. Until now only Opera supports this and will be ignored by
    525          * other browsers. Although this feature is only supported by SVG we have this method in {@link JXG.AbstractRenderer}
    526          * because it is called from outside the renderer.
    527          * @param {Node} node The SVG DOM Node which buffering type to update.
    528          * @param {String} type Either 'auto', 'dynamic', or 'static'. For an explanation see
    529          *   {@link http://www.w3.org/TR/SVGTiny12/painting.html#BufferedRenderingProperty}.
    530          */
    531         setBuffering: function (node, type) { /* stub */ },
    532
    533         /**
    534          * Sets an element's dash style.
    535          * @param {JXG.GeometryElement} element An JSXGraph element.
    536          */
    537         setDashStyle: function (element) { /* stub */ },
    538
    539         /**
    540          * Puts an object into draft mode, i.e. it's visual appearance will be changed. For GEONE<sub>x</sub>T backwards compatibility.
    541          * @param {JXG.GeometryElement} element Reference of the object that is in draft mode.
    542          */
    543         setDraft: function (element) { },
    544
    545         /**
    546          * Puts an object from draft mode back into normal mode.
    547          * @param {JXG.GeometryElement} element Reference of the object that no longer is in draft mode.
    548          */
    549         removeDraft: function (element) { },
    550
    551         /**
    552          * Sets up nodes for rendering a gradient fill.
    553          * @param element
    554          */
    555         setGradient: function (element) { /* stub */ },
    556
    557         /**
    558          * Updates the gradient fill.
    559          * @param {JXG.GeometryElement} element An JSXGraph element with an area that can be filled.
    560          */
    561         updateGradient: function (element) { /* stub */ },
    562
    563         /**
    564          * Sets the transition duration (in milliseconds) for fill color and stroke
    565          * color and opacity.
    566          * @param {JXG.GeometryElement} element Reference of the object that wants a
    567          *         new transition duration.
    568          * @param {Number} duration (Optional) duration in milliseconds. If not given,
    569          *        element.visProp.transitionDuration is taken. This is the default.
    570          */
    571         setObjectTransition: function (element, duration) { /* stub */ },
    572
    573         /**
    574          * Sets an objects fill color.
    575          * @param {JXG.GeometryElement} element Reference of the object that wants a new fill color.
    576          * @param {String} color Color in a HTML/CSS compatible format. If you don't want any fill color at all, choose 'none'.
    577          * @param {Number} opacity Opacity of the fill color. Must be between 0 and 1.
    578          */
    579         setObjectFillColor: function (element, color, opacity) { /* stub */ },
    580
    581         /**
    582          * Changes an objects stroke color to the given color.
    583          * @param {JXG.GeometryElement} element Reference of the {@link JXG.GeometryElement} that gets a new stroke color.
    584          * @param {String} color Color value in a HTML compatible format, e.g. <strong>#00ff00</strong> or <strong>green</strong> for green.
    585          * @param {Number} opacity Opacity of the fill color. Must be between 0 and 1.
    586          */
    587         setObjectStrokeColor: function (element, color, opacity) { /* stub */ },
    588
    589         /**
    590          * Sets an element's stroke width.
    591          * @param {JXG.GeometryElement} element Reference to the geometry element.
    592          * @param {Number} width The new stroke width to be assigned to the element.
    593          */
    594         setObjectStrokeWidth: function (element, width) { /* stub */ },
    595
    596         /**
    597          * Sets the shadow properties to a geometry element. This method is only a stub, it is implemented in the actual renderers.
    598          * @param {JXG.GeometryElement} element Reference to a geometry object, that should get a shadow
    599          */
    600         setShadow: function (element) { /* stub */ },
    601
    602         /**
    603          * Highlights an object, i.e. changes the current colors of the object to its highlighting colors
    604          * @param {JXG.GeometryElement} element Reference of the object that will be highlighted.
    605          * @returns {JXG.AbstractRenderer} Reference to the renderer
    606          */
    607         highlight: function (element) { },
    608
    609         /**
    610          * Uses the normal colors of an object, i.e. the opposite of {@link JXG.AbstractRenderer#highlight}.
    611          * @param {JXG.GeometryElement} element Reference of the object that will get its normal colors.
    612          * @returns {JXG.AbstractRenderer} Reference to the renderer
    613          */
    614         noHighlight: function (element) { },
    615
    616
    617         /* **************************
    618          * renderer control
    619          * **************************/
    620
    621         /**
    622          * Stop redraw. This method is called before every update, so a non-vector-graphics based renderer
    623          * can use this method to delete the contents of the drawing panel. This is an abstract method every
    624          * descendant renderer should implement, if appropriate.
    625          * @see JXG.AbstractRenderer#unsuspendRedraw
    626          */
    627         suspendRedraw: function () { /* stub */ },
    628
    629         /**
    630          * Restart redraw. This method is called after updating all the rendering node attributes.
    631          * @see JXG.AbstractRenderer#suspendRedraw
    632          */
    633         unsuspendRedraw: function () { /* stub */ },
    634
    635         /**
    636          * The tiny zoom bar shown on the bottom of a board (if showNavigation on board creation is true).
    637          * @param {JXG.Board} board Reference to a JSXGraph board.
    638          */
    639         drawZoomBar: function (board) { },
    640
    641         /**
    642          * Wrapper for getElementById for maybe other renderers which elements are not directly accessible by DOM methods like document.getElementById().
    643          * @param {String} id Unique identifier for element.
    644          * @returns {Object} Reference to a JavaScript object. In case of SVG/VMLRenderer it's a reference to a SVG/VML node.
    645          */
    646         getElementById: function (id) {
    647             return null;
    648         },
    649
    650         /**
    651          * Resizes the rendering element
    652          * @param {Number} w New width
    653          * @param {Number} h New height
    654          */
    655         resize: function (w, h) { /* stub */},
    656
    657         removeToInsertLater: function () {
    658             return function () {};
    659         }
    660
    661     });
    662
    663     /**
    664      * @ignore
    665      */
    666     JXG.NoRenderer.prototype = new AbstractRenderer();
    667
    668     return JXG.NoRenderer;
    669 });
    670