      1 /*
      2     Copyright 2008-2018
      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*/
     34 /*jslint nomen: true, plusplus: true*/
     35
     36 /* depends:
     37  jxg
     38  base/constants
     39  math/math
     40  utils/color
     41  utils/type
     42  */
     43
     44 define([
     45     'jxg', 'base/constants', 'math/math', 'utils/color', 'utils/type'
     46 ], function (JXG, Const, Mat, Color, Type) {
     47
     48     "use strict";
     49
     50     /**
     51      * Options Namespace
     52      * @description These are the default options of the board and of all geometry elements.
     53      * @namespace
     54      * @name JXG.Options
     55      */
     56     JXG.Options = {
     57         jc: {
     58             enabled: true,
     59             compile: true
     60         },
     61
     62         /*
     63          * Options that are used directly within the board class
     64          */
     65         board: {
     66             /**#@+
     67              * @visprop
     68              */
     69
     70             //updateType: 'hierarchical', // 'all'
     71
     72             /**
     73              * Bounding box of the visible area in user coordinates.
     74              * It is an array consisting of four values:
     75              * [x<sub>1</sub>, y<sub>1</sub>, x<sub>2</sub>, y<sub>2</sub>]
     76              *
     77              * The canvas will be spanned from the upper left corner (<sub>1</sub>, y<sub>1</sub>)
     78              * to the lower right corner (x<sub>2</sub>, y<sub>2</sub>).
     79              *
     80              * @name JXG.Board#boundingbox
     81              * @type Array
     82              * @default [-5, 5, 5, -5]
     83              */
     84             boundingBox: [-5, 5, 5, -5],
     85
     86             /**
     87              * Additional zoom factor multiplied to {@link JXG.Board#zoomX} and {@link JXG.Board#zoomY}.
     88              *
     89              * @name JXG.Board#zoomFactor
     90              * @type Number
     91              * @default 1.0
     92              */
     93             zoomFactor: 1,
     94
     95             /**
     96              * Zoom factor in horizontal direction.
     97              *
     98              * @name JXG.Board#zoomX
     99              * @see JXG.Board#zoomY
    100              * @type Number
    101              * @default 1.0
    102              */
    103             zoomX: 1,
    104
    105             /**
    106              * Zoom factor in vertical direction.
    107              *
    108              * @name JXG.Board#zoomY
    109              * @see JXG.Board#zoomX
    110              * @type Number
    111              * @default 1.0
    112              */
    113             zoomY: 1,
    114
    115             /**
    116              * Show copyright string in canvas.
    117              *
    118              * @name JXG.Board#showCopyright
    119              * @type Boolean
    120              * @default true
    121              */
    122             showCopyright: true,
    123
    124             /**
    125              * Show default axis.
    126              * If shown, the horizontal axis can be accessed via JXG.Board.defaultAxes.x, the
    127              * vertical axis can be accessed via JXG.Board.defaultAxes.y.
    128              * Both axes have a sub-element "defaultTicks".
    129              *
    130              * Value can be Boolean or an object containing axis attributes.
    131              *
    132              * @name JXG.Board#axis
    133              * @type Boolean
    134              * @default false
    135              */
    136             axis: false,
    137
    138             /**
    139              * Attributes for the default axes in case of the attribute
    140              * axis:true in {@link JXG.JSXGraph#initBoard}.
    141              *
    142              * @name JXG.Board#defaultAxes
    143              * @type {Object}
    144              * @default {x: {name:'x'}, y: {name: 'y'}}
    145              *
    146              */
    147             defaultAxes: {
    148                 x: {
    149                     name: 'x',
    150                     ticks: {
    151                         label: {
    152                             visible: 'inherit',
    153                             anchorX: 'middle',
    154                             anchorY: 'top',
    155                             fontSize: 12,
    156                             offset: [0, -3]
    157                         },
    158                         drawZero: false,
    159                         visible: 'inherit'
    160                     }
    161                 },
    162                 y: {
    163                     name: 'y',
    164                     ticks: {
    165                         label: {
    166                             visible: 'inherit',
    167                             anchorX: 'right',
    168                             anchorY: 'middle',
    169                             fontSize: 12,
    170                             offset: [-6, 0]
    171                         },
    172                         tickEndings: [1, 0],
    173                         drawZero: false,
    174                         visible: 'inherit'
    175                     }
    176                 }
    177             },
    178
    179             /**
    180              * Display of navigation arrows and zoom buttons
    181              *
    182              * @name JXG.Board#showNavigation
    183              * @type Boolean
    184              * @default true
    185              */
    186             showNavigation: true,
    187
    188             /**
    189              * Display of zoom buttons. To show zoom buttons, additionally
    190              * showNavigation has to be set to true.
    191              *
    192              * @name JXG.Board#showZoom
    193              * @type Boolean
    194              * @default true
    195              */
    196             showZoom: true,
    197
    198             /**
    199              * Show a button to force reload of a construction.
    200              * Works only with the JessieCode tag
    201              *
    202              * @name JXG.Board#showReload
    203              * @type Boolean
    204              * @default false
    205              */
    206             showReload: false,
    207
    208             showScreenshot: false,
    209
    210             screenshot: {
    211                 scale: 1.0,
    212                 type: 'png',
    213                 symbol: '\u2318', //'\u22b9', //'\u26f6',
    214                 css: 'background-color:#eeeeee; opacity:1.0; border:2px solid black; border-radius:10px; text-align:center',
    215                 cssButton:  'padding: 4px 10px; border: solid #356AA0 1px; border-radius: 5px; position: absolute; right: 2ex; top: 2ex; background-color: rgba(255, 255, 255, 0.3);'
    216             },
    217
    218             /**
    219              * Show a button which allows to clear all traces of a board.
    220              *
    221              * @name JXG.Board#showClearTraces
    222              * @type Boolean
    223              * @default false
    224              */
    225             showClearTraces: false,
    226
    227             /**
    228              * If set to true the bounding box might be changed such that
    229              * the ratio of width and height of the hosting HTML div is equal
    230              * to the ratio of wifth and height of the bounding box.
    231              *
    232              * This is necessary if circles should look like circles and not
    233              * like ellipses. It is recommended to set keepAspectRatio = true
    234              * for geometric applets. For function plotting keepAspectRatio = false
    235              * might be the better choice.
    236              *
    237              * @name JXG.Board#keepAspectRatio
    238              * @see JXG.Board#boundingbox
    239              * @see JXG.Board#setBoundingBox
    240              * @type Boolean
    241              * @default false
    242              */
    243             keepAspectRatio: false,
    244
    245             /**
    246              * If set true and
    247              * hasPoint() is true for both an element and it's label,
    248              * the element (and not the label) is taken as drag element.
    249              *
    250              * If set false and hasPoint() is true for both an element and it's label,
    251              * the label is taken (if it is on a higher layer than the element)
    252              *
    253              * @name JXG.Board#ignoreLabels
    254              * @type Booelan
    255              * @default true
    256              */
    257             ignoreLabels: true,
    258
    259             /**
    260              * Maximum number of digits in automatic label generation.
    261              * For example, if set to 1 automatic point labels end at "Z".
    262              * If set to 2, point labels end at "ZZ".
    263              *
    264              * @name JXG.Board#maxNameLength
    265              * @see JXG.Board#generateName
    266              * @type Number
    267              * @default 1
    268              */
    269             maxNameLength: 1,
    270
    271             /**
    272              * Supply the document object. Defaults to window.document
    273              *
    274              * @name JXG.Board#document
    275              * @type DOM object
    276              * @default false (meaning window.document)
    277              */
    278             document: false,
    279
    280             /**
    281              * If true the first element of the set JXG.board.objects having hasPoint==true is taken as drag element.
    282              *
    283              * @name JXG.Board#takeFirst
    284              * @type Boolean
    285              * @default false
    286              */
    287             takeFirst: false,
    288
    289             /**
    290             * If true, when read from a file or string - the size of the div can be changed by the construction text.
    291             *
    292             * @name JXG.Board#takeSizeFromFile
    293             * @type Boolean
    294             * @default false
    295             */
    296             takeSizeFromFile: false,
    297
    298             /**
    299              * Default rendering engine. Possible values are 'svg', 'canvas', 'vml', 'no', or 'auto'.
    300              * If the rendering engine is not available JSXGraph tries to detect a different engine.
    301              *
    302              * <p>
    303              * In case of 'canvas' it is advisable to call 'board.update()' after all elements have been
    304              * constructed. This ensures that all elements are drawn with their intended visual appearance.
    305              *
    306              * @name JXG.Board#renderer
    307              * @type String
    308              * @default 'auto'
    309              */
    310             renderer: 'auto',
    311
    312             /**
    313              * Time (in msec) between two animation steps. Used in
    314              * {@link JXG.CoordsElement#moveAlong}, {@link JXG.CoordsElement#moveTo} and
    315              * {@link JXG.CoordsElement#visit}.
    316              *
    317              * @name JXG.Board#animationDelay
    318              * @type Number
    319              * @default 35
    320              * @see JXG.CoordsElement#moveAlong
    321              * @see JXG.CoordsElement#moveTo
    322              * @see JXG.CoordsElement#visit
    323              */
    324             animationDelay: 35,
    325
    326             /**
    327              * Allow user interaction by registering mouse and touch events.
    328              *
    329              * @name JXG.Board#registerEvents
    330              * @type Boolean
    331              * @default true
    332              */
    333             registerEvents: true,
    334
    335             /**
    336              * Change redraw strategy in SVG rendering engine.
    337              *
    338              * If set to 'svg', before every redrawing of the JSXGraph construction
    339              * the SVG sub-tree of the DOM tree is taken out of the DOM.
    340              *
    341              * If set to 'all', before every redrawing of the JSXGraph construction the
    342              * complete DOM tree is taken out of the DOM.
    343              * If set to 'none' the redrawing is done in-place.
    344              *
    345              * Using 'svg' or 'all' speeds up the update process considerably. The risk
    346              * is that if there is an exception, only a white div or window is left.
    347              *
    348              * @name JXG.Board#minimizeReflow
    349              * @type String
    350              * @default 'svg'
    351              */
    352             minimizeReflow: 'svg',
    353
    354             /**
    355              * A number that will be added to the absolute position of the board used in mouse coordinate
    356              * calculations in {@link JXG.Board#getCoordsTopLeftCorner}.
    357              *
    358              * @name JXG.Board#offsetX
    359              * @see JXG.Board#offsetY
    360              * @type Number
    361              * @default 0
    362              */
    363             offsetX: 0,
    364
    365             /**
    366              * A number that will be added to the absolute position of the board used in mouse coordinate
    367              * calculations in {@link JXG.Board#getCoordsTopLeftCorner}.
    368              *
    369              * @name JXG.Board#offsetY
    370              * @see JXG.Board#offsetX
    371              * @type Number
    372              * @default 0
    373              */
    374             offsetY: 0,
    375
    376             /**
    377              * Control the possibilities for zoom interaction.
    378              *
    379              * Possible sub-attributes with default values are:
    380              * <pre>
    381              * zoom: {
    382              *   factorX: 1.25,  // horizontal zoom factor (multiplied to {@link JXG.Board#zoomX})
    383              *   factorY: 1.25,  // vertical zoom factor (multiplied to {@link JXG.Board#zoomY})
    384              *   wheel: true,     // allow zooming by mouse wheel or
    385              *   				   // by pinch-to-toom gesture on touch devices
    386              *   needShift: true, // mouse wheel zooming needs pressing of the shift key
    387              *   min: 0.001        // minimal values of {@link JXG.Board#zoomX} and {@link JXG.Board#zoomY}, limits zoomOut
    388              *   max: 1000.0       // maximal values of {@link JXG.Board#zoomX} and {@link JXG.Board#zoomY}, limits zoomIn
    389              *
    390              *   pinchHorizontal: true // Allow pinch-to-zoom to zoom only horizontal axis
    391              *   pinchVertical: true   // Allow pinch-to-zoom to zoom only vertical axis
    392              *   pinchSensitivity: 7   // Sensitivity (in degrees) for recognizing horizontal or vertical pinch-to-zoom gestures.
    393              * }
    394              * </pre>
    395              *
    396              * Deprecated: zoom.eps which is superseded by zoom.min
    397              *
    398              * @name JXG.Board#zoom
    399              * @type Object
    400              * @default
    401              */
    402             zoom: {
    403                 enabled: true,
    404                 factorX: 1.25,
    405                 factorY: 1.25,
    406                 wheel: true,
    407                 needShift: true,
    408                 min: 0.0001,
    409                 max: 10000.0,
    410                 pinchHorizontal: true,
    411                 pinchVertical: true,
    412                 pinchSensitivity: 7
    413             },
    414
    415             /**
    416              * Control the possibilities for panning interaction (i.e. moving the origin).
    417              *
    418              * Possible sub-attributes with default values are:
    419              * <pre>
    420              * pan: {
    421              *   enabled: true   // Allow panning
    422              *   needTwoFingers: true, // panning is done with two fingers on touch devices
    423              *   needShift: true, // mouse panning needs pressing of the shift key
    424              * }
    425              * </pre>
    426              *
    427              * @name JXG.Board#pan
    428              * @type Object
    429              * @default
    430              */
    431             pan: {
    432                 needShift: true,
    433                 needTwoFingers: false,
    434                 enabled: true
    435             },
    436
    437             /**
    438              * Control the possibilities for a selection rectangle.
    439              * Starting a selection event triggers the "startselecting" event.
    440              * When the mouse pointer is released, the "stopselecting" event is fired.
    441              * The "stopselecting" event must be supplied by the user.
    442              * <p>
    443              * Possible sub-attributes with default values are:
    444              * <pre>
    445              * selection: {
    446              *   enabled: false,
    447              *   name: 'selectionPolygon',
    448              *   needShift: false,  // mouse selection needs pressing of the shift key
    449              *   needCtrl: true,    // mouse selection needs pressing of the shift key
    450              *   withLines: false,  // Selection polygon has border lines
    451              *   vertices: {
    452              *       visible: false
    453              *   },
    454              *   fillColor: '#ffff00',
    455              *   visible: false      // Initial visibility. Should be set to false always
    456              * }
    457              * </pre>
    458              *
    459              * @example
    460              * board.on('stopselecting', function(){
    461              *     var box = board.stopSelectionMode(),
    462              *     // bbox has the coordinates of the selectionr rectangle.
    463              *     // Attention: box[i].usrCoords have the form [1, x, y], i.e.
    464              *     // are homogeneous coordinates.
    465              *     bbox = box[0].usrCoords.slice(1).concat(box[1].usrCoords.slice(1));
    466              *     // Set a new bounding box
    467              *     board.setBoundingBox(bbox, false);
    468              * });
    469              *
    470              * @name JXG.Board#selection
    471              * @see JXG.Board#startselecting
    472              * @see JXG.Board#stopselecting
    473              * @see JXG.Board#mousestartselecting
    474              * @see JXG.Board#pointerstartselecting
    475              * @see JXG.Board#touchstartselecting
    476              * @see JXG.Board#mousestopselecting
    477              * @see JXG.Board#pointerstopselecting
    478              * @see JXG.Board#touchstopselecting
    479              * @type Object
    480              * @default
    481              */
    482             selection: {
    483                 enabled: false,
    484                 name: 'selectionPolygon',
    485                 needShift: false,
    486                 needCtrl: true,
    487                 withLines: false,
    488                 vertices: {
    489                     visible: false
    490                 },
    491                 fillColor: '#ffff00',
    492                 visible: false
    493             }
    494             /**#@-*/
    495         },
    496
    497         /**
    498          * Options that are used by the navigation bar.
    499          *
    500          * Default values are
    501          * <pre>
    502          * JXG.Option.navbar: {
    503          *   strokeColor: '#333333',
    504          *   fillColor: 'transparent',
    505          *   highlightFillColor: '#aaaaaa',
    506          *   padding: '2px',
    507          *   position: 'absolute',
    508          *   fontSize: '14px',
    509          *   cursor: 'pointer',
    510          *   zIndex: '100',
    511          *   right: '5px',
    512          *   bottom: '5px'
    513          * },
    514          * </pre>
    515          */
    516         navbar: {
    517             strokeColor: '#333333', //'#aaaaaa',
    518             fillColor: 'transparent', //#f5f5f5',
    519             highlightFillColor: '#aaaaaa',
    520             padding: '2px',
    521             position: 'absolute',
    522             fontSize: '14px',
    523             cursor: 'pointer',
    524             zIndex: '100',
    525             right: '5px',
    526             bottom: '5px'
    527             //border: 'none 1px black',
    528             //borderRadius: '4px'
    529         },
    530
    531          /*
    532           *  Generic options used by {@link JXG.GeometryElement}
    533           */
    534         elements: {

    536
    537             /**#@+
    538              * @visprop
    539              */
    540
    541             /**
    542              * The stroke color of the given geometry element.
    543              * @type String
    544              * @name JXG.GeometryElement#strokeColor
    545              * @see JXG.GeometryElement#highlightStrokeColor
    546              * @see JXG.GeometryElement#strokeWidth
    547              * @see JXG.GeometryElement#strokeOpacity
    548              * @see JXG.GeometryElement#highlightStrokeOpacity
    549              * @default {@link JXG.Options.elements.color#strokeColor}
    550              */
    551             strokeColor: '#0000ff',
    552
    553             /**
    554              * The stroke color of the given geometry element when the user moves the mouse over it.
    555              * @type String
    556              * @name JXG.GeometryElement#highlightStrokeColor
    557              * @see JXG.GeometryElement#strokeColor
    558              * @see JXG.GeometryElement#strokeWidth
    559              * @see JXG.GeometryElement#strokeOpacity
    560              * @see JXG.GeometryElement#highlightStrokeOpacity
    561              * @default {@link JXG.Options.elements.color#highlightStrokeColor}
    562              */
    563             highlightStrokeColor: '#C3D9FF',
    564
    565             /**
    566              * The fill color of this geometry element.
    567              * @type String
    568              * @name JXG.GeometryElement#fillColor
    569              * @see JXG.GeometryElement#highlightFillColor
    570              * @see JXG.GeometryElement#fillOpacity
    571              * @see JXG.GeometryElement#highlightFillOpacity
    572              * @default {@link JXG.Options.elements.color#fillColor}
    573              */
    574             fillColor: 'red',
    575
    576             /**
    577              * The fill color of the given geometry element when the mouse is pointed over it.
    578              * @type String
    579              * @name JXG.GeometryElement#highlightFillColor
    580              * @see JXG.GeometryElement#fillColor
    581              * @see JXG.GeometryElement#fillOpacity
    582              * @see JXG.GeometryElement#highlightFillOpacity
    583              * @default {@link JXG.Options.elements.color#highlightFillColor}
    584              */
    585             highlightFillColor: 'none',
    586
    587             /**
    588              * Opacity for element's stroke color.
    589              * @type number
    590              * @name JXG.GeometryElement#strokeOpacity
    591              * @see JXG.GeometryElement#strokeColor
    592              * @see JXG.GeometryElement#highlightStrokeColor
    593              * @see JXG.GeometryElement#strokeWidth
    594              * @see JXG.GeometryElement#highlightStrokeOpacity
    595              * @default {@link JXG.Options.elements#strokeOpacity}
    596              */
    597             strokeOpacity: 1,
    598
    599             /**
    600              * Opacity for stroke color when the object is highlighted.
    601              * @type number
    602              * @name JXG.GeometryElement#highlightStrokeOpacity
    603              * @see JXG.GeometryElement#strokeColor
    604              * @see JXG.GeometryElement#highlightStrokeColor
    605              * @see JXG.GeometryElement#strokeWidth
    606              * @see JXG.GeometryElement#strokeOpacity
    607              * @default {@link JXG.Options.elements#highlightStrokeOpacity}
    608              */
    609             highlightStrokeOpacity: 1,
    610
    611             /**
    612              * Opacity for fill color.
    613              * @type number
    614              * @name JXG.GeometryElement#fillOpacity
    615              * @see JXG.GeometryElement#fillColor
    616              * @see JXG.GeometryElement#highlightFillColor
    617              * @see JXG.GeometryElement#highlightFillOpacity
    618              * @default {@link JXG.Options.elements.color#fillOpacity}
    619              */
    620             fillOpacity: 1,
    621
    622             /**
    623              * Opacity for fill color when the object is highlighted.
    624              * @type number
    625              * @name JXG.GeometryElement#highlightFillOpacity
    626              * @see JXG.GeometryElement#fillColor
    627              * @see JXG.GeometryElement#highlightFillColor
    628              * @see JXG.GeometryElement#fillOpacity
    629              * @default {@link JXG.Options.elements.color#highlightFillOpacity}
    630              */
    631             highlightFillOpacity: 1,
    632
    633             /**
    634              * Transition duration (in milliseconds) for color and opacity
    635              * changes. Works in SVG renderer, only.
    636              * @type Number
    637              * @name JXG.GeometryElement#transitionDuration
    638              * @see JXG.GeometryElement#strokeColor
    639              * @see JXG.GeometryElement#highlightStrokeColor
    640              * @see JXG.GeometryElement#strokeOpacity
    641              * @see JXG.GeometryElement#highlightStrokeOpacity
    642              * @see JXG.GeometryElement#fillColor
    643              * @see JXG.GeometryElement#highlightFillColor
    644              * @see JXG.GeometryElement#fillOpacity
    645              * @see JXG.GeometryElement#highlightFillOpacity
    646              * @default {@link JXG.Options.elements#transitionDuration}
    647              */
    648             transitionDuration: 100,
    649
    650             /**
    651              * Width of the element's stroke.
    652              * @type number
    653              * @name JXG.GeometryElement#strokeWidth
    654              * @see JXG.GeometryElement#strokeColor
    655              * @see JXG.GeometryElement#highlightStrokeColor
    656              * @see JXG.GeometryElement#strokeOpacity
    657              * @see JXG.GeometryElement#highlightStrokeOpacity
    658              * @default {@link JXG.Options.elements#strokeWidth}
    659              */
    660             strokeWidth: 2,
    661
    662             /**
    663              * Width of the element's stroke when the mouse is pointed over it.
    664              * @type number
    665              * @name JXG.GeometryElement#highlightStrokeWidth
    666              * @see JXG.GeometryElement#strokeColor
    667              * @see JXG.GeometryElement#highlightStrokeColor
    668              * @see JXG.GeometryElement#strokeOpacity
    669              * @see JXG.GeometryElement#highlightStrokeOpacity
    670              * @see JXG.GeometryElement#highlightFillColor
    671              * @default {@link JXG.Options.elements#strokeWidth}
    672              */
    673             highlightStrokeWidth: 2,
    674
    675             /**
    676              * If true the element is fixed and can not be dragged around. The element
    677              * will be repositioned on zoom and moveOrigin events.
    678              * @type Boolean
    679              * @default false
    680              * @name JXG.GeometryElement#fixed
    681              */
    682             fixed: false,
    683
    684             /**
    685              * If true the element is fixed and can not be dragged around. The element
    686              * will even stay at its position on zoom and moveOrigin events.
    687              * Only free elements like points, texts, curves can be frozen.
    688              * @type Boolean
    689              * @default false
    690              * @name JXG.GeometryElement#frozen
    691              */
    692             frozen: false,
    693
    694             /**
    695              * If true a label will display the element's name.
    696              * @type Boolean
    697              * @default false
    698              * @name JXG.GeometryElement#withLabel
    699              */
    700             withLabel: false,
    701
    702             /**
    703              * If false the element won't be visible on the board, otherwise it is shown.
    704              * @type boolean
    705              * @name JXG.GeometryElement#visible
    706              * @see JXG.GeometryElement#hideElement
    707              * @see JXG.GeometryElement#showElement
    708              * @default true
    709              */
    710             visible: true,
    711
    712             /**
    713              * A private element will be inaccessible in certain environments, e.g. a graphical user interface.
    714              * @default false
    715              */
    716             priv: false,
    717
    718             /**
    719              * Display layer which will contain the element.
    720              * @see JXG.Options#layer
    721              * @default See {@link JXG.Options#layer}
    722              */
    723             layer: 0,
    724
    725             /**
    726              * Determines the elements border-style.
    727              * Possible values are:
    728              * <ul><li>0 for a solid line</li>
    729              * <li>1 for a dotted line</li>
    730              * <li>2 for a line with small dashes</li>
    731
    732
    733              * <li>3 for a line with medium dashes</li>
    734              * <li>4 for a line with big dashes</li>
    735              * <li>5 for a line with alternating medium and big dashes and large gaps</li>
    736              * <li>6 for a line with alternating medium and big dashes and small gaps</li></ul>
    737              * @type Number
    738              * @name JXG.GeometryElement#dash
    739              * @default 0
    740              */
    741             dash: 0,
    742
    743             /**
    744              * If true the element will get a shadow.
    745              * @type boolean
    746              * @name JXG.GeometryElement#shadow
    747              * @default false
    748              */
    749             shadow: false,
    750
    751             /**
    752              * If true the element will be traced, i.e. on every movement the element will be copied
    753              * to the background. Use {@link JXG.GeometryElement#clearTrace} to delete the trace elements.
    754              * @see JXG.GeometryElement#clearTrace
    755              * @see JXG.GeometryElement#traces
    756              * @see JXG.GeometryElement#numTraces
    757              * @type Boolean
    758              * @default false
    759              * @name JXG.GeometryElement#trace
    760              */
    761             trace: false,
    762
    763             /**
    764              * Extra visual properties for traces of an element
    765              * @type Object
    766              * @see JXG.GeometryElement#trace
    767              * @name JXG.GeometryElement#traceAttributes
    768              */
    769             traceAttributes: {},
    770
    771             /**
    772              *
    773              * @type Boolean
    774              * @default true
    775              * @name JXG.GeometryElement#highlight
    776              */
    777             highlight: true,
    778
    779             /**
    780              * If this is set to true, the element is updated in every update
    781              * call of the board. If set to false, the element is updated only after
    782              * zoom events or more generally, when the bounding box has been changed.
    783              * Examples for the latter behaviour should be axes.
    784              * @type Boolean
    785              * @default true
    786              * @see JXG.GeometryElement#needsRegularUpdate
    787              * @name JXG.GeometryElement#needsRegularUpdate
    788              */
    789             needsRegularUpdate: true,
    790
    791             /**
    792              * Snaps the element or its parents to the grid. Currently only relevant for points, circles,
    793              * and lines. Points are snapped to grid directly, on circles and lines it's only the parent
    794              * points that are snapped
    795              * @type Boolean
    796              * @default false
    797              * @name JXG.GeometryElement#snapToGrid
    798              */
    799             snapToGrid: false,
    800
    801             /**
    802              * Determines whether two-finger manipulation of this object may change its size.
    803              * If set to false, the object is only rotated and translated.
    804              * <p>
    805              * In case the element is a horizontal or vertical line having ticks, "scalable==true"
    806              * enables zooming of the board by dragging ticks lines. This feature is enabled,
    807              * for the ticks element of the line element the attribute "fixed" has to be false
    808              * and the line element's scalable attribute has to be true.
    809              *
    810              * @type Boolean
    811              * @default true
    812              * @name JXG.GeometryElement#scalable
    813              * @see JXG.Ticks#fixed
    814              */
    815             scalable: true,
    816
    817             /**
    818              * If the element is dragged it will be moved on mousedown or touchstart to the
    819              * top of its layer. Works only for SVG renderer and for ssimple elements
    820              * consisting of one SVG node.
    821              * @type Boolean
    822              * @default false
    823              * @name JXG.GeometryElement#scalable
    824              */
    825             dragToTopOfLayer: false,
    826
    827             /*draft options */
    828             draft: {
    829                 /**
    830                  * If true the element will be drawn in grey scale colors to visualize that it's only a draft.
    831                  * @type boolean
    832                  * @name JXG.GeometryElement#draft
    833                  * @default {@link JXG.Options.elements.draft#draft}
    834                  */
    835                 draft: false,
    836                 strokeColor: '#565656',
    837                 fillColor: '#565656',
    838                 strokeOpacity: 0.8,
    839                 fillOpacity: 0.8,
    840                 strokeWidth: 1
    841             },
    842
    843             /**
    844              * @private
    845              * By default, an element is not a label. Do not change this.
    846              */
    847             isLabel: false
    848             // close the meta tag
    849             /**#@-*/
    850         },
    851
    852          /*
    853           *  Generic options used by {@link JXG.Ticks}
    854           */
    855         ticks: {
    856             /**#@+
    857              * @visprop
    858              */
    859
    860             /**
    861              * A function that expects two {@link JXG.Coords}, the first one representing the coordinates of the
    862              * tick that is to be labeled, the second one the coordinates of the center (the tick with position 0).
    863              *
    864              * @type function
    865              * @name Ticks#generateLabelText
    866              */
    867             generateLabelText: null,
    868
    869             /**
    870              * A function that expects two {@link JXG.Coords}, the first one representing the coordinates of the
    871              * tick that is to be labeled, the second one the coordinates of the center (the tick with position 0).
    872              *
    873              * @deprecated Use {@link JGX.Options@generateLabelValue}
    874              * @type function
    875              * @name Ticks#generateLabelValue
    876              */
    877             generateLabelValue: null,
    878
    879             /**
    880              * Draw labels yes/no
    881              *
    882              * @type Boolean
    883              * @name Ticks#drawLabels
    884              * @default false
    885              */
    886             drawLabels: false,
    887             label: {
    888             },
    889
    890             /**
    891              * Use the unicode character 0x2212, i.e. the HTML entity &minus; as minus sign.
    892              * That is −1 instead of -1.
    893              *
    894              * @type Boolean
    895              * @name Ticks#useUnicodeMinus
    896              * @default true
    897              */
    898             useUnicodeMinus: true,
    899
    900             /**
    901              * Determine the position of the tick with value 0. 'left' means point1 of the line, 'right' means point2,
    902              * and 'middle' is equivalent to the midpoint of the defining points. This attribute is ignored if the parent
    903              * line is of type axis and is parallel to either the x (i.e. y = 0) or the y (i.e. x = 0) axis.
    904              *
    905              * @type String
    906              * @name Ticks#anchor
    907              * @default 'left'
    908              */
    909             anchor: 'left',
    910
    911             /**
    912              * Draw the zero tick, that lies at line.point1?
    913              *
    914              * @type Boolean
    915              * @name Ticks#drawZero
    916              * @default false
    917              */
    918             drawZero: false,
    919
    920             /**
    921              * If the distance between two ticks is too big we could insert new ticks. If insertTicks
    922              * is <tt>true</tt>, we'll do so, otherwise we leave the distance as is.
    923              * This option is ignored if equidistant is false. In the example below the distance between
    924              * two ticks is given as <tt>1</tt> but because insertTicks is set to true many ticks will
    925              * be omitted in the rendering process to keep the display clear.
    926              *
    927              * @type Boolean
    928              * @name Ticks#insertTicks
    929              * @see Ticks#equidistant
    930              * @see Ticks#minTicksDistance
    931              * @default false
    932              * @example
    933              * // Create an axis providing two coord pairs.
    934              *   var p1 = board.create('point', [0, 0]);
    935              *   var p2 = board.create('point', [50, 25]);
    936              *   var l1 = board.create('line', [p1, p2]);
    937              *   var t = board.create('ticks', [l1, 1], {
    938              *      insertTicks: true,
    939              *      majorHeight: -1,
    940              *      label: {
    941              *          offset: [4, -9]
    942              *      },
    943              *      drawLabels: true
    944              *  });
    945              * </pre><div class="jxgbox" id="2f6fb842-40bd-4223-aa28-3e9369d2097f" style="width: 300px; height: 300px;"></div>
    946              * <script type="text/javascript">
    947              * (function () {
    948              *   var board = JXG.JSXGraph.initBoard('2f6fb842-40bd-4223-aa28-3e9369d2097f', {boundingbox: [-100, 70, 70, -100], showcopyright: false, shownavigation: false});
    949              *   var p1 = board.create('point', [0, 0]);
    950              *   var p2 = board.create('point', [50, 25]);
    951              *   var l1 = board.create('line', [p1, p2]);
    952              *   var t = board.create('ticks', [l1, 1], {insertTicks: true, majorHeight: -1, label: {offset: [4, -9]}, drawLabels: true});
    953              * })();
    954              * </script><pre>
    955              */
    956             insertTicks: false,
    957             minTicksDistance: 10,
    958
    959             /**
    960              * Total height of a minor tick. If negative the full height of the board is taken.
    961              *
    962              * @type Number
    963              * @name Ticks#minorHeight
    964              * @default 4
    965              */
    966             minorHeight: 4,
    967
    968             /**
    969              * Total height of a major tick. If negative the full height of the board is taken.
    970              *
    971              * @type Number
    972              * @name Ticks#majorHeight
    973              * @default 10
    974              */
    975             majorHeight: 10,
    976
    977             /**
    978              * Decides in which direction finite ticks are visible. Possible values are either the constants
    979              * 0=false or 1=true or a function returning 0 or 1.
    980              *
    981              * In case of [0,1] the tick is only visible to the right of the line. In case of
    982              * [1,0] the tick is only visible to the left of the line.
    983              *
    984              * @type Array
    985              * @name Ticks#tickEndings
    986              * @default [1, 1]
    987              */
    988             tickEndings: [1, 1],
    989
    990             /**
    991              * The number of minor ticks between two major ticks.
    992              * @type Number
    993              * @name Ticks#minorTicks
    994              * @default 4
    995              */
    996             minorTicks: 4,
    997
    998             /**
    999              * Scale the ticks but not the tick labels.
    1000              * @type Number
    1001              * @default 1
    1002              * @name Ticks#scale
    1003              * @see Ticks#scaleSymbol
    1004              */
    1005             scale: 1,
    1006
    1007             /**
    1008              * A string that is appended to every tick, used to represent the scale
    1009              * factor given in {@link JXG.Ticks#scaleSymbol}.
    1010              *
    1011              * @type String
    1012              * @default ''
    1013              * @name Ticks#scaleSymbol
    1014              * @see Ticks#scale
    1015              */
    1016             scaleSymbol: '',
    1017
    1018             /**
    1019              * User defined labels for special ticks. Instead of the i-th tick's position, the i-th string stored in this array
    1020              * is shown. If the number of strings in this array is less than the number of special ticks, the tick's position is
    1021              * shown as a fallback.
    1022              *
    1023              * @type Array
    1024              * @name Ticks#labels
    1025              * @default []
    1026              */
    1027             labels: [],
    1028
    1029             /**
    1030              * The maximum number of characters a tick label can use.
    1031              *
    1032              * @type Number
    1033              * @name Ticks#maxLabelLength
    1034              * @see Ticks#precision
    1035              * @default 5
    1036              */
    1037             maxLabelLength: 5,
    1038
    1039             /**
    1040              * If a label exceeds {@link JXG.Ticks#maxLabelLength} this determines the precision used to shorten the tick label.
    1041              *
    1042              * @type Number
    1043              * @name Ticks#precision
    1044              * @see Ticks#maxLabelLength
    1045              * @default 3
    1046              */
    1047             precision: 3,
    1048
    1049             /**
    1050              * The default distance between two ticks. Please be aware that this value does not have
    1051              * to be used if {@link JXG.Ticks#insertTicks} is set to true.
    1052              *
    1053              * @type Number
    1054              * @name Ticks#ticksDistance
    1055              * @see Ticks#equidistant
    1056              * @see Ticks#insertTicks
    1057              * @default 1
    1058              */
    1059             ticksDistance: 1,
    1060             strokeOpacity: 1,
    1061             strokeWidth: 1,
    1062             strokeColor: 'black',
    1063             highlightStrokeColor: '#888888',
    1064             visible: 'inherit',
    1065
    1066             /**
    1067              * Whether line boundaries should be counted or not in the lower and upper bounds when
    1068              * creating ticks.
    1069              *
    1070              * @type Boolean
    1071              * @name Ticks#includeBoundaries
    1072              * @default false
    1073              */
    1074             includeBoundaries: false
    1075             // close the meta tag
    1076             /**#@-*/
    1077         },
    1078
    1079          /*
    1080           *  Generic options used by {@link JXG.Hatch}
    1081           */
    1082         hatch: {
    1083             drawLabels: false,
    1084             drawZero: true,
    1085             majorHeight: 20,
    1086             anchor: 'middle',
    1087             strokeWidth: 2,
    1088             strokeColor: 'blue',
    1089             ticksDistance: 0.2
    1090         },
    1091
    1092         /**
    1093          * Precision options.
    1094          *
    1095          * The default values are
    1096          * <pre>
    1097          * JXG.Options.precision: {
    1098          *   touch: 30,
    1099          *   touchMax: 100,
    1100          *   mouse: 4,
    1101          *   epsilon: 0.0001,
    1102          *   hasPoint: 4
    1103          * }
    1104          * </pre>
    1105          */
    1106         precision: {
    1107             touch: 15,
    1108             touchMax: 100,
    1109             mouse: 4,
    1110             epsilon: 0.0001,
    1111             hasPoint: 4
    1112         },
    1113
    1114         /**
    1115          * Default ordering of the layers.
    1116          *
    1117          * The default values are
    1118          * <pre>
    1119          * JXG.Options.layer: {
    1120          *   numlayers: 20, // only important in SVG
    1121          *   text: 9,
    1122          *   point: 9,
    1123          *   glider: 9,
    1124          *   arc: 8,
    1125          *   line: 7,
    1126          *   circle: 6,
    1127          *   curve: 5,
    1128          *   turtle: 5,
    1129          *   polygon: 3,
    1130          *   sector: 3,
    1131          *   angle: 3,
    1132          *   integral: 3,
    1133          *   axis: 2,
    1134          *   ticks: 2,
    1135          *   grid: 1,
    1136          *   image: 0,
    1137          *   trace: 0
    1138          * }
    1139          * </pre>
    1140          */
    1141         layer: {
    1142             numlayers: 20, // only important in SVG
    1143             text: 9,
    1144             point: 9,
    1145             glider: 9,
    1146             arc: 8,
    1147             line: 7,
    1148             circle: 6,
    1149             curve: 5,
    1150             turtle: 5,
    1151             polygon: 3,
    1152             sector: 3,
    1153             angle: 3,
    1154             integral: 3,
    1155             axis: 2,
    1156             ticks: 2,
    1157             grid: 1,
    1158             image: 0,
    1159             trace: 0
    1160         },
    1161
    1162         /* special angle options */
    1163         angle: {
    1164             /**#@+
    1165              * @visprop
    1166              */
    1167
    1168             withLabel: true,
    1169
    1170             /**
    1171              * Radius of the sector, displaying the angle.
    1172              *
    1173              * @type Number
    1174              * @name Angle#radius
    1175              * @default 0.5
    1176              * @visprop
    1177              */
    1178             radius: 0.5,
    1179
    1180             /**
    1181              * Display type of the angle field. Possible values are
    1182              * 'sector' or 'sectordot' or 'square' or 'none'.
    1183              *
    1184              * @type String
    1185              * @default 'sector'
    1186              * @name Angle#type
    1187              * @visprop
    1188              */
    1189             type: 'sector',
    1190
    1191             /**
    1192              * Display type of the angle field in case of a right angle. Possible values are
    1193              * 'sector' or 'sectordot' or 'square' or 'none'.
    1194              *
    1195              * @type String
    1196              * @default square
    1197              * @name Angle#orthoType
    1198              * @see Angle#orthoSensitivity
    1199              * @visprop
    1200              */
    1201             orthoType: 'square',
    1202
    1203             /**
    1204              * Sensitivity (in degrees) to declare an angle as right angle.
    1205              * If the angle measure is inside this distance from a rigth angle, the orthoType
    1206              * of the angle is used for display.
    1207              *
    1208              * @type Number
    1209              * @default 1.0
    1210              * @name Angle#orthoSensitivity
    1211              * @see Angle#orthoType
    1212              * @visprop
    1213              */
    1214             orthoSensitivity: 1.0,
    1215
    1216             fillColor: '#FF7F00',
    1217             highlightFillColor: '#FF7F00',
    1218             strokeColor: '#FF7F00',
    1219             fillOpacity: 0.3,
    1220             highlightFillOpacity: 0.3,
    1221
    1222             /**
    1223              * @deprecated
    1224              */
    1225             radiuspoint: {
    1226                 withLabel: false,
    1227                 visible: false,
    1228                 name: ''
    1229             },
    1230             /**
    1231              * @deprecated
    1232              */
    1233             pointsquare: {
    1234                 withLabel: false,
    1235                 visible: false,
    1236                 name: ''
    1237             },
    1238
    1239             dot: {
    1240                 visible: false,
    1241                 strokeColor: 'none',
    1242                 fillColor: 'black',
    1243                 size: 2,
    1244                 face: 'o',
    1245                 withLabel: false,
    1246                 name: ''
    1247             },
    1248             label: {
    1249                 position: 'top',
    1250                 offset: [0, 0],
    1251                 strokeColor: '#0000FF'
    1252             },
    1253
    1254             arc: {
    1255                 visible: false
    1256             }
    1257
    1258             /**#@-*/
    1259         },
    1260
    1261         /* special arc options */
    1262         arc: {
    1263             /**#@+
    1264              * @visprop
    1265              */
    1266
    1267             /**
    1268              * Type of arc. Possible values are 'minor', 'major', and 'auto'.
    1269              *
    1270              * @type String
    1271              * @name Arc#selection
    1272              * @default 'auto'
    1273              */
    1274             selection: 'auto',
    1275
    1276             label: {
    1277                 anchorX: 'auto',
    1278                 anchorY: 'auto'
    1279             },
    1280             firstArrow: false,
    1281             lastArrow: false,
    1282             fillColor: 'none',
    1283             highlightFillColor: 'none',
    1284             strokeColor: '#0000ff',
    1285             highlightStrokeColor: '#C3D9FF',
    1286             useDirection: false
    1287
    1288             /**#@-*/
    1289         },
    1290
    1291         /* special axis options */
    1292         axis: {
    1293             /**#@+
    1294              * @visprop
    1295              */
    1296
    1297             name: '',                            // By default, do not generate names for axes.
    1298             needsRegularUpdate: false,           // Axes only updated after zooming and moving of the origin.
    1299             strokeWidth: 1,
    1300             lastArrow: {
    1301                 type: 1,
    1302                 size: 8
    1303             },
    1304             strokeColor: '#666666',
    1305             highlightStrokeWidth: 1,
    1306             highlightStrokeColor: '#888888',
    1307
    1308
    1309             /**
    1310              * Show / hide ticks.
    1311              *
    1312              * Deprecated. Suggested alternative is "ticks: {visible: false}"
    1313              *
    1314              * @type Boolean
    1315              * @name Axis#withTicks
    1316              * @default true
    1317              * @deprecated
    1318              */
    1319             withTicks: true,
    1320             straightFirst: true,
    1321             straightLast: true,
    1322             margin: -4,
    1323             withLabel: false,
    1324             scalable: false,
    1325
    1326             /**
    1327              * Attributes for ticks of the axis.
    1328              *
    1329              * @type Ticks
    1330              * @name Axis#ticks
    1331              */
    1332             ticks: {
    1333                 label: {
    1334                     offset: [4, -12 + 3],     // This seems to be a good offset for 12 point fonts
    1335                     parse: false,
    1336                     needsRegularUpdate: false,
    1337                     display: 'internal',
    1338                     visible: 'inherit',
    1339                     layer: 9
    1340                 },
    1341                 visible: 'inherit',
    1342                 needsRegularUpdate: false,
    1343                 strokeWidth: 1,
    1344                 strokeColor: '#666666',
    1345                 highlightStrokeColor: '#888888',
    1346                 drawLabels: true,
    1347                 drawZero: false,
    1348                 insertTicks: true,
    1349                 minTicksDistance: 5,
    1350                 minorHeight: 10,          // if <0: full width and height
    1351                 majorHeight: -1,          // if <0: full width and height
    1352                 tickEndings: [0, 1],
    1353                 minorTicks: 4,
    1354                 ticksDistance: 1,         // TODO doc
    1355                 strokeOpacity: 0.25
    1356             },
    1357
    1358             /**
    1359              * Attributes for first point the axis.
    1360              *
    1361              * @type Point
    1362              * @name Axis#point1
    1363              */
    1364             point1: {                  // Default values for point1 if created by line
    1365                 needsRegularUpdate: false,
    1366                 visible: false
    1367             },
    1368
    1369             /**
    1370              * Attributes for second point the axis.
    1371              *
    1372              * @type Point
    1373              * @name Axis#point2
    1374              */
    1375             point2: {                  // Default values for point2 if created by line
    1376                 needsRegularUpdate: false,
    1377                 visible: false
    1378             },
    1379
    1380             /**
    1381              * Attributes for the axis label.
    1382              *
    1383              * @type Label
    1384              * @name Axis#label
    1385              */
    1386             label: {
    1387                 position: 'lft',
    1388                 offset: [10, 10]
    1389             }
    1390             /**#@-*/
    1391         },
    1392
    1393         /* special options for angle bisector of 3 points */
    1394         bisector: {
    1395             /**#@+
    1396              * @visprop
    1397              */
    1398
    1399             strokeColor: '#000000', // Bisector line
    1400
    1401             /**
    1402              * Attributes for the helper point of the bisector.
    1403              *
    1404              * @type Point
    1405              * @name Bisector#point
    1406              */
    1407             point: {               // Bisector point
    1408                 visible: false,
    1409                 fixed: false,
    1410                 withLabel: false,
    1411                 name: ''
    1412             }
    1413
    1414             /**#@-*/
    1415         },
    1416
    1417         /* special options for the 2 bisectors of 2 lines */
    1418         bisectorlines: {
    1419             /**#@+
    1420              * @visprop
    1421              */
    1422
    1423             /**
    1424              * Attributes for first line.
    1425              *
    1426              * @type Line
    1427              * @name Bisectorlines#line1
    1428              */
    1429             line1: {               //
    1430                 strokeColor: 'black'
    1431             },
    1432
    1433             /**
    1434              * Attributes for second line.
    1435              *
    1436              * @type Line
    1437              * @name Bisectorlines#line2
    1438              */
    1439             line2: {               //
    1440                 strokeColor: 'black'
    1441             }
    1442
    1443             /**#@-*/
    1444         },
    1445
    1446         /* special button options */
    1447         button: {
    1448             /**#@+
    1449              * @visprop
    1450              */
    1451
    1452             /**
    1453              * Control the attribute "disabled" of the HTML button.
    1454              *
    1455              * @name disabled
    1456              * @memberOf Button.prototype
    1457              *
    1458              * @type Boolean
    1459              * @default false
    1460              */
    1461             disabled: false
    1462
    1463             /**#@-*/
    1464         },
    1465
    1466         /* special cardinal spline options */
    1467         cardinalspline: {
    1468             /**#@+
    1469              * @visprop
    1470              */
    1471
    1472              /**
    1473               * Controls if the data points of the cardinal spline when given as
    1474               * arrays should be converted into {@link JXG.Points}.
    1475               *
    1476               * @name createPoints
    1477               * @memberOf Cardinalspline.prototype
    1478               *
    1479               * @see Cardinalspline#points
    1480               *
    1481               * @type Boolean
    1482               * @default true
    1483               */
    1484             createPoints: true,
    1485
    1486             /**
    1487              * If set to true, the supplied coordinates are interpreted as
    1488              * [[x_0, y_0], [x_1, y_1], p, ...].
    1489              * Otherwise, if the data consists of two arrays of equal length,
    1490              * it is interpreted as
    1491              * [[x_o x_1, ..., x_n], [y_0, y_1, ..., y_n]]
    1492              *
    1493              * @name isArrayOfCoordinates
    1494              * @memberOf Cardinalspline.prototype
    1495              * @type {Boolean}
    1496              * @default false
    1497              */
    1498             isArrayOfCoordinates: false,
    1499
    1500             /**
    1501              * Attributes for the points generated by Cardinalspline in cases
    1502              * {@link createPoints} is set to true
    1503              *
    1504              * @name points
    1505              * @memberOf Cardinalspline.prototype
    1506              *
    1507              * @see Cardinalspline#createPoints
    1508              * @type Object
    1509              */
    1510             points: {
    1511                 strokeOpacity: 0.05,
    1512                 fillOpacity: 0.05,
    1513                 highlightStrokeOpacity: 1.0,
    1514                 highlightFillOpacity: 1.0,
    1515                 withLabel: false,
    1516                 name: '',
    1517                 fixed: false
    1518             }
    1519
    1520             /**#@-*/
    1521         },
    1522
    1523         /* special chart options */
    1524         chart: {
    1525             /**#@+
    1526              * @visprop
    1527              */
    1528
    1529             chartStyle: 'line',
    1530             colors: ['#B02B2C', '#3F4C6B', '#C79810', '#D15600', '#FFFF88', '#C3D9FF', '#4096EE', '#008C00'],
    1531             highlightcolors: null,
    1532             fillcolor: null,
    1533             highlightonsector: false,
    1534             highlightbysize: false,
    1535
    1536             fillOpacity: 0.6,
    1537             withLines:  false,
    1538
    1539             label: {
    1540             }
    1541             /**#@-*/
    1542         },
    1543
    1544         /* special html slider options */
    1545         checkbox: {
    1546             /**#@+
    1547              * @visprop
    1548              */
    1549
    1550             /**
    1551              * Control the attribute "disabled" of the HTML checkbox.
    1552              *
    1553              * @name disabled
    1554              * @memberOf Checkbox.prototype
    1555              *
    1556              * @type Boolean
    1557              * @default false
    1558              */
    1559             disabled: false,
    1560
    1561             /**
    1562              * Control the attribute "checked" of the HTML checkbox.
    1563              *
    1564              * @name checked
    1565              * @memberOf Checkbox.prototype
    1566              *
    1567              * @type Boolean
    1568              * @default false
    1569              */
    1570              checked: false
    1571
    1572
    1573             /**#@-*/
    1574         },
    1575
    1576         /*special circle options */
    1577         circle: {
    1578             /**#@+
    1579              * @visprop
    1580              */
    1581
    1582             /**
    1583              * If <tt>true</tt>, moving the mouse over inner points triggers hasPoint.
    1584              *
    1585              * @see JXG.GeometryElement#hasPoint
    1586              * @name Circle#hasInnerPoints
    1587              * @type Boolean
    1588              * @default false
    1589              */
    1590             hasInnerPoints: false,
    1591
    1592             fillColor: 'none',
    1593             highlightFillColor: 'none',
    1594             strokeColor: '#0000ff',
    1595             highlightStrokeColor: '#C3D9FF',
    1596
    1597             /**
    1598              * Attributes for center point.
    1599              *
    1600              * @type Point
    1601              * @name Circle#center
    1602              */
    1603             center: {
    1604                 visible: false,
    1605                 withLabel: false,
    1606                 fixed: false,
    1607                 name: ''
    1608             },
    1609
    1610             /**
    1611              * Attributes for circle label.
    1612              *
    1613              * @type Label
    1614              * @name Circle#label
    1615              */
    1616             label: {
    1617                 position: 'urt'
    1618             }
    1619             /**#@-*/
    1620         },
    1621
    1622         /* special options for circumcircle of 3 points */
    1623         circumcircle: {
    1624             /**#@+
    1625              * @visprop
    1626              */
    1627
    1628             fillColor: 'none',
    1629             highlightFillColor: 'none',
    1630             strokeColor: '#0000ff',
    1631             highlightStrokeColor: '#C3D9FF',
    1632
    1633             /**
    1634              * Attributes for center point.
    1635              *
    1636              * @type Point
    1637              * @name Circumcircle#center
    1638              */
    1639             center: {               // center point
    1640                 visible: false,
    1641                 fixed: false,
    1642                 withLabel: false,
    1643                 name: ''
    1644             }
    1645             /**#@-*/
    1646         },
    1647
    1648         circumcirclearc: {
    1649             /**#@+
    1650              * @visprop
    1651              */
    1652
    1653             fillColor: 'none',
    1654             highlightFillColor: 'none',
    1655             strokeColor: '#0000ff',
    1656             highlightStrokeColor: '#C3D9FF',
    1657
    1658             /**
    1659              * Attributes for center point.
    1660              *
    1661              * @type Point
    1662              * @name CircumcircleArc#center
    1663              */
    1664             center: {
    1665                 visible: false,
    1666                 withLabel: false,
    1667                 fixed: false,
    1668                 name: ''
    1669             }
    1670             /**#@-*/
    1671         },
    1672
    1673         /* special options for circumcircle sector of 3 points */
    1674         circumcirclesector: {
    1675             /**#@+
    1676              * @visprop
    1677              */
    1678
    1679             useDirection: true,
    1680             fillColor: '#00FF00',
    1681             highlightFillColor: '#00FF00',
    1682             fillOpacity: 0.3,
    1683             highlightFillOpacity: 0.3,
    1684             strokeColor: '#0000ff',
    1685             highlightStrokeColor: '#C3D9FF',
    1686
    1687             /**
    1688              * Attributes for center point.
    1689              *
    1690              * @type Point
    1691              * @name Circle#point
    1692              */
    1693             point: {
    1694                 visible: false,
    1695                 fixed: false,
    1696                 withLabel: false,
    1697                 name: ''
    1698             }
    1699             /**#@-*/
    1700         },
    1701
    1702         /* special conic options */
    1703         conic: {
    1704             /**#@+
    1705              * @visprop
    1706              */
    1707
    1708             fillColor: 'none',
    1709             highlightFillColor: 'none',
    1710             strokeColor: '#0000ff',
    1711             highlightStrokeColor: '#C3D9FF',
    1712
    1713             /**
    1714              * Attributes for foci points.
    1715              *
    1716              * @type Point
    1717              * @name Conic#foci
    1718              */
    1719             foci: {
    1720                 // points
    1721                 fixed: false,
    1722                 visible: false,
    1723                 withLabel: false,
    1724                 name: ''
    1725             },
    1726
    1727             /**
    1728              * Attributes for center point.
    1729              *
    1730              * @type Point
    1731              * @name Conic#center
    1732              */
    1733             center: {
    1734                 visible: false,
    1735                 withLabel: false,
    1736                 name: ''
    1737             },
    1738
    1739             /**
    1740              * Attributes for five points defining the conic, if some of them are given as coordinates.
    1741              *
    1742              * @type Point
    1743              * @name Conic#point
    1744              */
    1745             point: {
    1746                 withLabel: false,
    1747                 name: ''
    1748             }
    1749
    1750             /**#@-*/
    1751         },
    1752
    1753         /* special curve options */
    1754         curve: {
    1755             strokeWidth: 1,
    1756             strokeColor: '#0000ff',
    1757             fillColor: 'none',
    1758             fixed: true,
    1759
    1760             useQDT: false,
    1761
    1762             /**#@+
    1763              * @visprop
    1764              */
    1765
    1766             /**
    1767              * The data points of the curve are not connected with straight lines but with bezier curves.
    1768              * @name Curve#handDrawing
    1769              * @type Boolean
    1770              * @default false
    1771              */
    1772             handDrawing: false,
    1773
    1774             /**
    1775              * The curveType is set in {@link JXG.Curve#generateTerm} and used in {@link JXG.Curve#updateCurve}.
    1776              * Possible values are <ul>
    1777              * <li>'none'</li>
    1778              * <li>'plot': Data plot</li>
    1779              * <li>'parameter': we can not distinguish function graphs and parameter curves</li>
    1780              * <li>'functiongraph': function graph</li>
    1781              * <li>'polar'</li>
    1782              * <li>'implicit' (not yet)</li></ul>
    1783              * Only parameter and plot are set directly. Polar is set with {@link JXG.GeometryElement#setAttribute} only.
    1784              * @name Curve#curveType
    1785              * @type String
    1786              * @default null
    1787              */
    1788             curveType: null,
    1789
    1790             /**
    1791              * Apply Ramer-Douglas-Peuker smoothing.
    1792              *
    1793              * @type Boolean
    1794              * @name Curve#RDPsmoothing
    1795              * @default false
    1796              */
    1797             RDPsmoothing: false,     // Apply the Ramer-Douglas-Peuker algorithm
    1798
    1799             /**
    1800              * Number of points used for plotting triggered by up events in case {@link Curve#doAdvancedPlot} is false.
    1801              *
    1802              * @name Curve#numberPointsHigh
    1803              * @see Curve#doAdvancedPlot
    1804              * @type Number
    1805              * @default 1600
    1806              */
    1807             numberPointsHigh: 1600,  // Number of points on curves after mouseUp
    1808
    1809             /**
    1810              * Number of points used for plotting triggered by move events in case {@link Curve#doAdvancedPlot} is false.
    1811              *
    1812              * @name Curve#numberPointsLow
    1813              * @see Curve#doAdvancedPlot
    1814              * @type Number
    1815              * @default 400
    1816              */
    1817             numberPointsLow: 400,    // Number of points on curves after mousemove
    1818
    1819             /**
    1820              * If true use a recursive bisection algorithm.
    1821              * It is slower, but usually the result is better. It tries to detect jumps
    1822              * and singularities.
    1823              *
    1824              * @name Curve#doAdvancedPlot
    1825              * @type Boolean
    1826              * @default true
    1827              */
    1828             doAdvancedPlot: true,
    1829
    1830             /**
    1831              * If true use the algorithm by Gillam and Hohenwarter, which was default until version 0.98.
    1832              *
    1833              * @name Curve#doAdvancedPlotOld
    1834              * @see Curve#doAdvancedPlot
    1835              * @type Boolean
    1836              * @default false
    1837              */
    1838             doAdvancedPlotOld: false,
    1839
    1840             /**
    1841              * Attributes for circle label.
    1842              *
    1843              * @type Label
    1844              * @name Circle#label
    1845              */
    1846             label: {
    1847                 position: 'lft'
    1848             }
    1849
    1850             /**#@-*/
    1851         },
    1852
    1853         glider: {
    1854             /**#@+
    1855              * @visprop
    1856              */
    1857
    1858             label: {}
    1859             /**#@-*/
    1860         },
    1861
    1862         /* special grid options */
    1863         grid: {
    1864             /**#@+
    1865              * @visprop
    1866              */
    1867
    1868             /* grid styles */
    1869             needsRegularUpdate: false,
    1870             hasGrid: false,
    1871             gridX: 1,
    1872             gridY: 1,
    1873             //strokeColor: '#C0C0C0',
    1874             strokeColor: '#C0C0C0',
    1875             strokeOpacity: 0.5,
    1876             strokeWidth: 1,
    1877             dash: 0,    // dashed grids slow down the iPad considerably
    1878             /* snap to grid options */
    1879
    1880             /**
    1881              * @deprecated
    1882              */
    1883             snapToGrid: false,
    1884             /**
    1885              * @deprecated
    1886              */
    1887             snapSizeX: 10,
    1888             /**
    1889              * @deprecated
    1890              */
    1891             snapSizeY: 10
    1892
    1893             /**#@-*/
    1894         },
    1895
    1896         group: {
    1897             needsRegularUpdate: true
    1898         },
    1899
    1900         /* special html slider options */
    1901         htmlslider: {
    1902             /**#@+
    1903              * @visprop
    1904              */
    1905
    1906             /**
    1907              *
    1908              * These affect the DOM element input type="range".
    1909              * The other attributes affect the DOM element div containing the range element.
    1910              */
    1911             widthRange: 100,
    1912             widthOut: 34,
    1913             step: 0.01,
    1914
    1915             frozen: true,
    1916             isLabel: false,
    1917             strokeColor: 'black',
    1918             display: 'html',
    1919             anchorX: 'left',
    1920             anchorY: 'middle',
    1921             withLabel: false
    1922
    1923             /**#@-*/
    1924         },
    1925
    1926         /* special image options */
    1927         image: {
    1928             /**#@+
    1929              * @visprop
    1930              */
    1931
    1932             imageString: null,
    1933             fillOpacity: 1.0,
    1934             highlightFillOpacity: 0.6,
    1935
    1936
    1937             /**
    1938              * Defines the CSS class used by the image. CSS attributes defined in
    1939              * this class will overwrite the corresponding JSXGraph attributes, e.g.
    1940              * opacity.
    1941              * The default CSS class is defined in jsxgraph.css.
    1942              *
    1943              * @name Image#cssClass
    1944              *
    1945              * @see Image#highlightCssClass
    1946              * @type String
    1947              * @default 'JXGimage'
    1948              */
    1949             cssClass: 'JXGimage',
    1950
    1951             /**
    1952              * Defines the CSS class used by the image when highlighted.
    1953              * CSS attributes defined in this class will overwrite the
    1954              * corresponding JSXGraph attributes, e.g. highlightFillOpacity.
    1955              * The default CSS class is defined in jsxgraph.css.
    1956              *
    1957              * @name Image#highlightCssClass
    1958              *
    1959              * @see Image#cssClass
    1960              * @type String
    1961              * @default 'JXGimageHighlight'
    1962              */
    1963             highlightCssClass: 'JXGimageHighlight',
    1964
    1965             /**
    1966              * Image rotation in degrees.
    1967              *
    1968              * @name Image#rotate
    1969              * @type Number
    1970              * @default 0
    1971              */
    1972             rotate: 0,
    1973
    1974             /**
    1975              * Defines together with {@link Image#snapSizeY} the grid the image snaps on to.
    1976              * The image will only snap on integer multiples to snapSizeX in x and snapSizeY in y direction.
    1977              * If this value is equal to or less than <tt>0</tt>, it will use the grid displayed by the major ticks
    1978              * of the default ticks of the default x axes of the board.
    1979              *
    1980              * @name Image#snapSizeX
    1981              *
    1982              * @see JXG.Point#snapToGrid
    1983              * @see Image#snapSizeY
    1984              * @see JXG.Board#defaultAxes
    1985              * @type Number
    1986              * @default 1
    1987              */
    1988             snapSizeX: 1,
    1989
    1990             /**
    1991              * Defines together with {@link Image#snapSizeX} the grid the image snaps on to.
    1992              * The image will only snap on integer multiples to snapSizeX in x and snapSizeY in y direction.
    1993              * If this value is equal to or less than <tt>0</tt>, it will use the grid displayed by the major ticks
    1994              * of the default ticks of the default y axes of the board.
    1995              *
    1996              * @name Image#snapSizeY
    1997              *
    1998              * @see JXG.Point#snapToGrid
    1999              * @see Image#snapSizeX
    2000              * @see JXG.Board#defaultAxes
    2001              * @type Number
    2002              * @default 1
    2003              */
    2004             snapSizeY: 1,
    2005
    2006             /**
    2007              * List of attractor elements. If the distance of the image is less than
    2008              * attractorDistance the image is made to glider of this element.
    2009              *
    2010              * @name Image#attractors
    2011              *
    2012              * @type array
    2013              * @default empty
    2014              */
    2015             attractors: []
    2016
    2017             /**#@-*/
    2018         },
    2019
    2020         /* special options for incircle of 3 points */
    2021         incircle: {
    2022             /**#@+
    2023              * @visprop
    2024              */
    2025
    2026             fillColor: 'none',
    2027             highlightFillColor: 'none',
    2028             strokeColor: '#0000ff',
    2029             highlightStrokeColor: '#C3D9FF',
    2030
    2031             /**
    2032              * Attributes of circle center.
    2033              *
    2034              * @type Point
    2035              * @name Incircle#center
    2036              */
    2037             center: {               // center point
    2038                 visible: false,
    2039                 fixed: false,
    2040                 withLabel: false,
    2041                 name: ''
    2042             }
    2043             /**#@-*/
    2044         },
    2045
    2046         inequality: {
    2047             /**#@+
    2048              * @visprop
    2049              */
    2050
    2051             fillColor: 'red',
    2052             fillOpacity: 0.2,
    2053             strokeColor: 'none',
    2054
    2055             /**
    2056              * By default an inequality is less (or equal) than. Set inverse to <tt>true</tt> will consider the inequality
    2057              * greater (or equal) than.
    2058              *
    2059              * @type Boolean
    2060              * @default false
    2061              * @name Inequality#inverse
    2062              * @visprop
    2063              */
    2064             inverse: false
    2065             /**#@-*/
    2066         },
    2067
    2068         infobox: {
    2069             /**#@+
    2070              * @visprop
    2071              */
    2072
    2073             fontSize: 12,
    2074             isLabel: false,
    2075             strokeColor: '#bbbbbb',
    2076             display: 'html',             // 'html' or 'internal'
    2077             anchorX: 'left',             //  'left', 'middle', or 'right': horizontal alignment
    2078                                          //  of the text.
    2079             anchorY: 'middle',           //  'top', 'middle', or 'bottom': vertical alignment
    2080                                          //  of the text.
    2081             cssClass: 'JXGinfobox',
    2082             rotate: 0,                   // works for non-zero values only in combination
    2083                                          // with display=='internal'
    2084             visible: true,
    2085             parse: false,
    2086             transitionDuration: 0,
    2087             needsRegularUpdate: false
    2088
    2089             /**#@-*/
    2090         },
    2091
    2092         /* special options for integral */
    2093         integral: {
    2094             /**#@+
    2095              * @visprop
    2096              */
    2097
    2098             axis: 'x',        // 'x' or 'y'
    2099             withLabel: true,    // Show integral value as text
    2100             fixed: true,
    2101             strokeWidth: 0,
    2102             strokeOpacity: 0,
    2103             fillColor: 'red',
    2104             fillOpacity: 0.4,
    2105             highlightFillColor: 'red',
    2106             highlightFillOpacity: 0.2,
    2107
    2108             /**
    2109              * Attributes of the (left) starting point of the integral.
    2110              *
    2111              * @type Point
    2112              * @name Integral#curveLeft
    2113              * @see Integral#baseLeft
    2114              */
    2115             curveLeft: {    // Start point
    2116                 visible: true,
    2117                 withLabel: false,
    2118                 color: 'red',
    2119                 fillOpacity: 0.8,
    2120                 layer: 9
    2121             },
    2122
    2123             /**
    2124              * Attributes of the (left) base point of the integral.
    2125              *
    2126              * @type Point
    2127              * @name Integral#baseLeft
    2128              * @see Integral#curveLeft
    2129              */
    2130             baseLeft: {    // Start point
    2131                 visible: false,
    2132                 fixed: false,
    2133                 withLabel: false,
    2134                 name: ''
    2135             },
    2136
    2137             /**
    2138              * Attributes of the (right) end point of the integral.
    2139              *
    2140              * @type Point
    2141              * @name Integral#curveRight
    2142              * @see Integral#baseRight
    2143              */
    2144             curveRight: {      // End point
    2145                 visible: true,
    2146                 withLabel: false,
    2147                 color: 'red',
    2148                 fillOpacity: 0.8,
    2149                 layer: 9
    2150             },
    2151
    2152             /**
    2153              * Attributes of the (right) base point of the integral.
    2154              *
    2155              * @type Point
    2156              * @name Integral#baseRight
    2157              * @see Integral#curveRight
    2158              */
    2159             baseRight: {      // End point
    2160                 visible: false,
    2161                 fixed: false,
    2162                 withLabel: false,
    2163                 name: ''
    2164             },
    2165
    2166             /**
    2167              * Attributes for integral label.
    2168              *
    2169              * @type Label
    2170              * @name Integral#label
    2171              */
    2172             label: {
    2173                 fontSize: 20
    2174             }
    2175             /**#@-*/
    2176         },
    2177
    2178         /* special input options */
    2179         input: {
    2180             /**#@+
    2181              * @visprop
    2182              */
    2183
    2184             /**
    2185              * Control the attribute "disabled" of the HTML input field.
    2186              *
    2187              * @name disabled
    2188              * @memberOf Input.prototype
    2189              *
    2190              * @type Boolean
    2191              * @default false
    2192              */
    2193             disabled: false,
    2194
    2195             /**
    2196              * Control the attribute "maxlength" of the HTML input field.
    2197              *
    2198              * @name maxlength
    2199              * @memberOf Input.prototype
    2200              *
    2201              * @type Number
    2202              * @default 524288 (as in HTML)
    2203              */
    2204             maxlength: 524288
    2205
    2206             /**#@-*/
    2207         },
    2208
    2209         /* special intersection point options */
    2210         intersection: {
    2211             /**#@+
    2212              * @visprop
    2213              */
    2214
    2215             /**
    2216              * Used in {@link JXG.Intersection}.
    2217              * This flag sets the behaviour of intersection points of e.g.
    2218              * two segments. If true, the intersection is treated as intersection of lines. If false
    2219              * the intersection point exists if the segments intersect setwise.
    2220              *
    2221              * @name Intersection.alwaysIntersect
    2222              * @type Boolean
    2223              * @default true
    2224              */
    2225             alwaysIntersect: true
    2226
    2227             /**#@-*/
    2228         },
    2229
    2230         /* special label options */
    2231         label: {
    2232             /**#@+
    2233              * @visprop
    2234              */
    2235
    2236             visible: 'inherit',
    2237             strokeColor: 'black',
    2238             strokeOpacity: 1,
    2239             highlightStrokeOpacity: 0.666666,
    2240             highlightStrokeColor: 'black',
    2241
    2242             fixed: true,
    2243
    2244             /**
    2245              * Possible string values for the position of a label for
    2246              * label anchor points are:
    2247              * <ul>
    2248              * <li> 'lft'
    2249              * <li> 'rt'
    2250              * <li> 'top'
    2251              * <li> 'bot'
    2252              * <li> 'ulft'
    2253              * <li> 'urt'
    2254              * <li> 'llft'
    2255              * <li> 'lrt'
    2256              * </ul>
    2257              * This is relevant for non-points: line, circle, curve.
    2258              *
    2259              * The names have been borrowed from <a href="https://www.tug.org/metapost.html">MetaPost</a>.
    2260              *
    2261              * @name Label#position
    2262              * @see Label#offset
    2263              * @type String
    2264              * @default 'urt'
    2265              */
    2266             position: 'urt',
    2267
    2268             /**
    2269              *  Label offset from label anchor
    2270              *  The label anchor is determined by JXG.GeometryElement#label.position
    2271              *
    2272              * @name Label#offset
    2273              * @see Label#position
    2274              * @type Array
    2275              * @default [10,10]
    2276              **/
    2277             offset: [10, 10]
    2278
    2279             /**#@-*/
    2280         },
    2281
    2282         /* special legend options */
    2283         legend: {
    2284             /**
    2285              * @visprop
    2286              */
    2287             style: 'vertical',
    2288             labels: ['1', '2', '3', '4', '5', '6', '7', '8'],
    2289             colors: ['#B02B2C', '#3F4C6B', '#C79810', '#D15600', '#FFFF88', '#C3D9FF', '#4096EE', '#008C00']
    2290             /**#@-*/
    2291         },
    2292
    2293         /* special line options */
    2294         line: {
    2295             /**#@+
    2296              * @visprop
    2297              */
    2298
    2299             /**
    2300              * Line has an arrow head at the position of its first point or the corresponding
    2301              * intersection with the canvas border.
    2302              *
    2303              * @name Line#firstArrow
    2304              * @see Line#lastArrow
    2305              * @see Line#touchFirstPoint
    2306              * @type Boolean / Object
    2307              * @default false
    2308              */
    2309             firstArrow: false,
    2310
    2311             /**
    2312              * Line has an arrow head at the position of its second point or the corresponding
    2313              * intersection with the canvas border.
    2314              *
    2315              * @name Line#lastArrow
    2316              * @see Line#firstArrow
    2317              * @see Line#touchLastPoint
    2318              * @type Boolean / Object
    2319              * @default false
    2320              */
    2321             lastArrow: false,
    2322
    2323
    2324             /**
    2325              * This number (pixel value) controls where infinite lines end at the canvas border. If zero, the line
    2326              * ends exactly at the border, if negative there is a margin to the inside, if positive the line
    2327              * ends outside of the canvas (which is invisible).
    2328              * @type {Number}
    2329              * @default 0
    2330              */
    2331             margin: 0,
    2332
    2333             /**
    2334              * If true, line stretches infinitely in direction of its first point.
    2335              * Otherwise it ends at point1.
    2336              *
    2337              * @name Line#straightFirst
    2338              * @see Line#straightLast
    2339              * @type Boolean
    2340              * @default true
    2341              */
    2342             straightFirst: true,
    2343
    2344             /**
    2345              * If true, line stretches infinitely in direction of its second point.
    2346              * Otherwise it ends at point2.
    2347              *
    2348              * @name Line#straightLast
    2349              * @see Line#straightFirst
    2350              * @type Boolean
    2351              * @default true
    2352              */
    2353             straightLast: true,
    2354
    2355             fillColor: 'none',               // Important for VML on IE
    2356             highlightFillColor: 'none',  // Important for VML on IE
    2357             strokeColor: '#0000ff',
    2358             highlightStrokeColor: '#888888',
    2359             withTicks: false,
    2360
    2361             /**
    2362              * Attributes for first defining point of the line.
    2363              *
    2364              * @type Point
    2365              * @name Line#point1
    2366              */
    2367             point1: {                  // Default values for point1 if created by line
    2368                 visible: false,
    2369                 withLabel: false,
    2370                 fixed: false,
    2371                 name: ''
    2372             },
    2373
    2374             /**
    2375              * Attributes for second defining point of the line.
    2376              *
    2377              * @type Point
    2378              * @name Line#point2
    2379              */
    2380             point2: {                  // Default values for point2 if created by line
    2381                 visible: false,
    2382                 withLabel: false,
    2383                 fixed: false,
    2384                 name: ''
    2385             },
    2386
    2387             /**
    2388              * Attributes for ticks of the line.
    2389              *
    2390              * @type Ticks
    2391              * @name Line#ticks
    2392              */
    2393             ticks: {
    2394                 drawLabels: true,
    2395                 label: {
    2396                     offset: [4, -12 + 3] // This seems to be a good offset for 12 point fonts
    2397                 },
    2398                 drawZero: false,
    2399                 insertTicks: false,
    2400                 minTicksDistance: 50,
    2401                 minorHeight: 4,          // if <0: full width and height
    2402                 majorHeight: -1,         // if <0: full width and height
    2403                 minorTicks: 4,
    2404                 defaultDistance: 1,
    2405                 strokeOpacity: 0.3,
    2406                 visible: 'inherit'
    2407             },
    2408
    2409             /**
    2410              * Attributes for the line label.
    2411              *
    2412              * @type Label
    2413              * @name Line#label
    2414              */
    2415             label: {
    2416                 position: 'llft'
    2417             },
    2418
    2419             /**
    2420              * If set to true, the point will snap to a grid defined by
    2421              * {@link JXG.Point#snapSizeX} and {@link JXG.Point#snapSizeY}.
    2422              *
    2423              * @see Point#snapSizeX
    2424              * @see Point#snapSizeY
    2425              * @type Boolean
    2426              * @name Line#snapToGrid
    2427              * @default false
    2428              */
    2429             snapToGrid: false,
    2430
    2431             /**
    2432              * Defines together with {@link JXG.Point#snapSizeY} the grid the point snaps on to.
    2433              * The point will only snap on integer multiples to snapSizeX in x and snapSizeY in y direction.
    2434              * If this value is equal to or less than <tt>0</tt>, it will use the grid displayed by the major ticks
    2435              * of the default ticks of the default x axes of the board.
    2436              *
    2437              * @see Point#snapToGrid
    2438              * @see Point#snapSizeY
    2439              * @see JXG.Board#defaultAxes
    2440              * @type Number
    2441              * @name Line#snapSizeX
    2442              * @default 1
    2443              */
    2444             snapSizeX: 1,
    2445
    2446             /**
    2447              * Defines together with {@link JXG.Point#snapSizeX} the grid the point snaps on to.
    2448              * The point will only snap on integer multiples to snapSizeX in x and snapSizeY in y direction.
    2449              * If this value is equal to or less than <tt>0</tt>, it will use the grid displayed by the major ticks
    2450              * of the default ticks of the default y axes of the board.
    2451              *
    2452              * @see Point#snapToGrid
    2453              * @see Point#snapSizeX
    2454              * @see Board#defaultAxes
    2455              * @type Number
    2456              * @name Line#snapSizeY
    2457              * @default 1
    2458              */
    2459             snapSizeY: 1,
    2460
    2461             /**
    2462              * If set to true and {@link Line#firstArrow} is set to true, the arrow head will just touch
    2463              * the circle line of the start point of the line.
    2464              *
    2465              * @see Line#firstArrow
    2466              * @type Boolean
    2467              * @name Line#touchFirstPoint
    2468              * @default false
    2469              */
    2470             touchFirstPoint: false,
    2471
    2472             /**
    2473              * If set to true and {@link Line#lastArrow} is set to true, the arrow head will just touch
    2474              * the circle line of the start point of the line.
    2475              * @see Line#firstArrow
    2476              * @type Boolean
    2477              * @name Line#touchLastPoint
    2478              * @default false
    2479              */
    2480             touchLastPoint: false,
    2481
    2482             /**
    2483              * Line endings (linecap) of a straight line.
    2484              * Possible values are:
    2485              * <ul>
    2486              * <li> 'butt',
    2487              * <li> 'round',
    2488              * <li> 'square'.
    2489              * </ul>
    2490              * Not available for VML renderer.
    2491              * [lineCap description]
    2492              * @name Line#lineCap
    2493              * @type {String}
    2494              * @default 'butt'
    2495              */
    2496             lineCap: 'butt'
    2497
    2498
    2499             /**#@-*/
    2500         },
    2501
    2502         /* special options for locus curves */
    2503         locus: {
    2504             /**#@+
    2505              * @visprop
    2506              */
    2507
    2508             translateToOrigin: false,
    2509             translateTo10: false,
    2510             stretch: false,
    2511             toOrigin: null,
    2512             to10: null
    2513             /**#@-*/
    2514         },
    2515
    2516         // /* special options for Msector of 3 points */
    2517         // msector: {
    2518         //     strokeColor: '#000000', // Msector line
    2519         //     point: {               // Msector point
    2520         //         visible: false,
    2521         //         fixed: false,
    2522         //         withLabel: false,
    2523         //         name: ''
    2524         //     }
    2525         // },
    2526
    2527         /* special options for normal lines */
    2528         normal: {
    2529             /**#@+
    2530              * @visprop
    2531              */
    2532
    2533             strokeColor: '#000000', //  normal line
    2534
    2535             /**
    2536              * Attributes of helper point of normal.
    2537              *
    2538              * @type Point
    2539              * @name Normal#point
    2540              */
    2541             point: {
    2542                 visible: false,
    2543                 fixed: false,
    2544                 withLabel: false,
    2545                 name: ''
    2546             }
    2547             /**#@-*/
    2548         },
    2549
    2550         /* special options for orthogonal projection points */
    2551         orthogonalprojection: {
    2552             /**#@+
    2553              * @visprop
    2554              */
    2555
    2556
    2557             /**#@-*/
    2558         },
    2559
    2560         /* special options for parallel lines */
    2561         parallel: {
    2562             /**#@+
    2563              * @visprop
    2564              */
    2565
    2566             strokeColor: '#000000', // Parallel line
    2567
    2568             /**
    2569              * Attributes of helper point of normal.
    2570              *
    2571              * @type Point
    2572              * @name Parallel#point
    2573              */
    2574             point: {
    2575                 visible: false,
    2576                 fixed: false,
    2577                 withLabel: false,
    2578                 name: ''
    2579             },
    2580
    2581             label: {
    2582                 position: 'llft'
    2583             }
    2584             /**#@-*/
    2585         },
    2586
    2587         /* special perpendicular options */
    2588         perpendicular: {
    2589             /**#@+
    2590              * @visprop
    2591              */
    2592
    2593             strokeColor: '#000000', // Perpendicular line
    2594             straightFirst: true,
    2595             straightLast: true
    2596             /**#@-*/
    2597         },
    2598
    2599         /* special perpendicular options */
    2600         perpendicularsegment: {
    2601             /**#@+
    2602              * @visprop
    2603              */
    2604
    2605             strokeColor: '#000000', // Perpendicular segment
    2606             straightFirst: false,
    2607             straightLast: false,
    2608             point: {               // Perpendicular point
    2609                 visible: false,
    2610                 fixed: true,
    2611                 withLabel: false,
    2612                 name: ''
    2613             }
    2614             /**#@-*/
    2615         },
    2616
    2617         /* special point options */
    2618         point: {
    2619             /**#@+
    2620              * @visprop
    2621              */
    2622
    2623             withLabel: true,
    2624             label: {},
    2625
    2626             /**
    2627              * This attribute was used to determined the point layout. It was derived from GEONExT and was
    2628              * replaced by {@link Point#face} and {@link Point#size}.
    2629              *
    2630              * @name Point#style
    2631              *
    2632              * @see Point#face
    2633              * @see Point#size
    2634              * @type Number
    2635              * @default 5
    2636              * @deprecated
    2637              */
    2638             style: 5,
    2639
    2640             /**
    2641              * There are different point styles which differ in appearance.
    2642              * Posssible values are
    2643              * <table><tr><th>Value</th></tr>
    2644              * <tr><td>cross</td></tr>
    2645              * <tr><td>circle</td></tr>
    2646              * <tr><td>square</td></tr>
    2647              * <tr><td>plus</td></tr>
    2648              * <tr><td>diamond</td></tr>
    2649              * <tr><td>triangleUp</td></tr>
    2650              * <tr><td>triangleDown</td></tr>
    2651              * <tr><td>triangleLeft</td></tr>
    2652              * <tr><td>triangleRight</td></tr>
    2653              * </table>
    2654              *
    2655              * @name Point#face
    2656              *
    2657              * @type string
    2658              * @see Point#setStyle
    2659              * @default circle
    2660              */
    2661             face: 'o',
    2662
    2663             /**
    2664              * Size of a point.
    2665              * Means radius resp. half the width of a point (depending on the face).
    2666              *
    2667              * @name Point#size
    2668              *
    2669              * @see Point#face
    2670              * @see Point#setStyle
    2671              * @type number
    2672              * @default 3
    2673              */
    2674             size: 3,
    2675
    2676             fillColor: '#ff0000',
    2677             highlightFillColor: '#EEEEEE',
    2678             strokeWidth: 2,
    2679             strokeColor: '#ff0000',
    2680             highlightStrokeColor: '#C3D9FF',
    2681
    2682             /**
    2683              * If true, the point size changes on zoom events.
    2684              *
    2685              * @type Boolean
    2686              * @name Point#zoom
    2687              * @default false
    2688              *
    2689              */
    2690             zoom: false,             // Change the point size on zoom
    2691
    2692             /**
    2693              * If true, the infobox is shown on mouse over, else not.
    2694              *
    2695              * @name Point#showInfobox
    2696              *
    2697              * @type Boolean
    2698              * @default true
    2699              */
    2700             showInfobox: true,
    2701
    2702             /**
    2703              * Truncating rule for the digits in the infobox.
    2704              * <ul>
    2705              * <li>'auto': done automatically by JXG#autoDigits
    2706              * <li>'none': no truncation
    2707              * <li>number: truncate after "number digits" with JXG.toFixed();
    2708              * </ul>
    2709              *
    2710              * @name Point#infoboxDigits
    2711              *
    2712              * @type String, Number
    2713              * @default 'auto'
    2714              */
    2715             infoboxDigits: 'auto',
    2716
    2717             draft: false,
    2718
    2719             /**
    2720              * List of attractor elements. If the distance of the point is less than
    2721              * attractorDistance the point is made to glider of this element.
    2722              *
    2723              * @name Point#attractors
    2724              *
    2725              * @type array
    2726              * @default empty
    2727              */
    2728             attractors: [],
    2729
    2730             /**
    2731              * Unit for attractorDistance and snatchDistance, used for magnetized points and for snapToPoints.
    2732              * Possible values are 'screen' and 'user.
    2733              *
    2734              * @name Point#attractorUnit
    2735              *
    2736              * @see Point#attractorDistance
    2737              * @see Point#snatchDistance
    2738              * @see Point#snapToPoints
    2739              * @see Point#attractors
    2740              * @type string
    2741              * @default 'user'
    2742              */
    2743             attractorUnit: 'user',    // 'screen', 'user'
    2744
    2745             /**
    2746              * If the distance of the point to one of its attractors is less
    2747              * than this number the point will be a glider on this
    2748              * attracting element.
    2749              * If set to zero nothing happens.
    2750              *
    2751              * @name Point#attractorDistance
    2752              *
    2753              * @type number
    2754              * @default 0.0
    2755              */
    2756             attractorDistance: 0.0,
    2757
    2758             /**
    2759              * If the distance of the point to one of its attractors is at least
    2760              * this number the point will be released from being a glider on the
    2761              * attracting element.
    2762              * If set to zero nothing happens.
    2763              *
    2764              * @name Point#snatchDistance
    2765              *
    2766              * @type number
    2767              * @default 0.0
    2768              */
    2769             snatchDistance: 0.0,
    2770
    2771             /**
    2772              * If set to true, the point will snap to a grid defined by
    2773              * {@link Point#snapSizeX} and {@link Point#snapSizeY}.
    2774              *
    2775              * @name Point#snapToGrid
    2776              *
    2777              * @see JXG.Point#snapSizeX
    2778              * @see JXG.Point#snapSizeY
    2779              * @type Boolean
    2780              * @default false
    2781              */
    2782             snapToGrid: false,
    2783
    2784             /**
    2785              * Defines together with {@link Point#snapSizeY} the grid the point snaps on to.
    2786              * The point will only snap on integer multiples to snapSizeX in x and snapSizeY in y direction.
    2787              * If this value is equal to or less than <tt>0</tt>, it will use the grid displayed by the major ticks
    2788              * of the default ticks of the default x axes of the board.
    2789              *
    2790              * @name Point#snapSizeX
    2791              *
    2792              * @see Point#snapToGrid
    2793              * @see Point#snapSizeY
    2794              * @see Board#defaultAxes
    2795              * @type Number
    2796              * @default 1
    2797              */
    2798             snapSizeX: 1,
    2799
    2800             /**
    2801              * Defines together with {@link Point#snapSizeX} the grid the point snaps on to.
    2802              * The point will only snap on integer multiples to snapSizeX in x and snapSizeY in y direction.
    2803              * If this value is equal to or less than <tt>0</tt>, it will use the grid displayed by the major ticks
    2804              * of the default ticks of the default y axes of the board.
    2805              *
    2806              * @name Point#snapSizeY
    2807              *
    2808              * @see Point#snapToGrid
    2809              * @see Point#snapSizeX
    2810              * @see Board#defaultAxes
    2811              * @type Number
    2812              * @default 1
    2813              */
    2814             snapSizeY: 1,
    2815
    2816             /**
    2817              * If set to true, the point will snap to the nearest point in distance of
    2818              * {@link Point#attractorDistance}.
    2819              *
    2820              * @name Point#snapToPoints
    2821              *
    2822              * @see Point#attractorDistance
    2823              * @type Boolean
    2824              * @default false
    2825              */
    2826             snapToPoints: false,
    2827
    2828             /**
    2829              * List of elements which are ignored by snapToPoints.
    2830              * @name Point#ignoredSnapToPoints
    2831              *
    2832              * @type array
    2833              * @default empty
    2834              */
    2835             ignoredSnapToPoints: []
    2836
    2837             /**#@-*/
    2838         },
    2839
    2840         /* special polygon options */
    2841         polygon: {
    2842             /**#@+
    2843              * @visprop
    2844              */
    2845
    2846             /**
    2847              * If <tt>true</tt>, moving the mouse over inner points triggers hasPoint.
    2848              *
    2849              * @see JXG.GeometryElement#hasPoint
    2850              * @name Polygon#hasInnerPoints
    2851              * @type Boolean
    2852              * @default false
    2853              */
    2854             hasInnerPoints: false,
    2855
    2856             fillColor: '#00FF00',
    2857             highlightFillColor: '#00FF00',
    2858             fillOpacity: 0.3,
    2859             highlightFillOpacity: 0.3,
    2860
    2861             /**
    2862              * Is the polygon bordered by lines?
    2863              *
    2864              * @type Boolean
    2865              * @name Polygon#withLines
    2866              * @default true
    2867              */
    2868             withLines: true,
    2869
    2870             /**
    2871              * Attributes for the polygon border lines.
    2872              *
    2873              * @type Line
    2874              * @name Polygon#borders
    2875              */
    2876             borders: {
    2877                 withLabel: false,
    2878                 strokeWidth: 1,
    2879                 highlightStrokeWidth: 1,
    2880                 // Polygon layer + 1
    2881                 layer: 5,
    2882                 label: {
    2883                     position: 'top'
    2884                 },
    2885                 visible: 'inherit'
    2886             },
    2887
    2888             /**
    2889              * Attributes for the polygon vertices.
    2890              *
    2891              * @type Point
    2892              * @name Polygon#vertices
    2893              */
    2894             vertices: {
    2895                 layer: 9,
    2896                 withLabel: false,
    2897                 name: '',
    2898                 strokeColor: '#ff0000',
    2899                 fillColor: '#ff0000',
    2900                 fixed: false,
    2901                 visible: 'inherit'
    2902             },
    2903
    2904             /**
    2905              * Attributes for the polygon label.
    2906              *
    2907              * @type Label
    2908              * @name Polygon#label
    2909              */
    2910             label: {
    2911                 offset: [0, 0]
    2912             }
    2913
    2914             /**#@-*/
    2915         },
    2916
    2917         /* special prescribed angle options
    2918         * Not yet implemented. But angle.setAngle(val) is implemented.
    2919         */
    2920         prescribedangle: {
    2921             /**#@+
    2922              * @visprop
    2923              */
    2924
    2925             /**
    2926              * Attributes for the helper point of the prescribed angle.
    2927              *
    2928              * @type Point
    2929              * @name PrescribedAngle#anglepoint
    2930              */
    2931             anglepoint: {
    2932                 size: 2,
    2933                 visible: false,
    2934                 withLabel: false
    2935             }
    2936
    2937             /**#@-*/
    2938         },
    2939
    2940         /* special regular polygon options */
    2941         regularpolygon: {
    2942             /**#@+
    2943              * @visprop
    2944              */
    2945
    2946             /**
    2947              * If <tt>true</tt>, moving the mouse over inner points triggers hasPoint.
    2948              * @see JXG.GeometryElement#hasPoint
    2949              *
    2950              * @name RegularPolygon#hasInnerPoints
    2951              * @type Boolean
    2952              * @default false
    2953              */
    2954             hasInnerPoints: false,
    2955             fillColor: '#00FF00',
    2956             highlightFillColor: '#00FF00',
    2957             fillOpacity: 0.3,
    2958             highlightFillOpacity: 0.3,
    2959
    2960             /**
    2961              * Is the polygon bordered by lines?
    2962              *
    2963              * @type Boolean
    2964              * @name RegularPolygon#withLines
    2965              * @default true
    2966              */
    2967             withLines: true,
    2968
    2969             /**
    2970              * Attributes for the polygon border lines.
    2971              *
    2972              * @type Line
    2973              * @name RegularPolygon#borders
    2974              */
    2975             borders: {
    2976                 withLabel: false,
    2977                 strokeWidth: 1,
    2978                 highlightStrokeWidth: 1,
    2979                 // Polygon layer + 1
    2980                 layer: 5,
    2981                 label: {
    2982                     position: 'top'
    2983                 }
    2984             },
    2985
    2986             /**
    2987              * Attributes for the polygon vertices.
    2988              *
    2989              * @type Point
    2990              * @name RegularPolygon#vertices
    2991              */
    2992             vertices: {
    2993                 layer: 9,
    2994                 withLabel: true,
    2995                 strokeColor: '#ff0000',
    2996                 fillColor: '#ff0000',
    2997                 fixed: false
    2998             },
    2999
    3000             /**
    3001              * Attributes for the polygon label.
    3002              *
    3003              * @type Label
    3004              * @name Polygon#label
    3005              */
    3006             label: {
    3007                 offset: [0, 0]
    3008             }
    3009
    3010             /**#@-*/
    3011         },
    3012
    3013         /* special options for riemann sums */
    3014         riemannsum: {
    3015             /**#@+
    3016              * @visprop
    3017              */
    3018
    3019             withLabel: false,
    3020             fillOpacity: 0.3,
    3021             fillColor: '#ffff00'
    3022
    3023             /**#@-*/
    3024         },
    3025
    3026         /* special sector options */
    3027         sector: {
    3028             /**#@+
    3029              * @visprop
    3030              */
    3031
    3032             fillColor: '#00FF00',
    3033             highlightFillColor: '#00FF00',
    3034             fillOpacity: 0.3,
    3035             highlightFillOpacity: 0.3,
    3036             highlightOnSector: false,
    3037             highlightStrokeWidth: 0,
    3038
    3039             /**
    3040              * Type of sector. Possible values are 'minor', 'major', and 'auto'.
    3041              *
    3042              * @type String
    3043              * @name Sector#selection
    3044              * @default 'auto'
    3045              */
    3046             selection: 'auto',
    3047
    3048             /**
    3049              * Attributes for sub-element arc. It is only available, if the sector is defined by three points.
    3050              *
    3051              * @type Arc
    3052              * @name Sector#arc
    3053              */
    3054             arc: {
    3055                 visible: false,
    3056                 fillColor: 'none'
    3057             },
    3058
    3059             /**
    3060              * Attributes for helper point radiuspoint in case it is provided by coordinates.
    3061              *
    3062              * @type Point
    3063              * @name Sector#radiuspoint
    3064              */
    3065             radiuspoint: {
    3066                 visible: false,
    3067                 withLabel: false
    3068             },
    3069
    3070             /**
    3071              * Attributes for helper point center in case it is provided by coordinates.
    3072              *
    3073              * @type Point
    3074              * @name Sector#center
    3075              */
    3076             center: {
    3077                 visible: false,
    3078                 withLabel: false
    3079             },
    3080
    3081             /**
    3082              * Attributes for helper point anglepoint in case it is provided by coordinates.
    3083              *
    3084              * @type Point
    3085              * @name Sector#anglepoint
    3086              */
    3087             anglepoint: {
    3088                 visible: false,
    3089                 withLabel: false
    3090             },
    3091
    3092             /**
    3093              * Attributes for the sector label.
    3094              *
    3095              * @type Label
    3096              * @name Sector#label
    3097              */
    3098             label: {
    3099                 offset: [0, 0],
    3100                 anchorX: 'auto',
    3101                 anchorY: 'auto'
    3102             }
    3103
    3104             /**#@-*/
    3105         },
    3106
    3107         /* special segment options */
    3108         segment: {
    3109             /**#@+
    3110              * @visprop
    3111              */
    3112
    3113             label: {
    3114                 position: 'top'
    3115             }
    3116             /**#@-*/
    3117         },
    3118
    3119         semicircle: {
    3120             /**#@+
    3121              * @visprop
    3122              */
    3123
    3124             /**
    3125              * Attributes for center point of the semicircle.
    3126              *
    3127              * @type Point
    3128              * @name Semicircle#midpoint
    3129              */
    3130             midpoint: {
    3131                 visible: false,
    3132                 withLabel: false,
    3133                 fixed: false,
    3134                 name: ''
    3135             }
    3136
    3137             /**#@-*/
    3138         },
    3139
    3140         /* special slider options */
    3141         slider: {
    3142             /**#@+
    3143              * @visprop
    3144              */
    3145
    3146             /**
    3147              * The slider only returns integer multiples of this value, e.g. for discrete values set this property to <tt>1</tt>. For
    3148              * continuous results set this to <tt>-1</tt>.
    3149              *
    3150              * @memberOf Slider.prototype
    3151              * @name snapWidth
    3152              * @type Number
    3153              */
    3154             snapWidth: -1,      // -1 = deactivated
    3155
    3156             /**
    3157              * The precision of the slider value displayed in the optional text.
    3158              * @memberOf Slider.prototype
    3159              * @name precision
    3160              * @type Number
    3161              * @default 2
    3162              */
    3163             precision: 2,
    3164
    3165             firstArrow: false,
    3166             lastArrow: false,
    3167
    3168             /**
    3169              * Show slider ticks.
    3170              *
    3171              * @type Boolean
    3172              * @name Slider#withTicks
    3173              * @default true
    3174              */
    3175             withTicks: true,
    3176
    3177             /**
    3178              * Show slider label.
    3179              *
    3180              * @type Boolean
    3181              * @name Slider#withLabel
    3182              * @default true
    3183              */
    3184             withLabel: true,
    3185
    3186             /**
    3187              * If not null, this replaces the part "name = " in the slider label.
    3188              * Possible types: string, number or function.
    3189              * @type {String}
    3190              * @name suffixLabel
    3191              * @memberOf Slider.prototype
    3192              * @default null
    3193              * @see JXG.Slider#unitLabel
    3194              * @see JXG.Slider#postLabel
    3195              */
    3196             suffixLabel: null,
    3197
    3198             /**
    3199              * If not null, this is appended to the value in the slider label.
    3200              * Possible types: string, number or function.
    3201              * @type {String}
    3202              * @name unitLabel
    3203              * @memberOf Slider.prototype
    3204              * @default null
    3205              * @see JXG.Slider#suffixLabel
    3206              * @see JXG.Slider#postLabel
    3207              */
    3208             unitLabel: null,
    3209
    3210             /**
    3211              * If not null, this is appended to the value and to unitLabel in the slider label.
    3212              * Possible types: string, number or function.
    3213              * @type {String}
    3214              * @name postLabel
    3215              * @memberOf Slider.prototype
    3216              * @default null
    3217              * @see JXG.Slider#suffixLabel
    3218              * @see JXG.Slider#unitLabel
    3219              */
    3220             postLabel: null,
    3221
    3222             layer: 9,
    3223             showInfobox: false,
    3224             name: '',
    3225             visible: true,
    3226             strokeColor: '#000000',
    3227             highlightStrokeColor: '#888888',
    3228             fillColor: '#ffffff',
    3229             highlightFillColor: 'none',
    3230
    3231             /**
    3232              * Size of slider point.
    3233              *
    3234              * @type Number
    3235              * @name Slider#size
    3236              * @default 6
    3237              * @see Point#size
    3238              */
    3239             size: 6,
    3240
    3241             /**
    3242              * Attributes for first (left) helper point defining the slider position.
    3243              *
    3244              * @type Point
    3245              * @name Slider#point1
    3246              */
    3247             point1: {
    3248                 needsRegularUpdate: false,
    3249                 showInfobox: false,
    3250                 withLabel: false,
    3251                 visible: false,
    3252                 fixed: true,
    3253                 name: ''
    3254             },
    3255
    3256             /**
    3257              * Attributes for second (right) helper point defining the slider position.
    3258              *
    3259              * @type Point
    3260              * @name Slider#point2
    3261              */
    3262             point2: {
    3263                 needsRegularUpdate: false,
    3264                 showInfobox: false,
    3265                 withLabel: false,
    3266                 visible: false,
    3267                 fixed: true,
    3268                 name: ''
    3269             },
    3270
    3271             /**
    3272              * Attributes for the base line of the slider.
    3273              *
    3274              * @type Line
    3275              * @name Slider#baseline
    3276              */
    3277             baseline: {
    3278                 needsRegularUpdate: false,
    3279                 fixed: true,
    3280                 scalable: false,
    3281                 name: '',
    3282                 strokeWidth: 1,
    3283                 strokeColor: '#000000',
    3284                 highlightStrokeColor: '#888888'
    3285             },
    3286
    3287             /**
    3288              * Attributes for the ticks of the base line of the slider.
    3289              *
    3290              * @type Ticks
    3291              * @name Slider#ticks
    3292              */
    3293             ticks: {
    3294                 needsRegularUpdate: false,
    3295                 fixed: true,
    3296
    3297                 // Label drawing
    3298                 drawLabels: false,
    3299                 precision: 2,
    3300                 includeBoundaries: 1,
    3301                 drawZero: true,
    3302                 label: {
    3303                     offset: [-4, -14],
    3304                     display: 'internal'
    3305                 },
    3306
    3307                 minTicksDistance: 30,
    3308                 insertTicks: true,
    3309                 minorHeight: 4,         // if <0: full width and height
    3310                 majorHeight: 5,        // if <0: full width and height
    3311                 minorTicks: 0,
    3312                 defaultDistance: 1,
    3313                 strokeOpacity: 1,
    3314                 strokeWidth: 1,
    3315                 tickEndings: [0, 1],
    3316                 strokeColor: '#000000',
    3317                 visible: 'inherit'
    3318
    3319             },
    3320
    3321             /**
    3322              * Attributes for the highlighting line of the slider.
    3323              *
    3324              * @type Line
    3325              * @name Slider#highline
    3326              */
    3327             highline: {
    3328                 strokeWidth: 3,
    3329                 fixed: true,
    3330                 name: '',
    3331                 strokeColor: '#000000',
    3332                 highlightStrokeColor: '#888888'
    3333             },
    3334
    3335             /**
    3336              * Attributes for the slider label.
    3337              *
    3338              * @type Label
    3339              * @name Slider#label
    3340              */
    3341             label: {
    3342                 strokeColor: '#000000'
    3343             }
    3344
    3345             /**#@-*/
    3346         },
    3347
    3348         /* special options for slope triangle */
    3349         slopetriangle: {
    3350             /**#@+
    3351              * @visprop
    3352              */
    3353
    3354             fillColor: 'red',
    3355             fillOpacity: 0.4,
    3356             highlightFillColor: 'red',
    3357             highlightFillOpacity: 0.3,
    3358
    3359             borders: {
    3360                 lastArrow: {
    3361                     type: 1,
    3362                     size: 6
    3363                 }
    3364             },
    3365
    3366             /**
    3367              * Attributes for the gliding helper point.
    3368              *
    3369              * @type Point
    3370              * @name Slopetriangle#glider
    3371              */
    3372             glider: {
    3373                 fixed: true,
    3374                 visible: false,
    3375                 withLabel: false
    3376             },
    3377
    3378             /**
    3379              * Attributes for the base line.
    3380              *
    3381              * @type Line
    3382              * @name Slopetriangle#baseline
    3383              */
    3384             baseline: {
    3385                 visible: false,
    3386                 withLabel: false,
    3387                 name: ''
    3388             },
    3389
    3390             /**
    3391              * Attributes for the base point.
    3392              *
    3393              * @type Point
    3394              * @name Slopetriangle#basepoint
    3395              */
    3396             basepoint: {
    3397                 visible: false,
    3398                 withLabel: false,
    3399                 name: ''
    3400             },
    3401
    3402             /**
    3403              * Attributes for the tangent.
    3404              * The tangent is constructed by slop triangle if the construction
    3405              * is based on a glider, solely.
    3406              *
    3407              * @type Line
    3408              * @name Slopetriangle#tangent
    3409              */
    3410             tangent: {
    3411                 visible: false,
    3412                 withLabel: false,
    3413                 name: ''
    3414             },
    3415
    3416             /**
    3417              * Attributes for the top point.
    3418              *
    3419              * @type Point
    3420              * @name Slopetriangle#toppoint
    3421              */
    3422             toppoint: {
    3423                 visible: false,
    3424                 withLabel: false,
    3425                 name: ''
    3426             },
    3427
    3428             /**
    3429              * Attributes for the slope triangle label.
    3430              *
    3431              * @type Label
    3432              * @name Slopetriangle#label
    3433              */
    3434             label: {
    3435                 visible: true
    3436             }
    3437             /**#@-*/
    3438         },
    3439
    3440         /* special options for step functions */
    3441         stepfunction: {
    3442             /**#@+
    3443              * @visprop
    3444              */
    3445
    3446             /**#@-*/
    3447         },
    3448
    3449         /* special tape measure options */
    3450         tapemeasure: {
    3451             /**#@+
    3452              * @visprop
    3453              */
    3454
    3455             strokeColor: '#000000',
    3456             strokeWidth: 2,
    3457             highlightStrokeColor: '#000000',
    3458
    3459             /**
    3460              * Show tape measure ticks.
    3461              *
    3462              * @type Boolean
    3463              * @name Tapemeasure#withTicks
    3464              * @default true
    3465              */
    3466             withTicks: true,
    3467
    3468             /**
    3469              * Show tape measure label.
    3470              *
    3471              * @type Boolean
    3472              * @name Tapemeasure#withLabel
    3473              * @default true
    3474              */
    3475             withLabel: true,
    3476
    3477             /**
    3478              * The precision of the tape measure value displayed in the optional text.
    3479              * @memberOf Tapemeasure.prototype
    3480              * @name precision
    3481              * @type Number
    3482              * @default 2
    3483              */
    3484             precision: 2,
    3485
    3486             /**
    3487              * Attributes for first helper point defining the tape measure position.
    3488              *
    3489              * @type Point
    3490              * @name Tapemeasure#point1
    3491              */
    3492             point1: {
    3493                 visible: 'inherit',
    3494                 strokeColor: '#000000',
    3495                 fillColor: '#ffffff',
    3496                 fillOpacity: 0.0,
    3497                 highlightFillOpacity: 0.1,
    3498                 size: 6,
    3499                 snapToPoints: true,
    3500                 attractorUnit: 'screen',
    3501                 attractorDistance: 20,
    3502                 showInfobox: false,
    3503                 withLabel: false,
    3504                 name: ''
    3505             },
    3506
    3507             /**
    3508              * Attributes for second helper point defining the tape measure position.
    3509              *
    3510              * @type Point
    3511              * @name Tapemeasure#point2
    3512              */
    3513             point2: {
    3514                 visible: 'inherit',
    3515                 strokeColor: '#000000',
    3516                 fillColor: '#ffffff',
    3517                 fillOpacity: 0.0,
    3518                 highlightFillOpacity: 0.1,
    3519                 size: 6,
    3520                 snapToPoints: true,
    3521                 attractorUnit: 'screen',
    3522                 attractorDistance: 20,
    3523                 showInfobox: false,
    3524                 withLabel: false,
    3525                 name: ''
    3526             },
    3527
    3528             /**
    3529              * Attributes for the ticks of the tape measure.
    3530              *
    3531              * @type Ticks
    3532              * @name Tapemeasure#ticks
    3533              */
    3534             ticks: {
    3535                 drawLabels: false,
    3536                 drawZero: true,
    3537                 insertTicks: true,
    3538                 minorHeight: 8,
    3539                 majorHeight: 16,
    3540                 minorTicks: 4,
    3541                 tickEndings: [0, 1],
    3542                 defaultDistance: 0.1,
    3543                 strokeOpacity: 1,
    3544                 strokeWidth: 1,
    3545                 strokeColor: '#000000',
    3546                 visible: 'inherit'
    3547             },
    3548
    3549             /**
    3550              * Attributes for the tape measure label.
    3551              *
    3552              * @type Label
    3553              * @name Tapemeasure#label
    3554              */
    3555             label: {
    3556                 position: 'top'
    3557             }
    3558             /**#@-*/
    3559         },
    3560
    3561         /* special text options */
    3562         text: {
    3563             /**#@+
    3564              * @visprop
    3565              */
    3566
    3567             /**
    3568              * The font size in pixels.
    3569              *
    3570              * @name fontSize
    3571              * @memberOf Text.prototype
    3572              * @default 12
    3573              * @type Number
    3574              */
    3575             fontSize: 12,
    3576
    3577             /**
    3578              * Used to round texts given by a number.
    3579              *
    3580              * @name digits
    3581              * @memberOf Text.prototype
    3582              * @default 2
    3583              * @type Number
    3584              */
    3585             digits: 2,
    3586
    3587             /**
    3588              * If set to true, the text is parsed and evaluated.
    3589              * For labels parse==true results in converting names of the form k_a to subscripts.
    3590              * If the text is given by string and parse==true, the string is parsed as
    3591              * JessieCode expression.
    3592              *
    3593              * @name parse
    3594              * @memberOf Text.prototype
    3595              * @default true
    3596              * @type Boolean
    3597              */
    3598             parse: true,
    3599
    3600             /**
    3601              * If set to true and caja's sanitizeHTML function can be found it
    3602              * will be used to sanitize text output.
    3603              *
    3604              * @name useCaja
    3605              * @memberOf Text.prototype
    3606              * @default false
    3607              * @type Boolean
    3608              */
    3609             useCaja: false,
    3610
    3611             /**
    3612              * If enabled, the text will be handled as label. Intended for internal use.
    3613              *
    3614              * @name isLabel
    3615              * @memberOf Text.prototype
    3616              * @default false
    3617              * @type Boolean
    3618              */
    3619             isLabel: false,
    3620
    3621             strokeColor: 'black',
    3622             highlightStrokeColor: 'black',
    3623             highlightStrokeOpacity: 0.666666,
    3624
    3625             /**
    3626              * Default CSS properties of the HTML text element.
    3627              * <p>
    3628              * The CSS properties which are set here, are handed over to the style property
    3629              * of the HTML text element. That means, they have higher property than any
    3630              * CSS class.
    3631              * <p>
    3632              * If a property which is set here should be overruled by a CSS class
    3633              * then this property should be removed here.
    3634              * <p>
    3635              * The reason, why this attribute should be kept to its default value at all,
    3636              * is that screen dumps of SVG boards with <tt>board.renderer.dumpToCanvas()</tt>
    3637              * will ignore the font-family if it is set in a CSS class.
    3638              * It has to be set explicitly as style attribute.
    3639              * <p>
    3640              * In summary, the order of priorities from high to low is
    3641              * <ol>
    3642              *  <li> JXG.Options.text.cssStyle
    3643              *  <li> JXG.Options.text.cssDefaultStyle
    3644              *  <li> JXG.Options.text.cssClass
    3645              * </ol>
    3646              * @example
    3647              * If all texts should get its font-family from the default CSS class
    3648              * before initializing the board
    3649              * <pre>
    3650              *   JXG.Options.text.cssDefaultStyle = '';
    3651              * </pre>
    3652              * should be called.
    3653              *
    3654              * @name cssDefaultStyle
    3655              * @memberOf Text.prototype
    3656              * @default  'font-family: Arial, Helvetica, Geneva, sans-serif;'
    3657              * @type String
    3658              * @see JXG.Text#highlightCssDefaultStyle
    3659              * @see JXG.Text#cssStyle
    3660              * @see JXG.Text#highlightCssStyle
    3661              */
    3662             cssDefaultStyle: 'font-family: Arial, Helvetica, Geneva, sans-serif;',
    3663
    3664             /**
    3665              * Default CSS properties of the HTML text element in case of highlighting.
    3666              * <p>
    3667              * The CSS properties which are set here, are haded over to the style property
    3668              * of the HTML text element. That means, they have higher property than any
    3669              * CSS class.
    3670              *
    3671              * @name highlightCssDefaultStyle
    3672              * @memberOf Text.prototype
    3673              * @default  'font-family: Arial, Helvetica, Geneva, sans-serif;'
    3674              * @type String
    3675              * @see JXG.Text#cssDefaultStyle
    3676              * @see JXG.Text#cssStyle
    3677              * @see JXG.Text#highlightCssStyle
    3678             */
    3679             highlightCssDefaultStyle: 'font-family: Arial, Helvetica, Geneva, sans-serif;',
    3680
    3681             /**
    3682              * CSS properties of the HTML text element.
    3683              * <p>
    3684              * The CSS properties which are set here, are haded over to the style property
    3685              * of the HTML text element. That means, they have higher property than any
    3686              * CSS class.
    3687              *
    3688              * @name cssStyle
    3689              * @memberOf Text.prototype
    3690              * @default  ''
    3691              * @type String
    3692              * @see JXG.Text#cssDefaultStyle
    3693              * @see JXG.Text#highlightCssDefaultStyle
    3694              * @see JXG.Text#highlightCssStyle
    3695             */
    3696             cssStyle: '',
    3697
    3698             /**
    3699              * CSS properties of the HTML text element in case of highlighting.
    3700              * <p>
    3701              * The CSS properties which are set here, are haded over to the style property
    3702              * of the HTML text element. That means, they have higher property than any
    3703              * CSS class.
    3704              *
    3705              * @name highlightCssStyle
    3706              * @memberOf Text.prototype
    3707              * @default  ''
    3708              * @type String
    3709              * @see JXG.Text#cssDefaultStyle
    3710              * @see JXG.Text#highlightCssDefaultStyle
    3711              * @see JXG.Text#cssStyle
    3712             */
    3713             highlightCssStyle: '',
    3714
    3715             /**
    3716              * If true the input will be given to ASCIIMathML before rendering.
    3717              *
    3718              * @name useASCIIMathML
    3719              * @memberOf Text.prototype
    3720              * @default false
    3721              * @type Boolean
    3722              */
    3723             useASCIIMathML: false,
    3724
    3725             /**
    3726              * If true MathJax will be used to render the input string.
    3727              *
    3728              * @name useMathJax
    3729              * @memberOf Text.prototype
    3730              * @default false
    3731              * @type Boolean
    3732              */
    3733             useMathJax: false,
    3734
    3735             /**
    3736              * Determines the rendering method of the text. Possible values
    3737              * include <tt>'html'</tt> and <tt>'internal</tt>.
    3738              *
    3739              * @name display
    3740              * @memberOf Text.prototype
    3741              * @default 'html'
    3742              * @type String
    3743              */
    3744             display: 'html',
    3745
    3746             /**
    3747              * Anchor element {@link Point}, {@link Text} or {@link Image} of the text. If it exists, the coordinates of the text are relative
    3748              * to this anchor element.
    3749              *
    3750              * @name anchor
    3751              * @memberOf Text.prototype
    3752              * @default null
    3753              * @type Object
    3754              */
    3755             anchor: null,
    3756
    3757             /**
    3758              * The horizontal alignment of the text. Possible values include <tt>'auto</tt>, <tt>'left'</tt>, <tt>'middle'</tt>, and
    3759              * <tt>'right'</tt>.
    3760              *
    3761              * @name anchorX
    3762              * @memberOf Text.prototype
    3763              * @default 'left'
    3764              * @type String
    3765              */
    3766             anchorX: 'left',
    3767
    3768             /**
    3769              * The vertical alignment of the text. Possible values include <tt>'auto</tt>, <tt>'top'</tt>, <tt>'middle'</tt>, and
    3770              * <tt>'bottom'</tt>.
    3771              *
    3772              * @name anchorY
    3773              * @memberOf Text.prototype
    3774              * @default 'auto'
    3775              * @type String
    3776              */
    3777             anchorY: 'middle',
    3778
    3779             /**
    3780              * CSS class of the text in non-highlighted view.
    3781              *
    3782              * @name cssClass
    3783              * @memberOf Text.prototype
    3784              * @type String
    3785              */
    3786             cssClass: 'JXGtext',
    3787
    3788             /**
    3789              * CSS class of the text in highlighted view.
    3790              *
    3791              * @name highlightCssClass
    3792              * @memberOf Text.prototype
    3793              * @type String
    3794              */
    3795             highlightCssClass: 'JXGtext',
    3796
    3797             /**
    3798              * Sensitive area for dragging the text.
    3799              * Possible values are 'all', or something else.
    3800              * This may be extended to left, right, ... in the future.
    3801              *
    3802              * @name Text#dragArea
    3803              * @type String
    3804              * @default 'all'
    3805              */
    3806             dragArea: 'all',
    3807
    3808             withLabel: false,
    3809
    3810             /**
    3811              * Text rotation in degrees.
    3812              * Works for non-zero values only in combination with display=='internal'.
    3813              *
    3814              * @name Text#rotate
    3815              * @type Number
    3816              * @default 0
    3817              */
    3818             rotate: 0,
    3819
    3820             visible: true,
    3821
    3822             /**
    3823              * Defines together with {@link Text#snapSizeY} the grid the text snaps on to.
    3824              * The text will only snap on integer multiples to snapSizeX in x and snapSizeY in y direction.
    3825              * If this value is equal to or less than <tt>0</tt>, it will use the grid displayed by the major ticks
    3826              * of the default ticks of the default x axes of the board.
    3827              *
    3828              * @name snapSizeX
    3829              * @memberOf Text.prototype
    3830              *
    3831              * @see JXG.Point#snapToGrid
    3832              * @see Text#snapSizeY
    3833              * @see JXG.Board#defaultAxes
    3834              * @type Number
    3835              * @default 1
    3836              */
    3837             snapSizeX: 1,
    3838
    3839             /**
    3840              * Defines together with {@link Text#snapSizeX} the grid the text snaps on to.
    3841              * The text will only snap on integer multiples to snapSizeX in x and snapSizeY in y direction.
    3842              * If this value is equal to or less than <tt>0</tt>, it will use the grid displayed by the major ticks
    3843              * of the default ticks of the default y axes of the board.
    3844              *
    3845              * @name snapSizeY
    3846              * @memberOf Text.prototype
    3847              *
    3848              * @see JXG.Point#snapToGrid
    3849              * @see Text#snapSizeX
    3850              * @see JXG.Board#defaultAxes
    3851              * @type Number
    3852              * @default 1
    3853              */
    3854             snapSizeY: 1,
    3855
    3856             /**
    3857              * List of attractor elements. If the distance of the text is less than
    3858              * attractorDistance the text is made to glider of this element.
    3859              *
    3860              * @name attractors
    3861              * @memberOf Text.prototype
    3862              * @type array
    3863              * @default empty
    3864              */
    3865             attractors: []
    3866
    3867             /**#@-*/
    3868         },
    3869
    3870         /* special options for trace curves */
    3871         tracecurve: {
    3872             /**#@+
    3873              * @visprop
    3874              */
    3875             strokeColor: '#000000',
    3876             fillColor: 'none',
    3877
    3878             /**
    3879              * The number of evaluated data points.
    3880              * @memberOf Tracecurve.prototype
    3881              * @default 100
    3882              * @name numberPoints
    3883              * @type Number
    3884              */
    3885             numberPoints: 100
    3886
    3887             /**#@-*/
    3888         },
    3889
    3890         /*special turtle options */
    3891         turtle: {
    3892             /**#@+
    3893              * @visprop
    3894              */
    3895
    3896             strokeWidth: 1,
    3897             fillColor: 'none',
    3898             strokeColor: '#000000',
    3899
    3900             /**
    3901              * Attributes for the turtle arrow.
    3902              *
    3903              * @type Curve
    3904              * @name Turtle#arrow
    3905              */
    3906             arrow: {
    3907                 strokeWidth: 2,
    3908                 withLabel: false,
    3909                 strokeColor: '#ff0000'
    3910             }
    3911             /**#@-*/
    3912         },
    3913
    3914         /**
    3915          * Abbreviations of properties. Setting the shortcut means setting abbreviated properties
    3916          * to the same value.
    3917          * It is used in {@link JXG.GeometryElement#setAttribute} and in
    3918          * the constructor {@link JXG.GeometryElement}.
    3919          * Attention: In Options.js abbreviations are not allowed.
    3920          */
    3921         shortcuts: {
    3922             color: ['strokeColor', 'fillColor'],
    3923             opacity: ['strokeOpacity', 'fillOpacity'],
    3924             highlightColor: ['highlightStrokeColor', 'highlightFillColor'],
    3925             highlightOpacity: ['highlightStrokeOpacity', 'highlightFillOpacity'],
    3926             strokeWidth: ['strokeWidth', 'highlightStrokeWidth']
    3927         }
    3928
    3929     };
    3930
    3931     /**
    3932      * Holds all possible properties and the according validators for geometry elements. A validator is either a function
    3933      * which takes one parameter and returns true, if the value is valid for the property, or it is false if no validator
    3934      * is required.
    3935      */
    3936     JXG.Validator = (function () {
    3937         var i,
    3938             validatePixel = function (v) {
    3939                 return (/^[0-9]+px$/).test(v);
    3940             },
    3941             validateDisplay = function (v) {
    3942                 return (v  === 'html' || v === 'internal');
    3943             },
    3944             validateColor = function (v) {
    3945                 // for now this should do it...
    3946                 return Type.isString(v);
    3947             },
    3948             validatePointFace = function (v) {
    3949                 return Type.exists(JXG.normalizePointFace(v));
    3950             },
    3951             validateInteger = function (v) {
    3952                 return (Math.abs(v - Math.round(v)) < Mat.eps);
    3953             },
    3954             validatePositiveInteger = function (v) {
    3955                 return validateInteger(v) && v > 0;
    3956             },
    3957             validateScreenCoords = function (v) {
    3958                 return v.length >= 2 && validateInteger(v[0]) && validateInteger(v[1]);
    3959             },
    3960             validateRenderer = function (v) {
    3961                 return (v === 'vml' || v === 'svg' || v === 'canvas' || v === 'no');
    3962             },
    3963             validatePositive = function (v) {
    3964                 return v > 0;
    3965             },
    3966             validateNotNegative = function (v) {
    3967                 return v >= 0;
    3968             },
    3969             v = {},
    3970             validators = {
    3971                 attractorDistance: validateNotNegative,
    3972                 color: validateColor,
    3973                 defaultDistance: Type.isNumber,
    3974                 display: validateDisplay,
    3975                 doAdvancedPlot: false,
    3976                 draft: false,
    3977                 drawLabels: false,
    3978                 drawZero: false,
    3979                 face: validatePointFace,
    3980                 factor: Type.isNumber,
    3981                 fillColor: validateColor,
    3982                 fillOpacity: Type.isNumber,
    3983                 firstArrow: false,
    3984                 fontSize: validateInteger,
    3985                 dash: validateInteger,
    3986                 gridX: Type.isNumber,
    3987                 gridY: Type.isNumber,
    3988                 hasGrid: false,
    3989                 highlightFillColor: validateColor,
    3990                 highlightFillOpacity: Type.isNumber,
    3991                 highlightStrokeColor: validateColor,
    3992                 highlightStrokeOpacity: Type.isNumber,
    3993                 insertTicks: false,
    3994                 //: validateScreenCoords,
    3995                 lastArrow: false,
    3996                 majorHeight: validateInteger,
    3997                 minorHeight: validateInteger,
    3998                 minorTicks: validateNotNegative,
    3999                 minTicksDistance: validatePositiveInteger,
    4000                 numberPointsHigh: validatePositiveInteger,
    4001                 numberPointsLow: validatePositiveInteger,
    4002                 opacity: Type.isNumber,
    4003                 radius: Type.isNumber,
    4004                 RDPsmoothing: false,
    4005                 renderer: validateRenderer,
    4006                 right: validatePixel,
    4007                 showCopyright: false,
    4008                 showInfobox: false,
    4009                 showNavigation: false,
    4010                 size: validateInteger,
    4011                 snapSizeX: validatePositive,
    4012                 snapSizeY: validatePositive,
    4013                 snapWidth: Type.isNumber,
    4014                 snapToGrid: false,
    4015                 snatchDistance: validateNotNegative,
    4016                 straightFirst: false,
    4017                 straightLast: false,
    4018                 stretch: false,
    4019                 strokeColor: validateColor,
    4020                 strokeOpacity: Type.isNumber,
    4021                 strokeWidth: validateInteger,
    4022                 takeFirst: false,
    4023                 takeSizeFromFile: false,
    4024                 to10: false,
    4025                 toOrigin: false,
    4026                 translateTo10: false,
    4027                 translateToOrigin: false,
    4028                 useASCIIMathML: false,
    4029                 useDirection: false,
    4030                 useMathJax: false,
    4031                 withLabel: false,
    4032                 withTicks: false,
    4033                 zoom: false
    4034             };
    4035
    4036         // this seems like a redundant step but it makes sure that
    4037         // all properties in the validator object have lower case names
    4038         // and the validator object is easier to read.
    4039         for (i in validators) {
    4040             if (validators.hasOwnProperty(i)) {
    4041                 v[i.toLowerCase()] = validators[i];
    4042             }
    4043         }
    4044
    4045         return v;
    4046     }());
    4047
    4048     /**
    4049      * All point faces can be defined with more than one name, e.g. a cross faced point can be given
    4050      * by face equal to 'cross' or equal to 'x'. This method maps all possible values to fixed ones to
    4051      * simplify if- and switch-clauses regarding point faces. The translation table is as follows:
    4052      * <table>
    4053      * <tr><th>Input</th><th>Output</th></tr>
    4054      * <tr><td>cross, x</td><td>x</td></tr>
    4055      * <tr><td>circle, o</td><td>o</td></tr>
    4056      * <tr><td>square, []</td><td>[]</td></tr>
    4057      * <tr><td>plus, +</td><td>+</td></tr>
    4058      * <tr><td>diamond, <></td><td><></td></tr>
    4059      * <tr><td>triangleup, a, ^</td><td>A</td></tr>
    4060      * <tr><td>triangledown, v</td><td>v</td></tr>
    4061      * <tr><td>triangleleft, <</td><td><</td></tr>
    4062      * <tr><td>triangleright, ></td><td>></td></tr>
    4063      * </table>
    4064      * @param {String} s A string which should determine a valid point face.
    4065      * @returns {String} Returns a normalized string or undefined if the given string is not a valid
    4066      * point face.
    4067      */
    4068     JXG.normalizePointFace = function (s) {
    4069         var map = {
    4070             cross: 'x',
    4071             x: 'x',
    4072             circle: 'o',
    4073             o: 'o',
    4074             square: '[]',
    4075             '[]': '[]',
    4076             plus: '+',
    4077             '+': '+',
    4078             diamond: '<>',
    4079             '<>': '<>',
    4080             triangleup: '^',
    4081             a: '^',
    4082             '^': '^',
    4083             triangledown: 'v',
    4084             v: 'v',
    4085             triangleleft: '<',
    4086             '<': '<',
    4087             triangleright: '>',
    4088             '>': '>'
    4089         };
    4090
    4091         return map[s];
    4092     };
    4093
    4094
    4095     /**
    4096      * Apply the options stored in this object to all objects on the given board.
    4097      * @param {JXG.Board} board The board to which objects the options will be applied.
    4098      */
    4099     JXG.useStandardOptions = function (board) {
    4100         var el, t, p, copyProps,
    4101             o = JXG.Options,
    4102             boardHadGrid = board.hasGrid;
    4103
    4104         board.options.grid.hasGrid = o.grid.hasGrid;
    4105         board.options.grid.gridX = o.grid.gridX;
    4106         board.options.grid.gridY = o.grid.gridY;
    4107         board.options.grid.gridColor = o.grid.gridColor;
    4108         board.options.grid.gridOpacity = o.grid.gridOpacity;
    4109         board.options.grid.gridDash = o.grid.gridDash;
    4110         board.options.grid.snapToGrid = o.grid.snapToGrid;
    4111         board.options.grid.snapSizeX = o.grid.SnapSizeX;
    4112         board.options.grid.snapSizeY = o.grid.SnapSizeY;
    4113         board.takeSizeFromFile = o.takeSizeFromFile;
    4114
    4115         copyProps = function (p, o) {
    4116             p.visProp.fillcolor = o.fillColor;
    4117             p.visProp.highlightfillcolor = o.highlightFillColor;
    4118             p.visProp.strokecolor = o.strokeColor;
    4119             p.visProp.highlightstrokecolor = o.highlightStrokeColor;
    4120         };
    4121
    4122         for (el in board.objects) {
    4123             if (board.objects.hasOwnProperty(el)) {
    4124                 p = board.objects[el];
    4125                 if (p.elementClass === Const.OBJECT_CLASS_POINT) {
    4126                     copyProps(p, o.point);
    4127                 } else if (p.elementClass === Const.OBJECT_CLASS_LINE) {
    4128                     copyProps(p, o.line);
    4129
    4130                     for (t = 0; t < p.ticks.length; t++) {
    4131                         p.ticks[t].majorTicks = o.line.ticks.majorTicks;
    4132                         p.ticks[t].minTicksDistance = o.line.ticks.minTicksDistance;
    4133                         p.ticks[t].visProp.minorheight = o.line.ticks.minorHeight;
    4134                         p.ticks[t].visProp.majorheight = o.line.ticks.majorHeight;
    4135                     }
    4136                 } else if (p.elementClass === Const.OBJECT_CLASS_CIRCLE) {
    4137                     copyProps(p, o.circle);
    4138                 } else if (p.type === Const.OBJECT_TYPE_ANGLE) {
    4139                     copyProps(p, o.angle);
    4140                 } else if (p.type === Const.OBJECT_TYPE_ARC) {
    4141                     copyProps(p, o.arc);
    4142                 } else if (p.type === Const.OBJECT_TYPE_POLYGON) {
    4143                     copyProps(p, o.polygon);
    4144                 } else if (p.type === Const.OBJECT_TYPE_CONIC) {
    4145                     copyProps(p, o.conic);
    4146                 } else if (p.type === Const.OBJECT_TYPE_CURVE) {
    4147                     copyProps(p, o.curve);
    4148                 } else if (p.type === Const.OBJECT_TYPE_SECTOR) {
    4149                     p.arc.visProp.fillcolor = o.sector.fillColor;
    4150                     p.arc.visProp.highlightfillcolor = o.sector.highlightFillColor;
    4151                     p.arc.visProp.fillopacity = o.sector.fillOpacity;
    4152                     p.arc.visProp.highlightfillopacity = o.sector.highlightFillOpacity;
    4153                 }
    4154             }
    4155         }
    4156
    4157         board.fullUpdate();
    4158         if (boardHadGrid && !board.hasGrid) {
    4159             board.removeGrids(board);
    4160         } else if (!boardHadGrid && board.hasGrid) {
    4161             board.create('grid', []);
    4162         }
    4163     };
    4164
    4165     /**
    4166      * Converts all color values to greyscale and calls useStandardOption to put them onto the board.
    4167      * @param {JXG.Board} board The board to which objects the options will be applied.
    4168      * @see #useStandardOptions
    4169      */
    4170     JXG.useBlackWhiteOptions = function (board) {
    4171         var o = JXG.Options;
    4172         o.point.fillColor = Color.rgb2bw(o.point.fillColor);
    4173         o.point.highlightFillColor = Color.rgb2bw(o.point.highlightFillColor);
    4174         o.point.strokeColor = Color.rgb2bw(o.point.strokeColor);
    4175         o.point.highlightStrokeColor = Color.rgb2bw(o.point.highlightStrokeColor);
    4176
    4177         o.line.fillColor = Color.rgb2bw(o.line.fillColor);
    4178         o.line.highlightFillColor = Color.rgb2bw(o.line.highlightFillColor);
    4179         o.line.strokeColor = Color.rgb2bw(o.line.strokeColor);
    4180         o.line.highlightStrokeColor = Color.rgb2bw(o.line.highlightStrokeColor);
    4181
    4182         o.circle.fillColor = Color.rgb2bw(o.circle.fillColor);
    4183         o.circle.highlightFillColor = Color.rgb2bw(o.circle.highlightFillColor);
    4184         o.circle.strokeColor = Color.rgb2bw(o.circle.strokeColor);
    4185         o.circle.highlightStrokeColor = Color.rgb2bw(o.circle.highlightStrokeColor);
    4186
    4187         o.arc.fillColor = Color.rgb2bw(o.arc.fillColor);
    4188         o.arc.highlightFillColor = Color.rgb2bw(o.arc.highlightFillColor);
    4189         o.arc.strokeColor = Color.rgb2bw(o.arc.strokeColor);
    4190         o.arc.highlightStrokeColor = Color.rgb2bw(o.arc.highlightStrokeColor);
    4191
    4192         o.polygon.fillColor = Color.rgb2bw(o.polygon.fillColor);
    4193         o.polygon.highlightFillColor  = Color.rgb2bw(o.polygon.highlightFillColor);
    4194
    4195         o.sector.fillColor = Color.rgb2bw(o.sector.fillColor);
    4196         o.sector.highlightFillColor  = Color.rgb2bw(o.sector.highlightFillColor);
    4197
    4198         o.curve.strokeColor = Color.rgb2bw(o.curve.strokeColor);
    4199         o.grid.gridColor = Color.rgb2bw(o.grid.gridColor);
    4200
    4201         JXG.useStandardOptions(board);
    4202     };
    4203
    4204     // needs to be exported
    4205     JXG.Options.normalizePointFace = JXG.normalizePointFace;
    4206
    4207     return JXG.Options;
    4208 });
    4209