[NUI] Add VisibilityChanged event to Layer

To notice the visibility changes of Layer, VisibilityChanged event is
added to Layer.

diff --git a/src/Tizen.NUI/src/public/Common/Layer.cs b/src/Tizen.NUI/src/public/Common/Layer.cs
index cc9629c..1afbade 100755 (executable)
--- a/src/Tizen.NUI/src/public/Common/Layer.cs
+++ b/src/Tizen.NUI/src/public/Common/Layer.cs
@@ -17,6 +17,7 @@
 using System;
 using Tizen.NUI.BaseComponents;
 using System.ComponentModel;
+using System.Runtime.InteropServices;
 
 namespace Tizen.NUI
 {
@@ -28,6 +29,10 @@ namespace Tizen.NUI
     {
         private Window window;
         private int layoutCount = 0;
+        private EventHandler<VisibilityChangedEventArgs> visibilityChangedEventHandler;
+        private VisibilityChangedEventCallbackType visibilityChangedEventCallback;
+        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+        private delegate void VisibilityChangedEventCallbackType(IntPtr data, bool visibility, VisibilityChangeType type);
 
         /// <summary>
         /// Creates a Layer object.
@@ -55,6 +60,12 @@ namespace Tizen.NUI
                 return;
             }
 
+            if (visibilityChangedEventCallback != null)
+            {
+                VisibilityChangedSignal(this).Disconnect(visibilityChangedEventCallback);
+                visibilityChangedEventCallback = null;
+            }
+
             LayoutCount = 0;
 
             base.Dispose(type);
@@ -611,6 +622,89 @@ namespace Tizen.NUI
             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
         }
 
+        /// <summary>
+        /// An event for visibility change which can be used to subscribe or unsubscribe the event handler.<br />
+        /// This signal is emitted when the visible property of this or a parent view is changed.<br />
+        /// </summary>
+        [EditorBrowsable(EditorBrowsableState.Never)]
+        public event EventHandler<VisibilityChangedEventArgs> VisibilityChanged
+        {
+            add
+            {
+                if (visibilityChangedEventHandler == null)
+                {
+                    visibilityChangedEventCallback = OnVisibilityChanged;
+                    VisibilityChangedSignal(this).Connect(visibilityChangedEventCallback);
+                }
+
+                visibilityChangedEventHandler += value;
+            }
+
+            remove
+            {
+                visibilityChangedEventHandler -= value;
+
+                if (visibilityChangedEventHandler == null && VisibilityChangedSignal(this).Empty() == false)
+                {
+                    VisibilityChangedSignal(this).Disconnect(visibilityChangedEventCallback);
+                    if (VisibilityChangedSignal(this).Empty() == true)
+                    {
+                        visibilityChangedEventCallback = null;
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Event arguments of visibility changed.
+        /// </summary>
+        [EditorBrowsable(EditorBrowsableState.Never)]
+        public class VisibilityChangedEventArgs : EventArgs
+        {
+            private Layer layer;
+            private bool visibility;
+
+            /// <summary>
+            /// The layer whose visibility has changed.
+            /// </summary>
+            [EditorBrowsable(EditorBrowsableState.Never)]
+            public Layer Layer
+            {
+                get
+                {
+                    return layer;
+                }
+                set
+                {
+                    layer = value;
+                }
+            }
+
+            /// <summary>
+            /// Whether the layer is now visible or not.
+            /// </summary>
+            [EditorBrowsable(EditorBrowsableState.Never)]
+            public bool Visibility
+            {
+                get
+                {
+                    return visibility;
+                }
+                set
+                {
+                    visibility = value;
+                }
+            }
+        }
+
+        // Since ViewVisibilityChangedSignal uses Actor's visibility, Layer uses it as well.
+        internal ViewVisibilityChangedSignal VisibilityChangedSignal(Layer layer)
+        {
+            ViewVisibilityChangedSignal ret = new ViewVisibilityChangedSignal(Interop.NDalic.VisibilityChangedSignal(Layer.getCPtr(layer)), false);
+            if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+            return ret;
+        }
+
         internal uint GetDepth()
         {
             var parentChildren = window?.LayersChildren;
@@ -799,5 +893,22 @@ namespace Tizen.NUI
         {
             internal static readonly int BEHAVIOR = Interop.Layer.BehaviorGet();
         }
+
+        // Callback for View visibility change signal
+        // type is not used because layer does not have parent so layer's visibility cannot be changed by its parent.
+        private void OnVisibilityChanged(IntPtr data, bool visibility, VisibilityChangeType type)
+        {
+            VisibilityChangedEventArgs e = new VisibilityChangedEventArgs();
+            if (data != null)
+            {
+                e.Layer = Registry.GetManagedBaseHandleFromNativePtr(data) as Layer;
+            }
+            e.Visibility = visibility;
+
+            if (visibilityChangedEventHandler != null)
+            {
+                visibilityChangedEventHandler(this, e);
+            }
+        }
     }
 }