devextreme/dist/transpiled/viz/translators/numeric_translator.js

HTML5 JavaScript Component Suite for Responsive Web Development

"use strict";

var isDefined = require("../../core/utils/type").isDefined,
    round = Math.round;

module.exports = {
    translate: function translate(bp, direction) {
        var that = this,
            specialValue = that.translateSpecialCase(bp);

        if (isDefined(specialValue)) {
            return specialValue;
        }

        if (isNaN(bp)) {
            return null;
        }
        return that.to(bp, direction);
    },

    untranslate: function untranslate(pos, _, enableOutOfCanvas, direction) {
        var that = this,
            canvasOptions = that._canvasOptions,
            startPoint = canvasOptions.startPoint;

        if (!enableOutOfCanvas && (pos < startPoint || pos > canvasOptions.endPoint) || !isDefined(canvasOptions.rangeMin) || !isDefined(canvasOptions.rangeMax)) {
            return null;
        }
        return that.from(pos, direction);
    },

    getInterval: function getInterval() {
        return round(this._canvasOptions.ratioOfCanvasRange * (this._businessRange.interval || Math.abs(this._canvasOptions.rangeMax - this._canvasOptions.rangeMin)));
    },

    _getValue: function _getValue(val) {
        return val;
    },

    zoom: function zoom(translate, scale) {
        var that = this,
            canvasOptions = that._canvasOptions,
            startPoint = canvasOptions.startPoint,
            endPoint = canvasOptions.endPoint,
            newStart = (startPoint + translate) / scale,
            newEnd = (endPoint + translate) / scale,
            translatedRangeMinMax = [that.translate(that._getValue(canvasOptions.rangeMin)), that.translate(that._getValue(canvasOptions.rangeMax))],
            minPoint = Math.min(translatedRangeMinMax[0], translatedRangeMinMax[1]),
            maxPoint = Math.max(translatedRangeMinMax[0], translatedRangeMinMax[1]);

        if (minPoint > newStart) {
            newEnd -= newStart - minPoint;
            newStart = minPoint;
        }

        if (maxPoint < newEnd) {
            newStart -= newEnd - maxPoint;
            newEnd = maxPoint;
        }
        if (maxPoint - minPoint < newEnd - newStart) {
            newStart = minPoint;
            newEnd = maxPoint;
        }

        translate = (endPoint - startPoint) * newStart / (newEnd - newStart) - startPoint;
        scale = (startPoint + translate) / newStart || 1;

        return {
            min: that.untranslate(newStart, undefined, true, 1),
            max: that.untranslate(newEnd, undefined, true, -1),
            translate: translate,
            scale: scale
        };
    },

    getMinScale: function getMinScale(zoom) {
        return zoom ? 1.1 : 0.9;
    },

    getScale: function getScale(val1, val2) {
        var canvasOptions = this._canvasOptions;
        val1 = isDefined(val1) ? val1 : canvasOptions.rangeMin;
        val2 = isDefined(val2) ? val2 : canvasOptions.rangeMax;
        return (canvasOptions.rangeMax - canvasOptions.rangeMin) / Math.abs(val1 - val2);
    },

    // dxRangeSelector

    isValid: function isValid(value) {
        var that = this,
            co = that._canvasOptions;

        return value !== null && !isNaN(value) && value.valueOf() + co.rangeDoubleError >= co.rangeMin && value.valueOf() - co.rangeDoubleError <= co.rangeMax;
    },

    getCorrectValue: function getCorrectValue(value, direction) {
        var that = this,
            breaks = that._breaks,
            prop;

        value = that._parse(value);

        if (that._breaks) {
            prop = that._checkValueAboutBreaks(breaks, value, "trFrom", "trTo", that._checkingMethodsAboutBreaks[0]);
            if (prop.inBreak === true) {
                return direction > 0 ? prop.break.trTo : prop.break.trFrom;
            }
        }

        return value;
    },

    _parse: function _parse(value) {
        return Number(value);
    },

    to: function to(bp, direction) {
        var that = this,
            canvasOptions = that._canvasOptions,
            breaks = that._breaks,
            prop = { length: 0 },
            commonBreakSize = 0;

        if (breaks !== undefined) {
            prop = that._checkValueAboutBreaks(breaks, bp, "trFrom", "trTo", that._checkingMethodsAboutBreaks[0]);
            commonBreakSize = isDefined(prop.breaksSize) ? prop.breaksSize : 0;
        }
        if (prop.inBreak === true) {
            if (direction > 0) {
                return prop.break.start;
            } else if (direction < 0) {
                return prop.break.end;
            } else {
                return null;
            }
        }
        return that._conversionValue(that._calculateProjection((bp - canvasOptions.rangeMinVisible - prop.length) * canvasOptions.ratioOfCanvasRange + commonBreakSize));
    },

    from: function from(pos, direction) {
        var that = this,
            breaks = that._breaks,
            prop = { length: 0 },
            canvasOptions = that._canvasOptions,
            startPoint = canvasOptions.startPoint,
            commonBreakSize = 0;

        if (breaks !== undefined) {
            prop = that._checkValueAboutBreaks(breaks, pos, "start", "end", that._checkingMethodsAboutBreaks[1]);
            commonBreakSize = isDefined(prop.breaksSize) ? prop.breaksSize : 0;
        }

        if (prop.inBreak === true) {
            if (direction > 0) {
                return prop.break.trTo;
            } else if (direction < 0) {
                return prop.break.trFrom;
            } else {
                return null;
            }
        }

        return this._calculateUnProjection((pos - startPoint - commonBreakSize) / canvasOptions.ratioOfCanvasRange + prop.length);
    },

    _add: function _add(value, diff, coeff) {
        return value + diff * coeff;
    },

    isValueProlonged: false
};