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