[NUI] Fix to get bezel wheel event on wearable device by WheelEvent (#1444)

diff --git a/src/Tizen.NUI/src/public/BaseComponents/ViewEvent.cs b/src/Tizen.NUI/src/public/BaseComponents/ViewEvent.cs
index 4cd9f5f..e91067d 100755 (executable)
--- a/src/Tizen.NUI/src/public/BaseComponents/ViewEvent.cs
+++ b/src/Tizen.NUI/src/public/BaseComponents/ViewEvent.cs
@@ -290,19 +290,28 @@ namespace Tizen.NUI.BaseComponents
                     _wheelEventCallback = OnWheelEvent;
                     this.WheelEventSignal().Connect(_wheelEventCallback);
                 }
-
                 _wheelEventHandler += value;
+
+                if (WindowWheelEventHandler == null)
+                {
+                    Window.Instance.WheelEvent += OnWindowWheelEvent;
+                }
+                WindowWheelEventHandler += value;
             }
 
             remove
             {
                 _wheelEventHandler -= value;
-
                 if (_wheelEventHandler == null && WheelEventSignal().Empty() == false)
                 {
                     this.WheelEventSignal().Disconnect(_wheelEventCallback);
                 }
 
+                WindowWheelEventHandler -= value;
+                if (WindowWheelEventHandler == null)
+                {
+                    Window.Instance.WheelEvent -= OnWindowWheelEvent;
+                }
             }
         }
 
@@ -1044,5 +1053,22 @@ namespace Tizen.NUI.BaseComponents
                 }
             }
         }
+
+        private EventHandlerWithReturnType<object, WheelEventArgs, bool> WindowWheelEventHandler;
+        private void OnWindowWheelEvent(object sender, Window.WheelEventArgs e)
+        {
+            if(e != null)
+            {
+                if(e.Wheel.Type == Wheel.WheelType.CustomWheel)
+                {
+                    var arg = new WheelEventArgs()
+                    {
+                        Wheel = e.Wheel,
+                    };
+                    WindowWheelEventHandler?.Invoke(this, arg);
+                }
+            }
+        }
+
     }
 }

diff --git a/src/Tizen.NUI/src/public/BaseComponents/ViewInternal.cs b/src/Tizen.NUI/src/public/BaseComponents/ViewInternal.cs
index 0321800..be7fbd4 100755 (executable)
--- a/src/Tizen.NUI/src/public/BaseComponents/ViewInternal.cs
+++ b/src/Tizen.NUI/src/public/BaseComponents/ViewInternal.cs
@@ -1085,6 +1085,11 @@ namespace Tizen.NUI.BaseComponents
                 this.WheelEventSignal().Disconnect(_wheelEventCallback);
             }
 
+            if (WindowWheelEventHandler != null)
+            {
+                Window.Instance.WheelEvent -= OnWindowWheelEvent;
+            }
+
             if (_hoverEventCallback != null)
             {
                 this.HoveredSignal().Disconnect(_hoverEventCallback);

diff --git a/src/Tizen.NUI/src/public/WindowEvent.cs b/src/Tizen.NUI/src/public/WindowEvent.cs
index a782be8..90dc0c0 100755 (executable)
--- a/src/Tizen.NUI/src/public/WindowEvent.cs
+++ b/src/Tizen.NUI/src/public/WindowEvent.cs
@@ -124,16 +124,29 @@ namespace Tizen.NUI
                 if (_stageWheelHandler == null)
                 {
                     _wheelEventCallback = OnStageWheel;
-                    this.StageWheelEventSignal().Connect(_wheelEventCallback);
+                    WheelEventSignal().Connect(_wheelEventCallback);
                 }
                 _stageWheelHandler += value;
+
+                if (DetentEventHandler == null)
+                {
+                    DetentEventCallback = OnDetentEvent;
+                    StageWheelEventSignal().Connect(DetentEventCallback);
+                }
+                DetentEventHandler += value;
             }
             remove
             {
                 _stageWheelHandler -= value;
-                if (_stageWheelHandler == null && StageWheelEventSignal().Empty() == false)
+                if (_stageWheelHandler == null && WheelEventSignal().Empty() == false)
+                {
+                    WheelEventSignal().Disconnect(_wheelEventCallback);
+                }
+
+                DetentEventHandler -= value;
+                if(DetentEventHandler ==  null && StageWheelEventSignal().Empty() == false)
                 {
-                    this.StageWheelEventSignal().Disconnect(_wheelEventCallback);
+                    StageWheelEventSignal().Disconnect(DetentEventCallback);
                 }
             }
         }
