added layer hitGraphEnabled flag

src/Layer.js

@@ -263,22 +263,43 @@
         },
         getStage: function() {
             return this.parent;
+        },
+        /**
+         * enable hit graph
+         * @name enableHitGraph
+         * @method
+         * @memberof Kinetic.Layer.prototype
+         * @returns {Node}
+         */
+        enableHitGraph: function() {
+            this.setHitGraphEnabled(true);
+            return this;
+        },
+        /**
+         * disable hit graph
+         * @name enableHitGraph
+         * @method
+         * @memberof Kinetic.Layer.prototype
+         * @returns {Node}
+         */
+        disableHitGraph: function() {
+            this.setHitGraphEnabled(false);
+            return this;
         }
     });
     Kinetic.Util.extend(Kinetic.Layer, Kinetic.Container);
 
     // add getters and setters
-    Kinetic.Factory.addGetterSetter(Kinetic.Layer, 'clearBeforeDraw', function() {
-        return true;
-    });
+    Kinetic.Factory.addGetterSetter(Kinetic.Layer, 'clearBeforeDraw', true);
 
     /**
      * set flag which determines if the layer is cleared or not
      *  before drawing
      * @name setClearBeforeDraw
      * @method
-     * @memberof Kinetic.Node.prototype
+     * @memberof Kinetic.Layer.prototype
      * @param {Boolean} clearBeforeDraw
+     * @returns {Node}
      */
 
     /**
@@ -286,6 +307,29 @@
      *  before drawing
      * @name getClearBeforeDraw
      * @method
-     * @memberof Kinetic.Node.prototype
+     * @memberof Kinetic.Layer.prototype
+     * @returns {Boolean}
      */
+
+    Kinetic.Factory.addGetterSetter(Kinetic.Layer, 'hitGraphEnabled', true);
+
+    /**
+     * enable / disable hit graph
+     * @name setHitGraphEnabled
+     * @method
+     * @memberof Kinetic.Layer.prototype
+     * @param {Boolean} enable
+     * @returns {Node}
+     */
+
+    /**
+     * get flag which determines if the layer is cleared or not
+     *  before drawing
+     * @name getHitGraphEnabled
+     * @method
+     * @memberof Kinetic.Layer.prototype
+     * @returns {Boolean}
+     */
+
+     Kinetic.Layer.prototype.isHitGraphEnabled = Kinetic.Layer.prototype.getHitGraphEnabled;
 })();

src/Node.js

@@ -418,7 +418,8 @@
          * @returns {Boolean}
          */
         shouldDrawHit: function() {
-            return  this.isListening() && this.isVisible() && !Kinetic.isDragging();
+            var layer = this.getLayer();
+            return  layer && layer.isHitGraphEnabled() && this.isListening() && this.isVisible() && !Kinetic.isDragging();
         },
         /**
          * determine if node is visible or not.  Node is visible only

src/Stage.js

@@ -82,6 +82,9 @@
             this._setAttr(CONTAINER, container);
             return this;
         },
+        shouldDrawHit: function() {
+            return true;
+        },
         draw: function() {
             Kinetic.Node.prototype.draw.call(this);
             return this;

test/performance/common/random-squares.js

@@ -79,16 +79,15 @@
 
       function make_shape(color) {
         if (VERSION === 'new') {
-      /*
+     
           return new Kinetic.Rect({
             fill: color,
             width: 10,
-            height: 10,
-            listening: false
+            height: 10
           });
-      */
       
  
+    /*
           return new Kinetic.Shape({
             drawFunc: function(context) {
               var _context = context._context;
@@ -99,6 +98,7 @@
               _context.fill();
             }
           });
+      */
      
         } else {
           return new Kinetic.Shape(function(){
@@ -120,7 +120,9 @@
             width: 578,
             height: 200
           });
-          circlesLayer = new Kinetic.Layer();
+          circlesLayer = new Kinetic.Layer({
+            hitGraphEnabled: false
+          });
         } else {
           stage = new Kinetic.Stage("container", width, height);
           circlesLayer = new Kinetic.Layer();

test/unit/Layer-test.js

@@ -261,4 +261,35 @@ suite('Layer', function() {
            quality: 1
         });
     });
+
+    // ======================================================
+    test('hit graph enable disable', function() {
+        var stage = addStage();
+        var layer = new Kinetic.Layer();
+
+        var circle = new Kinetic.Circle({
+            x: stage.getWidth() / 2,
+            y: stage.getHeight() / 2,
+            radius: 70,
+            fill: 'red',
+            stroke: 'black',
+            strokeWidth: 4
+        });
+
+        layer.add(circle);
+        stage.add(layer);
+
+        assert.equal(layer.isHitGraphEnabled(), true);
+        assert.equal(layer.shouldDrawHit(), true);
+
+        layer.disableHitGraph();
+
+        assert.equal(layer.isHitGraphEnabled(), false);
+        assert.equal(layer.shouldDrawHit(), false);  
+
+        layer.enableHitGraph();
+
+        assert.equal(layer.isHitGraphEnabled(), true);
+        assert.equal(layer.shouldDrawHit(), true);
+    });
 });