pyk 0.2.1 → 0.2.2

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    Njk2OTBkYTkzMjA3MTUwYmQ4NjUwYjE1OTU2YmY2Y2UyNjkxMTU5NA==
+    MDM1ODViMDUyODQ2MzQ1N2I3NTEwNGViYWRmNzE4ZGYxMjAwNTA2Ng==
   data.tar.gz: !binary |-
-    ZDA5ZGYxODIzYjhiNGEwZjQ2ZjhlYjY5NTcyZmY2ZjA5MDVhZjhkOQ==
+    MjFlYzM2NDUzYWNkZDk3ZmExOTA2NDgyZjE5Yzc3ZDk3MDI3Y2UwZQ==
 !binary "U0hBNTEy":
   metadata.gz: !binary |-
-    MzgxODZjZWU5YTk3ZjRlNzQxZjM2OGQxNzc3ZGViYjEzN2QyNzQ3YmZhOWM3
-    ZDY2NWQ5ZTU2NTAwNDljYTJlOWRjOTdmMGRmNjg3MWRjYWQ2ZThmZmMwZTA5
-    MTFlMWZkZjRlYzUzMGY5OGVlZDVlM2E1NzQ5YTFjMmEzNGU4NDk=
+    Y2YzYWViYTcxZjJjMDZkMDg3NGE2NDNlYzdjYzJlMTM0YzQ2YzZlZjdhYTEx
+    NmJhYWZkMjQ5ZjMyZWNlMWNkNGZmNGU3MTA4OWJkNDc0N2VmYzE4ZDNmNWM1
+    ZmNlZjg4MjU3NWZmM2Q4ZjEyZTlmZDU2NTkxMTI4MTI5M2JhOTg=
   data.tar.gz: !binary |-
-    NDBlYzg0MmY5YzA2ZjczYzNlNzUxYTBkNTVlY2EzM2RhMDBjN2U4YTFhZmQw
-    ZWUzZGQwZGQ3ZmE4NDM0NzlhYzcyMDY0YzllMTk2MWQ5MDhjZGEwNmY1OWY1
-    ZmFlZGYzZmI4NzJhNTc2ZDNjNTRiMzhkZmM0ZjUzYjVhZTNjOGE=
+    YmZlZTBkMmQ2OWQ3ZDVmODAwNTUyNmE4NWM4OWY5ZjhmM2M3OTliNjM1Zjc5
+    N2ViYmIzYmI3ZjU5NDNhYzAxZDFlYjI3NzA1M2Y2OTAyN2VjZTBjMTQ3Nzgy
+    OWI2MDcwZWM4YWY3ZWQyMzFkOTcyN2ZiZDAzNmQ4NDBlOTNiNjk=

data/app/assets/javascripts/vendor/crossfilter.js

@@ -0,0 +1 @@
+!function(r){function n(r){return r}function t(r,n){for(var t=0,e=n.length,u=Array(e);e>t;++t)u[t]=r[n[t]];return u}function e(r){function n(n,t,e,u){for(;u>e;){var f=e+u>>>1;r(n[f])<t?e=f+1:u=f}return e}function t(n,t,e,u){for(;u>e;){var f=e+u>>>1;t<r(n[f])?u=f:e=f+1}return e}return t.right=t,t.left=n,t}function u(r){function n(r,n,t){for(var u=t-n,f=(u>>>1)+1;--f>0;)e(r,f,u,n);return r}function t(r,n,t){for(var u,f=t-n;--f>0;)u=r[n],r[n]=r[n+f],r[n+f]=u,e(r,1,f,n);return r}function e(n,t,e,u){for(var f,o=n[--u+t],i=r(o);(f=t<<1)<=e&&(e>f&&r(n[u+f])>r(n[u+f+1])&&f++,!(i<=r(n[u+f])));)n[u+t]=n[u+f],t=f;n[u+t]=o}return n.sort=t,n}function f(r){function n(n,e,u,f){var o,i,a,c,l=Array(f=Math.min(u-e,f));for(i=0;f>i;++i)l[i]=n[e++];if(t(l,0,f),u>e){o=r(l[0]);do(a=r(c=n[e])>o)&&(l[0]=c,o=r(t(l,0,f)[0]));while(++e<u)}return l}var t=u(r);return n}function o(r){function n(n,t,e){for(var u=t+1;e>u;++u){for(var f=u,o=n[u],i=r(o);f>t&&r(n[f-1])>i;--f)n[f]=n[f-1];n[f]=o}return n}return n}function i(r){function n(r,n,u){return(U>u-n?e:t)(r,n,u)}function t(t,e,u){var f,o=0|(u-e)/6,i=e+o,a=u-1-o,c=e+u-1>>1,l=c-o,v=c+o,s=t[i],h=r(s),p=t[l],d=r(p),g=t[c],y=r(g),m=t[v],b=r(m),x=t[a],A=r(x);h>d&&(f=s,s=p,p=f,f=h,h=d,d=f),b>A&&(f=m,m=x,x=f,f=b,b=A,A=f),h>y&&(f=s,s=g,g=f,f=h,h=y,y=f),d>y&&(f=p,p=g,g=f,f=d,d=y,y=f),h>b&&(f=s,s=m,m=f,f=h,h=b,b=f),y>b&&(f=g,g=m,m=f,f=y,y=b,b=f),d>A&&(f=p,p=x,x=f,f=d,d=A,A=f),d>y&&(f=p,p=g,g=f,f=d,d=y,y=f),b>A&&(f=m,m=x,x=f,f=b,b=A,A=f);var k=p,O=d,E=m,w=b;t[i]=s,t[l]=t[e],t[c]=g,t[v]=t[u-1],t[a]=x;var M=e+1,U=u-2,z=w>=O&&O>=w;if(z)for(var N=M;U>=N;++N){var C=t[N],S=r(C);if(O>S)N!==M&&(t[N]=t[M],t[M]=C),++M;else if(S>O)for(;;){var q=r(t[U]);{if(!(q>O)){if(O>q){t[N]=t[M],t[M++]=t[U],t[U--]=C;break}t[N]=t[U],t[U--]=C;break}U--}}}else for(var N=M;U>=N;N++){var C=t[N],S=r(C);if(O>S)N!==M&&(t[N]=t[M],t[M]=C),++M;else if(S>w)for(;;){var q=r(t[U]);{if(!(q>w)){O>q?(t[N]=t[M],t[M++]=t[U],t[U--]=C):(t[N]=t[U],t[U--]=C);break}if(U--,N>U)break}}}if(t[e]=t[M-1],t[M-1]=k,t[u-1]=t[U+1],t[U+1]=E,n(t,e,M-1),n(t,U+2,u),z)return t;if(i>M&&U>a){for(var F,q;(F=r(t[M]))<=O&&F>=O;)++M;for(;(q=r(t[U]))<=w&&q>=w;)--U;for(var N=M;U>=N;N++){var C=t[N],S=r(C);if(O>=S&&S>=O)N!==M&&(t[N]=t[M],t[M]=C),M++;else if(w>=S&&S>=w)for(;;){var q=r(t[U]);{if(!(w>=q&&q>=w)){O>q?(t[N]=t[M],t[M++]=t[U],t[U--]=C):(t[N]=t[U],t[U--]=C);break}if(U--,N>U)break}}}}return n(t,M,U+1)}var e=o(r);return n}function a(r){return Array(r)}function c(r,n){return function(t){var e=t.length;return[r.left(t,n,0,e),r.right(t,n,0,e)]}}function l(r,n){var t=n[0],e=n[1];return function(n){var u=n.length;return[r.left(n,t,0,u),r.left(n,e,0,u)]}}function v(r){return[0,r.length]}function s(){return null}function h(){return 0}function p(r){return r+1}function d(r){return r-1}function g(r){return function(n,t){return n+ +r(t)}}function y(r){return function(n,t){return n-r(t)}}function m(){function r(r){var n=w,t=r.length;return t&&(E=E.concat(r),N=S(N,w+=t),F.forEach(function(e){e(r,n,t)})),O}function e(){for(var r=b(w,w),n=[],t=0,e=0;w>t;++t)N[t]?r[t]=e++:n.push(t);C.forEach(function(r){r(0,[],n)}),R.forEach(function(n){n(r)});for(var u,t=0,e=0;w>t;++t)(u=N[t])&&(t!==e&&(N[e]=u,E[e]=E[t]),++e);for(E.length=e;w>e;)N[--w]=0}function o(r){function e(n,e,u){T=n.map(r),V=$(x(u),0,u),T=t(T,V);var f,o=_(T),i=o[0],a=o[1];if(W)for(f=0;u>f;++f)W(T[f],f)||(N[V[f]+e]|=Y);else{for(f=0;i>f;++f)N[V[f]+e]|=Y;for(f=a;u>f;++f)N[V[f]+e]|=Y}if(!e)return P=T,Q=V,tn=i,en=a,void 0;var c=P,l=Q,v=0,s=0;for(P=Array(w),Q=b(w,w),f=0;e>v&&u>s;++f)c[v]<T[s]?(P[f]=c[v],Q[f]=l[v++]):(P[f]=T[s],Q[f]=V[s++]+e);for(;e>v;++v,++f)P[f]=c[v],Q[f]=l[v];for(;u>s;++s,++f)P[f]=T[s],Q[f]=V[s]+e;o=_(P),tn=o[0],en=o[1]}function o(r,n,t){rn.forEach(function(r){r(T,V,n,t)}),T=V=null}function a(r){for(var n,t=0,e=0;w>t;++t)N[n=Q[t]]&&(t!==e&&(P[e]=P[t]),Q[e]=r[n],++e);for(P.length=e;w>e;)Q[e++]=0;var u=_(P);tn=u[0],en=u[1]}function m(r){var n=r[0],t=r[1];if(W)return W=null,G(function(r,e){return e>=n&&t>e}),tn=n,en=t,X;var e,u,f,o=[],i=[];if(tn>n)for(e=n,u=Math.min(tn,t);u>e;++e)N[f=Q[e]]^=Y,o.push(f);else if(n>tn)for(e=tn,u=Math.min(n,en);u>e;++e)N[f=Q[e]]^=Y,i.push(f);if(t>en)for(e=Math.max(n,en),u=t;u>e;++e)N[f=Q[e]]^=Y,o.push(f);else if(en>t)for(e=Math.max(tn,t),u=en;u>e;++e)N[f=Q[e]]^=Y,i.push(f);return tn=n,en=t,C.forEach(function(r){r(Y,o,i)}),X}function O(r){return null==r?B():Array.isArray(r)?j(r):"function"==typeof r?D(r):z(r)}function z(r){return m((_=c(k,r))(P))}function j(r){return m((_=l(k,r))(P))}function B(){return m((_=v)(P))}function D(r){return _=v,G(W=r),tn=0,en=w,X}function G(r){var n,t,e,u=[],f=[];for(n=0;w>n;++n)!(N[t=Q[n]]&Y)^(e=r(P[n],n))&&(e?(N[t]&=Z,u.push(t)):(N[t]|=Y,f.push(t)));C.forEach(function(r){r(Y,u,f)})}function H(r){for(var n,t=[],e=en;--e>=tn&&r>0;)N[n=Q[e]]||(t.push(E[n]),--r);return t}function I(r){for(var n,t=[],e=tn;en>e&&r>0;)N[n=Q[e]]||(t.push(E[n]),--r),e++;return t}function J(r){function t(n,t,e,u){function f(){++T===L&&(m=q(m,K<<=1),B=q(B,K),L=A(K))}var l,v,h,p,d,g,y=j,m=b(T,L),x=H,k=J,O=T,M=0,U=0;for(X&&(x=k=s),j=Array(T),T=0,B=O>1?S(B,w):b(w,L),O&&(h=(v=y[0]).key);u>U&&!((p=r(n[U]))>=p);)++U;for(;u>U;){for(v&&p>=h?(d=v,g=h,m[M]=T,(v=y[++M])&&(h=v.key)):(d={key:p,value:k()},g=p),j[T]=d;!(p>g||(B[l=t[U]+e]=T,N[l]&Z||(d.value=x(d.value,E[l])),++U>=u));)p=r(n[U]);f()}for(;O>M;)j[m[M]=T]=y[M++],f();if(T>M)for(M=0;e>M;++M)B[M]=m[B[M]];l=C.indexOf(V),T>1?(V=o,W=a):(1===T?(V=i,W=c):(V=s,W=s),B=null),C[l]=V}function e(){if(T>1){for(var r=T,n=j,t=b(r,r),e=0,u=0;w>e;++e)N[e]&&(t[B[u]=B[e]]=1,++u);for(j=[],T=0,e=0;r>e;++e)t[e]&&(t[e]=T++,j.push(n[e]));if(T>1)for(var e=0;u>e;++e)B[e]=t[B[e]];else B=null;C[C.indexOf(V)]=T>1?(W=a,V=o):1===T?(W=c,V=i):W=V=s}else if(1===T){for(var e=0;w>e;++e)if(N[e])return;j=[],T=0,C[C.indexOf(V)]=V=W=s}}function o(r,n,t){if(r!==Y&&!X){var e,u,f,o;for(e=0,f=n.length;f>e;++e)N[u=n[e]]&Z||(o=j[B[u]],o.value=H(o.value,E[u]));for(e=0,f=t.length;f>e;++e)(N[u=t[e]]&Z)===r&&(o=j[B[u]],o.value=I(o.value,E[u]))}}function i(r,n,t){if(r!==Y&&!X){var e,u,f,o=j[0];for(e=0,f=n.length;f>e;++e)N[u=n[e]]&Z||(o.value=H(o.value,E[u]));for(e=0,f=t.length;f>e;++e)(N[u=t[e]]&Z)===r&&(o.value=I(o.value,E[u]))}}function a(){var r,n;for(r=0;T>r;++r)j[r].value=J();for(r=0;w>r;++r)N[r]&Z||(n=j[B[r]],n.value=H(n.value,E[r]))}function c(){var r,n=j[0];for(n.value=J(),r=0;w>r;++r)N[r]&Z||(n.value=H(n.value,E[r]))}function l(){return X&&(W(),X=!1),j}function v(r){var n=D(l(),0,j.length,r);return G.sort(n,0,n.length)}function m(r,n,t){return H=r,I=n,J=t,X=!0,F}function x(){return m(p,d,h)}function k(r){return m(g(r),y(r),h)}function O(r){function n(n){return r(n.value)}return D=f(n),G=u(n),F}function M(){return O(n)}function U(){return T}function z(){var r=C.indexOf(V);return r>=0&&C.splice(r,1),r=rn.indexOf(t),r>=0&&rn.splice(r,1),r=R.indexOf(e),r>=0&&R.splice(r,1),F}var F={top:v,all:l,reduce:m,reduceCount:x,reduceSum:k,order:O,orderNatural:M,size:U,dispose:z,remove:z};nn.push(F);var j,B,D,G,H,I,J,K=8,L=A(K),T=0,V=s,W=s,X=!0;return arguments.length<1&&(r=n),C.push(V),rn.push(t),R.push(e),t(P,Q,0,w),x().orderNatural()}function K(){var r=J(s),n=r.all;return delete r.all,delete r.top,delete r.order,delete r.orderNatural,delete r.size,r.value=function(){return n()[0].value},r}function L(){nn.forEach(function(r){r.dispose()});var r=F.indexOf(e);for(r>=0&&F.splice(r,1),r=F.indexOf(o),r>=0&&F.splice(r,1),r=R.indexOf(a),r>=0&&R.splice(r,1),r=0;w>r;++r)N[r]&=Z;return M&=Z,X}var P,Q,T,V,W,X={filter:O,filterExact:z,filterRange:j,filterFunction:D,filterAll:B,top:H,bottom:I,group:J,groupAll:K,dispose:L,remove:L},Y=~M&-~M,Z=~Y,$=i(function(r){return T[r]}),_=v,rn=[],nn=[],tn=0,en=0;return F.unshift(e),F.push(o),R.push(a),M|=Y,(U>=32?!Y:M&(1<<U)-1)&&(N=q(N,U<<=1)),e(E,0,w),o(E,0,w),X}function a(){function r(r,n){var t;if(!m)for(t=n;w>t;++t)N[t]||(a=c(a,E[t]))}function n(r,n,t){var e,u,f;if(!m){for(e=0,f=n.length;f>e;++e)N[u=n[e]]||(a=c(a,E[u]));for(e=0,f=t.length;f>e;++e)N[u=t[e]]===r&&(a=l(a,E[u]))}}function t(){var r;for(a=v(),r=0;w>r;++r)N[r]||(a=c(a,E[r]))}function e(r,n,t){return c=r,l=n,v=t,m=!0,s}function u(){return e(p,d,h)}function f(r){return e(g(r),y(r),h)}function o(){return m&&(t(),m=!1),a}function i(){var t=C.indexOf(n);return t>=0&&C.splice(t),t=F.indexOf(r),t>=0&&F.splice(t),s}var a,c,l,v,s={reduce:e,reduceCount:u,reduceSum:f,value:o,dispose:i,remove:i},m=!0;return C.push(n),F.push(r),r(E,0,w),u()}function m(){return w}var O={add:r,remove:e,dimension:o,groupAll:a,size:m},E=[],w=0,M=0,U=8,N=z(0),C=[],F=[],R=[];return arguments.length?r(arguments[0]):O}function b(r,n){return(257>n?z:65537>n?N:C)(r)}function x(r){for(var n=b(r,r),t=-1;++t<r;)n[t]=t;return n}function A(r){return 8===r?256:16===r?65536:4294967296}m.version="1.3.5",m.permute=t;var k=m.bisect=e(n);k.by=e;var O=m.heap=u(n);O.by=u;var E=m.heapselect=f(n);E.by=f;var w=m.insertionsort=o(n);w.by=o;var M=m.quicksort=i(n);M.by=i;var U=32,z=a,N=a,C=a,S=n,q=n;"undefined"!=typeof Uint8Array&&(z=function(r){return new Uint8Array(r)},N=function(r){return new Uint16Array(r)},C=function(r){return new Uint32Array(r)},S=function(r,n){if(r.length>=n)return r;var t=new r.constructor(n);return t.set(r),t},q=function(r,n){var t;switch(n){case 16:t=N(r.length);break;case 32:t=C(r.length);break;default:throw Error("invalid array width!")}return t.set(r),t}),r.crossfilter=m}(this);