@@ -451,7 +464,12 @@ namespace Tizen.NUI
 
             if (_wheelEventCallback != null)
             {
-                StageWheelEventSignal().Disconnect(_wheelEventCallback);
+                WheelEventSignal().Disconnect(_wheelEventCallback);
+            }
+
+            if(DetentEventCallback != null)
+            {
+                StageWheelEventSignal().Disconnect(DetentEventCallback);
             }
 
             if (_stageKeyCallbackDelegate != null)
@@ -495,14 +513,14 @@ namespace Tizen.NUI
             }
         }
 
-        private StageWheelSignal WheelEventSignal()
+        private StageWheelSignal StageWheelEventSignal()
         {
             StageWheelSignal ret = new StageWheelSignal(Interop.StageSignal.Stage_WheelEventSignal(stageCPtr), false);
             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
             return ret;
         }
 
-        private WheelSignal StageWheelEventSignal()
+        private WheelSignal WheelEventSignal()
         {
             WheelSignal ret = new WheelSignal(Interop.ActorSignal.Actor_WheelEventSignal(Layer.getCPtr(this.GetRootLayer())), false);
             if (NDalicPINVOKE.SWIGPendingException.Pending)
@@ -889,5 +907,25 @@ namespace Tizen.NUI
                 }
             }
         }
+
+        private EventHandler<WheelEventArgs> DetentEventHandler;
+
+        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+        private delegate void DetentEventCallbackType(IntPtr arg1);
+
+        private DetentEventCallbackType DetentEventCallback;
+
+        private void OnDetentEvent(IntPtr wheelEvent)
+        {
+            WheelEventArgs e = new WheelEventArgs();
+
+            if (wheelEvent != global::System.IntPtr.Zero)
+            {
+                e.Wheel = Wheel.GetWheelFromPtr(wheelEvent);
+            }
+
+            DetentEventHandler?.Invoke(this, e);
+        }
+
     }
 }

