[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 a611fa2..bd03e5b 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,15 @@ namespace Tizen.NUI
                 return;
             }
 
+            if (visibilityChangedEventCallback != null)
+            {
+                NUILog.Debug($"[Dispose] visibilityChangedEventCallback");
+
+                Interop.ActorSignal.VisibilityChangedDisconnect(GetBaseHandleCPtrHandleRef, visibilityChangedEventCallback.ToHandleRef(this));
+                NDalicPINVOKE.ThrowExceptionIfExistsDebug();
+                visibilityChangedEventCallback = null;
+            }
+
             LayoutCount = 0;
 
             base.Dispose(type);
@@ -609,6 +623,78 @@ 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;
+                    Interop.ActorSignal.VisibilityChangedConnect(SwigCPtr, visibilityChangedEventCallback.ToHandleRef(this));
+                    NDalicPINVOKE.ThrowExceptionIfExists();
+                }
+                visibilityChangedEventHandler += value;
+            }
+
+            remove
+            {
+                visibilityChangedEventHandler -= value;
+                if (visibilityChangedEventHandler == null && visibilityChangedEventCallback != null)
+                {
+                    Interop.ActorSignal.VisibilityChangedDisconnect(SwigCPtr, visibilityChangedEventCallback.ToHandleRef(this));
+                    NDalicPINVOKE.ThrowExceptionIfExists();
+                    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;
+                }
+            }
+        }
+
         internal uint GetDepth()
         {
             var parentChildren = window?.LayersChildren;
@@ -797,5 +883,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);
+            }
+        }
     }
 }