new transformsEnabled property which yields absolute best rendering performance

src/Context.js

@@ -224,16 +224,24 @@
             }
         },
         _applyAncestorTransforms: function(shape) {
-            var stage = shape.getStage(),
-                m;
+            var m;
 
-            if (stage && stage.isNestedTransformsEnabled()) {
-                m = shape.getAbsoluteTransform().getMatrix();
+            if (shape.isTransformsEnabled()) {
+                if (shape.isAncestorTransformsEnabled()) {
+                    // poor performance
+                    m = shape.getAbsoluteTransform().getMatrix();
+                }
+                else {
+                    // better performance
+                    m = shape.getTransform().getMatrix();
+                }
+                this.transform(m[0], m[1], m[2], m[3], m[4], m[5]);
             }
             else {
-                m = shape.getTransform().getMatrix();
+                // best performance
+                this.translate(shape.getX(), shape.getY());
             }
-            this.transform(m[0], m[1], m[2], m[3], m[4], m[5]);
+            
         },
         _clip: function(container) {
             var clipX = container.getClipX(),

src/Node.js

@@ -1344,6 +1344,46 @@
             this.drawScene();
             this.drawHit();
             return this;
+        },
+        /**
+         * enable ancestor transforms
+         * @method
+         * @memberof Kinetic.Node.prototype
+         * @returns {Node}
+         */
+        enableAncestorTransforms: function() {
+            this.setAncestorTransformsEnabled(true);
+            return this;
+        },
+        /**
+         * disable ancestor transforms
+         * @method
+         * @memberof Kinetic.Node.prototype
+         * @returns {Node}
+         */
+        disableAncestorTransforms: function() {
+            this.setAncestorTransformsEnabled(false);
+            return this;
+        },
+        /**
+         * enable transforms
+         * @method
+         * @memberof Kinetic.Node.prototype
+         * @returns {Node}
+         */
+        enableTransforms: function() {
+            this.setTransformsEnabled(true);
+            return this;
+        },
+        /**
+         * disable transforms
+         * @method
+         * @memberof Kinetic.Node.prototype
+         * @returns {Node}
+         */
+        disableTransforms: function() {
+            this.setTransformsEnabled(false);
+            return this;
         }
     });
 
@@ -1743,6 +1783,48 @@
      * @returns {Boolean}
      */
 
+    Kinetic.Factory.addGetterSetter(Kinetic.Node, 'ancestorTransformsEnabled', true);
+
+    /**
+     * enable/disable ancestor transforms
+     * @name setAncestorTransformsEnabled
+     * @method
+     * @memberof Kinetic.Node.prototype
+     * @param {Boolean} enabled
+     * @returns {Node}
+     */
+
+    /**
+     * determine if ancestor transforms are enabled
+     * @name getAncestorTransformsEnabled
+     * @method
+     * @memberof Kinetic.Node.prototype
+     * @returns {Boolean}
+     */
+
+    Kinetic.Node.prototype.isAncestorTransformsEnabled = Kinetic.Node.prototype.getAncestorTransformsEnabled;
+
+    Kinetic.Factory.addGetterSetter(Kinetic.Node, 'transformsEnabled', true);
+
+    /**
+     * enable/disable transforms
+     * @name setTransformsEnabled
+     * @method
+     * @memberof Kinetic.Node.prototype
+     * @param {Boolean} enabled
+     * @returns {Node}
+     */
+
+    /**
+     * determine if transforms are enabled
+     * @name getTransformsEnabled
+     * @method
+     * @memberof Kinetic.Node.prototype
+     * @returns {Boolean}
+     */
+
+    Kinetic.Node.prototype.isTransformsEnabled = Kinetic.Node.prototype.getTransformsEnabled;
+
     Kinetic.Collection.mapMethods([
         'on',
         'off',

src/Stage.js

@@ -643,26 +643,6 @@
                 baseEvent = types[n];
                 this.content.addEventListener(baseEvent, handler, false);
             }
-        },
-        /**
-         * enable nested transforms
-         * @method
-         * @memberof Kinetic.Stage.prototype
-         * @returns {Node}
-         */
-        enableNestedTransforms: function() {
-            this.setNestedTransformsEnabled(true);
-            return this;
-        },
-        /**
-         * disable nested transforms
-         * @method
-         * @memberof Kinetic.Stage.prototype
-         * @returns {Node}
-         */
-        disableNestedTransforms: function() {
-            this.setNestedTransformsEnabled(false);
-            return this;
         }
     });
     Kinetic.Util.extend(Kinetic.Stage, Kinetic.Container);
@@ -677,24 +657,4 @@
      * @memberof Kinetic.Stage.prototype
      */
 
-    Kinetic.Factory.addGetterSetter(Kinetic.Stage, 'nestedTransformsEnabled', true);
-
-    /**
-     * enable/disable nested transforms
-     * @name setNestedTransformsEnabled
-     * @method
-     * @memberof Kinetic.Stage.prototype
-     * @param {Boolean} enabled
-     * @returns {Node}
-     */
-
-    /**
-     * determine if nested transforms are enabled
-     * @name getNestedTransformsEnabled
-     * @method
-     * @memberof Kinetic.Stage.prototype
-     * @returns {Boolean}
-     */
-
-     Kinetic.Stage.prototype.isNestedTransformsEnabled = Kinetic.Stage.prototype.getNestedTransformsEnabled;
 })();