data/app/assets/javascripts/vendor/dc.js

@@ -0,0 +1,4078 @@
+/*!
+ *  dc 1.6.0-dev
+ *  http://nickqizhu.github.io/dc.js/
+ *  Copyright 2012 Nick Zhu and other contributors
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+
+dc = (function(){
+'use strict';
+
+var dc = {
+    version: "1.6.0-dev",
+    constants: {
+        CHART_CLASS: "dc-chart",
+        DEBUG_GROUP_CLASS: "debug",
+        STACK_CLASS: "stack",
+        DESELECTED_CLASS: "deselected",
+        SELECTED_CLASS: "selected",
+        NODE_INDEX_NAME: "__index__",
+        GROUP_INDEX_NAME: "__group_index__",
+        DEFAULT_CHART_GROUP: "__default_chart_group__",
+        EVENT_DELAY: 40,
+        NEGLIGIBLE_NUMBER: 1e-10
+    },
+    _renderlet: null
+};
+
+dc.chartRegistry = function() {
+    // chartGroup:string => charts:array
+    var _chartMap = {};
+
+    function initializeChartGroup(group) {
+        if (!group)
+            group = dc.constants.DEFAULT_CHART_GROUP;
+
+        if (!_chartMap[group])
+            _chartMap[group] = [];
+
+        return group;
+    }
+
+    return {
+        has: function(chart) {
+            for (var e in _chartMap) {
+                if (_chartMap[e].indexOf(chart) >= 0)
+                    return true;
+            }
+            return false;
+        },
+
+        register: function(chart, group) {
+            group = initializeChartGroup(group);
+            _chartMap[group].push(chart);
+        },
+
+        clear: function() {
+            _chartMap = {};
+        },
+
+        list: function(group) {
+            group = initializeChartGroup(group);
+            return _chartMap[group];
+        }
+    };
+}();
+
+dc.registerChart = function(chart, group) {
+    dc.chartRegistry.register(chart, group);
+};
+
+dc.hasChart = function(chart) {
+    return dc.chartRegistry.has(chart);
+};
+
+dc.deregisterAllCharts = function() {
+    dc.chartRegistry.clear();
+};
+
+dc.filterAll = function(group) {
+    var charts = dc.chartRegistry.list(group);
+    for (var i = 0; i < charts.length; ++i) {
+        charts[i].filterAll();
+    }
+};
+
+dc.renderAll = function(group) {
+    var charts = dc.chartRegistry.list(group);
+    for (var i = 0; i < charts.length; ++i) {
+        charts[i].render();
+    }
+
+    if(dc._renderlet !== null)
+        dc._renderlet(group);
+};
+
+dc.redrawAll = function(group) {
+    var charts = dc.chartRegistry.list(group);
+    for (var i = 0; i < charts.length; ++i) {
+        charts[i].redraw();
+    }
+
+    if(dc._renderlet !== null)
+        dc._renderlet(group);
+};
+
+dc.transition = function(selections, duration, callback) {
+    if (duration <= 0 || duration === undefined)
+        return selections;
+
+    var s = selections
+        .transition()
+        .duration(duration);
+
+    if (callback instanceof Function) {
+        callback(s);
+    }
+
+    return s;
+};
+
+dc.units = {};
+dc.units.integers = function(s, e) {
+    return Math.abs(e - s);
+};
+
+dc.units.ordinal = function(s, e, domain){
+    return domain;
+};
+dc.units.fp = {};
+dc.units.fp.precision = function(precision){
+    var _f = function(s, e){return Math.ceil(Math.abs((e-s)/_f.resolution));};
+    _f.resolution = precision;
+    return _f;
+};
+
+dc.round = {};
+dc.round.floor = function(n) {
+    return Math.floor(n);
+};
+dc.round.ceil = function(n) {
+    return Math.ceil(n);
+};
+dc.round.round = function(n) {
+    return Math.round(n);
+};
+
+dc.override = function(obj, functionName, newFunction) {
+    var existingFunction = obj[functionName];
+    obj["_" + functionName] = existingFunction;
+    obj[functionName] = newFunction;
+};
+
+dc.renderlet = function(_){
+    if(!arguments.length) return dc._renderlet;
+    dc._renderlet = _;
+    return dc;
+};
+
+dc.instanceOfChart = function (o) {
+    return o instanceof Object && o.__dc_flag__;
+};
+
+dc.errors = {};
+
+dc.errors.Exception = function(msg) {
+    var _msg = msg !== undefined ? msg : "Unexpected internal error";
+
+    this.message = _msg;
+
+    this.toString = function(){
+        return _msg;
+    };
+};
+
+dc.errors.InvalidStateException = function() {
+    dc.errors.Exception.apply(this, arguments);
+};
+
+dc.dateFormat = d3.time.format("%m/%d/%Y");
+
+dc.printers = {};
+
+dc.printers.filters = function (filters) {
+    var s = "";
+
+    for (var i = 0; i < filters.length; ++i) {
+        if (i > 0) s += ", ";
+        s += dc.printers.filter(filters[i]);
+    }
+
+    return s;
+};
+
+dc.printers.filter = function (filter) {
+    var s = "";
+
+    if (filter) {
+        if (filter instanceof Array) {
+            if (filter.length >= 2)
+                s = "[" + dc.utils.printSingleValue(filter[0]) + " -> " + dc.utils.printSingleValue(filter[1]) + "]";
+            else if (filter.length >= 1)
+                s = dc.utils.printSingleValue(filter[0]);
+        } else {
+            s = dc.utils.printSingleValue(filter);
+        }
+    }
+
+    return s;
+};
+
+dc.utils = {};
+
+dc.utils.printSingleValue = function (filter) {
+    var s = "" + filter;
+
+    if (filter instanceof Date)
+        s = dc.dateFormat(filter);
+    else if (typeof(filter) == "string")
+        s = filter;
+    else if (dc.utils.isFloat(filter))
+        s = dc.utils.printSingleValue.fformat(filter);
+    else if (dc.utils.isInteger(filter))
+        s = Math.round(filter);
+
+    return s;
+};
+dc.utils.printSingleValue.fformat = d3.format(".2f");
+
+dc.utils.add = function (l, r) {
+    if (typeof r === "string")
+        r = r.replace("%", "");
+
+    if (l instanceof Date) {
+        if (typeof r === "string") r = +r;
+        var d = new Date();
+        d.setTime(l.getTime());
+        d.setDate(l.getDate() + r);
+        return d;
+    } else if (typeof r === "string") {
+        var percentage = (+r / 100);
+        return l > 0 ? l * (1 + percentage) : l * (1 - percentage);
+    } else {
+        return l + r;
+    }
+};
+
+dc.utils.subtract = function (l, r) {
+    if (typeof r === "string")
+        r = r.replace("%", "");
+
+    if (l instanceof Date) {
+        if (typeof r === "string") r = +r;
+        var d = new Date();
+        d.setTime(l.getTime());
+        d.setDate(l.getDate() - r);
+        return d;
+    } else if (typeof r === "string") {
+        var percentage = (+r / 100);
+        return l < 0 ? l * (1 + percentage) : l * (1 - percentage);
+    } else {
+        return l - r;
+    }
+};
+
+dc.utils.GroupStack = function () {
+    var _dataLayers = [[ ]];
+    var _groups = [];
+    var _defaultAccessor;
+
+    function initializeDataLayer(i) {
+        if (!_dataLayers[i])
+            _dataLayers[i] = [];
+    }
+
+    this.setDataPoint = function (layerIndex, pointIndex, data) {
+        initializeDataLayer(layerIndex);
+        _dataLayers[layerIndex][pointIndex] = data;
+    };
+
+    this.getDataPoint = function (x, y) {
+        initializeDataLayer(x);
+        var dataPoint = _dataLayers[x][y];
+        if (dataPoint === undefined)
+            dataPoint = 0;
+        return dataPoint;
+    };
+
+    this.addGroup = function (group, accessor) {
+        if (!accessor)
+            accessor = _defaultAccessor;
+        _groups.push([group, accessor]);
+        return _groups.length - 1;
+    };
+
+    this.getGroupByIndex = function (index) {
+        return _groups[index][0];
+    };
+
+    this.getAccessorByIndex = function (index) {
+        return _groups[index][1];
+    };
+
+    this.size = function () {
+        return _groups.length;
+    };
+
+    this.clear = function () {
+        _dataLayers = [];
+        _groups = [];
+    };
+
+    this.setDefaultAccessor = function (retriever) {
+        _defaultAccessor = retriever;
+    };
+
+    this.getDataLayers = function () {
+        return _dataLayers;
+    };
+
+    this.toLayers = function () {
+        var layers = [];
+
+        for (var i = 0; i < _dataLayers.length; ++i) {
+            var layer = {index: i, points: []};
+            var dataPoints = _dataLayers[i];
+
+            for (var j = 0; j < dataPoints.length; ++j)
+                layer.points.push(dataPoints[j]);
+
+            layers.push(layer);
+        }
+
+        return layers;
+    };
+};
+
+dc.utils.isNumber = function(n) {
+    return n===+n;
+};
+
+dc.utils.isFloat = function (n) {
+    return n===+n && n!==(n|0);
+};
+
+dc.utils.isInteger = function (n) {
+    return n===+n && n===(n|0);
+};
+
+dc.utils.isNegligible = function (max) {
+    return max === undefined || (max < dc.constants.NEGLIGIBLE_NUMBER && max > -dc.constants.NEGLIGIBLE_NUMBER);
+};
+
+dc.utils.groupMax = function (group, accessor) {
+    var max = d3.max(group.all(), function (e) {
+        return accessor(e);
+    });
+    if (dc.utils.isNegligible(max)) max = 0;
+    return max;
+};
+
+dc.utils.groupMin = function (group, accessor) {
+    var min = d3.min(group.all(), function (e) {
+        return accessor(e);
+    });
+    if (dc.utils.isNegligible(min)) min = 0;
+    return min;
+};
+
+dc.utils.nameToId = function (name) {
+    return name.toLowerCase().replace(/[\s]/g, "_").replace(/[\.']/g, "");
+};
+
+dc.utils.appendOrSelect = function (parent, name) {
+    var element = parent.select(name);
+    if (element.empty()) element = parent.append(name);
+    return element;
+};
+
+dc.utils.createLegendable = function (chart, group, index, accessor) {
+    var legendable = {name: chart.getGroupName(group, accessor), data: group};
+    if (typeof chart.colors === 'function') legendable.color = chart.colors()(index);
+    return legendable;
+};
+
+dc.utils.safeNumber = function(n){return dc.utils.isNumber(+n)?+n:0;};
+
+dc.events = {
+    current: null
+};
+
+dc.events.trigger = function(closure, delay) {
+    if (!delay){
+        closure();
+        return;
+    }
+
+    dc.events.current = closure;
+
+    setTimeout(function() {
+        if (closure == dc.events.current)
+            closure();
+    }, delay);
+};
+
+dc.cumulative = {};
+
+dc.cumulative.Base = function() {
+    this._keyIndex = [];
+    this._map = {};
+
+    this.sanitizeKey = function(key) {
+        key = key + "";
+        return key;
+    };
+
+    this.clear = function() {
+        this._keyIndex = [];
+        this._map = {};
+    };
+
+    this.size = function() {
+        return this._keyIndex.length;
+    };
+
+    this.getValueByKey = function(key) {
+        key = this.sanitizeKey(key);
+        var value = this._map[key];
+        return value;
+    };
+
+    this.setValueByKey = function(key, value) {
+        key = this.sanitizeKey(key);
+        return this._map[key] = value;
+    };
+
+    this.indexOfKey = function(key) {
+        key = this.sanitizeKey(key);
+        return this._keyIndex.indexOf(key);
+    };
+
+    this.addToIndex = function(key) {
+        key = this.sanitizeKey(key);
+        this._keyIndex.push(key);
+    };
+
+    this.getKeyByIndex = function(index) {
+        return this._keyIndex[index];
+    };
+};
+
+dc.cumulative.Sum = function() {
+    dc.cumulative.Base.apply(this, arguments);
+
+    this.add = function(key, value) {
+        if (!value)
+            value = 0;
+
+        if (this.getValueByKey(key) === undefined) {
+            this.addToIndex(key);
+            this.setValueByKey(key, value);
+        } else {
+            this.setValueByKey(key, this.getValueByKey(key) + value);
+        }
+    };
+
+    this.minus = function(key, value) {
+        this.setValueByKey(key, this.getValueByKey(key) - value);
+    };
+
+    this.cumulativeSum = function(key) {
+        var keyIndex = this.indexOfKey(key);
+        if (keyIndex < 0) return 0;
+        var cumulativeValue = 0;
+        for (var i = 0; i <= keyIndex; ++i) {
+            var k = this.getKeyByIndex(i);
+            cumulativeValue += this.getValueByKey(k);
+        }
+        return cumulativeValue;
+    };
+};
+dc.cumulative.Sum.prototype = new dc.cumulative.Base();
+
+dc.cumulative.CountUnique = function() {
+    dc.cumulative.Base.apply(this, arguments);
+
+    function hashSize(hash) {
+        var size = 0, key;
+        for (key in hash) {
+            if (hash.hasOwnProperty(key)) size++;
+        }
+        return size;
+    }
+
+    this.add = function(key, e) {
+        if (this.getValueByKey(key) === undefined) {
+            this.setValueByKey(key, {});
+            this.addToIndex(key);
+        }
+
+        if (e !== undefined) {
+            if (this.getValueByKey(key)[e] === undefined)
+                this.getValueByKey(key)[e] = 0;
+
+            this.getValueByKey(key)[e] += 1;
+        }
+    };
+
+    this.minus = function(key, e) {
+        this.getValueByKey(key)[e] -= 1;
+        if (this.getValueByKey(key)[e] <= 0)
+            delete this.getValueByKey(key)[e];
+    };
+
+    this.count = function(key) {
+        return hashSize(this.getValueByKey(key));
+    };
+
+    this.cumulativeCount = function(key) {
+        var keyIndex = this.indexOfKey(key);
+        if (keyIndex < 0) return 0;
+        var cumulativeCount = 0;
+        for (var i = 0; i <= keyIndex; ++i) {
+            var k = this.getKeyByIndex(i);
+            cumulativeCount += this.count(k);
+        }
+        return cumulativeCount;
+    };
+};
+dc.cumulative.CountUnique.prototype = new dc.cumulative.Base();
+
+dc.baseChart = function (_chart) {
+    _chart.__dc_flag__ = true;
+
+    var _dimension;
+    var _group;
+
+    var _anchor;
+    var _root;
+    var _svg;
+
+    var _width = 200, _height = 200;
+
+    var _keyAccessor = function (d) {
+        return d.key;
+    };
+    var _valueAccessor = function (d) {
+        return d.value;
+    };
+    var _ordering = function (p) {
+        return p.key;
+    };
+
+    var _label = function (d) {
+        return d.key;
+    };
+    var _renderLabel = false;
+
+    var _title = function (d) {
+        return d.key + ": " + d.value;
+    };
+    var _renderTitle = false;
+
+    var _transitionDuration = 750;
+
+    var _filterPrinter = dc.printers.filters;
+
+    var _renderlets = [];
+
+    var _chartGroup = dc.constants.DEFAULT_CHART_GROUP;
+
+    var NULL_LISTENER = function (chart) {
+    };
+    var _listeners = {
+        preRender: NULL_LISTENER,
+        postRender: NULL_LISTENER,
+        preRedraw: NULL_LISTENER,
+        postRedraw: NULL_LISTENER,
+        filtered: NULL_LISTENER,
+        zoomed: NULL_LISTENER
+    };
+    var _legend;
+
+    var _filters = [];
+    var _filterHandler = function (dimension, filters) {
+        dimension.filter(null);
+
+        if (filters.length === 0)
+            dimension.filter(null);
+        else if (filters.length === 1)
+            dimension.filter(filters[0]);
+        else
+            dimension.filterFunction(function (d) {
+                return filters.indexOf(d) >= 0;
+            });
+
+        return filters;
+    };
+
+    _chart.width = function (w) {
+        if (!arguments.length) return _width;
+        _width = w;
+        return _chart;
+    };
+
+    _chart.height = function (h) {
+        if (!arguments.length) return _height;
+        _height = h;
+        return _chart;
+    };
+
+    _chart.dimension = function (d) {
+        if (!arguments.length) return _dimension;
+        _dimension = d;
+        _chart.expireCache();
+        return _chart;
+    };
+
+    _chart.group = function (g, name) {
+        if (!arguments.length) return _group;
+        _group = g;
+        _chart.expireCache();
+        if (typeof name === 'string') _chart.setGroupName(_group, name);
+        return _chart;
+    };
+
+    _chart.setGroupName = function (g, name, accessor) {
+        if (!g.__names__) g.__names__ = {};
+        g.__names__[groupNameKey(accessor)] = name;
+    };
+
+    function groupNameKey(accessor) {
+        var defaultKey = "default";
+        return accessor ? (accessor == _chart.valueAccessor() ? defaultKey : accessor) : defaultKey;
+    }
+
+    _chart.getGroupName = function (g, accessor) {
+        if (!g.__names__) g.__names__ = {};
+        return g.__names__[groupNameKey(accessor)];
+    };
+
+    _chart.ordering = function(o) {
+        if (!arguments.length) return _ordering;
+        _ordering = o;
+        _chart.expireCache();
+        return _chart;
+    };
+
+    _chart.computeOrderedGroups = function(arr) {
+        var data = arr ? arr : _chart.group().all().slice(0); // clone
+        if(data.length < 2)
+            return data;
+        var sort = crossfilter.quicksort.by(_chart.ordering());
+        return sort(data,0,data.length);
+    };
+
+    _chart.filterAll = function () {
+        return _chart.filter(null);
+    };
+
+    _chart.dataSet = function () {
+        return _dimension !== undefined && _group !== undefined;
+    };
+
+    _chart.select = function (s) {
+        return _root.select(s);
+    };
+
+    _chart.selectAll = function (s) {
+        return _root ? _root.selectAll(s) : null;
+    };
+
+    _chart.anchor = function (a, chartGroup) {
+        if (!arguments.length) return _anchor;
+        if (dc.instanceOfChart(a)) {
+            _anchor = a.anchor();
+            _root = a.root();
+        } else {
+            _anchor = a;
+            _root = d3.select(_anchor);
+            _root.classed(dc.constants.CHART_CLASS, true);
+            dc.registerChart(_chart, chartGroup);
+        }
+        _chartGroup = chartGroup;
+        return _chart;
+    };
+
+    _chart.anchorName = function () {
+        var a = _chart.anchor();
+        if (a && a.id) return a.id;
+        if (a) return a.replace('#','');
+        return '';
+    };
+
+    _chart.root = function (r) {
+        if (!arguments.length) return _root;
+        _root = r;
+        return _chart;
+    };
+
+    _chart.svg = function (_) {
+        if (!arguments.length) return _svg;
+        _svg = _;
+        return _chart;
+    };
+
+    _chart.resetSvg = function () {
+        _chart.select("svg").remove();
+        return _chart.generateSvg();
+    };
+
+    _chart.generateSvg = function () {
+        _svg = _chart.root().append("svg")
+            .attr("width", _chart.width())
+            .attr("height", _chart.height());
+        return _svg;
+    };
+
+    _chart.filterPrinter = function (_) {
+        if (!arguments.length) return _filterPrinter;
+        _filterPrinter = _;
+        return _chart;
+    };
+
+    _chart.turnOnControls = function () {
+        if (_root) {
+            _chart.selectAll(".reset").style("display", null);
+            _chart.selectAll(".filter").text(_filterPrinter(_chart.filters())).style("display", null);
+        }
+        return _chart;
+    };
+
+    _chart.turnOffControls = function () {
+        if (_root) {
+            _chart.selectAll(".reset").style("display", "none");
+            _chart.selectAll(".filter").style("display", "none").text(_chart.filter());
+        }
+        return _chart;
+    };
+
+    _chart.transitionDuration = function (d) {
+        if (!arguments.length) return _transitionDuration;
+        _transitionDuration = d;
+        return _chart;
+    };
+
+    _chart.render = function () {
+        _listeners.preRender(_chart);
+
+        if (_dimension === undefined)
+            throw new dc.errors.InvalidStateException("Mandatory attribute chart.dimension is missing on chart[#"
+                + _chart.anchorName() + "]");
+
+        if (_group === undefined)
+            throw new dc.errors.InvalidStateException("Mandatory attribute chart.group is missing on chart[#"
+                + _chart.anchorName() + "]");
+
+        var result = _chart.doRender();
+
+        if (_legend) _legend.render();
+
+        _chart.activateRenderlets("postRender");
+
+        return result;
+    };
+
+    _chart.activateRenderlets = function (event) {
+        if (_chart.transitionDuration() > 0 && _svg) {
+            _svg.transition().duration(_chart.transitionDuration())
+                .each("end", function () {
+                    runAllRenderlets();
+                    if (event) _listeners[event](_chart);
+                });
+        } else {
+            runAllRenderlets();
+            if (event) _listeners[event](_chart);
+        }
+    };
+
+    _chart.redraw = function () {
+        _listeners.preRedraw(_chart);
+
+        var result = _chart.doRedraw();
+
+        _chart.activateRenderlets("postRedraw");
+
+        return result;
+    };
+
+    _chart.invokeFilteredListener = function (f) {
+        if (f !== undefined) _listeners.filtered(_chart, f);
+    };
+
+    _chart.invokeZoomedListener = function () {
+        _listeners.zoomed(_chart);
+    };
+
+    _chart.hasFilter = function (filter) {
+        if (!arguments.length) return _filters.length > 0;
+        return _filters.indexOf(filter) >= 0;
+    };
+
+    function removeFilter(_) {
+        _filters.splice(_filters.indexOf(_), 1);
+        applyFilters();
+        _chart.invokeFilteredListener(_);
+    }
+
+    function addFilter(_) {
+        _filters.push(_);
+        applyFilters();
+        _chart.invokeFilteredListener(_);
+    }
+
+    function resetFilters() {
+        _filters = [];
+        applyFilters();
+        _chart.invokeFilteredListener(null);
+    }
+
+    function applyFilters() {
+        if (_chart.dataSet() && _chart.dimension().filter !== undefined) {
+            var fs = _filterHandler(_chart.dimension(), _filters);
+            _filters = fs ? fs : _filters;
+        }
+    }
+
+    _chart.filter = function (_) {
+        if (!arguments.length) return _filters.length > 0 ? _filters[0] : null;
+
+        if (_ === null) {
+            resetFilters();
+        } else {
+            if (_chart.hasFilter(_))
+                removeFilter(_);
+            else
+                addFilter(_);
+        }
+
+        if (_root !== null && _chart.hasFilter()) {
+            _chart.turnOnControls();
+        } else {
+            _chart.turnOffControls();
+        }
+
+        return _chart;
+    };
+
+    _chart.filters = function () {
+        return _filters;
+    };
+
+    _chart.highlightSelected = function (e) {
+        d3.select(e).classed(dc.constants.SELECTED_CLASS, true);
+        d3.select(e).classed(dc.constants.DESELECTED_CLASS, false);
+    };
+
+    _chart.fadeDeselected = function (e) {
+        d3.select(e).classed(dc.constants.SELECTED_CLASS, false);
+        d3.select(e).classed(dc.constants.DESELECTED_CLASS, true);
+    };
+
+    _chart.resetHighlight = function (e) {
+        d3.select(e).classed(dc.constants.SELECTED_CLASS, false);
+        d3.select(e).classed(dc.constants.DESELECTED_CLASS, false);
+    };
+
+    _chart.onClick = function (d) {
+        var filter = _chart.keyAccessor()(d);
+        dc.events.trigger(function () {
+            _chart.filter(filter);
+            dc.redrawAll(_chart.chartGroup());
+        });
+    };
+
+    _chart.filterHandler = function (_) {
+        if (!arguments.length) return _filterHandler;
+        _filterHandler = _;
+        return _chart;
+    };
+
+    // abstract function stub
+    _chart.doRender = function () {
+        // do nothing in base, should be overridden by sub-function
+        return _chart;
+    };
+
+    _chart.doRedraw = function () {
+        // do nothing in base, should be overridden by sub-function
+        return _chart;
+    };
+
+    _chart.legendables = function () {
+        // do nothing in base, should be overridden by sub-function
+        return [];
+    };
+
+    _chart.legendHighlight = function (d) {
+        // do nothing in base, should be overridden by sub-function
+    };
+
+    _chart.legendReset = function (d) {
+        // do nothing in base, should be overridden by sub-function
+    };
+
+    _chart.keyAccessor = function (_) {
+        if (!arguments.length) return _keyAccessor;
+        _keyAccessor = _;
+        return _chart;
+    };
+
+    _chart.valueAccessor = function (_) {
+        if (!arguments.length) return _valueAccessor;
+        _valueAccessor = _;
+        return _chart;
+    };
+
+    _chart.label = function (_) {
+        if (!arguments.length) return _label;
+        _label = _;
+        _renderLabel = true;
+        return _chart;
+    };
+
+    _chart.renderLabel = function (_) {
+        if (!arguments.length) return _renderLabel;
+        _renderLabel = _;
+        return _chart;
+    };
+
+    _chart.title = function (_) {
+        if (!arguments.length) return _title;
+        _title = _;
+        _renderTitle = true;
+        return _chart;
+    };
+
+    _chart.renderTitle = function (_) {
+        if (!arguments.length) return _renderTitle;
+        _renderTitle = _;
+        return _chart;
+    };
+
+    _chart.renderlet = function (_) {
+        _renderlets.push(_);
+        return _chart;
+    };
+
+    function runAllRenderlets() {
+        for (var i = 0; i < _renderlets.length; ++i) {
+            _renderlets[i](_chart);
+        }
+    }
+
+    _chart.chartGroup = function (_) {
+        if (!arguments.length) return _chartGroup;
+        _chartGroup = _;
+        return _chart;
+    };
+
+    _chart.on = function (event, listener) {
+        _listeners[event] = listener;
+        return _chart;
+    };
+
+    _chart.expireCache = function () {
+        // do nothing in base, should be overridden by sub-function
+        return _chart;
+    };
+
+    _chart.legend = function (l) {
+        if (!arguments.length) return _legend;
+        _legend = l;
+        _legend.parent(_chart);
+        return _chart;
+    };
+
+    return _chart;
+};
+
+dc.marginable = function (_chart) {
+    var _margin = {top: 10, right: 50, bottom: 30, left: 30};
+
+    _chart.margins = function (m) {
+        if (!arguments.length) return _margin;
+        _margin = m;
+        return _chart;
+    };
+
+    _chart.effectiveWidth = function () {
+        return _chart.width() - _chart.margins().left - _chart.margins().right;
+    };
+
+    _chart.effectiveHeight = function () {
+        return _chart.height() - _chart.margins().top - _chart.margins().bottom;
+    };
+
+    return _chart;
+};
+
+dc.coordinateGridChart = function (_chart) {
+    var GRID_LINE_CLASS = "grid-line";
+    var HORIZONTAL_CLASS = "horizontal";
+    var VERTICAL_CLASS = "vertical";
+    var Y_AXIS_LABEL_CLASS = 'y-axis-label';
+    var X_AXIS_LABEL_CLASS = 'x-axis-label';
+    var DEFAULT_AXIS_LABLEL_PADDING = 12;
+
+    _chart = dc.colorChart(dc.marginable(dc.baseChart(_chart)));
+
+    _chart.colors(d3.scale.category10());
+
+    var _parent;
+    var _g;
+    var _chartBodyG;
+
+    var _x;
+    var _xOriginalDomain;
+    var _xAxis = d3.svg.axis();
+    var _xUnits = dc.units.integers;
+    var _xAxisPadding = 0;
+    var _xElasticity = false;
+    var _xAxisLabel;
+    var _xAxisLabelPadding = 0;
+
+    var _y;
+    var _yAxis = d3.svg.axis();
+    var _yAxisPadding = 0;
+    var _yElasticity = false;
+    var _yAxisLabel;
+    var _yAxisLabelPadding = 0;
+
+    var _brush = d3.svg.brush();
+    var _brushOn = true;
+    var _round;
+
+    var _renderHorizontalGridLine = false;
+    var _renderVerticalGridLine = false;
+
+    var _refocused = false;
+    var _unitCount;
+
+    var _zoomScale = [-10, 100];  // -10 to allow zoom out of the original domain
+    var _zoomOutRestrict = false; // restrict zoomOut to the original domain?
+
+    var _rangeChart;
+    var _focusChart;
+
+    var _mouseZoomable = false;
+    var _clipPadding = 0;
+
+    _chart.title(function (d) {
+        return d.data.key + ": " + d.data.value;
+    });
+
+    _chart.rescale = function () {
+        _unitCount = undefined;
+        _chart.xUnitCount();
+    };
+
+    _chart.rangeChart = function (_) {
+        if (!arguments.length) return _rangeChart;
+        _rangeChart = _;
+        _rangeChart.focusChart(_chart);
+        return _chart;
+    };
+
+    _chart.zoomScale = function (_) {
+        if (!arguments.length) return _zoomScale;
+        _zoomScale = _;
+        return _chart;
+    };
+
+    _chart.zoomOutRestrict = function (_) {
+        if (!arguments.length) return _zoomOutRestrict;
+        _zoomOutRestrict = _;
+        return _chart;
+    };
+
+    _chart.generateG = function (parent) {
+        if (parent === undefined)
+            _parent = _chart.svg();
+        else
+            _parent = parent;
+
+        _g = _parent.append("g");
+
+        _chartBodyG = _g.append("g").attr("class", "chart-body")
+            .attr("transform", "translate(" + _chart.margins().left + ", " + _chart.margins().top + ")")
+            .attr("clip-path", "url(#" + getClipPathId() + ")");
+
+        return _g;
+    };
+
+    _chart.g = function (_) {
+        if (!arguments.length) return _g;
+        _g = _;
+        return _chart;
+    };
+
+    _chart.mouseZoomable = function (z) {
+        if (!arguments.length) return _mouseZoomable;
+        _mouseZoomable = z;
+        return _chart;
+    };
+
+    _chart.chartBodyG = function (_) {
+        if (!arguments.length) return _chartBodyG;
+        _chartBodyG = _;
+        return _chart;
+    };
+
+    _chart.x = function (_) {
+        if (!arguments.length) return _x;
+        _x = _;
+        _xOriginalDomain = _x.domain();
+        return _chart;
+    };
+
+    _chart.xOriginalDomain = function () {
+        return _xOriginalDomain;
+    };
+
+    _chart.xUnits = function (_) {
+        if (!arguments.length) return _xUnits;
+        _xUnits = _;
+        return _chart;
+    };
+
+    _chart.xAxis = function (_) {
+        if (!arguments.length) return _xAxis;
+        _xAxis = _;
+        return _chart;
+    };
+
+    _chart.elasticX = function (_) {
+        if (!arguments.length) return _xElasticity;
+        _xElasticity = _;
+        return _chart;
+    };
+
+    _chart.xAxisPadding = function (_) {
+        if (!arguments.length) return _xAxisPadding;
+        _xAxisPadding = _;
+        return _chart;
+    };
+
+    _chart.xUnitCount = function () {
+        if (_unitCount === undefined) {
+            var units = _chart.xUnits()(_chart.x().domain()[0], _chart.x().domain()[1], _chart.x().domain());
+
+            if (units instanceof Array)
+                _unitCount = units.length;
+            else
+                _unitCount = units;
+        }
+
+        return _unitCount;
+    };
+
+    _chart.isOrdinal = function () {
+        return _chart.xUnits() === dc.units.ordinal;
+    };
+
+    _chart.prepareOrdinalXAxis = function (count) {
+        if (!count)
+            count = _chart.xUnitCount();
+        var range = [];
+        var increment = _chart.xAxisLength() / (count + 1);
+        var currentPosition = increment/2;
+        for (var i = 0; i < count; i++) {
+            range[i] = currentPosition;
+            currentPosition += increment;
+        }
+        _x.range(range);
+    };
+
+    function prepareXAxis(g) {
+        if (_chart.elasticX() && !_chart.isOrdinal()) {
+            _x.domain([_chart.xAxisMin(), _chart.xAxisMax()]);
+        }
+        else if (_chart.isOrdinal() && _x.domain().length===0) {
+            _x.domain(_chart.computeOrderedGroups().map(function(kv) { return kv.key; }));
+        }
+
+        if (_chart.isOrdinal()) {
+            _chart.prepareOrdinalXAxis();
+        } else {
+            _x.range([0, _chart.xAxisLength()]);
+        }
+
+        _xAxis = _xAxis.scale(_chart.x()).orient("bottom");
+
+        renderVerticalGridLines(g);
+    }
+
+    _chart.renderXAxis = function (g) {
+        var axisXG = g.selectAll("g.x");
+
+        if (axisXG.empty())
+            axisXG = g.append("g")
+                .attr("class", "axis x")
+                .attr("transform", "translate(" + _chart.margins().left + "," + _chart.xAxisY() + ")");
+
+        var axisXLab = g.selectAll("text."+X_AXIS_LABEL_CLASS);
+        if (axisXLab.empty() && _chart.xAxisLabel())
+        axisXLab = g.append('text')
+            .attr("transform", "translate(" + _chart.xAxisLength() / 2 + "," + (_chart.height() - _xAxisLabelPadding) + ")")
+            .attr('class', X_AXIS_LABEL_CLASS)
+            .attr('text-anchor', 'middle')
+            .text(_chart.xAxisLabel());
+        if (_chart.xAxisLabel() && axisXLab.text() != _chart.xAxisLabel())
+            axisYLab.text(_chart.xAxisLabel());
+
+        dc.transition(axisXG, _chart.transitionDuration())
+            .call(_xAxis);
+    };
+
+    function renderVerticalGridLines(g) {
+        var gridLineG = g.selectAll("g." + VERTICAL_CLASS);
+
+        if (_renderVerticalGridLine) {
+            if (gridLineG.empty())
+                gridLineG = g.insert("g", ":first-child")
+                    .attr("class", GRID_LINE_CLASS + " " + VERTICAL_CLASS)
+                    .attr("transform", "translate(" + _chart.yAxisX() + "," + _chart.margins().top + ")");
+
+            var ticks = _xAxis.tickValues() ? _xAxis.tickValues() : _x.ticks(_xAxis.ticks()[0]);
+
+            var lines = gridLineG.selectAll("line")
+                .data(ticks);
+
+            // enter
+            var linesGEnter = lines.enter()
+                .append("line")
+                .attr("x1", function (d) {
+                    return _x(d);
+                })
+                .attr("y1", _chart.xAxisY() - _chart.margins().top)
+                .attr("x2", function (d) {
+                    return _x(d);
+                })
+                .attr("y2", 0)
+                .attr("opacity", 0);
+            dc.transition(linesGEnter, _chart.transitionDuration())
+                .attr("opacity", 1);
+
+            // update
+            dc.transition(lines, _chart.transitionDuration())
+                .attr("x1", function (d) {
+                    return _x(d);
+                })
+                .attr("y1", _chart.xAxisY() - _chart.margins().top)
+                .attr("x2", function (d) {
+                    return _x(d);
+                })
+                .attr("y2", 0);
+
+            // exit
+            lines.exit().remove();
+        }
+        else {
+            gridLineG.selectAll("line").remove();
+        }
+    }
+
+    _chart.xAxisY = function () {
+        return (_chart.height() - _chart.margins().bottom);
+    };
+
+    _chart.xAxisLength = function () {
+        return _chart.effectiveWidth();
+    };
+
+    _chart.xAxisLabel = function (_,pad) {
+        if (!arguments.length) return _xAxisLabel;
+        _xAxisLabel = _;
+        _chart.margins().bottom -= _xAxisLabelPadding;
+        _xAxisLabelPadding = (pad===undefined) ? DEFAULT_AXIS_LABLEL_PADDING : pad;
+        _chart.margins().bottom += _xAxisLabelPadding;
+        return _chart;
+    };
+
+    function prepareYAxis(g) {
+        if (_y === undefined || _chart.elasticY()) {
+            _y = d3.scale.linear();
+            _y.domain([_chart.yAxisMin(), _chart.yAxisMax()]).rangeRound([_chart.yAxisHeight(), 0]);
+        }
+
+        _y.range([_chart.yAxisHeight(), 0]);
+        _yAxis = _yAxis.scale(_y).orient("left");
+
+        renderHorizontalGridLines(g);
+    }
+
+    _chart.renderYAxis = function (g) {
+        var axisYG = g.selectAll("g.y");
+        if (axisYG.empty())
+            axisYG = g.append("g")
+                .attr("class", "axis y")
+                .attr("transform", "translate(" + _chart.yAxisX() + "," + _chart.margins().top + ")");
+
+        var axisYLab = g.selectAll("text."+Y_AXIS_LABEL_CLASS);
+        if (axisYLab.empty() && _chart.yAxisLabel())
+        axisYLab = g.append('text')
+            .attr("transform", "translate(" + _yAxisLabelPadding + "," + _chart.yAxisHeight()/2 + "),rotate(-90)")
+            .attr('class', Y_AXIS_LABEL_CLASS)
+            .attr('text-anchor', 'middle')
+            .text(_chart.yAxisLabel());
+        if (_chart.yAxisLabel() && axisYLab.text() != _chart.yAxisLabel())
+            axisYLab.text(_chart.yAxisLabel());
+
+        dc.transition(axisYG, _chart.transitionDuration())
+            .call(_yAxis);
+    };
+
+
+    function renderHorizontalGridLines(g) {
+        var gridLineG = g.selectAll("g." + HORIZONTAL_CLASS);
+
+        if (_renderHorizontalGridLine) {
+            var ticks = _yAxis.tickValues() ? _yAxis.tickValues() : _y.ticks(_yAxis.ticks()[0]);
+
+            if (gridLineG.empty())
+                gridLineG = g.insert("g", ":first-child")
+                    .attr("class", GRID_LINE_CLASS + " " + HORIZONTAL_CLASS)
+                    .attr("transform", "translate(" + _chart.yAxisX() + "," + _chart.margins().top + ")");
+
+            var lines = gridLineG.selectAll("line")
+                .data(ticks);
+
+            // enter
+            var linesGEnter = lines.enter()
+                .append("line")
+                .attr("x1", 1)
+                .attr("y1", function (d) {
+                    return _y(d);
+                })
+                .attr("x2", _chart.xAxisLength())
+                .attr("y2", function (d) {
+                    return _y(d);
+                })
+                .attr("opacity", 0);
+            dc.transition(linesGEnter, _chart.transitionDuration())
+                .attr("opacity", 1);
+
+            // update
+            dc.transition(lines, _chart.transitionDuration())
+                .attr("x1", 1)
+                .attr("y1", function (d) {
+                    return _y(d);
+                })
+                .attr("x2", _chart.xAxisLength())
+                .attr("y2", function (d) {
+                    return _y(d);
+                });
+
+            // exit
+            lines.exit().remove();
+        }
+        else {
+            gridLineG.selectAll("line").remove();
+        }
+    }
+
+    _chart.yAxisX = function () {
+        return _chart.margins().left;
+    };
+
+    _chart.yAxisLabel = function (_,pad) {
+        if (!arguments.length) return _yAxisLabel;
+        _yAxisLabel = _;
+        _chart.margins().left -= _yAxisLabelPadding;
+        _yAxisLabelPadding = (pad===undefined) ? DEFAULT_AXIS_LABLEL_PADDING : pad;
+        _chart.margins().left += _yAxisLabelPadding;
+        return _chart;
+    };
+
+    _chart.y = function (_) {
+        if (!arguments.length) return _y;
+        _y = _;
+        return _chart;
+    };
+
+    _chart.yAxis = function (y) {
+        if (!arguments.length) return _yAxis;
+        _yAxis = y;
+        return _chart;
+    };
+
+    _chart.elasticY = function (_) {
+        if (!arguments.length) return _yElasticity;
+        _yElasticity = _;
+        return _chart;
+    };
+
+    _chart.renderHorizontalGridLines = function (_) {
+        if (!arguments.length) return _renderHorizontalGridLine;
+        _renderHorizontalGridLine = _;
+        return _chart;
+    };
+
+    _chart.renderVerticalGridLines = function (_) {
+        if (!arguments.length) return _renderVerticalGridLine;
+        _renderVerticalGridLine = _;
+        return _chart;
+    };
+
+    _chart.xAxisMin = function () {
+        var min = d3.min(_chart.group().all(), function (e) {
+            return _chart.keyAccessor()(e);
+        });
+        return dc.utils.subtract(min, _xAxisPadding);
+    };
+
+    _chart.xAxisMax = function () {
+        var max = d3.max(_chart.group().all(), function (e) {
+            return _chart.keyAccessor()(e);
+        });
+        return dc.utils.add(max, _xAxisPadding);
+    };
+
+    _chart.yAxisMin = function () {
+        var min = d3.min(_chart.group().all(), function (e) {
+            return _chart.valueAccessor()(e);
+        });
+        min = dc.utils.subtract(min, _yAxisPadding);
+        return min;
+    };
+
+    _chart.yAxisMax = function () {
+        var max = d3.max(_chart.group().all(), function (e) {
+            return _chart.valueAccessor()(e);
+        });
+        max = dc.utils.add(max, _yAxisPadding);
+        return max;
+    };
+
+    _chart.yAxisPadding = function (_) {
+        if (!arguments.length) return _yAxisPadding;
+        _yAxisPadding = _;
+        return _chart;
+    };
+
+    _chart.yAxisHeight = function () {
+        return _chart.effectiveHeight();
+    };
+
+    _chart.round = function (_) {
+        if (!arguments.length) return _round;
+        _round = _;
+        return _chart;
+    };
+
+    dc.override(_chart, "filter", function (_) {
+        if (!arguments.length) return _chart._filter();
+
+        _chart._filter(_);
+
+        if (_) {
+            _chart.brush().extent(_);
+        } else {
+            _chart.brush().clear();
+        }
+
+        return _chart;
+    });
+
+    _chart.brush = function (_) {
+        if (!arguments.length) return _brush;
+        _brush = _;
+        return _chart;
+    };
+
+    function brushHeight() {
+        return _chart.xAxisY() - _chart.margins().top;
+    }
+
+    _chart.renderBrush = function (g) {
+        if (_chart.isOrdinal())
+            _brushOn = false;
+
+        if (_brushOn) {
+            _brush.on("brushstart", brushStart)
+                .on("brush", brushing)
+                .on("brushend", brushEnd);
+
+            var gBrush = g.append("g")
+                .attr("class", "brush")
+                .attr("transform", "translate(" + _chart.margins().left + "," + _chart.margins().top + ")")
+                .call(_brush.x(_chart.x()));
+            gBrush.selectAll("rect").attr("height", brushHeight());
+            gBrush.selectAll(".resize").append("path").attr("d", _chart.resizeHandlePath);
+
+            if (_chart.hasFilter()) {
+                _chart.redrawBrush(g);
+            }
+        }
+    };
+
+    function brushStart(p) {
+    }
+
+    _chart.extendBrush = function () {
+        var extent = _brush.extent();
+        if (_chart.round()) {
+            extent[0] = extent.map(_chart.round())[0];
+            extent[1] = extent.map(_chart.round())[1];
+
+            _g.select(".brush")
+                .call(_brush.extent(extent));
+        }
+        return extent;
+    };
+
+    _chart.brushIsEmpty = function (extent) {
+        return _brush.empty() || !extent || extent[1] <= extent[0];
+    };
+
+    function brushing(p) {
+        var extent = _chart.extendBrush();
+
+        _chart.redrawBrush(_g);
+
+        if (_chart.brushIsEmpty(extent)) {
+            dc.events.trigger(function () {
+                _chart.filter(null);
+                dc.redrawAll(_chart.chartGroup());
+            });
+        } else {
+            dc.events.trigger(function () {
+                _chart.filter(null);
+                _chart.filter([extent[0], extent[1]]);
+                dc.redrawAll(_chart.chartGroup());
+            }, dc.constants.EVENT_DELAY);
+        }
+    }
+
+    function brushEnd(p) {
+    }
+
+    _chart.redrawBrush = function (g) {
+        if (_brushOn) {
+            if (_chart.filter() && _chart.brush().empty())
+                _chart.brush().extent(_chart.filter());
+
+            var gBrush = g.select("g.brush");
+            gBrush.call(_chart.brush().x(_chart.x()));
+            gBrush.selectAll("rect").attr("height", brushHeight());
+        }
+
+        _chart.fadeDeselectedArea();
+    };
+
+    _chart.fadeDeselectedArea = function () {
+        // do nothing, sub-chart should override this function
+    };
+
+    // borrowed from Crossfilter example
+    _chart.resizeHandlePath = function (d) {
+        var e = +(d == "e"), x = e ? 1 : -1, y = brushHeight() / 3;
+        return "M" + (0.5 * x) + "," + y
+            + "A6,6 0 0 " + e + " " + (6.5 * x) + "," + (y + 6)
+            + "V" + (2 * y - 6)
+            + "A6,6 0 0 " + e + " " + (0.5 * x) + "," + (2 * y)
+            + "Z"
+            + "M" + (2.5 * x) + "," + (y + 8)
+            + "V" + (2 * y - 8)
+            + "M" + (4.5 * x) + "," + (y + 8)
+            + "V" + (2 * y - 8);
+    };
+
+    function getClipPathId() {
+        return _chart.anchorName() + "-clip";
+    }
+
+    _chart.clipPadding = function (p) {
+        if (!arguments.length) return _clipPadding;
+        _clipPadding = p;
+        return _chart;
+    };
+
+    function generateClipPath() {
+        var defs = dc.utils.appendOrSelect(_parent, "defs");
+
+        var chartBodyClip = dc.utils.appendOrSelect(defs, "clipPath").attr("id", getClipPathId());
+
+        var padding = _clipPadding * 2;
+
+        dc.utils.appendOrSelect(chartBodyClip, "rect")
+            .attr("width", _chart.xAxisLength() + padding)
+            .attr("height", _chart.yAxisHeight() + padding);
+    }
+
+    _chart.doRender = function () {
+        if (_x === undefined)
+            throw new dc.errors.InvalidStateException("Mandatory attribute chart.x is missing on chart[#"
+                + _chart.anchorName() + "]");
+
+        _chart.resetSvg();
+
+        if (_chart.dataSet()) {
+            _chart.generateG();
+
+            generateClipPath();
+            prepareXAxis(_chart.g());
+            prepareYAxis(_chart.g());
+
+            _chart.plotData();
+
+            _chart.renderXAxis(_chart.g());
+            _chart.renderYAxis(_chart.g());
+
+            _chart.renderBrush(_chart.g());
+
+            enableMouseZoom();
+        }
+
+        return _chart;
+    };
+
+    function enableMouseZoom() {
+        if (_mouseZoomable) {
+            _chart.root().call(d3.behavior.zoom()
+                .x(_chart.x())
+                .scaleExtent(_zoomScale)
+                .on("zoom", function () {
+                    _chart.focus(_chart.x().domain());
+                    _chart.invokeZoomedListener();
+                    updateRangeSelChart();
+                }));
+        }
+    }
+
+    function updateRangeSelChart() {
+        if (_rangeChart) {
+            var refDom = _chart.x().domain();
+            if (_zoomOutRestrict) {
+                var origDom = _rangeChart.xOriginalDomain();
+                var newDom = [
+                  refDom[0] < origDom[0] ? refDom[0] : origDom[0],
+                  refDom[1] > origDom[1] ? refDom[1] : origDom[1]];
+                _rangeChart.focus(newDom);
+            } else {
+              _rangeChart.focus(refDom);
+            }
+            _rangeChart.filter(null);
+            _rangeChart.filter(refDom);
+
+            dc.events.trigger(function () {
+                dc.redrawAll(_chart.chartGroup());
+            });
+        }
+    }
+
+    _chart.doRedraw = function () {
+        prepareXAxis(_chart.g());
+        prepareYAxis(_chart.g());
+
+        _chart.plotData();
+
+        if (_chart.elasticY())
+            _chart.renderYAxis(_chart.g());
+
+        if (_chart.elasticX() || _refocused)
+            _chart.renderXAxis(_chart.g());
+
+        _chart.redrawBrush(_chart.g());
+
+        return _chart;
+    };
+
+    _chart.subRender = function () {
+        if (_chart.dataSet()) {
+            _chart.plotData();
+        }
+
+        return _chart;
+    };
+
+    _chart.brushOn = function (_) {
+        if (!arguments.length) return _brushOn;
+        _brushOn = _;
+        return _chart;
+    };
+
+    _chart.getDataWithinXDomain = function (group) {
+        var data = [];
+
+        if (_chart.isOrdinal()) {
+            data = group.all();
+        } else {
+            group.all().forEach(function (d) {
+                var key = _chart.keyAccessor()(d);
+                if (key >= _chart.x().domain()[0] && key <= _chart.x().domain()[1])
+                    data.push(d);
+            });
+        }
+
+        return data;
+    };
+
+    function hasRangeSelected(range) {
+        return range instanceof Array && range.length > 1;
+    }
+
+    _chart.focus = function (range) {
+        _refocused = true;
+
+        if (hasRangeSelected(range)) {
+            _chart.x().domain(range);
+        } else {
+            _chart.x().domain(_chart.xOriginalDomain());
+        }
+
+        _chart.rescale();
+
+        _chart.redraw();
+
+        if (!hasRangeSelected(range))
+            _refocused = false;
+    };
+
+    _chart.refocused = function () {
+        return _refocused;
+    };
+
+    _chart.focusChart = function (c) {
+        if (!arguments.length) return _focusChart;
+        _focusChart = c;
+        _chart.on("filtered", function (chart) {
+            dc.events.trigger(function () {
+                _focusChart.focus(chart.filter());
+                _focusChart.filter(chart.filter());
+                dc.redrawAll(chart.chartGroup());
+            });
+        });
+        return _chart;
+    };
+
+    return _chart;
+};
+
+dc.colorChart = function(_chart) {
+    var _colors = d3.scale.category20c();
+
+    var _colorDomain = [0, _colors.range().length];
+
+    var _colorCalculator = function(value) {
+        var minValue = _colorDomain[0];
+        var maxValue = _colorDomain[1];
+
+        if (isNaN(value)) value = 0;
+        if(maxValue === null) return _colors(value);
+
+        var colorsLength = _chart.colors().range().length;
+        var denominator = (maxValue - minValue) / colorsLength;
+        var colorValue = Math.abs(Math.min(colorsLength - 1, Math.round((value - minValue) / denominator)));
+        return _chart.colors()(colorValue);
+    };
+
+    var _colorAccessor = function(d, i){return i;};
+
+    _chart.colors = function(_) {
+        if (!arguments.length) return _colors;
+
+        if (_ instanceof Array) {
+            _colors = d3.scale.ordinal().range(_);
+            var domain = [];
+            for(var i = 0; i < _.length; ++i){
+                domain.push(i);
+            }
+            _colors.domain(domain);
+        } else {
+            _colors = _;
+        }
+
+        _colorDomain = [0, _colors.range().length];
+
+        return _chart;
+    };
+
+    _chart.colorCalculator = function(_){
+        if(!arguments.length) return _colorCalculator;
+        _colorCalculator = _;
+        return _chart;
+    };
+
+    _chart.getColor = function(d, i){
+        return _colorCalculator(_colorAccessor(d, i));
+    };
+
+    _chart.colorAccessor = function(_){
+        if(!arguments.length) return _colorAccessor;
+        _colorAccessor = _;
+        return _chart;
+    };
+
+    _chart.colorDomain = function(_){
+        if(!arguments.length) return _colorDomain;
+        _colorDomain = _;
+        return _chart;
+    };
+
+    return _chart;
+};
+
+dc.stackableChart = function (_chart) {
+    var _groupStack = new dc.utils.GroupStack();
+    var _stackLayout = d3.layout.stack()
+        .offset("zero")
+        .order("default")
+        .values(function (d) {
+            return d.points;
+        });
+    var _allGroups;
+    var _allValueAccessors;
+    var _allKeyAccessors;
+    var _stackLayers;
+
+    _chart.stack = function (group, p2, retriever) {
+        if(!arguments.length)
+            _groupStack.clear();
+
+        if (typeof p2 === 'string')
+            _chart.setGroupName(group, p2, retriever);
+        else if (typeof p2 === 'function')
+            retriever = p2;
+
+        _groupStack.setDefaultAccessor(_chart.valueAccessor());
+        _groupStack.addGroup(group, retriever);
+
+        _chart.expireCache();
+
+        return _chart;
+    };
+
+    _chart.expireCache = function () {
+        _allGroups = null;
+        _allValueAccessors = null;
+        _allKeyAccessors = null;
+        _stackLayers = null;
+        return _chart;
+    };
+
+    _chart.allGroups = function () {
+        if (_allGroups === null) {
+            _allGroups = [];
+
+            _allGroups.push(_chart.group());
+
+            for (var i = 0; i < _groupStack.size(); ++i)
+                _allGroups.push(_groupStack.getGroupByIndex(i));
+        }
+
+        return _allGroups;
+    };
+
+    _chart.allValueAccessors = function () {
+        if (_allValueAccessors === null) {
+            _allValueAccessors = [];
+
+            _allValueAccessors.push(_chart.valueAccessor());
+
+            for (var i = 0; i < _groupStack.size(); ++i)
+                _allValueAccessors.push(_groupStack.getAccessorByIndex(i));
+        }
+
+        return _allValueAccessors;
+    };
+
+    _chart.getValueAccessorByIndex = function (groupIndex) {
+        return _chart.allValueAccessors()[groupIndex];
+    };
+
+    _chart.yAxisMin = function () {
+        var min, all = flattenStack();
+
+        min = d3.min(all, function (p) {
+            return  (p.y + p.y0 < p.y0) ? (p.y + p.y0) : p.y0;
+        });
+
+        min = dc.utils.subtract(min, _chart.yAxisPadding());
+
+        return min;
+    };
+
+    _chart.yAxisMax = function () {
+        var max, all = flattenStack();
+
+        max = d3.max(all, function (p) {
+            return p.y + p.y0;
+        });
+
+        max = dc.utils.add(max, _chart.yAxisPadding());
+
+        return max;
+    };
+
+    function flattenStack() {
+        var all = [];
+
+        if (_chart.x()) {
+            var xDomain = _chart.x().domain();
+
+            _chart.stackLayers().forEach(function (e) {
+                e.points.forEach(function (p) {
+                    if (p.x >= xDomain[0] && p.x <= xDomain[xDomain.length-1])
+                        all.push(p);
+                });
+            });
+        } else {
+            _chart.stackLayers().forEach(function (e) {
+                all = all.concat(e.points);
+            });
+        }
+
+        return all;
+    }
+
+    _chart.allKeyAccessors = function () {
+        if (_allKeyAccessors === null) {
+            _allKeyAccessors = [];
+
+            _allKeyAccessors.push(_chart.keyAccessor());
+
+            for (var i = 0; i < _groupStack.size(); ++i)
+                _allKeyAccessors.push(_chart.keyAccessor());
+        }
+
+        return _allKeyAccessors;
+    };
+
+    _chart.getKeyAccessorByIndex = function (groupIndex) {
+        return _chart.allKeyAccessors()[groupIndex];
+    };
+
+    _chart.xAxisMin = function () {
+        var min = null;
+        var allGroups = _chart.allGroups();
+
+        for (var groupIndex = 0; groupIndex < allGroups.length; ++groupIndex) {
+            var group = allGroups[groupIndex];
+            var m = dc.utils.groupMin(group, _chart.getKeyAccessorByIndex(groupIndex));
+            if (min === null || min > m) min = m;
+        }
+
+        return dc.utils.subtract(min, _chart.xAxisPadding());
+    };
+
+    _chart.xAxisMax = function () {
+        var max = null;
+        var allGroups = _chart.allGroups();
+
+        for (var groupIndex = 0; groupIndex < allGroups.length; ++groupIndex) {
+            var group = allGroups[groupIndex];
+            var m = dc.utils.groupMax(group, _chart.getKeyAccessorByIndex(groupIndex));
+            if (max === null || max < m) max = m;
+        }
+
+        return dc.utils.add(max, _chart.xAxisPadding());
+    };
+
+    function getKeyFromData(groupIndex, d) {
+        return _chart.getKeyAccessorByIndex(groupIndex)(d);
+    }
+
+    function getValueFromData(groupIndex, d) {
+        return _chart.getValueAccessorByIndex(groupIndex)(d);
+    }
+
+    function calculateDataPointMatrix(data, groupIndex) {
+        for (var dataIndex = 0; dataIndex < data.length; ++dataIndex) {
+            var d = data[dataIndex];
+            var key = getKeyFromData(groupIndex, d);
+            var value = getValueFromData(groupIndex, d);
+
+            _groupStack.setDataPoint(groupIndex, dataIndex, {data: d, x: key, y: value});
+        }
+    }
+
+    _chart.calculateDataPointMatrixForAll = function () {
+        var groups = _chart.allGroups();
+        for (var groupIndex = 0; groupIndex < groups.length; ++groupIndex) {
+            var group = groups[groupIndex];
+            var data = group.all();
+
+            calculateDataPointMatrix(data, groupIndex);
+        }
+    };
+
+    _chart.getChartStack = function () {
+        return _groupStack;
+    };
+
+    dc.override(_chart, "valueAccessor", function (_) {
+        if (!arguments.length) return _chart._valueAccessor();
+        _chart.expireCache();
+        return _chart._valueAccessor(_);
+    });
+
+    dc.override(_chart, "keyAccessor", function (_) {
+        if (!arguments.length) return _chart._keyAccessor();
+        _chart.expireCache();
+        return _chart._keyAccessor(_);
+    });
+
+    _chart.stackLayout = function (stack) {
+        if (!arguments.length) return _stackLayout;
+        _stackLayout = stack;
+        return _chart;
+    };
+
+    _chart.stackLayers = function (_) {
+        if (!arguments.length) {
+            if (_stackLayers === null) {
+                _chart.calculateDataPointMatrixForAll();
+                _stackLayers = _chart.stackLayout()(_groupStack.toLayers());
+            }
+            return _stackLayers;
+        } else {
+            _stackLayers = _;
+        }
+    };
+
+    _chart.legendables = function () {
+        var items = [];
+        _allGroups.forEach(function (g, i) {
+            items.push(dc.utils.createLegendable(_chart, g, i, _chart.getValueAccessorByIndex(i)));
+        });
+        return items;
+    };
+
+    return _chart;
+};
+
+dc.abstractBubbleChart = function (_chart) {
+    var _maxBubbleRelativeSize = 0.3;
+    var _minRadiusWithLabel = 10;
+
+    _chart.BUBBLE_NODE_CLASS = "node";
+    _chart.BUBBLE_CLASS = "bubble";
+    _chart.MIN_RADIUS = 10;
+
+    _chart = dc.colorChart(_chart);
+
+    _chart.renderLabel(true);
+    _chart.renderTitle(false);
+
+    var _r = d3.scale.linear().domain([0, 100]);
+
+    var _rValueAccessor = function (d) {
+        return d.r;
+    };
+
+    _chart.r = function (_) {
+        if (!arguments.length) return _r;
+        _r = _;
+        return _chart;
+    };
+
+    _chart.radiusValueAccessor = function (_) {
+        if (!arguments.length) return _rValueAccessor;
+        _rValueAccessor = _;
+        return _chart;
+    };
+
+    _chart.rMin = function () {
+        var min = d3.min(_chart.group().all(), function (e) {
+            return _chart.radiusValueAccessor()(e);
+        });
+        return min;
+    };
+
+    _chart.rMax = function () {
+        var max = d3.max(_chart.group().all(), function (e) {
+            return _chart.radiusValueAccessor()(e);
+        });
+        return max;
+    };
+
+    _chart.bubbleR = function (d) {
+        var value = _chart.radiusValueAccessor()(d);
+        var r = _chart.r()(value);
+        if (isNaN(r) || value <= 0)
+            r = 0;
+        return r;
+    };
+
+    var labelFunction = function (d) {
+        return _chart.label()(d);
+    };
+
+    var labelOpacity = function (d) {
+        return (_chart.bubbleR(d) > _minRadiusWithLabel) ? 1 : 0;
+    };
+
+    _chart.doRenderLabel = function (bubbleGEnter) {
+        if (_chart.renderLabel()) {
+            var label = bubbleGEnter.select("text");
+
+            if (label.empty()) {
+                label = bubbleGEnter.append("text")
+                    .attr("text-anchor", "middle")
+                    .attr("dy", ".3em")
+                    .on("click", _chart.onClick);
+            }
+
+            label
+                .attr("opacity", 0)
+                .text(labelFunction);
+            dc.transition(label, _chart.transitionDuration())
+                .attr("opacity", labelOpacity);
+        }
+    };
+
+    _chart.doUpdateLabels = function (bubbleGEnter) {
+        if (_chart.renderLabel()) {
+            var labels = bubbleGEnter.selectAll("text")
+                .text(labelFunction);
+            dc.transition(labels, _chart.transitionDuration())
+                .attr("opacity", labelOpacity);
+        }
+    };
+
+    var titleFunction = function (d) {
+        return _chart.title()(d);
+    };
+
+    _chart.doRenderTitles = function (g) {
+        if (_chart.renderTitle()) {
+            var title = g.select("title");
+
+            if (title.empty())
+                g.append("title").text(titleFunction);
+        }
+    };
+
+    _chart.doUpdateTitles = function (g) {
+        if (_chart.renderTitle()) {
+            g.selectAll("title").text(titleFunction);
+        }
+    };
+
+    _chart.minRadiusWithLabel = function (_) {
+        if (!arguments.length) return _minRadiusWithLabel;
+        _minRadiusWithLabel = _;
+        return _chart;
+    };
+
+    _chart.maxBubbleRelativeSize = function (_) {
+        if (!arguments.length) return _maxBubbleRelativeSize;
+        _maxBubbleRelativeSize = _;
+        return _chart;
+    };
+
+    _chart.initBubbleColor = function (d, i) {
+        this[dc.constants.NODE_INDEX_NAME] = i;
+        return _chart.getColor(d, i);
+    };
+
+    _chart.updateBubbleColor = function (d, i) {
+        // a work around to get correct node index since
+        return _chart.getColor(d, this[dc.constants.NODE_INDEX_NAME]);
+    };
+
+    _chart.fadeDeselectedArea = function () {
+        if (_chart.hasFilter()) {
+            _chart.selectAll("g." + _chart.BUBBLE_NODE_CLASS).each(function (d) {
+                if (_chart.isSelectedNode(d)) {
+                    _chart.highlightSelected(this);
+                } else {
+                    _chart.fadeDeselected(this);
+                }
+            });
+        } else {
+            _chart.selectAll("g." + _chart.BUBBLE_NODE_CLASS).each(function (d) {
+                _chart.resetHighlight(this);
+            });
+        }
+    };
+
+    _chart.isSelectedNode = function (d) {
+        return _chart.hasFilter(d.key);
+    };
+
+    _chart.onClick = function (d) {
+        var filter = d.key;
+        dc.events.trigger(function () {
+            _chart.filter(filter);
+            dc.redrawAll(_chart.chartGroup());
+        });
+    };
+
+    return _chart;
+};
+
+dc.pieChart = function (parent, chartGroup) {
+    var DEFAULT_MIN_ANGLE_FOR_LABEL = 0.5;
+
+    var _sliceCssClass = "pie-slice";
+
+    var _radius,
+        _innerRadius = 0;
+
+    var _g;
+
+    var _minAngleForLabel = DEFAULT_MIN_ANGLE_FOR_LABEL;
+
+    var _chart = dc.colorChart(dc.baseChart({}));
+
+    var _slicesCap = Infinity;
+    var _othersLabel = "Others";
+    var _othersGrouper = function (topRows) {
+        var topRowsSum = d3.sum(topRows, _chart.valueAccessor()),
+            allRows = _chart.group().all(),
+            allRowsSum = d3.sum(allRows, _chart.valueAccessor()),
+            topKeys = topRows.map(_chart.keyAccessor()),
+            allKeys = allRows.map(_chart.keyAccessor()),
+            topSet = d3.set(topKeys),
+            others = allKeys.filter(function(d){return !topSet.has(d);});
+        topRows.push({"others": others,"key": _othersLabel, "value": allRowsSum - topRowsSum });
+    };
+
+    function assemblePieData() {
+        if (_slicesCap == Infinity) {
+            return _chart.computeOrderedGroups();
+        } else {
+            var topRows = _chart.group().top(_slicesCap); // ordered by value
+            topRows = _chart.computeOrderedGroups(topRows); // re-order by key
+            _othersGrouper(topRows);
+            return topRows;
+        }
+    }
+
+    _chart.label(function (d) {
+        return _chart.keyAccessor()(d.data);
+    });
+
+    _chart.renderLabel(true);
+
+    _chart.title(function (d) {
+        return _chart.keyAccessor()(d.data) + ": " + _chart.valueAccessor()(d.data);
+    });
+
+    _chart.transitionDuration(350);
+
+    _chart.doRender = function () {
+        _chart.resetSvg();
+
+        _g = _chart.svg()
+            .append("g")
+            .attr("transform", "translate(" + _chart.cx() + "," + _chart.cy() + ")");
+
+        drawChart();
+
+        return _chart;
+    };
+
+    function drawChart() {
+        if (_chart.dataSet()) {
+            var pie = calculateDataPie();
+
+            // set radius on basis of chart dimension if missing
+            _radius = _radius ? _radius : d3.min([_chart.width(), _chart.height()]) /2;
+
+            var arc = _chart.buildArcs();
+
+            var pieData = pie(assemblePieData());
+
+            if (_g) {
+                var slices = _g.selectAll("g." + _sliceCssClass)
+                    .data(pieData);
+
+                createElements(slices, arc, pieData);
+
+                updateElements(pieData, arc);
+
+                removeElements(slices);
+
+                highlightFilter();
+            }
+        }
+    }
+
+    function createElements(slices, arc, pieData) {
+        var slicesEnter = createSliceNodes(slices);
+
+        createSlicePath(slicesEnter, arc);
+
+        createTitles(slicesEnter);
+
+        createLabels(pieData, arc);
+    }
+
+    function createSliceNodes(slices) {
+        var slicesEnter = slices
+            .enter()
+            .append("g")
+            .attr("class", function (d, i) {
+                return _sliceCssClass + " _" + i;
+            });
+        return slicesEnter;
+    }
+
+    function createSlicePath(slicesEnter, arc) {
+        var slicePath = slicesEnter.append("path")
+            .attr("fill", function (d, i) {
+                return _chart.getColor(d, i);
+            })
+            .on("click", onClick)
+            .attr("d", function (d, i) {
+                return safeArc(d, i, arc);
+            });
+        slicePath.transition()
+            .duration(_chart.transitionDuration())
+            .attrTween("d", tweenPie);
+    }
+
+    function createTitles(slicesEnter) {
+        if (_chart.renderTitle()) {
+            slicesEnter.append("title").text(function (d) {
+                return _chart.title()(d);
+            });
+        }
+    }
+
+    function createLabels(pieData, arc) {
+        if (_chart.renderLabel()) {
+            var labels = _g.selectAll("text." + _sliceCssClass)
+                .data(pieData);
+
+            labels.exit().remove();
+
+            var labelsEnter = labels
+                .enter()
+                .append("text")
+                .attr("class", function (d, i) {
+                    return _sliceCssClass + " _" + i;
+                })
+                .on("click", onClick);
+            dc.transition(labelsEnter, _chart.transitionDuration())
+                .attr("transform", function (d) {
+                    d.innerRadius = _chart.innerRadius();
+                    d.outerRadius = _radius;
+                    var centroid = arc.centroid(d);
+                    if (isNaN(centroid[0]) || isNaN(centroid[1])) {
+                        return "translate(0,0)";
+                    } else {
+                        return "translate(" + centroid + ")";
+                    }
+                })
+                .attr("text-anchor", "middle")
+                .text(function (d) {
+                    var data = d.data;
+                    if (sliceHasNoData(data) || sliceTooSmall(d))
+                        return "";
+                    return _chart.label()(d);
+                });
+        }
+    }
+
+    function updateElements(pieData, arc) {
+        updateSlicePaths(pieData, arc);
+        updateLabels(pieData, arc);
+        updateTitles(pieData);
+    }
+
+    function updateSlicePaths(pieData, arc) {
+        var slicePaths = _g.selectAll("g." + _sliceCssClass)
+            .data(pieData)
+            .select("path")
+            .attr("d", function (d, i) {
+                return safeArc(d, i, arc);
+            });
+        dc.transition(slicePaths, _chart.transitionDuration(),
+            function (s) {
+                s.attrTween("d", tweenPie);
+            }).attr("fill", function (d, i) {
+                return _chart.getColor(d, i);
+            });
+    }
+
+    function updateLabels(pieData, arc) {
+        if (_chart.renderLabel()) {
+            var labels = _g.selectAll("text." + _sliceCssClass)
+                .data(pieData);
+            dc.transition(labels, _chart.transitionDuration())
+                .attr("transform", function (d) {
+                    d.innerRadius = _chart.innerRadius();
+                    d.outerRadius = _radius;
+                    var centroid = arc.centroid(d);
+                    if (isNaN(centroid[0]) || isNaN(centroid[1])) {
+                        return "translate(0,0)";
+                    } else {
+                        return "translate(" + centroid + ")";
+                    }
+                })
+                .attr("text-anchor", "middle")
+                .text(function (d) {
+                    var data = d.data;
+                    if (sliceHasNoData(data) || sliceTooSmall(d))
+                        return "";
+                    return _chart.label()(d);
+                });
+        }
+    }
+
+    function updateTitles(pieData) {
+        if (_chart.renderTitle()) {
+            _g.selectAll("g." + _sliceCssClass)
+                .data(pieData)
+                .select("title")
+                .text(function (d) {
+                    return _chart.title()(d);
+                });
+        }
+    }
+
+    function removeElements(slices) {
+        slices.exit().remove();
+    }
+
+    function highlightFilter() {
+        if (_chart.hasFilter()) {
+            _chart.selectAll("g." + _sliceCssClass).each(function (d) {
+                if (_chart.isSelectedSlice(d)) {
+                    _chart.highlightSelected(this);
+                } else {
+                    _chart.fadeDeselected(this);
+                }
+            });
+        } else {
+            _chart.selectAll("g." + _sliceCssClass).each(function (d) {
+                _chart.resetHighlight(this);
+            });
+        }
+    }
+
+    _chart.innerRadius = function (r) {
+        if (!arguments.length) return _innerRadius;
+        _innerRadius = r;
+        return _chart;
+    };
+
+    _chart.radius = function (r) {
+        if (!arguments.length) return _radius;
+        _radius = r;
+        return _chart;
+    };
+
+    _chart.cx = function () {
+        return _chart.width() / 2;
+    };
+
+    _chart.cy = function () {
+        return _chart.height() / 2;
+    };
+
+    _chart.buildArcs = function () {
+        return d3.svg.arc().outerRadius(_radius).innerRadius(_innerRadius);
+    };
+
+    _chart.isSelectedSlice = function (d) {
+        return _chart.hasFilter(_chart.keyAccessor()(d.data));
+    };
+
+    _chart.doRedraw = function () {
+        drawChart();
+        return _chart;
+    };
+
+    _chart.minAngleForLabel = function (_) {
+        if (!arguments.length) return _minAngleForLabel;
+        _minAngleForLabel = _;
+        return _chart;
+    };
+
+    _chart.slicesCap = function (_) {
+        if (!arguments.length) return _slicesCap;
+        _slicesCap = _;
+        return _chart;
+    };
+
+    _chart.othersLabel = function (_) {
+        if (!arguments.length) return _othersLabel;
+        _othersLabel = _;
+        return _chart;
+    };
+
+    _chart.othersGrouper = function (_) {
+        if (!arguments.length) return _othersGrouper;
+        _othersGrouper = _;
+        return _chart;
+    };
+
+    function calculateDataPie() {
+        return d3.layout.pie().sort(null).value(function (d) {
+            return _chart.valueAccessor()(d);
+        });
+    }
+
+    function sliceTooSmall(d) {
+        var angle = (d.endAngle - d.startAngle);
+        return isNaN(angle) || angle < _minAngleForLabel;
+    }
+
+    function sliceHasNoData(data) {
+        return _chart.valueAccessor()(data) === 0;
+    }
+
+    function tweenPie(b) {
+        b.innerRadius = _chart.innerRadius();
+        var current = this._current;
+        if (isOffCanvas(current))
+            current = {startAngle: 0, endAngle: 0};
+        var i = d3.interpolate(current, b);
+        this._current = i(0);
+        return function (t) {
+            return safeArc(i(t), 0, _chart.buildArcs());
+        };
+    }
+
+    function isOffCanvas(current) {
+        return !current || isNaN(current.startAngle) || isNaN(current.endAngle);
+    }
+
+    function onClick(d) {
+        if (d.data.others)
+            d.data.others.forEach(function(f) {
+                _chart.filter(f);
+            });
+        _chart.onClick(d.data);
+    }
+
+    function safeArc(d, i, arc) {
+        var path = arc(d, i);
+        if (path.indexOf("NaN") >= 0)
+            path = "M0,0";
+        return path;
+    }
+
+    return _chart.anchor(parent, chartGroup);
+};
+
+dc.barChart = function (parent, chartGroup) {
+    var MIN_BAR_WIDTH = 1;
+    var DEFAULT_GAP_BETWEEN_BARS = 2;
+
+    var _chart = dc.stackableChart(dc.coordinateGridChart({}));
+
+    var _gap = DEFAULT_GAP_BETWEEN_BARS;
+    var _centerBar = false;
+
+    var _numberOfBars;
+    var _barWidth;
+
+    dc.override(_chart, 'rescale', function () {
+        _chart._rescale();
+        _numberOfBars = undefined;
+        _barWidth = undefined;
+        getNumberOfBars();
+    });
+
+    _chart.plotData = function () {
+        var layers = _chart.chartBodyG().selectAll("g.stack")
+            .data(_chart.stackLayers());
+
+        calculateBarWidth();
+
+        layers
+            .enter()
+            .append("g")
+            .attr("class", function (d, i) {
+                return "stack " + "_" + i;
+            });
+
+        layers.each(function (d, i) {
+            var layer = d3.select(this);
+
+            renderBars(layer, d, i);
+        });
+
+        _chart.stackLayers(null);
+    };
+
+    function barHeight(d) {
+        return dc.utils.safeNumber(Math.abs(_chart.y()(d.y + d.y0) - _chart.y()(d.y0)));
+    }
+
+    function renderBars(layer, d, i) {
+        var bars = layer.selectAll("rect.bar")
+            .data(d.points);
+
+        bars.enter()
+            .append("rect")
+            .attr("class", "bar")
+            .attr("fill", function (d) {
+                return _chart.colors()(i);
+            })
+            .append("title").text(_chart.title());
+
+        if (_chart.isOrdinal())
+            bars.on("click", onClick);
+
+        dc.transition(bars, _chart.transitionDuration())
+            .attr("x", function (d) {
+                var x = _chart.x()(d.x);
+                if (_centerBar || _chart.isOrdinal()) x -= _barWidth / 2;
+                return  dc.utils.safeNumber(x);
+            })
+            .attr("y", function (d) {
+                var y = _chart.y()(d.y + d.y0);
+
+                if (d.y < 0)
+                    y -= barHeight(d);
+
+                return dc.utils.safeNumber(y);
+            })
+            .attr("width", _barWidth)
+            .attr("height", function (d) {
+                return barHeight(d);
+            })
+            .select("title").text(_chart.title());
+
+        dc.transition(bars.exit(), _chart.transitionDuration())
+            .attr("height", 0)
+            .remove();
+    }
+
+    function calculateBarWidth() {
+        if (_barWidth === undefined) {
+            var numberOfBars = _chart.isOrdinal() ? getNumberOfBars() + 1 : getNumberOfBars();
+
+            var w = Math.floor((_chart.xAxisLength() - (numberOfBars - 1) * _gap) / numberOfBars);
+
+            if (w == Infinity || isNaN(w) || w < MIN_BAR_WIDTH)
+                w = MIN_BAR_WIDTH;
+
+            _barWidth = w;
+        }
+    }
+
+    function getNumberOfBars() {
+        if (_numberOfBars === undefined) {
+            _numberOfBars = _chart.xUnitCount();
+        }
+
+        return _numberOfBars;
+    }
+
+    _chart.fadeDeselectedArea = function () {
+        var bars = _chart.chartBodyG().selectAll("rect.bar");
+        var extent = _chart.brush().extent();
+
+        if (_chart.isOrdinal()) {
+            if (_chart.hasFilter()) {
+                bars.classed(dc.constants.SELECTED_CLASS, function (d) {
+                    return _chart.hasFilter(_chart.keyAccessor()(d.data));
+                });
+                bars.classed(dc.constants.DESELECTED_CLASS, function (d) {
+                    return !_chart.hasFilter(_chart.keyAccessor()(d.data));
+                });
+            } else {
+                bars.classed(dc.constants.SELECTED_CLASS, false);
+                bars.classed(dc.constants.DESELECTED_CLASS, false);
+            }
+        } else {
+            if (!_chart.brushIsEmpty(extent)) {
+                var start = extent[0];
+                var end = extent[1];
+
+                bars.classed(dc.constants.DESELECTED_CLASS, function (d) {
+                    var xValue = _chart.keyAccessor()(d.data);
+                    return xValue < start || xValue >= end;
+                });
+            } else {
+                bars.classed(dc.constants.DESELECTED_CLASS, false);
+            }
+        }
+    };
+
+    _chart.centerBar = function (_) {
+        if (!arguments.length) return _centerBar;
+        _centerBar = _;
+        return _chart;
+    };
+
+    function onClick(d) {
+        _chart.onClick(d.data);
+    }
+
+    _chart.gap = function (_) {
+        if (!arguments.length) return _gap;
+        _gap = _;
+        return _chart;
+    };
+
+    _chart.extendBrush = function () {
+        var extent = _chart.brush().extent();
+        if (_chart.round() && !_centerBar) {
+            extent[0] = extent.map(_chart.round())[0];
+            extent[1] = extent.map(_chart.round())[1];
+
+            _chart.chartBodyG().select(".brush")
+                .call(_chart.brush().extent(extent));
+        }
+        return extent;
+    };
+
+    _chart.legendHighlight = function (d) {
+        _chart.select('.chart-body').selectAll('rect.bar').filter(function () {
+            return d3.select(this).attr('fill') == d.color;
+        }).classed('highlight', true);
+        _chart.select('.chart-body').selectAll('rect.bar').filter(function () {
+            return d3.select(this).attr('fill') != d.color;
+        }).classed('fadeout', true);
+    };
+
+    _chart.legendReset = function (d) {
+        _chart.selectAll('.chart-body').selectAll('rect.bar').filter(function () {
+            return d3.select(this).attr('fill') == d.color;
+        }).classed('highlight', false);
+        _chart.selectAll('.chart-body').selectAll('rect.bar').filter(function () {
+            return d3.select(this).attr('fill') != d.color;
+        }).classed('fadeout', false);
+    };
+
+    return _chart.anchor(parent, chartGroup);
+};
+
+dc.lineChart = function (parent, chartGroup) {
+    var DEFAULT_DOT_RADIUS = 5;
+    var TOOLTIP_G_CLASS = "dc-tooltip";
+    var DOT_CIRCLE_CLASS = "dot";
+    var Y_AXIS_REF_LINE_CLASS = "yRef";
+    var X_AXIS_REF_LINE_CLASS = "xRef";
+
+    var _chart = dc.stackableChart(dc.coordinateGridChart({}));
+    var _renderArea = false;
+    var _dotRadius = DEFAULT_DOT_RADIUS;
+    var _interpolate = 'linear';
+    var _tension = 0.7;
+
+    _chart.transitionDuration(500);
+
+    _chart.plotData = function () {
+        var layers = _chart.chartBodyG().selectAll("g.stack")
+            .data(_chart.stackLayers());
+
+        var layersEnter = layers
+            .enter()
+            .append("g")
+            .attr("class", function (d, i) {
+                return "stack " + "_" + i;
+            });
+
+        drawLine(layersEnter, layers);
+
+        drawArea(layersEnter, layers);
+
+        drawDots(layers);
+
+        _chart.stackLayers(null);
+    };
+
+    _chart.interpolate = function(_){
+        if (!arguments.length) return _interpolate;
+        _interpolate = _;
+        return _chart;
+    };
+
+    _chart.tension = function(_){
+        if (!arguments.length) return _tension;
+        _tension = _;
+        return _chart;
+    };
+
+    _chart.renderArea = function (_) {
+        if (!arguments.length) return _renderArea;
+        _renderArea = _;
+        return _chart;
+    };
+
+    function drawLine(layersEnter, layers) {
+        var line = d3.svg.line()
+            .x(function (d) {
+                return _chart.x()(d.x);
+            })
+            .y(function (d) {
+                return _chart.y()(d.y + d.y0);
+            })
+            .interpolate(_interpolate)
+            .tension(_tension);
+
+        layersEnter.append("path")
+            .attr("class", "line")
+            .attr("stroke", function (d, i) {
+                return _chart.colors()(i);
+            })
+            .attr("fill", function (d, i) {
+                return _chart.colors()(i);
+            });
+
+        dc.transition(layers.select("path.line"), _chart.transitionDuration())
+            .attr("d", function (d) {
+                return safeD(line(d.points));
+            });
+    }
+
+    function drawArea(layersEnter, layers) {
+        if (_renderArea) {
+            var area = d3.svg.area()
+                .x(function (d) {
+                    return _chart.x()(d.x);
+                })
+                .y(function (d) {
+                    return _chart.y()(d.y + d.y0);
+                })
+                .y0(function (d) {
+                    return _chart.y()(d.y0);
+                })
+                .interpolate(_interpolate)
+                .tension(_tension);
+
+            layersEnter.append("path")
+                .attr("class", "area")
+                .attr("fill", function (d, i) {
+                    return _chart.colors()(i);
+                })
+                .attr("d", function (d) {
+                    return safeD(area(d.points));
+                });
+
+            dc.transition(layers.select("path.area"), _chart.transitionDuration())
+                .attr("d", function (d) {
+                    return safeD(area(d.points));
+                });
+        }
+    }
+
+    function safeD(d){
+        return (!d || d.indexOf("NaN") >= 0) ? "M0,0" : d;
+    }
+
+    function drawDots(layersEnter) {
+        if (!_chart.brushOn()) {
+            layersEnter.each(function (d, i) {
+                var layer = d3.select(this);
+
+                var g = layer.select("g." + TOOLTIP_G_CLASS);
+                if (g.empty()) g = layer.append("g").attr("class", TOOLTIP_G_CLASS);
+
+                createRefLines(g);
+
+                var dots = g.selectAll("circle." + DOT_CIRCLE_CLASS)
+                    .data(g.datum().points);
+
+                dots.enter()
+                    .append("circle")
+                    .attr("class", DOT_CIRCLE_CLASS)
+                    .attr("r", _dotRadius)
+                    .attr("fill", function (d) {
+                        return _chart.colors()(i);
+                    })
+                    .style("fill-opacity", 1e-6)
+                    .style("stroke-opacity", 1e-6)
+                    .on("mousemove", function (d) {
+                        var dot = d3.select(this);
+                        showDot(dot);
+                        showRefLines(dot, g);
+                    })
+                    .on("mouseout", function (d) {
+                        var dot = d3.select(this);
+                        hideDot(dot);
+                        hideRefLines(g);
+                    })
+                    .append("title").text(_chart.title());
+
+                dots.attr("cx", function (d) {
+                        return dc.utils.safeNumber(_chart.x()(d.x));
+                    })
+                    .attr("cy", function (d) {
+                        return dc.utils.safeNumber(_chart.y()(d.y + d.y0));
+                    })
+                    .select("title").text(_chart.title());
+
+                dots.exit().remove();
+            });
+        }
+    }
+
+    function createRefLines(g) {
+        var yRefLine = g.select("path." + Y_AXIS_REF_LINE_CLASS).empty() ? g.append("path").attr("class", Y_AXIS_REF_LINE_CLASS) : g.select("path." + Y_AXIS_REF_LINE_CLASS);
+        yRefLine.style("display", "none").attr("stroke-dasharray", "5,5");
+
+        var xRefLine = g.select("path." + X_AXIS_REF_LINE_CLASS).empty() ? g.append("path").attr("class", X_AXIS_REF_LINE_CLASS) : g.select("path." + X_AXIS_REF_LINE_CLASS);
+        xRefLine.style("display", "none").attr("stroke-dasharray", "5,5");
+    }
+
+    function showDot(dot) {
+        dot.style("fill-opacity", 0.8);
+        dot.style("stroke-opacity", 0.8);
+        return dot;
+    }
+
+    function showRefLines(dot, g) {
+        var x = dot.attr("cx");
+        var y = dot.attr("cy");
+        g.select("path." + Y_AXIS_REF_LINE_CLASS).style("display", "").attr("d", "M0 " + y + "L" + (x) + " " + (y));
+        g.select("path." + X_AXIS_REF_LINE_CLASS).style("display", "").attr("d", "M" + x + " " + _chart.yAxisHeight() + "L" + x + " " + y);
+    }
+
+    function hideDot(dot) {
+        dot.style("fill-opacity", 1e-6).style("stroke-opacity", 1e-6);
+    }
+
+    function hideRefLines(g) {
+        g.select("path." + Y_AXIS_REF_LINE_CLASS).style("display", "none");
+        g.select("path." + X_AXIS_REF_LINE_CLASS).style("display", "none");
+    }
+
+    _chart.dotRadius = function (_) {
+        if (!arguments.length) return _dotRadius;
+        _dotRadius = _;
+        return _chart;
+    };
+
+    _chart.legendHighlight = function (d) {
+        _chart.selectAll('.chart-body').selectAll('path').filter(function () {
+            return d3.select(this).attr('fill') == d.color;
+        }).classed('highlight', true);
+        _chart.selectAll('.chart-body').selectAll('path').filter(function () {
+            return d3.select(this).attr('fill') != d.color;
+        }).classed('fadeout', true);
+    };
+
+    _chart.legendReset = function (d) {
+        _chart.selectAll('.chart-body').selectAll('path').filter(function () {
+            return d3.select(this).attr('fill') == d.color;
+        }).classed('highlight', false);
+        _chart.selectAll('.chart-body').selectAll('path').filter(function () {
+            return d3.select(this).attr('fill') != d.color;
+        }).classed('fadeout', false);
+    };
+
+    return _chart.anchor(parent, chartGroup);
+};
+
+dc.dataCount = function(parent, chartGroup) {
+    var _formatNumber = d3.format(",d");
+    var _chart = dc.baseChart({});
+
+    _chart.doRender = function() {
+        _chart.selectAll(".total-count").text(_formatNumber(_chart.dimension().size()));
+        _chart.selectAll(".filter-count").text(_formatNumber(_chart.group().value()));
+
+        return _chart;
+    };
+
+    _chart.doRedraw = function(){
+        return _chart.doRender();
+    };
+
+    return _chart.anchor(parent, chartGroup);
+};
+
+dc.dataTable = function(parent, chartGroup) {
+    var LABEL_CSS_CLASS = "dc-table-label";
+    var ROW_CSS_CLASS = "dc-table-row";
+    var COLUMN_CSS_CLASS = "dc-table-column";
+    var GROUP_CSS_CLASS = "dc-table-group";
+
+    var _chart = dc.baseChart({});
+
+    var _size = 25;
+    var _columns = [];
+    var _sortBy = function(d) {
+        return d;
+    };
+    var _order = d3.ascending;
+    var _sort;
+
+    _chart.doRender = function() {
+        _chart.selectAll("tbody").remove();
+
+        renderRows(renderGroups());
+
+        return _chart;
+    };
+
+    function renderGroups() {
+        var groups = _chart.root().selectAll("tbody")
+            .data(nestEntries(), function(d) {
+                return _chart.keyAccessor()(d);
+            });
+
+        var rowGroup = groups
+            .enter()
+            .append("tbody");
+
+        rowGroup
+            .append("tr")
+            .attr("class", GROUP_CSS_CLASS)
+                .append("td")
+                .attr("class", LABEL_CSS_CLASS)
+                .attr("colspan", _columns.length)
+                .html(function(d) {
+                    return _chart.keyAccessor()(d);
+                });
+
+        groups.exit().remove();
+
+        return rowGroup;
+    }
+
+    function nestEntries() {
+        if (!_sort)
+            _sort = crossfilter.quicksort.by(_sortBy);
+
+        var entries = _chart.dimension().top(_size);
+
+        return d3.nest()
+            .key(_chart.group())
+            .sortKeys(_order)
+            .sortValues(_order)
+            .entries(_sort(entries, 0, entries.length));
+    }
+
+    function renderRows(groups) {
+        var rows = groups.order()
+            .selectAll("tr." + ROW_CSS_CLASS)
+            .data(function(d) {
+                return d.values;
+            });
+
+        var rowEnter = rows.enter()
+            .append("tr")
+            .attr("class", ROW_CSS_CLASS);
+
+        for (var i = 0; i < _columns.length; ++i) {
+            var f = _columns[i];
+            rowEnter.append("td")
+                .attr("class", COLUMN_CSS_CLASS + " _" + i)
+                .html(function(d) {
+                    return f(d);
+                });
+        }
+
+        rows.exit().remove();
+
+        return rows;
+    }
+
+    _chart.doRedraw = function() {
+        return _chart.doRender();
+    };
+
+    _chart.size = function(s) {
+        if (!arguments.length) return _size;
+        _size = s;
+        return _chart;
+    };
+
+    _chart.columns = function(_) {
+        if (!arguments.length) return _columns;
+        _columns = _;
+        return _chart;
+    };
+
+    _chart.sortBy = function(_) {
+        if (!arguments.length) return _sortBy;
+        _sortBy = _;
+        return _chart;
+    };
+
+    _chart.order = function(_) {
+        if (!arguments.length) return _order;
+        _order = _;
+        return _chart;
+    };
+
+    return _chart.anchor(parent, chartGroup);
+};
+
+dc.bubbleChart = function(parent, chartGroup) {
+    var _chart = dc.abstractBubbleChart(dc.coordinateGridChart({}));
+
+    var _elasticRadius = false;
+
+    _chart.transitionDuration(750);
+
+    var bubbleLocator = function(d) {
+        return "translate(" + (bubbleX(d)) + "," + (bubbleY(d)) + ")";
+    };
+
+    _chart.elasticRadius = function(_) {
+        if (!arguments.length) return _elasticRadius;
+        _elasticRadius = _;
+        return _chart;
+    };
+
+    _chart.plotData = function() {
+        if (_elasticRadius)
+            _chart.r().domain([_chart.rMin(), _chart.rMax()]);
+
+        _chart.r().range([_chart.MIN_RADIUS, _chart.xAxisLength() * _chart.maxBubbleRelativeSize()]);
+
+        var bubbleG = _chart.chartBodyG().selectAll("g." + _chart.BUBBLE_NODE_CLASS)
+            .data(_chart.group().all());
+
+        renderNodes(bubbleG);
+
+        updateNodes(bubbleG);
+
+        removeNodes(bubbleG);
+
+        _chart.fadeDeselectedArea();
+    };
+
+    function renderNodes(bubbleG) {
+        var bubbleGEnter = bubbleG.enter().append("g");
+
+        bubbleGEnter
+            .attr("class", _chart.BUBBLE_NODE_CLASS)
+            .attr("transform", bubbleLocator)
+            .append("circle").attr("class", function(d, i) {
+                return _chart.BUBBLE_CLASS + " _" + i;
+            })
+            .on("click", _chart.onClick)
+            .attr("fill", _chart.initBubbleColor)
+            .attr("r", 0);
+        dc.transition(bubbleG, _chart.transitionDuration())
+            .attr("r", function(d) {
+                return _chart.bubbleR(d);
+            })
+            .attr("opacity", function(d) {
+                return (_chart.bubbleR(d) > 0) ? 1 : 0;
+            });
+
+        _chart.doRenderLabel(bubbleGEnter);
+
+        _chart.doRenderTitles(bubbleGEnter);
+    }
+
+    function updateNodes(bubbleG) {
+        dc.transition(bubbleG, _chart.transitionDuration())
+            .attr("transform", bubbleLocator)
+            .selectAll("circle." + _chart.BUBBLE_CLASS)
+            .attr("fill", _chart.updateBubbleColor)
+            .attr("r", function(d) {
+                return _chart.bubbleR(d);
+            })
+            .attr("opacity", function(d) {
+                return (_chart.bubbleR(d) > 0) ? 1 : 0;
+            });
+
+        _chart.doUpdateLabels(bubbleG);
+        _chart.doUpdateTitles(bubbleG);
+    }
+
+    function removeNodes(bubbleG) {
+        bubbleG.exit().remove();
+    }
+
+    function bubbleX(d) {
+        var x = _chart.x()(_chart.keyAccessor()(d));
+        if (isNaN(x))
+            x = 0;
+        return x;
+    }
+
+    function bubbleY(d) {
+        var y = _chart.y()(_chart.valueAccessor()(d));
+        if (isNaN(y))
+            y = 0;
+        return y;
+    }
+
+    _chart.renderBrush = function(g) {
+        // override default x axis brush from parent chart
+    };
+
+    _chart.redrawBrush = function(g) {
+        // override default x axis brush from parent chart
+        _chart.fadeDeselectedArea();
+    };
+
+    return _chart.anchor(parent, chartGroup);
+};
+
+dc.compositeChart = function (parent, chartGroup) {
+    var SUB_CHART_CLASS = "sub";
+
+    var _chart = dc.coordinateGridChart({});
+    var _children = [];
+
+    _chart.transitionDuration(500);
+
+    dc.override(_chart, "generateG", function () {
+        var g = this._generateG();
+
+        for (var i = 0; i < _children.length; ++i) {
+            var child = _children[i];
+
+            generateChildG(child, i);
+
+            if (child.dimension() === undefined) child.dimension(_chart.dimension());
+            if (child.group() === undefined) child.group(_chart.group());
+            child.chartGroup(_chart.chartGroup());
+            child.svg(_chart.svg());
+            child.xUnits(_chart.xUnits());
+            child.transitionDuration(_chart.transitionDuration());
+            child.brushOn(_chart.brushOn());
+        }
+
+        return g;
+    });
+
+    function generateChildG(child, i) {
+        child.generateG(_chart.g());
+        child.g().attr("class", SUB_CHART_CLASS + " _" + i);
+    }
+
+    _chart.plotData = function () {
+        for (var i = 0; i < _children.length; ++i) {
+            var child = _children[i];
+
+            if (child.g() === undefined) {
+                generateChildG(child, i);
+            }
+
+            child.x(_chart.x());
+            child.y(_chart.y());
+            child.xAxis(_chart.xAxis());
+            child.yAxis(_chart.yAxis());
+
+            child.plotData();
+
+            child.activateRenderlets();
+        }
+    };
+
+    _chart.fadeDeselectedArea = function () {
+        for (var i = 0; i < _children.length; ++i) {
+            var child = _children[i];
+            child.brush(_chart.brush());
+            child.fadeDeselectedArea();
+        }
+    };
+
+    _chart.compose = function (charts) {
+        _children = charts;
+        for (var i = 0; i < _children.length; ++i) {
+            var child = _children[i];
+            child.height(_chart.height());
+            child.width(_chart.width());
+            child.margins(_chart.margins());
+        }
+        return _chart;
+    };
+
+    _chart.children = function () {
+        return _children;
+    };
+
+    function getAllYAxisMinFromChildCharts() {
+        var allMins = [];
+        for (var i = 0; i < _children.length; ++i) {
+            allMins.push(_children[i].yAxisMin());
+        }
+        return allMins;
+    }
+
+    _chart.yAxisMin = function () {
+        return d3.min(getAllYAxisMinFromChildCharts());
+    };
+
+    function getAllYAxisMaxFromChildCharts() {
+        var allMaxes = [];
+        for (var i = 0; i < _children.length; ++i) {
+            allMaxes.push(_children[i].yAxisMax());
+        }
+        return allMaxes;
+    }
+
+    _chart.yAxisMax = function () {
+        return dc.utils.add(d3.max(getAllYAxisMaxFromChildCharts()), _chart.yAxisPadding());
+    };
+
+    function getAllXAxisMinFromChildCharts() {
+        var allMins = [];
+        for (var i = 0; i < _children.length; ++i) {
+            allMins.push(_children[i].xAxisMin());
+        }
+        return allMins;
+    }
+
+    _chart.xAxisMin = function () {
+        return dc.utils.subtract(d3.min(getAllXAxisMinFromChildCharts()), _chart.xAxisPadding());
+    };
+
+    function getAllXAxisMaxFromChildCharts() {
+        var allMaxes = [];
+        for (var i = 0; i < _children.length; ++i) {
+            allMaxes.push(_children[i].xAxisMax());
+        }
+        return allMaxes;
+    }
+
+    _chart.xAxisMax = function () {
+        return dc.utils.add(d3.max(getAllXAxisMaxFromChildCharts()), _chart.xAxisPadding());
+    };
+
+    _chart.legendables = function () {
+        var items = [];
+
+        for (var j = 0; j < _children.length; ++j) {
+            var childChart = _children[j];
+            childChart.allGroups().forEach(function (g, i) {
+                items.push(dc.utils.createLegendable(childChart, g, i, childChart.getValueAccessorByIndex(i)));
+            });
+        }
+
+        return items;
+    };
+
+    _chart.legendHighlight = function (d) {
+        for (var j = 0; j < _children.length; ++j) {
+            var child = _children[j];
+            child.legendHighlight(d);
+        }
+    };
+
+    _chart.legendReset = function (d) {
+        for (var j = 0; j < _children.length; ++j) {
+            var child = _children[j];
+            child.legendReset(d);
+        }
+    };
+
+    return _chart.anchor(parent, chartGroup);
+};
+
+dc.geoChoroplethChart = function (parent, chartGroup) {
+    var _chart = dc.colorChart(dc.baseChart({}));
+
+    _chart.colorAccessor(function (d, i) {
+        return d;
+    });
+
+    var _geoPath = d3.geo.path();
+    var _projectionFlag;
+
+    var _geoJsons = [];
+
+    _chart.doRender = function () {
+        _chart.resetSvg();
+        for (var layerIndex = 0; layerIndex < _geoJsons.length; ++layerIndex) {
+            var states = _chart.svg().append("g")
+                .attr("class", "layer" + layerIndex);
+
+            var regionG = states.selectAll("g." + geoJson(layerIndex).name)
+                .data(geoJson(layerIndex).data)
+                .enter()
+                .append("g")
+                .attr("class", geoJson(layerIndex).name);
+
+            regionG
+                .append("path")
+                .attr("fill", "white")
+                .attr("d", _geoPath);
+
+            regionG.append("title");
+
+            plotData(layerIndex);
+        }
+        _projectionFlag = false;
+    };
+
+    function plotData(layerIndex) {
+        var maxValue = dc.utils.groupMax(_chart.group(), _chart.valueAccessor());
+        var data = generateLayeredData();
+
+        if (isDataLayer(layerIndex)) {
+            var regionG = renderRegionG(layerIndex);
+
+            renderPaths(regionG, layerIndex, data, maxValue);
+
+            renderTitle(regionG, layerIndex, data);
+        }
+    }
+
+    function generateLayeredData() {
+        var data = {};
+        var groupAll = _chart.group().all();
+        for (var i = 0; i < groupAll.length; ++i) {
+            data[_chart.keyAccessor()(groupAll[i])] = _chart.valueAccessor()(groupAll[i]);
+        }
+        return data;
+    }
+
+    function isDataLayer(layerIndex) {
+        return geoJson(layerIndex).keyAccessor;
+    }
+
+    function renderRegionG(layerIndex) {
+        var regionG = _chart.svg()
+            .selectAll(layerSelector(layerIndex))
+            .classed("selected", function (d) {
+                return isSelected(layerIndex, d);
+            })
+            .classed("deselected", function (d) {
+                return isDeselected(layerIndex, d);
+            })
+            .attr("class", function (d) {
+                var layerNameClass = geoJson(layerIndex).name;
+                var regionClass = dc.utils.nameToId(geoJson(layerIndex).keyAccessor(d));
+                var baseClasses = layerNameClass + " " + regionClass;
+                if (isSelected(layerIndex, d)) baseClasses += " selected";
+                if (isDeselected(layerIndex, d)) baseClasses += " deselected";
+                return baseClasses;
+            });
+        return regionG;
+    }
+
+    function layerSelector(layerIndex) {
+        return "g.layer" + layerIndex + " g." + geoJson(layerIndex).name;
+    }
+
+    function isSelected(layerIndex, d) {
+        return _chart.hasFilter() && _chart.hasFilter(getKey(layerIndex, d));
+    }
+
+    function isDeselected(layerIndex, d) {
+        return _chart.hasFilter() && !_chart.hasFilter(getKey(layerIndex, d));
+    }
+
+    function getKey(layerIndex, d) {
+        return geoJson(layerIndex).keyAccessor(d);
+    }
+
+    function geoJson(index) {
+        return _geoJsons[index];
+    }
+
+    function renderPaths(regionG, layerIndex, data) {
+        var paths = regionG
+            .select("path")
+            .attr("fill", function (d) {
+                var currentFill = d3.select(this).attr("fill");
+                if (currentFill)
+                    return currentFill;
+                return "none";
+            })
+            .on("click", function (d) {
+                return _chart.onClick(d, layerIndex);
+            });
+
+        dc.transition(paths, _chart.transitionDuration()).attr("fill", function (d, i) {
+            return _chart.getColor(data[geoJson(layerIndex).keyAccessor(d)], i);
+        });
+    }
+
+    _chart.onClick = function (d, layerIndex) {
+        var selectedRegion = geoJson(layerIndex).keyAccessor(d);
+        dc.events.trigger(function () {
+            _chart.filter(selectedRegion);
+            dc.redrawAll(_chart.chartGroup());
+        });
+    };
+
+    function renderTitle(regionG, layerIndex, data) {
+        if (_chart.renderTitle()) {
+            regionG.selectAll("title").text(function (d) {
+                var key = getKey(layerIndex, d);
+                var value = data[key];
+                return _chart.title()({key: key, value: value});
+            });
+        }
+    }
+
+    _chart.doRedraw = function () {
+        for (var layerIndex = 0; layerIndex < _geoJsons.length; ++layerIndex) {
+            plotData(layerIndex);
+            if(_projectionFlag) {
+                _chart.svg().selectAll("g." + geoJson(layerIndex).name + " path").attr("d", _geoPath);
+            }
+        }
+        _projectionFlag = false;
+    };
+
+    _chart.overlayGeoJson = function (json, name, keyAccessor) {
+        for (var i = 0; i < _geoJsons.length; ++i) {
+            if (_geoJsons[i].name == name) {
+                _geoJsons[i].data = json;
+                _geoJsons[i].keyAccessor = keyAccessor;
+                return _chart;
+            }
+        }
+        _geoJsons.push({name: name, data: json, keyAccessor: keyAccessor});
+        return _chart;
+    };
+
+    _chart.projection = function (projection) {
+        _geoPath.projection(projection);
+        _projectionFlag = true;
+        return _chart;
+    };
+
+    _chart.geoJsons = function () {
+        return _geoJsons;
+    };
+
+    _chart.removeGeoJson = function (name) {
+        var geoJsons = [];
+
+        for (var i = 0; i < _geoJsons.length; ++i) {
+            var layer = _geoJsons[i];
+            if (layer.name != name) {
+                geoJsons.push(layer);
+            }
+        }
+
+        _geoJsons = geoJsons;
+
+        return _chart;
+    };
+
+    return _chart.anchor(parent, chartGroup);
+};
+
+dc.bubbleOverlay = function(root, chartGroup) {
+    var BUBBLE_OVERLAY_CLASS = "bubble-overlay";
+    var BUBBLE_NODE_CLASS = "node";
+    var BUBBLE_CLASS = "bubble";
+
+    var _chart = dc.abstractBubbleChart(dc.baseChart({}));
+    var _g;
+    var _points = [];
+
+    _chart.transitionDuration(750);
+
+    _chart.radiusValueAccessor(function(d) {
+        return d.value;
+    });
+
+    _chart.point = function(name, x, y) {
+        _points.push({name: name, x: x, y: y});
+        return _chart;
+    };
+
+    _chart.doRender = function() {
+        _g = initOverlayG();
+
+        _chart.r().range([_chart.MIN_RADIUS, _chart.width() * _chart.maxBubbleRelativeSize()]);
+
+        initializeBubbles();
+
+        _chart.fadeDeselectedArea();
+
+        return _chart;
+    };
+
+    function initOverlayG() {
+        _g = _chart.select("g." + BUBBLE_OVERLAY_CLASS);
+        if (_g.empty())
+            _g = _chart.svg().append("g").attr("class", BUBBLE_OVERLAY_CLASS);
+        return _g;
+    }
+
+    function initializeBubbles() {
+        var data = mapData();
+
+        _points.forEach(function(point) {
+            var nodeG = getNodeG(point, data);
+
+            var circle = nodeG.select("circle." + BUBBLE_CLASS);
+
+            if (circle.empty())
+                circle = nodeG.append("circle")
+                    .attr("class", BUBBLE_CLASS)
+                    .attr("r", 0)
+                    .attr("fill", _chart.initBubbleColor)
+                    .on("click", _chart.onClick);
+
+            dc.transition(circle, _chart.transitionDuration())
+                .attr("r", function(d) {
+                    return _chart.bubbleR(d);
+                });
+
+            _chart.doRenderLabel(nodeG);
+
+            _chart.doRenderTitles(nodeG);
+        });
+    }
+
+    function mapData() {
+        var data = {};
+        _chart.group().all().forEach(function(datum) {
+            data[_chart.keyAccessor()(datum)] = datum;
+        });
+        return data;
+    }
+
+    function getNodeG(point, data) {
+        var bubbleNodeClass = BUBBLE_NODE_CLASS + " " + dc.utils.nameToId(point.name);
+
+        var nodeG = _g.select("g." + dc.utils.nameToId(point.name));
+
+        if (nodeG.empty()) {
+            nodeG = _g.append("g")
+                .attr("class", bubbleNodeClass)
+                .attr("transform", "translate(" + point.x + "," + point.y + ")");
+        }
+
+        nodeG.datum(data[point.name]);
+
+        return nodeG;
+    }
+
+    _chart.doRedraw = function() {
+        updateBubbles();
+
+        _chart.fadeDeselectedArea();
+
+        return _chart;
+    };
+
+    function updateBubbles() {
+        var data = mapData();
+
+        _points.forEach(function(point) {
+            var nodeG = getNodeG(point, data);
+
+            var circle = nodeG.select("circle." + BUBBLE_CLASS);
+
+            dc.transition(circle, _chart.transitionDuration())
+                .attr("r", function(d) {
+                    return _chart.bubbleR(d);
+                })
+                .attr("fill", _chart.updateBubbleColor);
+
+            _chart.doUpdateLabels(nodeG);
+
+            _chart.doUpdateTitles(nodeG);
+        });
+    }
+
+    _chart.debug = function(flag) {
+        if(flag){
+            var debugG = _chart.select("g." + dc.constants.DEBUG_GROUP_CLASS);
+
+            if(debugG.empty())
+                debugG = _chart.svg()
+                    .append("g")
+                    .attr("class", dc.constants.DEBUG_GROUP_CLASS);
+
+            var debugText = debugG.append("text")
+                .attr("x", 10)
+                .attr("y", 20);
+
+            debugG
+                .append("rect")
+                .attr("width", _chart.width())
+                .attr("height", _chart.height())
+                .on("mousemove", function() {
+                    var position = d3.mouse(debugG.node());
+                    var msg = position[0] + ", " + position[1];
+                    debugText.text(msg);
+                });
+        }else{
+            _chart.selectAll(".debug").remove();
+        }
+
+        return _chart;
+    };
+
+    _chart.anchor(root, chartGroup);
+
+    return _chart;
+};
+
+dc.rowChart = function (parent, chartGroup) {
+
+    var _g;
+
+    var _labelOffsetX = 10;
+
+    var _labelOffsetY = 15;
+
+    var _gap = 5;
+
+    var _rowCssClass = "row";
+
+    var _chart = dc.marginable(dc.colorChart(dc.baseChart({})));
+
+    var _x;
+
+    var _elasticX;
+
+    var _xAxis = d3.svg.axis().orient("bottom");
+
+    function calculateAxisScale() {
+        if (!_x || _elasticX) {
+            var extent = d3.extent(_chart.group().all(), _chart.valueAccessor());
+            if (extent[0] > 0) extent[0] = 0;
+            _x = d3.scale.linear().domain(extent)
+                .range([0, _chart.effectiveWidth()]);
+
+            _xAxis.scale(_x);
+        }
+    }
+
+    function drawAxis() {
+        var axisG = _g.select("g.axis");
+
+        calculateAxisScale();
+
+        if (axisG.empty())
+            axisG = _g.append("g").attr("class", "axis")
+                .attr("transform", "translate(0, " + _chart.effectiveHeight() + ")");
+
+        dc.transition(axisG, _chart.transitionDuration())
+            .call(_xAxis);
+    }
+
+    _chart.doRender = function () {
+        _chart.resetSvg();
+
+        _g = _chart.svg()
+            .append("g")
+            .attr("transform", "translate(" + _chart.margins().left + "," + _chart.margins().top + ")");
+
+        drawAxis();
+        drawGridLines();
+        drawChart();
+
+        return _chart;
+    };
+
+    _chart.title(function (d) {
+        return _chart.keyAccessor()(d) + ": " + _chart.valueAccessor()(d);
+    });
+
+    _chart.label(function (d) {
+        return _chart.keyAccessor()(d);
+    });
+
+    _chart.x = function(x){
+        if(!arguments.length) return _x;
+        _x = x;
+        return _chart;
+    };
+
+    function drawGridLines() {
+        _g.selectAll("g.tick")
+            .select("line.grid-line")
+            .remove();
+
+        _g.selectAll("g.tick")
+            .append("line")
+            .attr("class", "grid-line")
+            .attr("x1", 0)
+            .attr("y1", 0)
+            .attr("x2", 0)
+            .attr("y2", function (d) {
+                return -_chart.effectiveHeight();
+            });
+    }
+
+    function drawChart() {
+        drawAxis();
+        drawGridLines();
+
+        var rows = _g.selectAll("g." + _rowCssClass)
+            .data(_chart.group().all());
+
+        createElements(rows);
+        removeElements(rows);
+        updateElements(rows);
+    }
+
+    function createElements(rows) {
+        var rowEnter = rows.enter()
+            .append("g")
+            .attr("class", function (d, i) {
+                return _rowCssClass + " _" + i;
+            });
+
+        rowEnter.append("rect").attr("width", 0);
+
+        createLabels(rowEnter);
+        updateLabels(rows);
+    }
+
+    function removeElements(rows) {
+        rows.exit().remove();
+    }
+
+    function updateElements(rows) {
+        var height = rowHeight();
+
+        var rect = rows.attr("transform",function (d, i) {
+                return "translate(0," + ((i + 1) * _gap + i * height) + ")";
+            }).select("rect")
+            .attr("height", height)
+            .attr("fill", _chart.getColor)
+            .on("click", onClick)
+            .classed("deselected", function (d) {
+                return (_chart.hasFilter()) ? !_chart.isSelectedRow(d) : false;
+            })
+            .classed("selected", function (d) {
+                return (_chart.hasFilter()) ? _chart.isSelectedRow(d) : false;
+            });
+
+        dc.transition(rect, _chart.transitionDuration())
+            .attr("width", function (d) {
+                return Math.abs(_x(0) - _x(_chart.valueAccessor()(d)));
+            })
+            .attr("transform", translateX);
+
+        createTitles(rows);
+        updateLabels(rows);
+    }
+
+    function createTitles(rows) {
+        if (_chart.renderTitle()) {
+            rows.selectAll("title").remove();
+            rows.append("title").text(function (d) {
+                return _chart.title()(d);
+            });
+        }
+    }
+
+    function createLabels(rowEnter) {
+        if (_chart.renderLabel()) {
+            rowEnter.append("text")
+                .on("click", onClick);
+        }
+    }
+
+    function updateLabels(rows) {
+        if (_chart.renderLabel()) {
+            var lab = rows.select("text")
+                .attr("x", _labelOffsetX)
+                .attr("y", _labelOffsetY)
+                .attr("class", function (d, i) {
+                    return _rowCssClass + " _" + i;
+                })
+                .text(function (d) {
+                    return _chart.label()(d);
+                });
+            dc.transition(lab, _chart.transitionDuration())
+            .attr("transform", translateX);
+        }
+    }
+
+    function numberOfRows() {
+        return _chart.group().all().length;
+    }
+
+    function rowHeight() {
+        var n = numberOfRows();
+        return (_chart.effectiveHeight() - (n + 1) * _gap) / n;
+    }
+
+    function onClick(d) {
+        _chart.onClick(d);
+    }
+
+    function translateX(d) {
+        var x = _x(_chart.valueAccessor()(d)),
+            x0 = _x(0),
+            s = x > x0 ? x0 : x;
+        return "translate("+s+",0)";
+    }
+
+    _chart.doRedraw = function () {
+        drawChart();
+        return _chart;
+    };
+
+    _chart.xAxis = function () {
+        return _xAxis;
+    };
+
+    _chart.gap = function (g) {
+        if (!arguments.length) return _gap;
+        _gap = g;
+        return _chart;
+    };
+
+    _chart.elasticX = function (_) {
+        if (!arguments.length) return _elasticX;
+        _elasticX = _;
+        return _chart;
+    };
+
+    _chart.labelOffsetX = function (o) {
+        if (!arguments.length) return _labelOffsetX;
+        _labelOffsetX = o;
+        return _chart;
+    };
+
+    _chart.labelOffsetY = function (o) {
+        if (!arguments.length) return _labelOffsetY;
+        _labelOffsetY = o;
+        return _chart;
+    };
+
+    _chart.isSelectedRow = function (d) {
+        return _chart.hasFilter(_chart.keyAccessor()(d));
+    };
+
+    return _chart.anchor(parent, chartGroup);
+};
+
+dc.legend = function () {
+    var LABEL_GAP = 2;
+
+    var _legend = {},
+        _parent,
+        _x = 0,
+        _y = 0,
+        _itemHeight = 12,
+        _gap = 5;
+
+    var _g;
+
+    _legend.parent = function (p) {
+        if (!arguments.length) return _parent;
+        _parent = p;
+        return _legend;
+    };
+
+    _legend.render = function () {
+        _g = _parent.svg().append("g")
+            .attr("class", "dc-legend")
+            .attr("transform", "translate(" + _x + "," + _y + ")");
+
+        var itemEnter = _g.selectAll('g.dc-legend-item')
+            .data(_parent.legendables())
+            .enter()
+            .append("g")
+            .attr("class", "dc-legend-item")
+            .attr("transform", function (d, i) {
+                return "translate(0," + i * legendItemHeight() + ")";
+            })
+            .on("mouseover", function(d){
+                    _parent.legendHighlight(d);
+            })
+            .on("mouseout", function (d) {
+                    _parent.legendReset(d);
+            });
+
+        itemEnter
+            .append("rect")
+                .attr("width", _itemHeight)
+                .attr("height", _itemHeight)
+                .attr("fill", function(d){return d.color;});
+
+        itemEnter.append("text")
+                .text(function(d){return d.name;})
+                .attr("x", _itemHeight + LABEL_GAP)
+                .attr("y", function(){return _itemHeight / 2 + (this.clientHeight?this.clientHeight:13) / 2 - 2;});
+    };
+
+    function legendItemHeight() {
+        return _gap + _itemHeight;
+    }
+
+    _legend.x = function (x) {
+        if (!arguments.length) return _x;
+        _x = x;
+        return _legend;
+    };
+
+    _legend.y = function (y) {
+        if (!arguments.length) return _y;
+        _y = y;
+        return _legend;
+    };
+
+    _legend.gap = function (gap) {
+        if (!arguments.length) return _gap;
+        _gap = gap;
+        return _legend;
+    };
+
+    _legend.itemHeight = function (h) {
+        if (!arguments.length) return _itemHeight;
+        _itemHeight = h;
+        return _legend;
+    };
+
+    return _legend;
+};
+
+dc.scatterPlot = function (parent, chartGroup) {
+    var _chart = dc.coordinateGridChart({});
+
+    _chart.plotData = function(){
+        _chart.chartBodyG().selectAll("path.dc-symbol")
+                .data(_chart.group().all())
+            .enter()
+            .append("path")
+            .attr("class", "dc-symbol")
+            .attr("transform", function(d){
+                return "translate("+_chart.x()(_chart.keyAccessor()(d))+","+_chart.y()(_chart.valueAccessor()(d))+")";
+            })
+            .attr("d", d3.svg.symbol());
+    };
+
+    return _chart.anchor(parent, chartGroup);
+};
+
+dc.numberDisplay = function (parent, chartGroup) {
+    var SPAN_CLASS = 'number-display';
+    var _formatNumber = d3.format(".2s");
+    var _chart = dc.baseChart({});
+
+    _chart.dimension({}); // dummy dimension to remove warnings
+
+    _chart.value = function () {
+         var valObj = _chart.group().all && _chart.group().all()[0] || _chart.group().value();
+         return _chart.valueAccessor()(valObj);
+    };
+
+    _chart.doRender = function () {
+        var newValue = _chart.value(),
+            span     = _chart.selectAll("."+SPAN_CLASS);
+
+        if(span.empty())
+            span = span.data([0])
+                .enter()
+                .append("span")
+                .attr("class", SPAN_CLASS);
+
+        span.transition()
+            .duration(250)
+            .ease('quad-out-in')
+            .tween("text", function () {
+                var interp = d3.interpolateNumber(this.lastValue || 0, newValue);
+                this.lastValue = newValue;
+                return function (t) {
+                    this.textContent = _chart.formatNumber()(interp(t));
+                };
+            });
+
+        return _chart;
+    };
+
+    _chart.doRedraw = function(){
+        return _chart.doRender();
+    };
+
+    _chart.formatNumber = function (_) {
+        if (!arguments.length) return _formatNumber;
+        _formatNumber = _;
+        return _chart;
+    };
+
+    return _chart.anchor(parent, chartGroup);
+};
+
+return dc;})();