diff --git a/test/Tizen.NUI.Samples/Tizen.NUI.Samples/Samples/DimTest.cs b/test/Tizen.NUI.Samples/Tizen.NUI.Samples/Samples/DimTest.cs
new file mode 100755 (executable)
index 0000000..16cbd7d
--- /dev/null
+++ b/test/Tizen.NUI.Samples/Tizen.NUI.Samples/Samples/DimTest.cs
@@ -0,0 +1,200 @@
+
+using System;
+using Tizen.NUI.BaseComponents;
+
+namespace Tizen.NUI.Samples
+{
+    using tlog = Tizen.Log;
+    public class DimTest : IExample
+    {
+        const string tag = "NUITEST";
+
+        Window win;
+        DimmableView dimView;
+
+        class DimmableView : View
+        {
+            private View content;
+            private bool dimmed;
+            private View overlay;
+
+            public DimmableView()
+            {
+                overlay = new View();
+                overlay.BackgroundColor = Color.Black;
+                overlay.Opacity = 0.0f;
+                overlay.HeightResizePolicy = ResizePolicyType.FillToParent;
+                overlay.WidthResizePolicy = ResizePolicyType.FillToParent;
+                this.Add(overlay);
+            }
+
+            public View Content
+            {
+                get
+                {
+                    return content;
+                }
+                set
+                {
+                    if (content) Remove(content);
+                    Add(value);
+                    Remove(overlay);
+                    Add(overlay);
+                }
+            }
+
+            public bool Dimmed
+            {
+                get { return dimmed; }
+                set
+                {
+                    if (value)
+                    {
+                        overlay.Opacity = 0.5f;
+                    }
+                    else
+                    {
+                        overlay.Opacity = 0.0f;
+                    }
+                }
+            }
+        }
+
+        View filter;
+        public void Activate()
+        {
+            win = Window.Instance;
+            win.BackgroundColor = Color.Green;
+            win.KeyEvent += Window_KeyEvent;
+            win.WheelEvent += Win_WheelEvent;
+
+            dimView = new DimmableView();
+            dimView.PositionUsesPivotPoint = true;
+            dimView.ParentOrigin = ParentOrigin.Center;
+            dimView.PivotPoint = PivotPoint.Center;
+            dimView.Size = new Size(150, 300);
+            win.Add(dimView);
+
+            var child1 = new TextLabel();
+            child1.Position = new Position(10, 10);
+            child1.Size = new Size(100, 100);
+            child1.BackgroundColor = Color.Blue;
+            child1.Text = "child1";
+            child1.PointSize = 9;
+            child1.TouchEvent += Child1_TouchEvent;
+            dimView.Content = child1;
+
+            var child2 = new TextLabel();
+            child2.Position = new Position(100, 100);
+            child2.Size = new Size(100, 200);
+            child2.BackgroundColor = Color.Yellow;
+            child2.Text = "child2";
+            child2.PointSize = 8;
+            dimView.Content = child2;
+            child2.WheelEvent += Child2_DetentEvent;
+            child2.WheelEvent += Child2_DetentEvent2;
+
+            filter = new View();
+            filter.Position = new Position(50, 50);
+            filter.Size = new Size(300, 300);
+            filter.BackgroundColor = Color.Red;
+            filter.Opacity = 0;
+            filter.WheelEvent += Filter_WheelEvent;
+            win.Add(filter);
+        }
+
+        private bool Child2_DetentEvent(object sender, View.WheelEventArgs e)
+        {
+            tlog.Fatal(tag, $"Child2_DetentEvent() direction={e.Wheel.Direction} timestamp={e.Wheel.TimeStamp}");
+            if (sender is TextLabel)
+            {
+                var me = sender as TextLabel;
+                if (e.Wheel.Direction == 1)
+                {
+                    me.PositionX += 10;
+                }
+                else if (e.Wheel.Direction == -1)
+                {
+                    me.PositionX -= 10;
+                }
+            }
+            return true;
+        }
+
+        private bool Child2_DetentEvent2(object sender, View.WheelEventArgs e)
+        {
+            tlog.Fatal(tag, $"Child2_DetentEvent2() direction={e.Wheel.Direction} timestamp={e.Wheel.TimeStamp}");
+            if (sender is TextLabel)
+            {
+                var me = sender as TextLabel;
+                me.Text = "child2 pos x=" + me.PositionX;
+                me.MultiLine = true;
+            }
+            return true;
+        }
+
+        private bool Child1_TouchEvent(object source, View.TouchEventArgs e)
+        {
+            tlog.Fatal(tag, $"Child1_TouchEvent()");
+            return false;
+        }
+
+        private void Win_WheelEvent(object sender, Window.WheelEventArgs e)
+        {
+            tlog.Fatal(tag, $"Win_WheelEvent()");
+
+            if (e.Wheel.Type == Wheel.WheelType.CustomWheel)
+            {
+                tlog.Fatal(tag, $"z: {e.Wheel.Z}");
+            }
+        }
+
+        private bool Filter_WheelEvent(object source, View.WheelEventArgs e)
+        {
+            tlog.Fatal(tag, $"Filter_WheelEvent()");
+
+            if (e.Wheel.Type == Wheel.WheelType.CustomWheel)
+            {
+                tlog.Fatal(tag, $"z: {e.Wheel.Z}");
+            }
+            return true;
+        }
+
+        private void Window_KeyEvent(object sender, Window.KeyEventArgs e)
+        {
+            if (e.Key.State == Key.StateType.Up)
+            {
+                tlog.Fatal(tag, $"Window_KeyEvent() key:{e.Key.KeyPressedName}");
+                switch (e.Key.KeyPressedName)
+                {
+                    case "1":
+                        dimView.Dimmed = true;
+                        break;
+                    case "2":
+                        dimView.Dimmed = false;
+                        break;
+                    case "3":
+                        filter.RaiseToTop();
+                        break;
+                    case "4":
+                        filter.LowerToBottom();
+                        break;
+                    case "5":
+                        filter.Opacity = 0;
+                        break;
+                    case "6":
+                        filter.Opacity = 0.5f;
+                        break;
+                    case "7":
+                        filter.Opacity = 1;
+                        break;
+                }
+            }
+        }
+
+        public void Deactivate()
+        {
+            dimView.Unparent();
+        }
+    }
+}
\ No newline at end of file