#

API Docs for:
Show: Inherited Protected Private Deprecated

# File: input/charts/RightAxisLayout.js

    /**
     * RightAxisLayout contains algorithms for rendering a right axis.
     *
     * @module charts
     * @class RightAxisLayout
     * @constructor
     */
    RightAxisLayout = function(){};

    RightAxisLayout.prototype = {
        /**
         *  Default margins for text fields.
         *
         *  @private
         *  @method _getDefaultMargins
         *  @return Object
         */
        _getDefaultMargins: function()
        {
            return {
                top: 0,
                left: 4,
                right: 0,
                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("leftTickOffset", tickLength);
                    host.set("rightTickOffset", 0);
                break;
                case "outside" :
                    host.set("leftTickOffset", 0);
                    host.set("rightTickOffset", tickLength);
                break;
                case "cross" :
                    host.set("rightTickOffset", halfTick);
                    host.set("leftTickOffset", halfTick);
                break;
                default:
                    host.set("leftTickOffset", 0);
                    host.set("rightTickOffset", 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:padding.left + tickLength, 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 host = this,
                style = host.get("styles"),
                padding = style.padding,
                majorTicks = style.majorTicks,
                tickLength = majorTicks.length,
                display = majorTicks.display,
                pt = {x:padding.left, y:padding.top};
            if(display === "inside")
            {
                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("rightTickOffset"), 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 = this._totalTitleSize,
                    rightTickOffset = host.get("rightTickOffset"),
                    margin = styles.label.margin.right;
                host._maxLabelSize =  w - (rightTickOffset + 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,
                labelWidth = label.offsetWidth,
                labelHeight = label.offsetHeight,
                w = bounds.right - bounds.left,
                x = this.get("width") - (labelWidth * 0.5) - (w * 0.5),
                y = (host.get("height") * 0.5) - (labelHeight * 0.5);
            props.labelWidth = labelWidth;
            props.labelHeight = labelHeight;
            if(margin && margin.right)
            {
                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("rightTickOffset"),
                labelStyles = styles.label,
                margin = 0,
                leftOffset = pt.x,
                topOffset = pt.y,
                props = this._labelRotationProps,
                rot = props.rot,
                absRot = props.absRot,
                labelWidth = this._labelWidths[i],
                labelHeight = this._labelHeights[i];
            if(labelStyles.margin && labelStyles.margin.left)
            {
                margin = labelStyles.margin.left;
            }
            if(rot === 0)
            {
                topOffset -= labelHeight * 0.5;
            }
            else if(rot === 90)
            {
                leftOffset -= labelWidth * 0.5;
                topOffset -= labelHeight;
            }
            else if(rot === -90)
            {
                leftOffset -= labelWidth * 0.5;
            }
            else
            {
                topOffset -= labelHeight * 0.5;
                leftOffset += labelHeight/2 * absRot/90;
            }
            leftOffset += margin;
            leftOffset += tickOffset;
            props.labelWidth = labelWidth;
            props.labelHeight = labelHeight;
            props.x = Math.round(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 = 0,
                topOffset = 0,
                labelWidth = props.labelWidth,
                labelHeight = props.labelHeight;
            if(rot === 0)
            {
                topOffset = labelHeight * 0.5;
            }
            else if(rot === 90)
            {
                leftOffset = labelWidth * 0.5;
                topOffset = labelHeight;
            }
            else if(rot === -90)
            {
                leftOffset = labelWidth * 0.5;
            }
            else
            {
                topOffset = labelHeight * 0.5;
                leftOffset = labelHeight/2 * absRot/90;
            }
            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, 1];
            }
            else if(rot === -90)
            {
                transformOrigin = [0.5, 0];
            }
            else
            {
                transformOrigin = [0, 0.5];
            }
            return transformOrigin;
        },

        /**
         * Adjusts position for inner ticks.
         *
         * @method offsetNodeForTick
         * @param {Node} cb contentBox of the axis
         * @protected
         */
        offsetNodeForTick: function(cb)
        {
            var host = this,
                tickOffset = host.get("leftTickOffset"),
                offset = 0 - tickOffset;
            cb.setStyle("left", offset);
        },

        /**
         * Assigns a height based on the size of the contents.
         *
         * @method setCalculatedSize
         * @protected
         */
        setCalculatedSize: function()
        {
            var host = this,
                styles = host.get("styles"),
                labelStyle = styles.label,
                totalTitleSize = this._totalTitleSize,
                ttl = Math.round(host.get("rightTickOffset") + host._maxLabelSize + totalTitleSize + labelStyle.margin.left);
            if(this._explicitWidth)
            {
                ttl = this._explicitWidth;
            }
            host.set("calculatedWidth", ttl);
            host.get("contentBox").setStyle("width", ttl);
        }
    };

    Y.RightAxisLayout = RightAxisLayout;