From 291583148b7ec5e91d3c20880ebb23065c2cddd6 Mon Sep 17 00:00:00 2001
From: Eric Rowell <erowell83@gmail.com>
Date: Sun, 9 Dec 2012 09:52:33 -0800
Subject: [PATCH] moved all rendering logic into the Canvas renderer modules. 
 Shape draw funcs are now passed a renderer object, not a canvas context.  The
 context is accessible via canvas.getContext()

---
 src/Canvas.js                   |  95 +++++++++++++++++-----
 src/Layer.js                    |   8 +-
 src/Node.js                     |   2 +-
 src/Shape.js                    |  96 +++-------------------
 src/Stage.js                    |   6 +-
 src/shapes/Circle.js            |   5 +-
 src/shapes/Ellipse.js           |   6 +-
 src/shapes/Image.js             |  35 ++++----
 src/shapes/Line.js              |   6 +-
 src/shapes/Path.js              |   6 +-
 src/shapes/Polygon.js           |  11 +--
 src/shapes/Rect.js              |   5 +-
 src/shapes/RegularPolygon.js    |  13 +--
 src/shapes/Sprite.js            |  18 ++--
 src/shapes/Star.js              |  14 ++--
 src/shapes/Text.js              | 140 ++++++++++++++++++--------------
 src/shapes/TextPath.js          |  14 +---
 src/shapes/Wedge.js             |   5 +-
 tests/assets/unitDataUrls.js    |   2 +-
 tests/js/functionalTests.js     |  40 ++++-----
 tests/js/unit/containerTests.js |   3 +
 tests/js/unit/nodeTests.js      |  16 ++--
 tests/js/unit/shapeTests.js     |  35 ++++----
 23 files changed, 292 insertions(+), 289 deletions(-)

diff --git a/src/Canvas.js b/src/Canvas.js
index ae0ea7ae..7ff85ddf 100644
--- a/src/Canvas.js
+++ b/src/Canvas.js
@@ -1,19 +1,17 @@
 (function() {
     /**
-     * Canvas wrapper constructor
+     * Canvas Renderer constructor
      * @constructor
      * @param {Number} width
      * @param {Number} height
      */
-    Kinetic.Canvas = function(width, height, isHit) {
+    Kinetic.Canvas = function(width, height) {
         this.element = document.createElement('canvas');
         this.context = this.element.getContext('2d');
 
         // set dimensions
         this.element.width = width || 0;
         this.element.height = height || 0;
-
-        this.context.renderer = isHit ? new Kinetic.HitRenderer(this.context) : new Kinetic.SceneRenderer(this.context);
     };
 
     Kinetic.Canvas.prototype = {
@@ -102,14 +100,77 @@
                     return '';
                 }
             }
+        },
+        /**
+         * fill current path
+         * @name fill
+         * @methodOf Kinetic.Canvas.prototype
+         */
+        fill: function(shape) {
+            this._fill(shape);
+        },
+        /**
+         * stroke current path
+         * @name stroke
+         * @methodOf Kinetic.Canvas.prototype
+         */
+        stroke: function(shape) {
+            this._stroke(shape);
+        },
+        /**
+         * fill and stroke current path.&nbsp; Aside from being a convenience method
+         *  which fills and strokes the current path with a single method, its main purpose is
+         *  to ensure that the shadow object is not applied to both the fill and stroke.&nbsp; A shadow
+         *  will only be applied to either the fill or stroke.&nbsp; Fill
+         *  is given priority over stroke.
+         * @name fillStroke
+         * @param {CanvasContext} context
+         * @methodOf Kinetic.Canvas.prototype
+         */
+        fillStroke: function(shape) {
+            this._fill(shape);
+            this._stroke(shape, shape.getShadow() && shape.getFill());
+        },
+        /**
+         * apply shadow
+         * @name applyShadow
+         * @param {CanvasContext} context
+         * @param {Function} func draw function
+         * @methodOf Kinetic.Canvas.prototype
+         */
+        applyShadow: function(shape, func) {
+            var context = this.context;
+            context.save();
+            this._applyShadow(shape);
+            func();
+            context.restore();
+            func();
+        },
+        _applyLineCap: function(shape) {
+            var lineCap = shape.getLineCap();
+            if(lineCap) {
+                this.context.lineCap = lineCap;
+            }
+        },
+        _applyOpacity: function(shape) {
+            var absOpacity = shape.getAbsoluteOpacity();
+            if(absOpacity !== 1) {
+                this.context.globalAlpha = absOpacity;
+            }
+        },
+        _applyLineJoin: function(shape) {
+            var lineJoin = shape.getLineJoin();
+            if(lineJoin) {
+                this.context.lineJoin = lineJoin;
+            }
         }
     };
 
