nv.models.stackedAreaChart = function() {

    //============================================================
    // Public Variables with Default Settings
    //------------------------------------------------------------

    var stacked = nv.models.stackedArea()
        , xAxis = nv.models.axis()
        , yAxis = nv.models.axis()
        , legend = nv.models.legend()
        , controls = nv.models.legend()
        ;

    var margin = {top: 0, right: 0, bottom: 20, left: 35}
        , width = null
        , height = null
        , color = nv.utils.defaultColor() // a function that takes in d, i and returns color
        , controlsColor = ["#555", "#555", "#555"]
        , showControls = true
        , showLegend = true
        , showAxes = true
        , tooltips = true
        , tooltip = function(key, x, y, e, graph) {
            return '<h4>' + key + '</h4>' +
                '<p>' +  y + ' on ' + x + '</p>'
        }
        , x //can be accessed via chart.xScale()
        , y //can be accessed via chart.yScale()
        , yAxisTickFormat = d3.format(',f')
        , state = { style: stacked.style() }
        , noData = 'No Data Available.'
        , dispatch = d3.dispatch('tooltipShow', 'tooltipHide', 'stateChange', 'changeState')
        , controlWidth = 250
        ;

    if (showAxes){
        xAxis
            .orient('bottom')
        ;
        yAxis
            .orient('left')
        ;
    }
    stacked.scatter
        .pointActive(function(d) {
            //console.log(stacked.y()(d), !!Math.round(stacked.y()(d) * 100));
            return !!Math.round(stacked.y()(d) * 100);
        })
    ;

    //============================================================


    //============================================================
    // Private Variables
    //------------------------------------------------------------

    var showTooltip = function(e, offsetElement) {
        var left = e.pos[0] + ( offsetElement.offsetLeft || 0 ),
            top = e.pos[1] + ( offsetElement.offsetTop || 0),
            x = xAxis.tickFormat()(stacked.x()(e.point, e.pointIndex)),
            y = yAxis.tickFormat()(stacked.y()(e.point, e.pointIndex)),
            content = tooltip(e.series.key, x, y, e, chart);

        nv.tooltip.show([left, top], content, e.value < 0 ? 'n' : 's', null, offsetElement);
    };

    //============================================================


    function chart(selection) {
        selection.each(function(data) {
            var container = d3.select(this),
                that = this;

            var availableWidth = (width  || parseInt(container.style('width')) || 960)
                    - margin.left - margin.right,
                availableHeight = (height || parseInt(container.style('height')) || 400)
                    - margin.top - margin.bottom;

            chart.update = function() { chart(selection) };
            chart.container = this;

            //set state.disabled
            state.disabled = data.map(function(d) { return !!d.disabled });


            //------------------------------------------------------------
            // Display No Data message if there's nothing to show.

            if (!data || !data.length || !data.filter(function(d) { return d.values.length }).length) {
                var noDataText = container.selectAll('.nv-noData').data([noData]);

                noDataText.enter().append('text')
                    .attr('class', 'nvd3 nv-noData')
                    .attr('dy', '-.7em')
                    .style('text-anchor', 'middle');

                noDataText
                    .attr('x', margin.left + availableWidth / 2)
                    .attr('y', margin.top + availableHeight / 2)
                    .text(function(d) { return d });

                return chart;
            } else {
                container.selectAll('.nv-noData').remove();
            }

            //------------------------------------------------------------


            //------------------------------------------------------------
            // Setup Scales

            x = stacked.xScale();
            y = stacked.yScale();

            //------------------------------------------------------------


            //------------------------------------------------------------
            // Setup containers and skeleton of chart

            var wrap = container.selectAll('g.nv-wrap.nv-stackedAreaChart').data([data]);
            var gEnter = wrap.enter().append('g').attr('class', 'nvd3 nv-wrap nv-stackedAreaChart').append('g');
            var g = wrap.select('g');

            if (showAxes){
                gEnter.append('g').attr('class', 'nv-x nv-axis');
                gEnter.append('g').attr('class', 'nv-y nv-axis');
            }
            gEnter.append('g').attr('class', 'nv-stackedWrap');
            if (showLegend){
                gEnter.append('g').attr('class', 'nv-legendWrap');
            }
            if (showControls){
                gEnter.append('g').attr('class', 'nv-controlsWrap');
            }

            //------------------------------------------------------------


            //------------------------------------------------------------
            // Legend

            if (showLegend) {
                legend
                    .width( availableWidth - controlWidth );

                g.select('.nv-legendWrap')
                    .datum(data)
                    .call(legend);

                if ( margin.top != legend.height()) {
                    margin.top = legend.height();
                    availableHeight = (height || parseInt(container.style('height')) || 400)
                        - margin.top - margin.bottom;
                }

                g.select('.nv-legendWrap')
                    .attr('transform', 'translate(' + controlWidth + ',' + (-margin.top) +')');
            }

            //------------------------------------------------------------


            //------------------------------------------------------------
            // Controls

            if (showControls) {
                var controlsData = [
                    { key: 'Stacked', disabled: stacked.offset() != 'zero' },
                    { key: 'Stream', disabled: stacked.offset() != 'wiggle' },
                    { key: 'Expanded', disabled: stacked.offset() != 'expand' }
                ];

                controls
                    .width( controlWidth )
                    .color(chart.controlsColor());

                g.select('.nv-controlsWrap')
                    .datum(controlsData)
                    .call(controls);


                if ( margin.top != Math.max(controls.height(), legend.height()) ) {
                    margin.top = Math.max(controls.height(), legend.height());
                    availableHeight = (height || parseInt(container.style('height')) || 400)
                        - margin.top - margin.bottom;
                }


                g.select('.nv-controlsWrap')
                    .attr('transform', 'translate(0,' + (-margin.top) +')');
            }

            //------------------------------------------------------------


            wrap.attr('transform', 'translate(' + margin.left + ',' + margin.top + ')');


            //------------------------------------------------------------
            // Main Chart Component(s)

            stacked
                .width(availableWidth)
                .height(availableHeight)

            var stackedWrap = g.select('.nv-stackedWrap')
                .datum(data);
            //d3.transition(stackedWrap).call(stacked);
            stackedWrap.call(stacked);

            //------------------------------------------------------------


            //------------------------------------------------------------
            // Setup Axes
            if (showAxes){
                xAxis
                    .scale(x);

                g.select('.nv-x.nv-axis')
                    .attr('transform', 'translate(0,' + availableHeight + ')');
                //d3.transition(g.select('.nv-x.nv-axis'))
                g.select('.nv-x.nv-axis')
                    .transition()
                    .call(xAxis);

                yAxis
                    .scale(y)
                    .ticks(stacked.offset() == 'wiggle' ? 0 : availableHeight / 50)
                    .tickSize(-availableWidth, 0)
                    .setTickFormat(stacked.offset() == 'expand' ? d3.format('%') : yAxisTickFormat);

                //d3.transition(g.select('.nv-y.nv-axis'))
                g.select('.nv-y.nv-axis')
                    .transition()
                    .call(yAxis);
            }
            //------------------------------------------------------------


            //============================================================
            // Event Handling/Dispatching (in chart's scope)
            //------------------------------------------------------------

            stacked.dispatch.on('areaClick.toggle', function(e) {
                if (data.filter(function(d) { return !d.disabled }).length === 1)
                    data = data.map(function(d) {
                        d.disabled = false;
                        return d
                    });
                else
                    data = data.map(function(d,i) {
                        d.disabled = (i != e.seriesIndex);
                        return d
                    });

                state.disabled = data.map(function(d) { return !!d.disabled });
                dispatch.stateChange(state);

                //selection.transition().call(chart);
                chart(selection);
            });

            legend.dispatch.on('legendClick', function(d,i) {
                d.disabled = !d.disabled;

                if (!data.filter(function(d) { return !d.disabled }).length) {
                    data.map(function(d) {
                        d.disabled = false;
                        return d;
                    });
                }

                state.disabled = data.map(function(d) { return !!d.disabled });
                dispatch.stateChange(state);

                //selection.transition().call(chart);
                chart(selection);
            });

            controls.dispatch.on('legendClick', function(d,i) {
                if (!d.disabled) return;

                controlsData = controlsData.map(function(s) {
                    s.disabled = true;
                    return s;
                });
                d.disabled = false;

                switch (d.key) {
                    case 'Stacked':
                        stacked.style('stack');
                        break;
                    case 'Stream':
                        stacked.style('stream');
                        break;
                    case 'Expanded':
                        stacked.style('expand');
                        break;
                }

                state.style = stacked.style();
                dispatch.stateChange(state);

                //selection.transition().call(chart);
                chart(selection);
            });

            dispatch.on('tooltipShow', function(e) {
                if (tooltips) showTooltip(e, that.parentNode);
            });

            // Update chart from a state object passed to event handler
            dispatch.on('changeState', function(e) {

                if (typeof e.disabled !== 'undefined') {
                    data.forEach(function(series,i) {
                        series.disabled = e.disabled[i];
                    });

                    state.disabled = e.disabled;
                }

                if (typeof e.style !== 'undefined') {
                    stacked.style(e.style);
                }

                selection.call(chart);
            });

        });


        return chart;
    }


    //============================================================
    // Event Handling/Dispatching (out of chart's scope)
    //------------------------------------------------------------

    stacked.dispatch.on('tooltipShow', function(e) {
        //disable tooltips when value ~= 0
        //// TODO: consider removing points from voronoi that have 0 value instead of this hack
        /*
         if (!Math.round(stacked.y()(e.point) * 100)) {  // 100 will not be good for very small numbers... will have to think about making this valu dynamic, based on data range
         setTimeout(function() { d3.selectAll('.point.hover').classed('hover', false) }, 0);
         return false;
         }
         */

        e.pos = [e.pos[0] + margin.left, e.pos[1] + margin.top],
            dispatch.tooltipShow(e);
    });

    stacked.dispatch.on('tooltipHide', function(e) {
        dispatch.tooltipHide(e);
    });

    dispatch.on('tooltipHide', function() {
        if (tooltips) nv.tooltip.cleanup();
    });

    //============================================================


    //============================================================
    // Expose Public Variables
    //------------------------------------------------------------

    // expose chart's sub-components
    chart.dispatch = dispatch;
    chart.stacked = stacked;
    chart.legend = legend;
    chart.controls = controls;
    chart.xAxis = xAxis;
    chart.yAxis = yAxis;

    d3.rebind(chart, stacked, 'x', 'y', 'size', 'xScale', 'yScale', 'xDomain', 'yDomain', 'sizeDomain', 'interactive', 'offset', 'order', 'style', 'clipEdge', 'forceX', 'forceY', 'forceSize', 'interpolate');

    chart.margin = function(_) {
        if (!arguments.length) return margin;
        margin.top    = typeof _.top    != 'undefined' ? _.top    : margin.top;
        margin.right  = typeof _.right  != 'undefined' ? _.right  : margin.right;
        margin.bottom = typeof _.bottom != 'undefined' ? _.bottom : margin.bottom;
        margin.left   = typeof _.left   != 'undefined' ? _.left   : margin.left;
        return chart;
    };

    chart.width = function(_) {
        if (!arguments.length) return getWidth;
        width = _;
        return chart;
    };

    chart.height = function(_) {
        if (!arguments.length) return getHeight;
        height = _;
        return chart;
    };

    chart.color = function(_) {
        if (!arguments.length) return color;
        color = nv.utils.getColor(_);
        legend.color(color);
        stacked.color(color);
        return chart;
    };

    chart.showControls = function(_) {
        if (!arguments.length) return showControls;
        showControls = _;
        return chart;
    };

    chart.showLegend = function(_) {
        if (!arguments.length) return showLegend;
        showLegend = _;
        return chart;
    };

    chart.tooltip = function(_) {
        if (!arguments.length) return tooltip;
        tooltip = _;
        return chart;
    };

    chart.tooltips = function(_) {
        if (!arguments.length) return tooltips;
        tooltips = _;
        return chart;
    };

    chart.tooltipContent = function(_) {
        if (!arguments.length) return tooltip;
        tooltip = _;
        return chart;
    };

    chart.state = function(_) {
        if (!arguments.length) return state;
        state = _;
        return chart;
    };

    chart.noData = function(_) {
        if (!arguments.length) return noData;
        noData = _;
        return chart;
    };

    chart.showAxes = function(_) {
        if (!arguments.length) return showAxes;
        showAxes = _;
        if (!showAxes){
            //reset, cause no need for space for axes
            chart.margin({left: 0, right: 0, top: 0, bottom: 0})
        }
        return chart;
    };

    chart.controlsColor = function(_) {
        if (!arguments.length) return controlsColor;
        controlsColor = _;
        return chart;
    };

    yAxis.setTickFormat = yAxis.tickFormat;
    yAxis.tickFormat = function(_) {
        if (!arguments.length) return yAxisTickFormat;
        yAxisTickFormat = _;
        return yAxis;
    };

    //============================================================

    return chart;
}