visible attr can now be inherit, true, or false, like listening

src/Node.js

@@ -411,20 +411,20 @@
             }
         },
         /**
-         * determine if listening is enabled by taking into account descendants.  If self or any children
+         * determine if node is visible by taking into account ancestors.
-         * have _isListeningEnabled set to true, than self also has listening enabled.
+         *
-         * @method
+         * Parent    | Self      | isVisible
-         * @memberof Kinetic.Node.prototype
+         * visible   | visible   | 
-         * @returns {Boolean}
+         * ----------+-----------+------------
-         */
+         * T         | T         | T 
-        shouldDrawHit: function() {
+         * T         | F         | F
-            var layer = this.getLayer();
+         * F         | T         | T 
-            return  layer && layer.isHitGraphEnabled() && this.isListening() && this.isVisible() && !Kinetic.isDragging();
+         * F         | F         | F
-        },
+         * ----------+-----------+------------
-        /**
+         * T         | I         | T
-         * determine if node is visible or not.  Node is visible only
+         * F         | I         | F
-         *  if it's visible and all of its ancestors are visible.  If an ancestor
+         * I         | I         | T
-         *  is invisible, this means that the node is also invisible
+
          * @method
          * @memberof Kinetic.Node.prototype
          * @returns {Boolean}
@@ -436,10 +436,30 @@
             var visible = this.getVisible(),
                 parent = this.getParent();
 
-            if(visible && parent && !parent.isVisible()) {
+            // the following conditions are a simplification of the truth table above.
-                return false;
+            // please modify carefully
+            if (visible === 'inherit') {
+                if (parent) {
+                    return parent.isVisible();
+                }
+                else {
+                    return true;
+                }
             }
-            return visible;
+            else {
+                return visible;
+            }
+        },
+        /**
+         * determine if listening is enabled by taking into account descendants.  If self or any children
+         * have _isListeningEnabled set to true, than self also has listening enabled.
+         * @method
+         * @memberof Kinetic.Node.prototype
+         * @returns {Boolean}
+         */
+        shouldDrawHit: function() {
+            var layer = this.getLayer();
+            return  layer && layer.isHitGraphEnabled() && this.isListening() && this.isVisible() && !Kinetic.isDragging();
         },
         /**
          * show node
@@ -1747,7 +1767,7 @@
     Kinetic.Factory.addGetterSetter(Kinetic.Node, 'listening', 'inherit');
 
     /**
-     * listen or don't listen to events.  can be true, false, or 'inherit'
+     * listen or don't listen to events.  Can be "inherit", true, or false.  The default is "inherit".
      * @name setListening
      * @method
      * @memberof Kinetic.Node.prototype
@@ -1763,10 +1783,10 @@
      * @returns {Boolean|String}
      */
 
-    Kinetic.Factory.addGetterSetter(Kinetic.Node, 'visible', true);
+    Kinetic.Factory.addGetterSetter(Kinetic.Node, 'visible', 'inherit');
 
     /**
-     * set visible
+     * set visible.  Can be "inherit", true, or false.  The default is "inherit".
      * @name setVisible
      * @method
      * @memberof Kinetic.Node.prototype

test/unit/Node-test.js

@@ -2717,5 +2717,73 @@ suite('Node', function() {
     assert.equal(circle.isTransformsEnabled(), true);
 
 
+  });
+
+
+    // ======================================================
+  test('isVisible', function(){
+    var stage = addStage();
+    var layer = new Kinetic.Layer();
+    var group = new Kinetic.Group();
+    var circle = new Kinetic.Circle({
+        x: 100,
+        y: 100,
+        radius: 70,
+        fill: 'green',
+        stroke: 'black',
+        strokeWidth: 4,
+        name: 'myCircle',
+        draggable: true
+    });
+
+    group.add(circle);
+    layer.add(group);
+    stage.add(layer);
+
+    assert.equal(stage.isVisible(), true);
+    assert.equal(layer.isVisible(), true);
+    assert.equal(circle.isVisible(), true);
+
+    stage.setVisible(false);
+
+    assert.equal(stage.isVisible(), false);
+    assert.equal(layer.isVisible(), false);
+    assert.equal(circle.isVisible(), false);
+
+    stage.setVisible('inherit');
+    layer.setVisible(false);
+
+    assert.equal(stage.isVisible(), true);
+    assert.equal(layer.isVisible(), false);
+    assert.equal(circle.isVisible(), false);
+
+    layer.setVisible('inherit');
+    circle.setVisible(false);
+
+    assert.equal(stage.isVisible(), true);
+    assert.equal(layer.isVisible(), true);
+    assert.equal(circle.isVisible(), false);
+
+    circle.setVisible('inherit');
+    stage.setVisible(true);
+
+    assert.equal(stage.isVisible(), true);
+    assert.equal(layer.isVisible(), true);
+    assert.equal(circle.isVisible(), true);
+
+    stage.setVisible('inherit');
+    layer.setVisible(true);
+
+    assert.equal(stage.isVisible(), true);
+    assert.equal(layer.isVisible(), true);
+    assert.equal(circle.isVisible(), true);
+
+    layer.setVisible('inherit');
+    circle.setVisible(true);
+
+    assert.equal(stage.isVisible(), true);
+    assert.equal(layer.isVisible(), true);
+    assert.equal(circle.isVisible(), true);
+
   });
 });