-    Kinetic.SceneRenderer = function(context) {
-        this.context = context;
+    Kinetic.SceneCanvas = function(width, height) {
+        Kinetic.Canvas.call(this, width, height);
     };
 
-    Kinetic.SceneRenderer.prototype = {
+    Kinetic.SceneCanvas.prototype = {
         _fill: function(shape, skipShadow) {
             var context = this.context, fill = shape.getFill(), fillType = shape._getFillType(fill), shadow = shape.getShadow();
             if(fill) {
@@ -228,20 +289,15 @@
                 context.shadowOffsetX = offset.x;
                 context.shadowOffsetY = offset.y;
             }
-        },
-        _applyLineCap: function(shape) {
-            var lineCap = shape.getLineCap();
-            if(lineCap) {
-                this.context.lineCap = lineCap;
-            }
         }
     };
+    Kinetic.Global.extend(Kinetic.SceneCanvas, Kinetic.Canvas);
 
-    Kinetic.HitRenderer = function(context) {
-        this.context = context;
+    Kinetic.HitCanvas = function(width, height) {
+        Kinetic.Canvas.call(this, width, height);
     };
 
-    Kinetic.HitRenderer.prototype = {
+    Kinetic.HitCanvas.prototype = {
         _fill: function(shape) {
             var context = this.context;
             context.save();
@@ -259,12 +315,7 @@
                 context.stroke(context);
                 context.restore();
             }
-        },
-        _applyLineCap: function(shape) {
-            var lineCap = shape.getLineCap();
-            if(lineCap) {
-                this.context.lineCap = lineCap;
-            }
         }
     };
+    Kinetic.Global.extend(Kinetic.HitCanvas, Kinetic.Canvas);
 })();
diff --git a/src/Layer.js b/src/Layer.js
index 06d8afe0..e55eb389 100644
--- a/src/Layer.js
+++ b/src/Layer.js
@@ -38,9 +38,9 @@
             this.nodeType = 'Layer';
             this.beforeDrawFunc = undefined;
             this.afterDrawFunc = undefined;
-            this.canvas = new Kinetic.Canvas();
+            this.canvas = new Kinetic.SceneCanvas();
             this.canvas.getElement().style.position = 'absolute';
-            this.hitCanvas = new Kinetic.Canvas(0, 0, true);
+            this.hitCanvas = new Kinetic.HitCanvas(0, 0);
 
             // call super constructor
             Kinetic.Container.call(this, config);
@@ -231,10 +231,10 @@
              */
             if(!this.isVisible()) {
                 var stage = this.getStage();
-                canvas = new Kinetic.Canvas(stage.getWidth(), stage.getHeight());
+                canvas = new Kinetic.SceneCanvas(stage.getWidth(), stage.getHeight());
             }
             else if(config && config.width && config.height) {
-                canvas = new Kinetic.Canvas(config.width, config.height);
+                canvas = new Kinetic.SceneCanvas(config.width, config.height);
                 this.draw(canvas);
             }
             else {
diff --git a/src/Node.js b/src/Node.js
index 671c1711..696bf2c1 100644
--- a/src/Node.js
+++ b/src/Node.js
@@ -744,7 +744,7 @@
 
             //if width and height are defined, create new canvas to draw on, else reuse stage hit canvas
             if(config && config.width && config.height) {
-                canvas = new Kinetic.Canvas(config.width, config.height);
+                canvas = new Kinetic.SceneCanvas(config.width, config.height);
             }
             else {
                 canvas = this.getStage().bufferCanvas;
diff --git a/src/Shape.js b/src/Shape.js
index db6df365..56e6ff7c 100644
--- a/src/Shape.js
+++ b/src/Shape.js
@@ -119,82 +119,6 @@
                 return 'UNKNOWN';
             }
         },
-        /**
-         * fill current path
-         * @name fill
-         * @methodOf Kinetic.Shape.prototype
-         */
-        fill: function(context) {
-            context.renderer._fill(this);
-        },
-        /**
-         * stroke current path
-         * @name stroke
-         * @methodOf Kinetic.Shape.prototype
-         */
-        stroke: function(context) {
-            context.renderer._stroke(this);
-        },
-        /**
-         * fill and stroke current path.&nbsp; Aside from being a convenience method
-         *  which fills and strokes the current path with a single method, its main purpose is
-         *  to ensure that the shadow object is not applied to both the fill and stroke.&nbsp; A shadow
-         *  will only be applied to either the fill or stroke.&nbsp; Fill
-         *  is given priority over stroke.
-         * @name fillStroke
-         * @param {CanvasContext} context
-         * @methodOf Kinetic.Shape.prototype
-         */
-        fillStroke: function(context) {
-            context.renderer._fill(this);
-            context.renderer._stroke(this, this.getShadow() && this.getFill());
-        },
-        /**
-         * apply shadow
-         * @name applyShadow
-         * @param {CanvasContext} context
-         * @param {Function} func draw function
-         * @methodOf Kinetic.Shape.prototype
-         */
-        applyShadow: function(context, func) {
-            context.save();
-            context.renderer._applyShadow(this);
-            func();
-            context.restore();
-            func();
-        },
-        /**
-         * draw an image
-         * @name drawImage
-         * @methodOf Kinetic.Shape.prototype
-         * @param {CanvasContext} context
-         */
-        drawImage: function() {
-            var context = arguments[0];
-            context.save();
-            var a = Array.prototype.slice.call(arguments);
-
-            if(a.length === 6) {
-                context.drawImage(a[1], a[2], a[3], a[4], a[5]);
-            }
-            else if(a.length === 10) {
-                context.drawImage(a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8], a[9]);
-            }
-
-            context.restore();
-        },
-        _applyOpacity: function(context) {
-            var absOpacity = this.getAbsoluteOpacity();
-            if(absOpacity !== 1) {
-                context.globalAlpha = absOpacity;
-            }
-        },
-        _applyLineJoin: function(context) {
-            var lineJoin = this.getLineJoin();
-            if(lineJoin) {
-                context.lineJoin = lineJoin;
-            }
-        },
         /**
          * set shadow object
          * @name setShadow
@@ -306,20 +230,20 @@
                 }
 
                 context.save();
-                this._applyOpacity(context);
-                this._applyLineJoin(context);
+                canvas._applyOpacity(this);
+                canvas._applyLineJoin(this);
                 var len = family.length;
                 for(var n = 0; n < len; n++) {
                     var node = family[n], t = node.getTransform(), m = t.getMatrix();
                     context.transform(m[0], m[1], m[2], m[3], m[4], m[5]);
                 }
 
-                drawFunc.call(this, context);
+                drawFunc.call(this, canvas);
                 context.restore();
             }
         },
         drawScene: function() {
-            var attrs = this.attrs, drawFunc = attrs.drawFunc, context = this.getLayer().getCanvas().getContext();
+            var attrs = this.attrs, drawFunc = attrs.drawFunc, canvas = this.getLayer().getCanvas(), context = canvas.getContext();
 
             if(drawFunc && this.isVisible()) {
                 var stage = this.getStage(), family = [], parent = this.parent;
@@ -331,20 +255,20 @@
                 }
 
                 context.save();
-                this._applyOpacity(context);
-                this._applyLineJoin(context);
+                canvas._applyOpacity(this);
+                canvas._applyLineJoin(this);
                 var len = family.length;
                 for(var n = 0; n < len; n++) {
                     var node = family[n], t = node.getTransform(), m = t.getMatrix();
                     context.transform(m[0], m[1], m[2], m[3], m[4], m[5]);
                 }
 
-                drawFunc.call(this, context);
+                drawFunc.call(this, canvas);
                 context.restore();
             }
         },
         drawHit: function() {
-            var attrs = this.attrs, drawFunc = attrs.drawHitFunc || attrs.drawFunc, context = this.getLayer().hitCanvas.getContext();
+            var attrs = this.attrs, drawFunc = attrs.drawHitFunc || attrs.drawFunc, canvas = this.getLayer().hitCanvas, context = canvas.getContext();
 
             if(drawFunc && this.isVisible() && this.isListening()) {
                 var stage = this.getStage(), family = [], parent = this.parent;
@@ -356,14 +280,14 @@
                 }
 
                 context.save();
-                this._applyLineJoin(context);
+                canvas._applyLineJoin(this);
                 var len = family.length;
                 for(var n = 0; n < len; n++) {
                     var node = family[n], t = node.getTransform(), m = t.getMatrix();
                     context.transform(m[0], m[1], m[2], m[3], m[4], m[5]);
                 }
 
-                drawFunc.call(this, context);
+                drawFunc.call(this, canvas);
                 context.restore();
             }
         },
diff --git a/src/Stage.js b/src/Stage.js
index 2a0e6de1..13db2946 100644
--- a/src/Stage.js
+++ b/src/Stage.js
@@ -191,7 +191,7 @@
              */
             var width = config && config.width ? config.width : this.attrs.width;
             var height = config && config.height ? config.height : this.attrs.height;
