From 9b4767702c6b6cd48aa4f975b4aa0d6efbc55479 Mon Sep 17 00:00:00 2001 From: "duna.oh" Date: Tue, 28 May 2024 16:53:06 +0900 Subject: [PATCH] Introduce the new InputGesture feature supporting Edge Swipe, Edge Drag, Tap, and Palm Cover gestures --- .../internal/Interop/Interop.InputGesture.cs | 93 +++ .../src/public/EdgeDragEventArgs.cs | 58 ++ .../src/public/EdgeSwipeEventArgs.cs | 58 ++ .../src/public/InputGesture.cs | 578 ++++++++++++++++++ .../src/public/PalmCoverEventArgs.cs | 63 ++ .../src/public/TapEventArgs.cs | 48 ++ .../Tizen.NUI.WindowSystem.InputGesture.cs | 231 +++++++ ...Tizen.NUI.WindowSystem.InputGesture.csproj | 27 + .../Tizen.NUI.WindowSystem.InputGesture.png | Bin 0 -> 10097 bytes .../tizen-manifest.xml | 16 + .../tizen_dotnet_project.yaml | 9 + 11 files changed, 1181 insertions(+) create mode 100644 src/Tizen.NUI.WindowSystem/src/internal/Interop/Interop.InputGesture.cs create mode 100644 src/Tizen.NUI.WindowSystem/src/public/EdgeDragEventArgs.cs create mode 100644 src/Tizen.NUI.WindowSystem/src/public/EdgeSwipeEventArgs.cs create mode 100644 src/Tizen.NUI.WindowSystem/src/public/InputGesture.cs create mode 100644 src/Tizen.NUI.WindowSystem/src/public/PalmCoverEventArgs.cs create mode 100644 src/Tizen.NUI.WindowSystem/src/public/TapEventArgs.cs create mode 100644 test/Tizen.NUI.WindowSystem.InputGesture/Tizen.NUI.WindowSystem.InputGesture.cs create mode 100644 test/Tizen.NUI.WindowSystem.InputGesture/Tizen.NUI.WindowSystem.InputGesture.csproj create mode 100644 test/Tizen.NUI.WindowSystem.InputGesture/shared/res/Tizen.NUI.WindowSystem.InputGesture.png create mode 100644 test/Tizen.NUI.WindowSystem.InputGesture/tizen-manifest.xml create mode 100644 test/Tizen.NUI.WindowSystem.InputGesture/tizen_dotnet_project.yaml diff --git a/src/Tizen.NUI.WindowSystem/src/internal/Interop/Interop.InputGesture.cs b/src/Tizen.NUI.WindowSystem/src/internal/Interop/Interop.InputGesture.cs new file mode 100644 index 00000000000..f602a008881 --- /dev/null +++ b/src/Tizen.NUI.WindowSystem/src/internal/Interop/Interop.InputGesture.cs @@ -0,0 +1,93 @@ +using System; +using System.Runtime.InteropServices; +using System.Collections.Generic; +using System.Text; + +namespace Tizen.NUI.WindowSystem +{ + internal static partial class Interop + { + internal static class InputGesture + { + const string lib = "libcapi-ui-efl-util.so.0"; + + internal static string LogTag = "Tizen.NUI.WindowSystem"; + + [DllImport(lib, EntryPoint = "efl_util_gesture_initialize")] + internal static extern IntPtr Initialize(); + + [DllImport(lib, EntryPoint = "efl_util_gesture_deinitialize")] + internal static extern ErrorCode Deinitialize(IntPtr gestureHandler); + + [DllImport(lib, EntryPoint = "efl_util_gesture_edge_swipe_new")] + internal static extern IntPtr EdgeSwipeNew(IntPtr gestureHandler, int fingers, int edge); + + [DllImport(lib, EntryPoint = "efl_util_gesture_edge_swipe_free")] + internal static extern ErrorCode EdgeSwipeFree(IntPtr gestureHandler, IntPtr gestureData); + + [DllImport(lib, EntryPoint = "efl_util_gesture_edge_swipe_size_set")] + internal static extern ErrorCode EdgeSwipeSizeSet(IntPtr gestureData, int edgeSize, int startPoint, int endPoint); + + [DllImport(lib, EntryPoint = "efl_util_gesture_edge_drag_new")] + internal static extern IntPtr EdgeDragNew(IntPtr gestureHandler, int fingers, int edge); + + [DllImport(lib, EntryPoint = "efl_util_gesture_edge_drag_free")] + internal static extern ErrorCode EdgeDragFree(IntPtr gestureHandler, IntPtr gestureData); + + [DllImport(lib, EntryPoint = "efl_util_gesture_edge_drag_size_set")] + internal static extern ErrorCode EdgeDragSizeSet(IntPtr gestureData, int edgeSize, int startPoint, int endPoint); + + [DllImport(lib, EntryPoint = "efl_util_gesture_tap_new")] + internal static extern IntPtr TapNew(IntPtr gestureHandler, int fingers, int repeats); + + [DllImport(lib, EntryPoint = "efl_util_gesture_tap_free")] + internal static extern ErrorCode TapFree(IntPtr gestureHandler, IntPtr gestureData); + + [DllImport(lib, EntryPoint = "efl_util_gesture_palm_cover_new")] + internal static extern IntPtr PalmCoverNew(IntPtr gestureHandler); + + [DllImport(lib, EntryPoint = "efl_util_gesture_palm_cover_free")] + internal static extern ErrorCode PalmCoverFree(IntPtr gestureHandler, IntPtr gestureData); + + [DllImport(lib, EntryPoint = "efl_util_gesture_grab")] + internal static extern ErrorCode GestureGrab(IntPtr gestureHandler, IntPtr gestureData); + + [DllImport(lib, EntryPoint = "efl_util_gesture_ungrab")] + internal static extern ErrorCode GestureUngrab(IntPtr gestureHandler, IntPtr gestureData); + + [DllImport(lib, EntryPoint = "efl_util_gesture_edge_swipe_cb_set")] + internal static extern ErrorCode SetEdgeSwipeCb(IntPtr gestureHandler, EdgeSwipeCb cbFunc, IntPtr usergestureData); + + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + internal delegate void EdgeSwipeCb(IntPtr usergestureData, int mode, int fingers, int sx, int sy, int edge); + + [DllImport(lib, EntryPoint = "efl_util_gesture_edge_drag_cb_set")] + internal static extern ErrorCode SetEdgeDragCb(IntPtr gestureHandler, EdgeDragCb cbFunc, IntPtr usergestureData); + + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + internal delegate void EdgeDragCb(IntPtr usergestureData, int mode, int fingers, int cx, int cy, int edge); + + [DllImport(lib, EntryPoint = "efl_util_gesture_tap_cb_set")] + internal static extern ErrorCode SetTapCb(IntPtr gestureHandler, TapCb cbFunc, IntPtr usergestureData); + + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + internal delegate void TapCb(IntPtr usergestureData, int mode, int fingers, int repeats); + + [DllImport(lib, EntryPoint = "efl_util_gesture_palm_cover_cb_set")] + internal static extern ErrorCode SetPalmCoverCb(IntPtr gestureHandler, PalmCoverCb cbFunc, IntPtr usergestureData); + + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + internal delegate void PalmCoverCb(IntPtr usergestureData, int mode, int duration, int cx, int cy, int size, double pressure); + + internal enum ErrorCode + { + None = Tizen.Internals.Errors.ErrorCode.None, // Successful + OutOfMemory = Tizen.Internals.Errors.ErrorCode.OutOfMemory, // Out of memory + InvalidParameter = Tizen.Internals.Errors.ErrorCode.InvalidParameter, // Invalid parameter + InvalidOperation = Tizen.Internals.Errors.ErrorCode.InvalidOperation, // Invalid operation + PermissionDenied = Tizen.Internals.Errors.ErrorCode.PermissionDenied, // Permission denied + NotSupported = Tizen.Internals.Errors.ErrorCode.NotSupported, // NOT supported + }; + } + } +} diff --git a/src/Tizen.NUI.WindowSystem/src/public/EdgeDragEventArgs.cs b/src/Tizen.NUI.WindowSystem/src/public/EdgeDragEventArgs.cs new file mode 100644 index 00000000000..540df835ce1 --- /dev/null +++ b/src/Tizen.NUI.WindowSystem/src/public/EdgeDragEventArgs.cs @@ -0,0 +1,58 @@ +/* + * Copyright(c) 2024 Samsung Electronics Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ +using System; +using System.ComponentModel; + +namespace Tizen.NUI.WindowSystem +{ + /// + /// This class contains the data related to the EdgeDrag event. + /// + /// This class is need to be hidden as inhouse API. + [EditorBrowsable(EditorBrowsableState.Never)] + public class EdgeDragEventArgs : EventArgs + { + internal EdgeDragEventArgs(int mode, int fingers, int cx, int cy, int edge) + { + Mode = mode; + Fingers = fingers; + Cx = cx; + Cy = cy; + Edge = edge; + } + /// + /// Mode + /// + public int Mode{ get; internal set; } + /// + /// Fingers + /// + public int Fingers{ get; internal set;} + /// + /// Cx + /// + public int Cx{ get; internal set;} + /// + /// Cy + /// + public int Cy{ get; internal set;} + /// + /// Edge + /// + public int Edge{ get; internal set;} + } +} diff --git a/src/Tizen.NUI.WindowSystem/src/public/EdgeSwipeEventArgs.cs b/src/Tizen.NUI.WindowSystem/src/public/EdgeSwipeEventArgs.cs new file mode 100644 index 00000000000..e782d87d825 --- /dev/null +++ b/src/Tizen.NUI.WindowSystem/src/public/EdgeSwipeEventArgs.cs @@ -0,0 +1,58 @@ +/* + * Copyright(c) 2024 Samsung Electronics Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ +using System; +using System.ComponentModel; + +namespace Tizen.NUI.WindowSystem +{ + /// + /// This class contains the data related to the EdgeSwipe event. + /// + /// This class is need to be hidden as inhouse API. + [EditorBrowsable(EditorBrowsableState.Never)] + public class EdgeSwipeEventArgs : EventArgs + { + internal EdgeSwipeEventArgs(int mode, int fingers, int sx, int sy, int edge) + { + Mode = mode; + Fingers = fingers; + Sx = sx; + Sy = sy; + Edge = edge; + } + /// + /// Mode + /// + public int Mode{ get; internal set; } + /// + /// Fingers + /// + public int Fingers{ get; internal set;} + /// + /// Sx + /// + public int Sx{ get; internal set;} + /// + /// Sy + /// + public int Sy{ get; internal set;} + /// + /// Edge + /// + public int Edge{ get; internal set;} + } +} diff --git a/src/Tizen.NUI.WindowSystem/src/public/InputGesture.cs b/src/Tizen.NUI.WindowSystem/src/public/InputGesture.cs new file mode 100644 index 00000000000..b78fb7a269b --- /dev/null +++ b/src/Tizen.NUI.WindowSystem/src/public/InputGesture.cs @@ -0,0 +1,578 @@ +/* + * Copyright(c) 2024 Samsung Electronics Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +using System; +using System.ComponentModel; +using static Tizen.NUI.WindowSystem.Interop.InputGesture; + +namespace Tizen.NUI.WindowSystem +{ + /// + /// Enumeration of gesture modes. + /// + /// This enum is need to be hidden as inhouse API. + [EditorBrowsable(EditorBrowsableState.Never)] + public enum GestureMode + { + /// + /// None. + /// + None, + + /// + /// Begin. + /// + Begin, + + /// + /// Update. + /// + Update, + + /// + /// End. + /// + End, + + /// + /// Done. + /// + Done, + } + + /// + /// Enumeration of gesture edges. + /// + /// This enum is need to be hidden as inhouse API. + [EditorBrowsable(EditorBrowsableState.Never)] + public enum GestureEdge + { + /// + /// edge none. + /// + None, + + /// + /// edge top. + /// + Top, + + /// + /// edge right. + /// + Right, + + /// + /// edge bottom. + /// + Bottom, + + /// + /// edge left. + /// + Left, + } + + /// + /// Enumeration of gesture edge sizes. + /// + /// This enum is need to be hidden as inhouse API. + [EditorBrowsable(EditorBrowsableState.Never)] + public enum GestureEdgeSize + { + /// + /// edge size none. + /// + None, + + /// + /// edge size full. + /// + Full, + + /// + /// edge size partial. + /// + Partial, + } + + /// + /// Class for the Tizen Input Gesture. + /// + /// + /// http://tizen.org/privilege/gesturegrab + /// + /// This class is need to be hidden as inhouse API. + [EditorBrowsable(EditorBrowsableState.Never)] + public class InputGesture : IDisposable + { + private IntPtr _handler; + private bool disposed = false; + private bool isDisposeQueued = false; + + private event EventHandler _edgeSwipeEventHandler; + private EdgeSwipeCb _edgeSwipeDelegate; + + private event EventHandler _edgeDragEventHandler; + private EdgeDragCb _edgeDragDelegate; + + private event EventHandler _tapEventHandler; + private TapCb _tapDelegate; + + private event EventHandler _palmCoverEventHandler; + private PalmCoverCb _palmCoverDelegate; + + internal void ErrorCodeThrow(Interop.InputGesture.ErrorCode error) + { + switch (error) + { + case Interop.InputGesture.ErrorCode.None : + return; + case Interop.InputGesture.ErrorCode.OutOfMemory : + throw new Tizen.Applications.Exceptions.OutOfMemoryException("Out of Memory"); + case Interop.InputGesture.ErrorCode.InvalidParameter : + throw new ArgumentException("Invalid Parameter"); + case Interop.InputGesture.ErrorCode.PermissionDenied : + throw new Tizen.Applications.Exceptions.PermissionDeniedException("Permission denied"); + case Interop.InputGesture.ErrorCode.NotSupported : + throw new NotSupportedException("Not Supported"); + default : + throw new InvalidOperationException("Unknown Error"); + } + } + + /// + /// Creates a new InputGesture. + /// + /// This module operates in a NUI application and requires instantiation and disposal on the main thread. + /// Thrown when the memory is not enough to allocate. + /// Thrown when the feature is not supported. + /// Thrown when the permission is denied. + public InputGesture() + { + _handler = Interop.InputGesture.Initialize(); + if (_handler == IntPtr.Zero) + { + int err = Tizen.Internals.Errors.ErrorFacts.GetLastResult(); + ErrorCodeThrow((Interop.InputGesture.ErrorCode)err); + } + Log.Debug(LogTag, "InputGesture Created"); + } + + /// + /// Destructor. + /// + ~InputGesture() + { + if (!isDisposeQueued) + { + isDisposeQueued = true; + DisposeQueue.Instance.Add(this); + } + } + + /// + /// Dispose. + /// + public void Dispose() + { + if (isDisposeQueued) + { + Dispose(DisposeTypes.Implicit); + } + else + { + Dispose(DisposeTypes.Explicit); + GC.SuppressFinalize(this); + } + } + + /// + protected virtual void Dispose(DisposeTypes type) + { + if (disposed) + { + return; + } + + if (type == DisposeTypes.Explicit) + { + //Called by User + //Release your own managed resources here. + //You should release all of your own disposable objects here. + } + + //Release your own unmanaged resources here. + //You should not access any managed member here except static instance. + //because the execution order of Finalizes is non-deterministic. + if (_handler != global::System.IntPtr.Zero) + { + Interop.InputGesture.ErrorCode res = Interop.InputGesture.Deinitialize(_handler); + ErrorCodeThrow(res); + _handler = IntPtr.Zero; + } + + disposed = true; + } + + /// + /// Generates a edge swipe gesture's grab info handle + /// + /// The number of fingers + /// The position of edge + /// The edge swipe gesture data handle + /// Thrown when failed of invalid argument. + /// Thrown when the memory is not enough to allocate. + public IntPtr CreateEdgeSwipeData(int fingers, GestureEdge edge) + { + IntPtr edgeSwipeG = IntPtr.Zero; + edgeSwipeG = Interop.InputGesture.EdgeSwipeNew(_handler, fingers, (int)edge); + if (edgeSwipeG == IntPtr.Zero) + { + int err = Tizen.Internals.Errors.ErrorFacts.GetLastResult(); + ErrorCodeThrow((Interop.InputGesture.ErrorCode)err); + } + Log.Debug(LogTag, "CreateEdgeSwipeData" + "fingers: " + fingers, "edge: " + (int)edge); + return edgeSwipeG; + } + + /// + /// Frees a memory of edge swipe gesture's grab info handle + /// + /// The edge swipe gesture data handle + /// Thrown when failed of invalid argument. + public void ReleaseEdgeSwipeData(IntPtr data) + { + if (data == IntPtr.Zero) + { + throw new ArgumentException("EdgeSwipeData is not valid."); + } + Interop.InputGesture.ErrorCode res = Interop.InputGesture.EdgeSwipeFree(_handler, data); + ErrorCodeThrow(res); + Log.Debug(LogTag, "ReleaseEdgeSwipeData"); + } + + /// + /// Sets a specific size of edge for edge swipe gesture + /// + /// The edge swipe gesture data handle + /// The enum of gesture edge size + /// The start point of edge area + /// The end point of edge area + /// Thrown when failed of invalid argument. + public void SetEdgeSwipeSize(IntPtr data, GestureEdgeSize edgeSize, int startPoint, int endPoint) + { + if (data == IntPtr.Zero) + { + throw new ArgumentException("EdgeSwipeData is not valid."); + } + Interop.InputGesture.ErrorCode res = Interop.InputGesture.EdgeSwipeSizeSet(data, (int)edgeSize, startPoint, endPoint); + ErrorCodeThrow(res); + Log.Debug(LogTag, "SetEdgeSwipeSize" + "size: " + (int)edgeSize + "startPoint: " + startPoint + "endPoint: " + endPoint); + } + + /// + /// Generates a edge drag gesture's grab info handle + /// + /// The number of fingers + /// The position of edge + /// The edge drag gesture data handle + /// Thrown when failed of invalid argument. + /// Thrown when the memory is not enough to allocate. + public IntPtr CreateEdgeDragData(int fingers, GestureEdge edge) + { + IntPtr edgeDragG = IntPtr.Zero; + edgeDragG = Interop.InputGesture.EdgeDragNew(_handler, fingers, (int)edge); + if (edgeDragG == IntPtr.Zero) + { + int err = Tizen.Internals.Errors.ErrorFacts.GetLastResult(); + ErrorCodeThrow((Interop.InputGesture.ErrorCode)err); + } + Log.Debug(LogTag, "CreateEdgeDragData" + "fingers: " + fingers, "edge: " + (int)edge); + return edgeDragG; + } + + /// + /// Frees a memory of edge drag gesture's grab info handle + /// + /// The edge drag gesture data handle + /// Thrown when failed of invalid argument. + public void ReleaseEdgeDrageData(IntPtr data) + { + if (data == IntPtr.Zero) + { + throw new ArgumentException("EdgeDragData is not valid."); + } + Interop.InputGesture.ErrorCode res = Interop.InputGesture.EdgeDragFree(_handler, data); + ErrorCodeThrow(res); + Log.Debug(LogTag, "ReleaseEdgeDrageData"); + } + + /// + /// Sets a specific size of edge for edge drag gesture + /// + /// The edge drag gesture data handle + /// The enum of gesture edge size + /// The start point of edge area + /// The end point of edge area + /// Thrown when failed of invalid argument. + public void SetEdgeDragSize(IntPtr data, GestureEdgeSize edgeSize, int startPoint, int endPoint) + { + if (data == IntPtr.Zero) + { + throw new ArgumentException("EdgeDragData is not valid."); + } + Interop.InputGesture.ErrorCode res = Interop.InputGesture.EdgeDragSizeSet(data, (int)edgeSize, startPoint, endPoint); + ErrorCodeThrow(res); + Log.Debug(LogTag, "SetEdgeDragSize" + "size: " + (int)edgeSize + "startPoint: " + startPoint + "endPoint: " + endPoint); + } + + /// + /// Generates a tap gesture's grab info handle + /// + /// The number of fingers + /// The number of repeats + /// The tap gesture data handle + /// Thrown when failed of invalid argument. + /// Thrown when the memory is not enough to allocate. + public IntPtr CreateTapData(int fingers, int repeats) + { + IntPtr tapG = IntPtr.Zero; + tapG = Interop.InputGesture.TapNew(_handler, fingers, repeats); + if (tapG == IntPtr.Zero) + { + int err = Tizen.Internals.Errors.ErrorFacts.GetLastResult(); + ErrorCodeThrow((Interop.InputGesture.ErrorCode)err); + } + Log.Debug(LogTag, "CreateTapData" + "fingers: " + fingers, "repeats: " + repeats); + return tapG; + } + + /// + /// Frees a memory of tap gesture's grab info handle + /// + /// The tap gesture data handle + /// Thrown when failed of invalid argument. + public void ReleaseTapData(IntPtr data) + { + if (data == IntPtr.Zero) + { + throw new ArgumentException("tapData is not valid."); + } + Interop.InputGesture.ErrorCode res = Interop.InputGesture.TapFree(_handler, data); + ErrorCodeThrow(res); + Log.Debug(LogTag, "ReleaseTapData"); + } + + /// + /// Generates a palm cover gesture's grab info handle + /// + /// The palm cover gesture data handle + /// Thrown when failed of invalid argument. + /// Thrown when the memory is not enough to allocate. + public IntPtr CreatePalmCoverData() + { + IntPtr palmCoverG = IntPtr.Zero; + palmCoverG = Interop.InputGesture.PalmCoverNew(_handler); + if (palmCoverG == IntPtr.Zero) + { + int err = Tizen.Internals.Errors.ErrorFacts.GetLastResult(); + ErrorCodeThrow((Interop.InputGesture.ErrorCode)err); + } + Log.Debug(LogTag, "CreatePalmCoverData"); + return palmCoverG; + } + + /// + /// Frees a memory of palm cover gesture's grab info handle + /// + /// The palm cover gesture data handle + /// Thrown when failed of invalid argument. + public void ReleasePalmCoverData(IntPtr data) + { + if (data == IntPtr.Zero) + { + throw new ArgumentException("palmCoverData is not valid."); + } + Interop.InputGesture.ErrorCode res = Interop.InputGesture.PalmCoverFree(_handler, data); + ErrorCodeThrow(res); + Log.Debug(LogTag, "ReleasePalmCoverData"); + } + + /// + /// Grabs a global gesture + /// + /// gesture data to grab + /// Thrown when failed of invalid argument. + public void GrabGesture(IntPtr data) + { + if (data == IntPtr.Zero) + { + throw new ArgumentException("gesture data is not valid."); + } + Interop.InputGesture.ErrorCode res = Interop.InputGesture.GestureGrab(_handler, data); + ErrorCodeThrow(res); + Log.Debug(LogTag, "GrabGesture"); + } + + /// + /// Ungrabs a global gesture. + /// + /// gesture data to ungrab + /// Thrown when failed of invalid argument. + public void UngrabGesture(IntPtr data) + { + if (data == IntPtr.Zero) + { + throw new ArgumentException("gesture data is not valid."); + } + Interop.InputGesture.ErrorCode res = Interop.InputGesture.GestureUngrab(_handler, data); + ErrorCodeThrow(res); + Log.Debug(LogTag, "UngrabGesture"); + } + + /// + /// Emits the event when the edge swipe event comes + /// + /// Thrown when failed of invalid argument. + public event EventHandler EdgeSwipeEventHandler + { + add + { + if (_edgeSwipeEventHandler == null) + { + _edgeSwipeDelegate = (IntPtr userData, int mode, int fingers, int sx, int sy, int edge) => + { + EdgeSwipeEventArgs args = new EdgeSwipeEventArgs(mode, fingers, sx, sy, edge); + Log.Debug(LogTag, "EdgeSwipe Event received. mode: " + mode + ", fingers: " + fingers); + _edgeSwipeEventHandler?.Invoke(null, args); + }; + Interop.InputGesture.ErrorCode res = Interop.InputGesture.SetEdgeSwipeCb(_handler, _edgeSwipeDelegate, IntPtr.Zero); + ErrorCodeThrow(res); + } + + _edgeSwipeEventHandler += value; + } + remove + { + _edgeSwipeEventHandler -= value; + if (_edgeSwipeEventHandler == null) + { + Interop.InputGesture.ErrorCode res = Interop.InputGesture.SetEdgeSwipeCb(_handler, null, IntPtr.Zero); + ErrorCodeThrow(res); + } + } + } + + /// + /// Emits the event when the edge drag event comes + /// + /// Thrown when failed of invalid argument. + public event EventHandler EdgeDragEventHandler + { + add + { + if (_edgeDragEventHandler == null) + { + _edgeDragDelegate = (IntPtr userData, int mode, int fingers, int cx, int cy, int edge) => + { + EdgeDragEventArgs args = new EdgeDragEventArgs(mode, fingers, cx, cy, edge); + Log.Debug(LogTag, "EdgeDrag Event received. mode: " + mode + ", fingers: " + fingers); + _edgeDragEventHandler?.Invoke(null, args); + }; + Interop.InputGesture.ErrorCode res = Interop.InputGesture.SetEdgeDragCb(_handler, _edgeDragDelegate, IntPtr.Zero); + ErrorCodeThrow(res); + } + + _edgeDragEventHandler += value; + } + remove + { + _edgeDragEventHandler -= value; + if (_edgeDragEventHandler == null) + { + Interop.InputGesture.ErrorCode res = Interop.InputGesture.SetEdgeDragCb(_handler, null, IntPtr.Zero); + ErrorCodeThrow(res); + } + } + } + + /// + /// Emits the event when the tap event comes + /// + /// Thrown when failed of invalid argument. + public event EventHandler TapEventHandler + { + add + { + if (_tapEventHandler == null) + { + _tapDelegate = (IntPtr userData, int mode, int fingers, int repeats) => + { + TapEventArgs args = new TapEventArgs(mode, fingers, repeats); + Log.Debug(LogTag, "Tap Event received. mode: " + mode + ", fingers: " + fingers + ", repeats: " + repeats); + _tapEventHandler?.Invoke(null, args); + }; + Interop.InputGesture.ErrorCode res = Interop.InputGesture.SetTapCb(_handler, _tapDelegate, IntPtr.Zero); + ErrorCodeThrow(res); + } + + _tapEventHandler += value; + } + remove + { + _tapEventHandler -= value; + if (_tapEventHandler == null) + { + Interop.InputGesture.ErrorCode res = Interop.InputGesture.SetTapCb(_handler, null, IntPtr.Zero); + ErrorCodeThrow(res); + } + } + } + /// + /// Emits the event when the palm cover event comes + /// + /// Thrown when failed of invalid argument. + public event EventHandler PalmCoverEventHandler + { + add + { + if (_palmCoverEventHandler == null) + { + _palmCoverDelegate = (IntPtr userData, int mode, int duration, int cx, int cy, int size, double pressure) => + { + PalmCoverEventArgs args = new PalmCoverEventArgs(mode, duration, cx, cy, size, pressure); + Log.Debug(LogTag, "PalmCover Event received. mode: " + mode + ", duration: " + duration); + _palmCoverEventHandler?.Invoke(null, args); + }; + Interop.InputGesture.ErrorCode res = Interop.InputGesture.SetPalmCoverCb(_handler, _palmCoverDelegate, IntPtr.Zero); + ErrorCodeThrow(res); + } + _palmCoverEventHandler += value; + } + remove + { + _palmCoverEventHandler -= value; + if (_palmCoverEventHandler == null) + { + Interop.InputGesture.ErrorCode res = Interop.InputGesture.SetPalmCoverCb(_handler, null, IntPtr.Zero); + ErrorCodeThrow(res); + } + } + } + } +} diff --git a/src/Tizen.NUI.WindowSystem/src/public/PalmCoverEventArgs.cs b/src/Tizen.NUI.WindowSystem/src/public/PalmCoverEventArgs.cs new file mode 100644 index 00000000000..f24c051b254 --- /dev/null +++ b/src/Tizen.NUI.WindowSystem/src/public/PalmCoverEventArgs.cs @@ -0,0 +1,63 @@ +/* + * Copyright(c) 2024 Samsung Electronics Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ +using System; +using System.ComponentModel; + +namespace Tizen.NUI.WindowSystem +{ + /// + /// This class contains the data related to the PalmCover event. + /// + /// This class is need to be hidden as inhouse API. + [EditorBrowsable(EditorBrowsableState.Never)] + public class PalmCoverEventArgs : EventArgs + { + internal PalmCoverEventArgs(int mode, int duration, int cx, int cy, int size, double pressure) + { + Mode = mode; + Duration = duration; + Cx = cx; + Cy = cy; + Size = size; + Pressure = pressure; + } + /// + /// Mode + /// + public int Mode{ get; internal set; } + /// + /// Duration + /// + public int Duration{ get; internal set;} + /// + /// Cx + /// + public int Cx{ get; internal set;} + /// + /// Cy + /// + public int Cy{ get; internal set;} + /// + /// Size + /// + public double Size{ get; internal set;} + /// + /// Pressure + /// + public double Pressure{ get; internal set;} + } +} diff --git a/src/Tizen.NUI.WindowSystem/src/public/TapEventArgs.cs b/src/Tizen.NUI.WindowSystem/src/public/TapEventArgs.cs new file mode 100644 index 00000000000..4d84557ff87 --- /dev/null +++ b/src/Tizen.NUI.WindowSystem/src/public/TapEventArgs.cs @@ -0,0 +1,48 @@ +/* + * Copyright(c) 2024 Samsung Electronics Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ +using System; +using System.ComponentModel; + +namespace Tizen.NUI.WindowSystem +{ + /// + /// This class contains the data related to the Tap event. + /// + /// This class is need to be hidden as inhouse API. + [EditorBrowsable(EditorBrowsableState.Never)] + public class TapEventArgs : EventArgs + { + internal TapEventArgs(int mode, int fingers, int repeats) + { + Mode = mode; + Fingers = fingers; + Repeats = repeats; + } + /// + /// Mode + /// + public int Mode{ get; internal set; } + /// + /// Fingers + /// + public int Fingers{ get; internal set;} + /// + /// Repeats + /// + public int Repeats{ get; internal set;} + } +} diff --git a/test/Tizen.NUI.WindowSystem.InputGesture/Tizen.NUI.WindowSystem.InputGesture.cs b/test/Tizen.NUI.WindowSystem.InputGesture/Tizen.NUI.WindowSystem.InputGesture.cs new file mode 100644 index 00000000000..455bd67f873 --- /dev/null +++ b/test/Tizen.NUI.WindowSystem.InputGesture/Tizen.NUI.WindowSystem.InputGesture.cs @@ -0,0 +1,231 @@ +using System; +using Tizen; +using Tizen.NUI; +using Tizen.NUI.BaseComponents; +using Tizen.NUI.WindowSystem; +using System.Collections.Generic; + +namespace Tizen.NUI.WindowSystem +{ + class Program : NUIApplication + { + protected override void OnCreate() + { + base.OnCreate(); + Initialize(); + } + + void Initialize() + { + Window win = Window.Instance; + inputGesture = new InputGesture(); + + win.WindowSize = new Size2D(500, 500); + win.KeyEvent += OnKeyEvent; + win.BackgroundColor = Color.White; + + View windowView = new View(); + windowView.Size2D = new Size2D(500, 500); + windowView.BackgroundColor = Color.White; + windowView.TouchEvent += OnTouchEvent; + win.Add(windowView); + + centerLabel = new TextLabel("InputGesture Sample, Click to generate Return Key."); + centerLabel.HorizontalAlignment = HorizontalAlignment.Center; + centerLabel.VerticalAlignment = VerticalAlignment.Center; + centerLabel.TextColor = Color.Black; + centerLabel.PointSize = 12.0f; + centerLabel.HeightResizePolicy = ResizePolicyType.FillToParent; + centerLabel.WidthResizePolicy = ResizePolicyType.FillToParent; + windowView.Add(centerLabel); + + repeatCounter = 0; + } + + private void OnKeyEvent(object sender, Window.KeyEventArgs e) + { + if (e.Key.State == Key.StateType.Down && (e.Key.KeyPressedName == "XF86Back" || e.Key.KeyPressedName == "Escape")) + { + Exit(); + } + if (e.Key.State == Key.StateType.Down && e.Key.KeyPressedName == "Return") + { + repeatCounter++; + centerLabel.Text = "Return Key Pressed, counter: " + repeatCounter.ToString(); + } + + if (e.Key.State == Key.StateType.Down && (e.Key.KeyPressedName == "S" || e.Key.KeyPressedName == "s")) + { + if (edgeSwipeG == IntPtr.Zero) + edgeSwipeG = inputGesture.CreateEdgeSwipeData(2, GestureEdge.Left); + + if (edgeSwipeG == IntPtr.Zero) + { + centerLabel.Text = "'S' Key Pressed. edgeSwipeG NULL!!"; + return; + } + + if (!edgeSwipeGrabbed) + { + inputGesture.GrabGesture(edgeSwipeG); + centerLabel.Text = "'S' Key Pressed. edgeSwipe Grabbed"; + + inputGesture.EdgeSwipeEventHandler += _edgeSwipeEventHandler; + edgeSwipeGrabbed = true; + } + else + { + inputGesture.UngrabGesture(edgeSwipeG); + centerLabel.Text = "'S' Key Pressed. edgeSwipe Ungrabbed"; + edgeSwipeGrabbed = false; + } + } + if (e.Key.State == Key.StateType.Down && (e.Key.KeyPressedName == "D" || e.Key.KeyPressedName == "d")) + { + if (edgeDragG == IntPtr.Zero) + edgeDragG = inputGesture.CreateEdgeDragData(2, GestureEdge.Right); + + if (edgeDragG == IntPtr.Zero) + { + centerLabel.Text = "'D' Key Pressed. edgeDrag NULL!!!"; + return; + } + + if (!edgeDragGrabbed) + { + inputGesture.GrabGesture(edgeDragG); + centerLabel.Text = "'D' Key Pressed. edgeDrag Grabbed"; + + inputGesture.EdgeDragEventHandler += _edgeDragEventHandler; + edgeDragGrabbed = true; + } + else + { + inputGesture.UngrabGesture(edgeDragG); + centerLabel.Text = "'D' Key Pressed. edgeDrag Ungrabbed"; + edgeDragGrabbed = false; + } + } + if (e.Key.State == Key.StateType.Down && (e.Key.KeyPressedName == "T" || e.Key.KeyPressedName == "t")) + { + if (tapG == IntPtr.Zero) + tapG = inputGesture.CreateTapData(3, 2); + + if (tapG == IntPtr.Zero) + { + centerLabel.Text = "'T' Key Pressed. Tap NULL!!!"; + return; + } + + if (!tapGrabbed) + { + inputGesture.GrabGesture(tapG); + centerLabel.Text = "'T' Key Pressed. Tap Grabbed"; + + inputGesture.TapEventHandler += _tapEventHandler; + tapGrabbed = true; + } + else + { + inputGesture.UngrabGesture(tapG); + centerLabel.Text = "'T' Key Pressed. Tap Ungrabbed"; + tapGrabbed = false; + } + } + if (e.Key.State == Key.StateType.Down && (e.Key.KeyPressedName == "P" || e.Key.KeyPressedName == "p")) + { + if (palmG == IntPtr.Zero) + palmG = inputGesture.CreatePalmCoverData(); + + if (palmG == IntPtr.Zero) + { + centerLabel.Text = "'P' Key Pressed. PalmCover NULL!!!"; + return; + } + + if (!palmCoverGrabbed) + { + inputGesture.GrabGesture(palmG); + centerLabel.Text = "'P' Key Pressed. PalmCover Grabbed"; + + inputGesture.PalmCoverEventHandler += _palmCoverEventHandler; + palmCoverGrabbed = true; + } + else + { + inputGesture.UngrabGesture(palmG); + centerLabel.Text = "'P' Key Pressed. PalmCover Ungrabbed"; + palmCoverGrabbed = false; + } + } + } + + private bool OnTouchEvent(object sender, View.TouchEventArgs e) + { + touchCounter++; + // if (e.Touch.GetState(0) == PointStateType.Down) + // { + // centerLabel.Text = "Touch Down"; + // } + // else if (e.Touch.GetState(0) == PointStateType.Up) + // { + // centerLabel.Text = "Touch Up"; + // } + + return true; + } + + /// + /// + /// The sender object. + /// Argument of Event. + private static void _edgeSwipeEventHandler(object sender, EdgeSwipeEventArgs e) + { + Log.Debug("GestureSample", "Mode: " + (GestureMode)e.Mode + ", Fingers: " + e.Fingers + ", Sx: " + e.Sx + ", Sy: " + e.Sy + ", Edge: " + (GestureEdge)e.Edge); + } + /// + /// + /// The sender object. + /// Argument of Event. + private static void _edgeDragEventHandler(object sender, EdgeDragEventArgs e) + { + Log.Debug("GestureSample", "Mode: " + (GestureMode)e.Mode + ", Fingers: " + e.Fingers + ", Cx: " + e.Cx + ", Cy: " + e.Cy + ", Edge: " + (GestureEdge)e.Edge); + } + /// + /// + /// The sender object. + /// Argument of Event. + private static void _tapEventHandler(object sender, TapEventArgs e) + { + Log.Debug("GestureSample", "Mode: " + (GestureMode)e.Mode + ", Fingers: " + e.Fingers + ", Repeats: " + e.Fingers); + } + /// + /// + /// The sender object. + /// Argument of Event. + private static void _palmCoverEventHandler(object sender, PalmCoverEventArgs e) + { + Log.Debug("GestureSample", "Mode: " + (GestureMode)e.Mode + ", Duration: " + e.Duration + ", Cx: " + e.Cx + ", Cy: " + e.Cy + ", Size: " + e.Size + ", Pressure: " + e.Pressure); + } + + static void Main(string[] args) + { + var app = new Program(); + app.Run(args); + } + + private InputGesture inputGesture; + IntPtr edgeSwipeG; + IntPtr edgeDragG; + IntPtr tapG; + IntPtr palmG; + private TextLabel centerLabel; + int repeatCounter = 0; + int touchCounter = 0; + + bool edgeSwipeGrabbed; + bool edgeDragGrabbed; + bool tapGrabbed; + bool palmCoverGrabbed; + } +} diff --git a/test/Tizen.NUI.WindowSystem.InputGesture/Tizen.NUI.WindowSystem.InputGesture.csproj b/test/Tizen.NUI.WindowSystem.InputGesture/Tizen.NUI.WindowSystem.InputGesture.csproj new file mode 100644 index 00000000000..b0bb521cc41 --- /dev/null +++ b/test/Tizen.NUI.WindowSystem.InputGesture/Tizen.NUI.WindowSystem.InputGesture.csproj @@ -0,0 +1,27 @@ + + + + Exe + net6.0 + + + + portable + + + None + + + + + + + + + + + + True + + + diff --git a/test/Tizen.NUI.WindowSystem.InputGesture/shared/res/Tizen.NUI.WindowSystem.InputGesture.png b/test/Tizen.NUI.WindowSystem.InputGesture/shared/res/Tizen.NUI.WindowSystem.InputGesture.png new file mode 100644 index 0000000000000000000000000000000000000000..9f3cb98608134e7b9eb4beb7394fec9f03e40f63 GIT binary patch literal 10097 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 TJbOA100000NkvXXu0mjf?x(Kf literal 0 HcmV?d00001 diff --git a/test/Tizen.NUI.WindowSystem.InputGesture/tizen-manifest.xml b/test/Tizen.NUI.WindowSystem.InputGesture/tizen-manifest.xml new file mode 100644 index 00000000000..5c85e42c178 --- /dev/null +++ b/test/Tizen.NUI.WindowSystem.InputGesture/tizen-manifest.xml @@ -0,0 +1,16 @@ + + + + + + Tizen.NUI.WindowSystem.InputGesture.png + + + diff --git a/test/Tizen.NUI.WindowSystem.InputGesture/tizen_dotnet_project.yaml b/test/Tizen.NUI.WindowSystem.InputGesture/tizen_dotnet_project.yaml new file mode 100644 index 00000000000..cb53adc6fce --- /dev/null +++ b/test/Tizen.NUI.WindowSystem.InputGesture/tizen_dotnet_project.yaml @@ -0,0 +1,9 @@ +# csproj file path +csproj_file: Tizen.NUI.WindowSystem.InputGesture.csproj + +# files monitored for dirty/modified status +files: + - Tizen.NUI.WindowSystem.InputGesture.csproj + - Tizen.NUI.WindowSystem.InputGesture.cs + - tizen-manifest.xml + - shared/res/Tizen.NUI.WindowSystem.InputGesture.png \ No newline at end of file