jsxgraph 1.4.5 → 1.4.6

package/src/utils/env.js

@@ -793,53 +793,14 @@ define(['jxg', 'utils/type'], function (JXG, Type) {
             window.setTimeout(timerFun, 1);
         },
 
-        /**
-         * Calculate the scale factor and vertical shift for the JSXGraph div
-         * in full screen mode.
-         *
-         * @param {Object} obj Reference to a DOM node.
-         * @returns Object {scale: number, vshift: number}
-         * @see JXG.Board#fullscreenListener
-         * @private
-         */
-        _getScaleFactors: function (node) {
-            var width = node.getBoundingClientRect().width,
-                height = node.getBoundingClientRect().height,
-
-                // Determine the maximum scale factor.
-                r_w = window.screen.width / width,
-                r_h = window.screen.height / height,
-
-                // Determine the vertical shift to place the div in the center of the screen
-                vshift = (window.screen.height - height) * 0.5,
-
-                // Scaling factor: if not supplied, it's taken as large as possible
-                scale = Math.min(r_w, r_h);
-
-            // Adapt vshift and scale for landscape on tablets
-            if (window.matchMedia && window.matchMedia('(orientation:landscape)').matches &&
-                window.screen.width < window.screen.height) {
-                // Landscape on iOS: it returns 'landscape', but still width < height.
-                r_w = window.screen.height / width;
-                r_h = window.screen.width / height;
-                scale = Math.min(r_w, r_h);
-                vshift = (window.screen.width - height) * 0.5;
-            }
-            scale *= 0.85;
-
-            return { scale: scale, vshift: vshift, width: width };
-        },
-
         /**
          * Scale and vertically shift a DOM element (usually a JSXGraph div)
          * inside of a parent DOM
          * element which is set to fullscreen.
          * This is realized with a CSS transformation.
-         *          *
+         *
          * @param  {String} wrap_id  id of the parent DOM element which is in fullscreen mode
          * @param  {String} inner_id id of the DOM element which is scaled and shifted
-         * @param  {Number} scale    Scaling factor
-         * @param  {Number} vshift   Vertical shift (in pixel)
          * @param  {Object} doc      document object or shadow root
          *
          * @private
@@ -847,19 +808,37 @@ define(['jxg', 'utils/type'], function (JXG, Type) {
          * @see JXG.Board#fullscreenListener
          *
          */
-        scaleJSXGraphDiv: function (wrap_id, inner_id, scale, vshift, doc) {
-            var len = doc.styleSheets.length, style,
+         scaleJSXGraphDiv: function (wrap_id, inner_id, doc) {
+            var len = doc.styleSheets.length, style, rule, w, h, b, wi, hi, bi,
+                scale_l, vshift_l, // scale_p, vshift_p,
+                f = 0.85,
+                rule_inner_l, // rule_inner_p,
 
                 pseudo_keys = [':fullscreen', ':-webkit-full-screen', ':-moz-full-screen', ':-ms-fullscreen'],
                 len_pseudo = pseudo_keys.length, i,
 
-                // CSS rules to center the inner div horizontally and vertically.
-                rule_inner = '{margin:0 auto;transform:matrix(' + scale + ',0,0,' + scale + ',0,' + vshift + ');}',
-
                 // A previously installed CSS rule to center the JSXGraph div has to
                 // be searched and removed again.
                 regex = new RegExp('.*#' + wrap_id + ':.*full.*screen.*#' + inner_id + '.*auto;.*transform:.*matrix');
 
+            b = doc.getElementById(wrap_id).getBoundingClientRect();
+            h = b.height;
+            w = b.width;
+
+            bi = doc.getElementById(inner_id).getBoundingClientRect();
+            hi = bi.height;
+            wi = bi.width;
+
+            if (wi / hi >= w / h) {
+                scale_l = f * w / wi;
+            } else {
+                scale_l = f * h / hi;
+            }
+            vshift_l = (h - hi) * 0.5;
+
+            // CSS rules to center the inner div horizontally and vertically.
+            rule_inner_l = '{margin:0 auto;transform:matrix(' + scale_l + ',0,0,' + scale_l + ',0,' + vshift_l + ');}';
+
             if (len === 0) {
                 // In case there is not a single CSS rule defined at all.
                 style = document.createElement('style');
@@ -880,7 +859,10 @@ define(['jxg', 'utils/type'], function (JXG, Type) {
             // Install a CSS rule to center the JSXGraph div at the first position of the list.
             for (i = 0; i < len_pseudo; i++) {
                 try {
-                    doc.styleSheets[len - 1].insertRule('#' + wrap_id + pseudo_keys[i] + ' #' + inner_id + rule_inner, 0);
+                    rule = '#' + wrap_id + pseudo_keys[i] + ' #' + inner_id + rule_inner_l;
+                    // rule = '@media all and (orientation:landscape) {' + rule + '}';
+                    doc.styleSheets[len - 1].insertRule(rule, 0);
+
                     break;
                 } catch (err) {
                     // console.log('JXG.scaleJSXGraphDiv: Could not add CSS rule "' + pseudo_keys[i] + '".');
@@ -892,6 +874,7 @@ define(['jxg', 'utils/type'], function (JXG, Type) {
                 console.log('One possible reason could be that the id of the JSXGraph container does not start with a letter.');
             }
         }
+
     });
 
     return JXG;

package/src/utils/type.js

@@ -141,13 +141,21 @@ define([
          * @returns {Boolean} True, if v is of type JXG.Point.
          */
         isPoint: function (v) {
-            if (v !== null && typeof v === 'object') {
+            if (v !== null && typeof v === 'object' && this.exists(v.elementClass)) {
                 return (v.elementClass === Const.OBJECT_CLASS_POINT);
             }
 
             return false;
         },
 
+        isPoint3D: function (v) {
+            if (v !== null && typeof v === 'object' && this.exists(v.elType)) {
+                return (v.elType === 'point3d');
+            }
+
+            return false;
+        },
+
         /**
          * Checks if a given variable is a reference of a JSXGraph Point element or an array of length at least two or
          * a function returning an array of length two or three.
@@ -395,6 +403,71 @@ define([
             return points;
         },
 
+        /**
+         *  Test if the parents array contains existing points. If instead parents contains coordinate arrays or
+         *  function returning coordinate arrays
+         *  free points with these coordinates are created.
+         *
+         * @param {JXG.View3D} view View3D object
+         * @param {Array} parents Array containing parent elements for a new object. This array may contain
+         *    <ul>
+         *      <li> {@link JXG.Point3D} objects
+         *      <li> {@link JXG.GeometryElement#name} of {@link JXG.Point3D} objects
+         *      <li> {@link JXG.GeometryElement#id} of {@link JXG.Point3D} objects
+         *      <li> Coordinates of 3D points given as array of numbers of length three, e.g. [2, 3, 1].
+         *      <li> Coordinates of 3D points given as array of functions of length three. Each function returns one coordinate, e.g.
+         *           [function(){ return 2; }, function(){ return 3; }, function(){ return 1; }]
+         *      <li> Function returning coordinates, e.g. function() { return [2, 3, 1]; }
+         *    </ul>
+         *  In the last three cases a new 3D point will be created.
+         * @param {String} attrClass Main attribute class of newly created 3D points, see {@link JXG#copyAttributes}
+         * @param {Array} attrArray List of subtype attributes for the newly created 3D points. The list of subtypes is mapped to the list of new 3D points.
+         * @returns {Array} List of newly created {@link JXG.Point3D} elements or false if not all returned elements are 3D points.
+         */
+         providePoints3D: function (view, parents, attributes, attrClass, attrArray) {
+            var i, j,
+                len,
+                lenAttr = 0,
+                points = [], attr, val;
+
+            if (!this.isArray(parents)) {
+                parents = [parents];
+            }
+            len = parents.length;
+            if (this.exists(attrArray)) {
+                lenAttr = attrArray.length;
+            }
+            if (lenAttr === 0) {
+                attr = this.copyAttributes(attributes, view.board.options, attrClass);
+            }
+
+            for (i = 0; i < len; ++i) {
+                if (lenAttr > 0) {
+                    j = Math.min(i, lenAttr - 1);
+                    attr = this.copyAttributes(attributes, view.board.options, attrClass, attrArray[j]);
+                }
+
+                if (this.isArray(parents[i]) && parents[i].length > 1) {
+                    points.push(view.create('point3d', parents[i], attr));
+                    points[points.length - 1]._is_new = true;
+                } else if (this.isFunction(parents[i])) {
+                    val = parents[i]();
+                    if (this.isArray(val) && (val.length > 1)) {
+                        points.push(view.create('point3d', [parents[i]], attr));
+                        points[points.length - 1]._is_new = true;
+                    }
+                } else {
+                    points.push(view.select(parents[i]));
+                }
+
+                if (!this.isPoint3D(points[i])) {
+                    return false;
+                }
+            }
+
+            return points;
+        },
+
         /**
          * Generates a function which calls the function fn in the scope of owner.
          * @param {Function} fn Function to call.
@@ -732,7 +805,7 @@ define([
             var x = Math.abs(val),
                 str;
 
-            if (x > 0.1) {
+            if (x >= 0.1) {
                 str = this.toFixed(val, 2);
             } else if (x >= 0.01) {
                 str = this.toFixed(val, 4);

package/src/3d/threed.js

@@ -1,38 +0,0 @@
-/*
-    Copyright 2008-2022
-        Matthias Ehmann,
-        Carsten Miller,
-        Andreas Walter,
-        Alfred Wassermann
-
-    This file is part of JSXGraph.
-
-    JSXGraph is free software dual licensed under the GNU LGPL or MIT License.
-
-    You can redistribute it and/or modify it under the terms of the
-
-      * GNU Lesser General Public License as published by
-        the Free Software Foundation, either version 3 of the License, or
-        (at your option) any later version
-      OR
-      * MIT License: https://github.com/jsxgraph/jsxgraph/blob/master/LICENSE.MIT
-
-    JSXGraph is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Lesser General Public License for more details.
-
-    You should have received a copy of the GNU Lesser General Public License and
-    the MIT License along with JSXGraph. If not, see <http://www.gnu.org/licenses/>
-    and <http://opensource.org/licenses/MIT/>.
- */
-/*global JXG:true, define: true*/
-
-define(['jxg'
-], function (JXG) {
-    "use strict";
-
-    JXG.ThreeD = {};
-
-    return JXG.ThreeD;
-});