#

API Docs for:
Show: Inherited Protected Private Deprecated

# File: input/charts/LeftAxisLayout.js

    /**
     * Algorithmic strategy for rendering a left axis.
     *
     * @module charts
     * @class LeftAxisLayout
     * @constructor
     */
    LeftAxisLayout = function() {};

    LeftAxisLayout.prototype = {
        /**
         *  Default margins for text fields.
         *
         *  @private
         *  @method _getDefaultMargins
         *  @return Object
         */
        _getDefaultMargins: function()
        {
            return {
                top: 0,
                left: 0,
                right: 4,
                bottom: 0
            };
        },

        /**
         * Sets the length of the tick on either side of the axis line.
         *
         * @method setTickOffset
         * @protected
         */
        setTickOffsets: function()
        {
            var host = this,
                majorTicks = host.get("styles").majorTicks,
                tickLength = majorTicks.length,
                halfTick = tickLength * 0.5,
                display = majorTicks.display;
            host.set("topTickOffset",  0);
            host.set("bottomTickOffset",  0);

            switch(display)
            {
                case "inside" :
                    host.set("rightTickOffset",  tickLength);
                    host.set("leftTickOffset", 0);
                break;
                case "outside" :
                    host.set("rightTickOffset", 0);
                    host.set("leftTickOffset",  tickLength);
                break;
                case "cross":
                    host.set("rightTickOffset", halfTick);
                    host.set("leftTickOffset",  halfTick);
                break;
                default:
                    host.set("rightTickOffset", 0);
                    host.set("leftTickOffset", 0);
                break;
            }
        },

        /**
         * Draws a tick
         *
         * @method drawTick
         * @param {Path} path reference to the path `Path` element in which to draw the tick.
         * @param {Object} pt Point on the axis in which the tick will intersect.
         * @param {Object} tickStyle Hash of properties to apply to the tick.
         * @protected
         */
        drawTick: function(path, pt, tickStyles)
        {
            var host = this,
                style = host.get("styles"),
                padding = style.padding,
                tickLength = tickStyles.length,
                start = {x:padding.left, y:pt.y},
                end = {x:tickLength + padding.left, y:pt.y};
            host.drawLine(path, start, end);
        },

        /**
         * Calculates the coordinates for the first point on an axis.
         *
         * @method getLineStart
         * @return {Object}
         * @protected
         */
        getLineStart: function()
        {
            var style = this.get("styles"),
                padding = style.padding,
                majorTicks = style.majorTicks,
                tickLength = majorTicks.length,
                display = majorTicks.display,
                pt = {x:padding.left, y:0};
            if(display === "outside")
            {
                pt.x += tickLength;
            }
            else if(display === "cross")
            {
                pt.x += tickLength/2;
            }
            return pt;
        },

        /**
         * Calculates the point for a label.
         *
         * @method getLabelPoint
         * @param {Object} point Point on the axis in which the tick will intersect.
         * @return {Object}
         * @protected
         */
        getLabelPoint: function(point)
        {
            return {x:point.x - this.get("leftTickOffset"), y:point.y};
        },

        /**
         * Updates the value for the `maxLabelSize` for use in calculating total size.
         *
         * @method updateMaxLabelSize
         * @param {HTMLElement} label to measure
         * @protected
         */
        updateMaxLabelSize: function(labelWidth, labelHeight)
        {
            var host = this,
                props = this._labelRotationProps,
                rot = props.rot,
                absRot = props.absRot,
                sinRadians = props.sinRadians,
                cosRadians = props.cosRadians,
                max;
            if(rot === 0)
            {
                max = labelWidth;
            }
            else if(absRot === 90)
            {
                max = labelHeight;
            }
            else
            {
                max = (cosRadians * labelWidth) + (sinRadians * labelHeight);
            }
            host._maxLabelSize = Math.max(host._maxLabelSize, max);
        },

        /**
         * Determines the available label width when the axis width has been explicitly set.
         *
         * @method getExplicitlySized
         * @return Boolean
         * @protected
         */
        getExplicitlySized: function(styles)
        {
            if(this._explicitWidth)
            {
                var host = this,
                    w = host._explicitWidth,
                    totalTitleSize = host._totalTitleSize,
                    leftTickOffset = host.get("leftTickOffset"),
                    margin = styles.label.margin.right;
                host._maxLabelSize =  w - (leftTickOffset + margin + totalTitleSize);
                return true;
            }
            return false;
        },

        /**
         * Rotate and position title.
         *
         * @method positionTitle
         * @param {HTMLElement} label to rotate position
         * @protected
         */
        positionTitle: function(label)
        {
            var host = this,
                bounds = host._titleBounds,
                margin = host.get("styles").title.margin,
                props = host._titleRotationProps,
                w = bounds.right - bounds.left,
                labelWidth = label.offsetWidth,
                labelHeight = label.offsetHeight,
                x = (labelWidth * -0.5) + (w * 0.5),
                y = (host.get("height") * 0.5) - (labelHeight * 0.5);
            props.labelWidth = labelWidth;
            props.labelHeight = labelHeight;
            if(margin && margin.left)
            {
                x += margin.left;
            }
            props.x = x;
            props.y = y;
            props.transformOrigin = [0.5, 0.5];
            host._rotate(label, props);
        },

        /**
         * Rotate and position labels.
         *
         * @method positionLabel
         * @param {HTMLElement} label to rotate position
         * @param {Object} pt hash containing the x and y coordinates in which the label will be positioned
         * against.
         * @protected
         */
        positionLabel: function(label, pt, styles, i)
        {
            var host = this,
                tickOffset = host.get("leftTickOffset"),
                totalTitleSize = this._totalTitleSize,
                leftOffset = pt.x + totalTitleSize - tickOffset,
                topOffset = pt.y,
                props = this._labelRotationProps,
                rot = props.rot,
                absRot = props.absRot,
                maxLabelSize = host._maxLabelSize,
                labelWidth = this._labelWidths[i],
                labelHeight = this._labelHeights[i];
            if(rot === 0)
            {
                leftOffset -= labelWidth;
                topOffset -= labelHeight * 0.5;
            }
            else if(rot === 90)
            {
                leftOffset -= labelWidth * 0.5;
            }
            else if(rot === -90)
            {
                leftOffset -= labelWidth * 0.5;
                topOffset -= labelHeight;
            }
            else
            {
                leftOffset -= labelWidth + (labelHeight * absRot/360);
                topOffset -= labelHeight * 0.5;
            }
            props.labelWidth = labelWidth;
            props.labelHeight = labelHeight;
            props.x = Math.round(maxLabelSize + leftOffset);
            props.y = Math.round(topOffset);
            this._rotate(label, props);
        },

        /**
         * Adjusts the coordinates of an axis label based on the rotation.
         *
         * @method _setRotationCoords
         * @param {Object} props Coordinates, dimension and rotation properties of the label.
         * @protected
         */
        _setRotationCoords: function(props)
        {
            var rot = props.rot,
                absRot = props.absRot,
                leftOffset,
                topOffset,
                labelWidth = props.labelWidth,
                labelHeight = props.labelHeight;
            if(rot === 0)
            {
                leftOffset = labelWidth;
                topOffset = labelHeight * 0.5;
            }
            else if(rot === 90)
            {
                topOffset = 0;
                leftOffset = labelWidth * 0.5;
            }
            else if(rot === -90)
            {
                leftOffset = labelWidth * 0.5;
                topOffset = labelHeight;
            }
            else
            {
                leftOffset = labelWidth + (labelHeight * absRot/360);
                topOffset = labelHeight * 0.5;
            }
            props.x -= leftOffset;
            props.y -= topOffset;
        },

        /**
         * Returns the transformOrigin to use for an axis label based on the position of the axis
         * and the rotation of the label.
         *
         * @method _getTransformOrigin
         * @param {Number} rot The rotation (in degrees) of the label.
         * @return Array
         * @protected
         */
        _getTransformOrigin: function(rot)
        {
            var transformOrigin;
            if(rot === 0)
            {
                transformOrigin = [0, 0];
            }
            else if(rot === 90)
            {
                transformOrigin = [0.5, 0];
            }
            else if(rot === -90)
            {
                transformOrigin = [0.5, 1];
            }
            else
            {
                transformOrigin = [1, 0.5];
            }
            return transformOrigin;
        },

        /**
         * Adjust the position of the Axis widget's content box for internal axes.
         *
         * @method offsetNodeForTick
         * @param {Node} cb Content box of the Axis.
         * @protected
         */
        offsetNodeForTick: function(cb)
        {
        },

        /**
         * Sets the width of the axis based on its contents.
         *
         * @method setCalculatedSize
         * @protected
         */
        setCalculatedSize: function()
        {
            var host = this,
                graphic = this.get("graphic"),
                style = host.get("styles"),
                label = style.label,
                tickOffset = host.get("leftTickOffset"),
                max = host._maxLabelSize,
                totalTitleSize = this._totalTitleSize,
                ttl = Math.round(totalTitleSize + tickOffset + max + label.margin.right);
            if(this._explicitWidth)
            {
                ttl = this._explicitWidth;
            }
            this.set("calculatedWidth", ttl);
            graphic.set("x", ttl - tickOffset);
        }
    };

    Y.LeftAxisLayout = LeftAxisLayout;