-            var canvas = new Kinetic.Canvas(width, height);
+            var canvas = new Kinetic.SceneCanvas(width, height);
             var context = canvas.getContext();
             var layers = this.children;
 
@@ -569,8 +569,8 @@
             this.content.className = 'kineticjs-content';
             this.attrs.container.appendChild(this.content);
 
-            this.bufferCanvas = new Kinetic.Canvas();
-            this.hitCanvas = new Kinetic.Canvas(0, 0, true);
+            this.bufferCanvas = new Kinetic.SceneCanvas();
+            this.hitCanvas = new Kinetic.HitCanvas(0, 0);
 
             this._resizeDOM();
         },
diff --git a/src/shapes/Circle.js b/src/shapes/Circle.js
index a48a79ff..b2fd0674 100644
--- a/src/shapes/Circle.js
+++ b/src/shapes/Circle.js
@@ -21,11 +21,12 @@
             Kinetic.Shape.call(this, config);
             this._setDrawFuncs();
         },
-        drawFunc: function(context) {
+        drawFunc: function(canvas) {
+        	var context = canvas.getContext();
             context.beginPath();
             context.arc(0, 0, this.getRadius(), 0, Math.PI * 2, true);
             context.closePath();
-            this.fillStroke(context);
+            canvas.fillStroke(this);
         },
         getWidth: function() {
             return this.getRadius() * 2;
diff --git a/src/shapes/Ellipse.js b/src/shapes/Ellipse.js
index fe223458..a07ca26b 100644
--- a/src/shapes/Ellipse.js
+++ b/src/shapes/Ellipse.js
@@ -24,8 +24,8 @@
             Kinetic.Shape.call(this, config);
             this._setDrawFuncs();
         },
-        drawFunc: function(context) {
-            var r = this.getRadius();
+        drawFunc: function(canvas) {
+        	var context = canvas.getContext(), r = this.getRadius();
             context.beginPath();
             context.save();
             if(r.x !== r.y) {
@@ -34,7 +34,7 @@
             context.arc(0, 0, r.x, 0, Math.PI * 2, true);
             context.restore();
             context.closePath();
-            this.fillStroke(context);
+            canvas.fillStroke(this);
         },
         /**
          * set radius
diff --git a/src/shapes/Image.js b/src/shapes/Image.js
index 3b80cf69..e6b1224c 100644
--- a/src/shapes/Image.js
+++ b/src/shapes/Image.js
@@ -28,13 +28,13 @@
 
             this._syncSize();
         },
-        drawFunc: function(context) {
-            var width = this.getWidth(), height = this.getHeight(), params, that = this;
+        drawFunc: function(canvas) {
+            var width = this.getWidth(), height = this.getHeight(), params, that = this, context = canvas.getContext();
 
             context.beginPath();
             context.rect(0, 0, width, height);
             context.closePath();
-            this.fillStroke(context);
+            canvas.fillStroke(this);
 
             if(this.attrs.image) {
                 // if cropping
@@ -43,41 +43,40 @@
                     var cropY = this.attrs.crop.y || 0;
                     var cropWidth = this.attrs.crop.width;
                     var cropHeight = this.attrs.crop.height;
-                    params = [context, this.attrs.image, cropX, cropY, cropWidth, cropHeight, 0, 0, width, height];
+                    params = [this.attrs.image, cropX, cropY, cropWidth, cropHeight, 0, 0, width, height];
                 }
                 // no cropping
                 else {
-                    params = [context, this.attrs.image, 0, 0, width, height];
+                    params = [this.attrs.image, 0, 0, width, height];
                 }
 
                 if(this.getShadow()) {
-                    this.applyShadow(context, function() {
-                        that.drawImage.apply(that, params);
+                    canvas.applyShadow(this, function() {
+                        that._drawImage(context, params);
                     });
                 }
                 else {
-                    this.drawImage.apply(this, params);
+                    this._drawImage(context, params);
                 }
 
             }
 
         },
-        drawHitFunc: function(context) {
-            var width = this.getWidth(), height = this.getHeight(), imageHitRegion = this.imageHitRegion, appliedShadow = false;
+        drawHitFunc: function(canvas) {
+            var width = this.getWidth(), height = this.getHeight(), imageHitRegion = this.imageHitRegion, appliedShadow = false, context = canvas.getContext();
 
             if(imageHitRegion) {
-                this.drawImage(context, imageHitRegion, 0, 0, width, height);
-
+                context.drawImage(imageHitRegion, 0, 0, width, height);
                 context.beginPath();
                 context.rect(0, 0, width, height);
                 context.closePath();
-                this.stroke(context);
+                canvas.stroke(this);
             }
             else {
                 context.beginPath();
                 context.rect(0, 0, width, height);
                 context.closePath();
-                this.fillStroke(context);
+                canvas.fillStroke(this);
             }
         },
         /**
@@ -180,6 +179,14 @@
                     this.setHeight(this.attrs.image.height);
                 }
             }
+        },
+        _drawImage: function(context, a) {
+            if(a.length === 5) {
+                context.drawImage(a[0], a[1], a[2], a[3], a[4]);
+            }
+            else if(a.length === 9) {
+                context.drawImage(a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8]);
+            }
         }
     };
     Kinetic.Global.extend(Kinetic.Image, Kinetic.Shape);
diff --git a/src/shapes/Line.js b/src/shapes/Line.js
index ab747709..115383ac 100644
--- a/src/shapes/Line.js
+++ b/src/shapes/Line.js
@@ -24,8 +24,8 @@
             Kinetic.Shape.call(this, config);
             this._setDrawFuncs();
         },
-        drawFunc: function(context) {
-            var lastPos = {}, points = this.getPoints(), length = points.length, dashArray = this.getDashArray(), dashLength = dashArray.length;
+        drawFunc: function(canvas) {
+            var lastPos = {}, points = this.getPoints(), length = points.length, dashArray = this.getDashArray(), dashLength = dashArray.length, context = canvas.getContext();
             context.beginPath();
             context.moveTo(points[0].x, points[0].y);
 
@@ -34,7 +34,7 @@
                 context.lineTo(point.x, point.y);
             }
 
-            this.stroke(context);
+            canvas.stroke(this);
         },
         /**
          * set points array
diff --git a/src/shapes/Path.js b/src/shapes/Path.js
index 5ebd9cac..545d534c 100644
--- a/src/shapes/Path.js
+++ b/src/shapes/Path.js
@@ -25,8 +25,8 @@
                 that.dataArray = Kinetic.Path.parsePathData(that.attrs.data);
             });
         },
-        drawFunc: function(context) {
-            var ca = this.dataArray;
+        drawFunc: function(canvas) {
+            var ca = this.dataArray, context = canvas.getContext();
             // context position
             context.beginPath();
             for(var n = 0; n < ca.length; n++) {
@@ -66,7 +66,7 @@
                         break;
                 }
             }
-            this.fillStroke(context);
+            canvas.fillStroke(this);
         }
     };
     Kinetic.Global.extend(Kinetic.Path, Kinetic.Shape);
diff --git a/src/shapes/Polygon.js b/src/shapes/Polygon.js
index 17afcf65..973a2f33 100644
--- a/src/shapes/Polygon.js
+++ b/src/shapes/Polygon.js
@@ -21,14 +21,15 @@
             Kinetic.Shape.call(this, config);
             this._setDrawFuncs();
         },
-        drawFunc: function(context) {
+        drawFunc: function(canvas) {
+            var context = canvas.getContext(), points = this.getPoints(), length = points.length;
             context.beginPath();
-            context.moveTo(this.attrs.points[0].x, this.attrs.points[0].y);
-            for(var n = 1; n < this.attrs.points.length; n++) {
-                context.lineTo(this.attrs.points[n].x, this.attrs.points[n].y);
+            context.moveTo(points[0].x, points[0].y);
+            for(var n = 1; n < length; n++) {
+                context.lineTo(points[n].x, points[n].y);
             }
             context.closePath();
-            this.fillStroke(context);
+            canvas.fillStroke(this);
         },
         /**
          * set points array
diff --git a/src/shapes/Rect.js b/src/shapes/Rect.js
index ab46625a..b6771600 100644
--- a/src/shapes/Rect.js
+++ b/src/shapes/Rect.js
@@ -20,7 +20,8 @@
             Kinetic.Shape.call(this, config);
             this._setDrawFuncs();
         },
-        drawFunc: function(context) {
+        drawFunc: function(canvas) {
+        	var context = canvas.getContext();
             context.beginPath();
             var cornerRadius = this.getCornerRadius(), width = this.getWidth(), height = this.getHeight();
             if(cornerRadius === 0) {
@@ -40,7 +41,7 @@
                 context.arc(cornerRadius, cornerRadius, cornerRadius, Math.PI, Math.PI * 3 / 2, false);
             }
             context.closePath();
-            this.fillStroke(context);
+            canvas.fillStroke(this);
         }
     };
 
diff --git a/src/shapes/RegularPolygon.js b/src/shapes/RegularPolygon.js
index 120e7718..2e3c1136 100644
--- a/src/shapes/RegularPolygon.js
+++ b/src/shapes/RegularPolygon.js
@@ -22,17 +22,18 @@
             Kinetic.Shape.call(this, config);
             this._setDrawFuncs();
         },
-        drawFunc: function(context) {
+        drawFunc: function(canvas) {
+        	var context = canvas.getContext(), sides = this.attrs.sides, radius = this.attrs.radius;
             context.beginPath();
-            context.moveTo(0, 0 - this.attrs.radius);
+            context.moveTo(0, 0 - radius);
 
-            for(var n = 1; n < this.attrs.sides; n++) {
-                var x = this.attrs.radius * Math.sin(n * 2 * Math.PI / this.attrs.sides);
-                var y = -1 * this.attrs.radius * Math.cos(n * 2 * Math.PI / this.attrs.sides);
+            for(var n = 1; n < sides; n++) {
+                var x = radius * Math.sin(n * 2 * Math.PI / sides);
+                var y = -1 * radius * Math.cos(n * 2 * Math.PI / sides);
                 context.lineTo(x, y);
             }
             context.closePath();
-            this.fillStroke(context);
+            canvas.fillStroke(this);
         }
     };
     Kinetic.Global.extend(Kinetic.RegularPolygon, Kinetic.Shape);
diff --git a/src/shapes/Sprite.js b/src/shapes/Sprite.js
index 62451854..41c110ac 100644
--- a/src/shapes/Sprite.js
+++ b/src/shapes/Sprite.js
@@ -28,24 +28,20 @@
                 that.setIndex(0);
             });
         },
-        drawFunc: function(context) {
-            var anim = this.attrs.animation;
-            var index = this.attrs.index;
-            var f = this.attrs.animations[anim][index];
+        drawFunc: function(canvas) {
+            var anim = this.attrs.animation, index = this.attrs.index, f = this.attrs.animations[anim][index], context = canvas.getContext(), image = this.attrs.image;
 
-            if(this.attrs.image) {
-                this.drawImage(context, this.attrs.image, f.x, f.y, f.width, f.height, 0, 0, f.width, f.height);
+            if(image) {
+                context.drawImage(image, f.x, f.y, f.width, f.height, 0, 0, f.width, f.height);
             }
         },
-        drawHitFunc: function(context) {
-            var anim = this.attrs.animation;
-            var index = this.attrs.index;
-            var f = this.attrs.animations[anim][index];
+        drawHitFunc: function(canvas) {
+            var anim = this.attrs.animation, index = this.attrs.index, f = this.attrs.animations[anim][index], context = canvas.getContext();
 
             context.beginPath();
             context.rect(0, 0, f.width, f.height);
             context.closePath();
-            this.fill(context);
+            canvas.fill(this);
         },
         /**
          * start sprite animation
diff --git a/src/shapes/Star.js b/src/shapes/Star.js
index c8efc659..4318a42d 100644
--- a/src/shapes/Star.js
+++ b/src/shapes/Star.js
@@ -23,19 +23,21 @@
             Kinetic.Shape.call(this, config);
             this._setDrawFuncs();
         },
-        drawFunc: function(context) {
+        drawFunc: function(canvas) {
+            var context = canvas.getContext(), innerRadius = this.attrs.innerRadius, outerRadius = this.attrs.outerRadius, numPoints = this.attrs.numPoints;
+
             context.beginPath();
             context.moveTo(0, 0 - this.attrs.outerRadius);
 
-            for(var n = 1; n < this.attrs.numPoints * 2; n++) {
-                var radius = n % 2 === 0 ? this.attrs.outerRadius : this.attrs.innerRadius;
-                var x = radius * Math.sin(n * Math.PI / this.attrs.numPoints);
-                var y = -1 * radius * Math.cos(n * Math.PI / this.attrs.numPoints);
+            for(var n = 1; n < numPoints * 2; n++) {
+                var radius = n % 2 === 0 ? outerRadius : innerRadius;
+                var x = radius * Math.sin(n * Math.PI / numPoints);
+                var y = -1 * radius * Math.cos(n * Math.PI / numPoints);
                 context.lineTo(x, y);
             }
             context.closePath();
 
-            this.fillStroke(context);
+            canvas.fillStroke(this);
         }
     };
     Kinetic.Global.extend(Kinetic.Star, Kinetic.Shape);
diff --git a/src/shapes/Text.js b/src/shapes/Text.js
index 74e0fe31..74f652a9 100644
--- a/src/shapes/Text.js
+++ b/src/shapes/Text.js
@@ -42,9 +42,10 @@
             }
             that._setTextData();
         },
-        drawFunc: function(context) {
+        drawFunc: function(canvas) {
+            var context = canvas.getContext();
             // draw rect
-            Kinetic.Rect.prototype.drawFunc.call(this, context);
+            Kinetic.Rect.prototype.drawFunc.call(this, canvas);
 
             // draw text
             var p = this.attrs.padding;
@@ -71,7 +72,7 @@
                     context.translate((this.getWidth() - this._getTextSize(text).width - p * 2) / 2, 0);
                 }
 
-                this.fillStrokeText(context, text);
+                canvas.fillStrokeText(this, text);
                 context.restore();
                 context.translate(0, lineHeightPx);
             }
@@ -133,44 +134,6 @@
                 height: parseInt(this.attrs.fontSize, 10)
             };
         },
-        fillText: function(context, text, skipShadow) {
-            var textFill = this.getTextFill(), textShadow = this.getTextShadow();
-            if(textFill) {
-                context.save();
-                if(!skipShadow && textShadow) {
-                    this._applyTextShadow(context);
-                }
-                context.fillStyle = textFill;
-                context.fillText(text, 0, 0);
-                context.restore();
-
-                if(!skipShadow && textShadow && textShadow.opacity) {
-                    this.fillText(context, text, true);
-                }
-            }
-        },
-        strokeText: function(context, text, skipShadow) {
-            var textStroke = this.getTextStroke(), textStrokeWidth = this.getTextStrokeWidth(), textShadow = this.getTextShadow();
-            if(textStroke || textStrokeWidth) {
-                context.save();
-                if(!skipShadow && textShadow) {
-                    this._applyTextShadow(context);
-                }
-
-                context.lineWidth = textStrokeWidth || 2;
-                context.strokeStyle = textStroke || 'black';
-                context.strokeText(text, 0, 0);
-                context.restore();
-
-                if(!skipShadow && textShadow && textShadow.opacity) {
-                    this.strokeText(context, text, true);
-                }
-            }
-        },
-        fillStrokeText: function(context, text) {
-            this.fillText(context, text);
-            this.strokeText(context, text, this.getTextShadow() && this.getTextFill());
-        },
         /**
          * set text shadow object
          * @name setTextShadow
@@ -253,31 +216,84 @@
                 row++;
             }
             this.textArr = arr;
-        },
-        _applyTextShadow: function(context) {
-            var textShadow = this.getTextShadow();
-            if(textShadow) {
-                var aa = this.getAbsoluteOpacity();
-                // defaults
-                var color = textShadow.color || 'black';
-                var blur = textShadow.blur || 5;
-                var offset = textShadow.offset || {
-                    x: 0,
-                    y: 0
-                };
-
-                if(textShadow.opacity) {
-                    context.globalAlpha = textShadow.opacity * aa;
-                }
-                context.shadowColor = color;
-                context.shadowBlur = blur;
-                context.shadowOffsetX = offset.x;
-                context.shadowOffsetY = offset.y;
-            }
         }
     };
     Kinetic.Global.extend(Kinetic.Text, Kinetic.Shape);
 
+    /*
+     * extend canvas renderers
+     */
+    var fillText = function(shape, text, skipShadow) {
+        var textFill = shape.getTextFill(), textShadow = shape.getTextShadow(), context = this.context;
+        if(textFill) {
+            context.save();
+            if(!skipShadow && textShadow) {
+                this._applyTextShadow(shape);
+            }
+            context.fillStyle = textFill;
+            context.fillText(text, 0, 0);
+            context.restore();
+
+            if(!skipShadow && textShadow && textShadow.opacity) {
+                this.fillText(shape, text, true);
+            }
+        }
+    };
+    var strokeText = function(shape, text, skipShadow) {
+        var textStroke = shape.getTextStroke(), textStrokeWidth = shape.getTextStrokeWidth(), textShadow = shape.getTextShadow(), context = this.context;
+        if(textStroke || textStrokeWidth) {
+            context.save();
+            if(!skipShadow && textShadow) {
+                this._applyTextShadow(shape);
+            }
+
+            context.lineWidth = textStrokeWidth || 2;
+            context.strokeStyle = textStroke || 'black';
+            context.strokeText(text, 0, 0);
+            context.restore();
+
+            if(!skipShadow && textShadow && textShadow.opacity) {
+                this.strokeText(shape, text, true);
+            }
+        }
+    };
+    var fillStrokeText = function(shape, text) {
+        this.fillText(shape, text);
+        this.strokeText(shape, text, shape.getTextShadow() && shape.getTextFill());
+    };
+    var _applyTextShadow = function(shape) {
+        var textShadow = shape.getTextShadow(), context = this.context;
+        if(textShadow) {
+            var aa = shape.getAbsoluteOpacity();
+            // defaults
+            var color = textShadow.color || 'black';
+            var blur = textShadow.blur || 5;
+            var offset = textShadow.offset || {
+                x: 0,
+                y: 0
+            };
+
+            if(textShadow.opacity) {
+                context.globalAlpha = textShadow.opacity * aa;
+            }
+            context.shadowColor = color;
+            context.shadowBlur = blur;
+            context.shadowOffsetX = offset.x;
+            context.shadowOffsetY = offset.y;
+        }
+    };
+    // scene canvases
+    Kinetic.SceneCanvas.prototype.fillText = fillText;
+    Kinetic.SceneCanvas.prototype.strokeText = strokeText;
+    Kinetic.SceneCanvas.prototype.fillStrokeText = fillStrokeText;
+    Kinetic.SceneCanvas.prototype._applyTextShadow = _applyTextShadow;
+
+    // hit canvases
+    Kinetic.HitCanvas.prototype.fillText = fillText;
+    Kinetic.HitCanvas.prototype.strokeText = strokeText;
+    Kinetic.HitCanvas.prototype.fillStrokeText = fillStrokeText;
+    Kinetic.HitCanvas.prototype._applyTextShadow = _applyTextShadow;
+
     // add getters setters
     Kinetic.Node.addGettersSetters(Kinetic.Text, ['fontFamily', 'fontSize', 'fontStyle', 'textFill', 'textStroke', 'textStrokeWidth', 'padding', 'align', 'lineHeight']);
     Kinetic.Node.addGetters(Kinetic.Text, ['text', 'textShadow']);
diff --git a/src/shapes/TextPath.js b/src/shapes/TextPath.js
index 0dddae92..fc572a01 100644
--- a/src/shapes/TextPath.js
+++ b/src/shapes/TextPath.js
@@ -41,8 +41,8 @@
             }
             that._setTextData();
         },
-        drawFunc: function(context) {
-            var charArr = this.charArr;
+        drawFunc: function(canvas) {
+            var charArr = this.charArr, context = canvas.getContext();
 
             context.font = this.attrs.fontStyle + ' ' + this.attrs.fontSize + 'pt ' + this.attrs.fontFamily;
             context.textBaseline = 'middle';
@@ -50,15 +50,7 @@
             context.save();
 
             var glyphInfo = this.glyphInfo;
-
-            var appliedShadow = this.appliedShadow;
             for(var i = 0; i < glyphInfo.length; i++) {
-                /*
-                 * need to reset appliedShadow flag so that shadows
-                 * are appropriately applied to each line of text
-                 */
-                this.appliedShadow = appliedShadow;
-
                 context.save();
 
                 var p0 = glyphInfo[i].p0;
@@ -68,7 +60,7 @@
                 context.translate(p0.x, p0.y);
                 context.rotate(glyphInfo[i].rotation);
 
-                this.fillStrokeText(context, glyphInfo[i].text);
+                canvas.fillStrokeText(this, glyphInfo[i].text);
 
                 context.restore();
 
diff --git a/src/shapes/Wedge.js b/src/shapes/Wedge.js
index dba8069b..f505f55c 100644
--- a/src/shapes/Wedge.js
+++ b/src/shapes/Wedge.js
@@ -23,12 +23,13 @@
             Kinetic.Shape.call(this, config);
             this._setDrawFuncs();
         },
-        drawFunc: function(context) {
+        drawFunc: function(canvas) {
+            var context = canvas.getContext();
             context.beginPath();
             context.arc(0, 0, this.getRadius(), 0, this.getAngle(), this.getClockwise());
             context.lineTo(0, 0);
             context.closePath();
-            this.fillStroke(context);
+            canvas.fillStroke(this);
         },
         setAngleDeg: function(deg) {
             this.setAngle(Kinetic.Type._degToRad(deg));
diff --git a/tests/assets/unitDataUrls.js b/tests/assets/unitDataUrls.js
index c92df7b1..cc2b18a8 100644
--- a/tests/assets/unitDataUrls.js
+++ b/tests/assets/unitDataUrls.js
@@ -12,7 +12,7 @@ var dataUrls = {
     'invert image': 'data:image/png;base64,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',
     'regular and cached polygon': 'data:image/png;base64,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',
     'blue on top of green': 'data:image/png;base64,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',
-    'node shape type selector': 'data:image/png;base64,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',
+    'node shape type selector': 'data:image/png;base64,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',
     'multiline text with shadows' : 'data:image/png;base64,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',
     'group to image' : 'data:image/png;base64,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',
     'clone group': 'data:image/png;base64,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',
diff --git a/tests/js/functionalTests.js b/tests/js/functionalTests.js
index d7bf6c75..c555749f 100644
--- a/tests/js/functionalTests.js
+++ b/tests/js/functionalTests.js
@@ -38,7 +38,6 @@ Test.Modules.DD = {
         circle.on('dragend', function() {
             dragEnd = true;
         });
-
         warn(layer.toDataURL() === dataUrls['drag circle before'], 'start data url is incorrect');
         /*
         * simulate drag and drop
@@ -179,7 +178,7 @@ Test.Modules.DD = {
 
         var top = stage.content.getBoundingClientRect().top;
 
-		//console.log(layer.toDataURL())
+        //console.log(layer.toDataURL())
         warn(layer.toDataURL() === dataUrls['drag layer before'], 'start data url is incorrect');
 
         /*
@@ -199,7 +198,7 @@ Test.Modules.DD = {
             clientX: 210,
             clientY: 109 + top
         });
-		//console.log(layer.toDataURL())
+        //console.log(layer.toDataURL())
         warn(layer.toDataURL() === dataUrls['drag layer after'], 'end data url is incorrect');
 
     }
@@ -869,12 +868,13 @@ Test.Modules['HIT FUNCS'] = {
             strokeWidth: 4,
             fill: 'red',
             stroke: 'black',
-            drawHitFunc: function(context) {
+            drawHitFunc: function(canvas) {
+                var context = canvas.getContext()
                 context.beginPath();
                 context.arc(0, 0, this.getRadius() + 100, 0, Math.PI * 2, true);
                 context.closePath();
-                this.fill(context);
-                this.stroke(context);
+                canvas.fill(this);
+                canvas.stroke(this);
             }
         });
 
@@ -895,8 +895,7 @@ Test.Modules['HIT FUNCS'] = {
         circle.on('mouseout', function() {
             mouseouts++;
         });
-
-		// move mouse far outside circle
+        // move mouse far outside circle
         stage._mousemove({
             clientX: 113,
             clientY: 112 + top
@@ -923,47 +922,48 @@ Test.Modules['HIT FUNCS'] = {
 
         // set drawBufferFunc with setter
 
-        circle.setDrawHitFunc(function(context) {
+        circle.setDrawHitFunc(function(canvas) {
+            var context = canvas.getContext();
             context.beginPath();
             context.arc(0, 0, this.getRadius() - 50, 0, Math.PI * 2, true);
             context.closePath();
-            this.fill(context);
-            this.stroke(context);
+            canvas.fill(this);
+            canvas.stroke(this);
         });
-        
+
         layer.drawHit();
-        
+
         // move mouse far outside circle
         stage._mousemove({
             clientX: 113,
             clientY: 112 + top
         });
-        
+
         test(mouseovers === 1, 'mouseovers should be 1');
         test(mouseouts === 1, 'mouseouts should be 1');
-        
+
         stage._mousemove({
             clientX: 286,
             clientY: 118 + top
         });
-        
+
         test(mouseovers === 1, 'mouseovers should be 1');
         test(mouseouts === 1, 'mouseouts should be 1');
-        
+
         stage._mousemove({
             clientX: 321,
             clientY: 112 + top
         });
-        
+
         test(mouseovers === 1, 'mouseovers should be 1');
         test(mouseouts === 1, 'mouseouts should be 1');
-        
+
         // move to center of circle
         stage._mousemove({
             clientX: 375,
             clientY: 112 + top
         });
-        
+
         test(mouseovers === 2, 'mouseovers should be 2');
         test(mouseouts === 1, 'mouseouts should be 1');
     }
diff --git a/tests/js/unit/containerTests.js b/tests/js/unit/containerTests.js
index 55e9a417..a53d8f01 100644
--- a/tests/js/unit/containerTests.js
+++ b/tests/js/unit/containerTests.js
@@ -625,8 +625,11 @@ Test.Modules.CONTAINER = {
         test(group.get('Rect').length === 1, 'group should have 1 rects');
         test(group.get('Circle').length === 1, 'gropu should have 1 circles');
 
+		//console.log(dataUrls['node shape type selector']);
+
         stage.toDataURL({
             callback: function(dataUrl) {
+            	//console.log(dataUrl)
                 warn(dataUrl === dataUrls['node shape type selector'], 'problem with node and shape type selector render.');
             }
         });
diff --git a/tests/js/unit/nodeTests.js b/tests/js/unit/nodeTests.js
index 84b602ef..7cbc457d 100644
--- a/tests/js/unit/nodeTests.js
+++ b/tests/js/unit/nodeTests.js
@@ -278,6 +278,7 @@ Test.Modules.NODE = {
             draggable: true,
             name: 'myGroup'
         });
+
         var rect = new Kinetic.Rect({
             x: 0,
             y: 50,
@@ -741,7 +742,6 @@ Test.Modules.NODE = {
             width: 500,
             height: 300,
             callback: function(imageObj) {
-
                 //document.body.appendChild(imageObj)
                 test(Kinetic.Type._isElement(imageObj), 'shape toImage() should be an image object');
 
@@ -2008,14 +2008,15 @@ Test.Modules.NODE = {
         var layer = new Kinetic.Layer();
         var group = new Kinetic.Group();
 
-        var drawTriangle = function(context) {
+        var drawTriangle = function(canvas) {
+        	var context = canvas.getContext();
             context.beginPath();
             context.moveTo(200, 50);
             context.lineTo(420, 80);
             context.quadraticCurveTo(300, 100, 260, 170);
             context.closePath();
-            this.fill(context);
-            this.stroke(context);
+            canvas.fill(this);
+            canvas.stroke(this);
         };
         var triangle = new Kinetic.Shape({
             drawFunc: drawTriangle,
@@ -2051,14 +2052,15 @@ Test.Modules.NODE = {
 
     },
     'load stage with custom shape using json': function(containerId) {
-        var drawTriangle = function(context) {
+        var drawTriangle = function(canvas) {
+        	var context = canvas.getContext();
             context.beginPath();
             context.moveTo(200, 50);
             context.lineTo(420, 80);
             context.quadraticCurveTo(300, 100, 260, 170);
             context.closePath();
-            this.fill(context);
-            this.stroke(context);
+            canvas.fill(this);
+            canvas.stroke(this);
         };
         var json = '{"attrs":{"width":578,"height":200,"visible":true,"listening":true,"opacity":1,"x":0,"y":0,"scale":{"x":1,"y":1},"rotation":0,"offset":{"x":0,"y":0},"draggable":false},"nodeType":"Stage","children":[{"attrs":{"clearBeforeDraw":true,"visible":true,"listening":true,"opacity":1,"x":0,"y":0,"scale":{"x":1,"y":1},"rotation":0,"offset":{"x":0,"y":0},"draggable":false},"nodeType":"Layer","children":[{"attrs":{"visible":true,"listening":true,"opacity":1,"x":0,"y":0,"scale":{"x":1,"y":1},"rotation":0,"offset":{"x":0,"y":0},"draggable":false},"nodeType":"Group","children":[{"attrs":{"visible":true,"listening":true,"opacity":1,"x":0,"y":0,"scale":{"x":1,"y":1},"rotation":0,"offset":{"x":0,"y":0},"draggable":false,"fill":"#00D2FF","stroke":"black","strokeWidth":4,"id":"myTriangle"},"nodeType":"Shape"}]}]}]}';
 
diff --git a/tests/js/unit/shapeTests.js b/tests/js/unit/shapeTests.js
index 5b8f1b2b..be7d0ad0 100644
--- a/tests/js/unit/shapeTests.js
+++ b/tests/js/unit/shapeTests.js
@@ -53,20 +53,21 @@ Test.Modules.SHAPE = {
         });
         var layer = new Kinetic.Layer();
 
-        var drawTriangle = function(context) {
+        var drawTriangle = function(canvas) {
+        	var context = canvas.getContext();
             context.beginPath();
             context.moveTo(200, 50);
             context.lineTo(420, 80);
             context.quadraticCurveTo(300, 100, 260, 170);
             context.closePath();
-            this.fillStroke(context);
+            canvas.fillStroke(this);
 
             context.beginPath();
             context.moveTo(300, 150);
             context.lineTo(520, 180);
             context.quadraticCurveTo(400, 200, 360, 270);
             context.closePath();
-            this.fillStroke(context);
+            canvas.fillStroke(this);
         };
         var triangle = new Kinetic.Shape({
             drawFunc: drawTriangle,
@@ -98,14 +99,15 @@ Test.Modules.SHAPE = {
         });
         var layer = new Kinetic.Layer();
         var shape = new Kinetic.Shape({
-            drawFunc: function(context) {
+            drawFunc: function(canvas) {
+            	var context = canvas.getContext();
                 context.beginPath();
                 context.moveTo(0, 0);
                 context.lineTo(100, 0);
                 context.lineTo(100, 100);
                 context.closePath();
-                this.fill(context);
-                this.stroke(context);
+                canvas.fill(this);
+                canvas.stroke(this);
             },
             x: 200,
             y: 100,
@@ -125,14 +127,15 @@ Test.Modules.SHAPE = {
         });
         var layer = new Kinetic.Layer();
         var shape = new Kinetic.Shape({
-            drawFunc: function(context) {
+            drawFunc: function(canvas) {
+            	var context = canvas.getContext();
                 context.beginPath();
                 context.moveTo(0, 0);
                 context.lineTo(100, 0);
                 context.lineTo(100, 100);
                 context.closePath();
-                this.fill(context);
-                this.stroke(context);
+                canvas.fill(this);
+                canvas.stroke(this);
             },
             x: 200,
             y: 100,
@@ -141,14 +144,15 @@ Test.Modules.SHAPE = {
             strokeWidth: 5
         });
 
-        shape.setDrawFunc(function(context) {
+        shape.setDrawFunc(function(canvas) {
+        	var context = canvas.getContext();
             context.beginPath();
             context.moveTo(0, 0);
             context.lineTo(200, 0);
             context.lineTo(200, 100);
             context.closePath();
-            this.fill(context);
-            this.stroke(context);
+            canvas.fill(this);
+            canvas.stroke(this);
         });
         var rect = new Kinetic.Rect({
             x: 10,
@@ -161,14 +165,15 @@ Test.Modules.SHAPE = {
             draggable: true
         });
 
-        rect.setDrawFunc(function(context) {
+        rect.setDrawFunc(function(canvas) {
+        	var context = canvas.getContext();
             context.beginPath();
             context.moveTo(0, 0);
             context.lineTo(200, 0);
             context.lineTo(200, 100);
             context.closePath();
-            this.fill(context);
-            this.stroke(context);
+            canvas.fill(this);
+            canvas.stroke(this);
         });
 
         layer.add(shape);