src/Tizen.NUI/src/public/Events/PanGestureDetector.cs

   1 /*
   2  * Copyright(c) 2021 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17 using System;
  18 using System.Runtime.InteropServices;
  19 using Tizen.NUI.BaseComponents;
  20 using System.ComponentModel;
  21
  22 namespace Tizen.NUI
  23 {
  24     /// <summary>
  25     /// This class emits a signals when a pan gesture occurs.<br />
  26     /// </summary>
  27     /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
  28     [EditorBrowsable(EditorBrowsableState.Never)]
  29     public class PanGestureDetector : GestureDetector
  30     {
  31         /// <summary>
  32         /// Creates an initialized PanGestureDetector.
  33         /// </summary>
  34         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
  35         [EditorBrowsable(EditorBrowsableState.Never)]
  36         public PanGestureDetector() : this(Interop.PanGestureDetector.New(), true)
  37         {
  38             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
  39
  40         }
  41
  42         /// <summary>
  43         /// The copy constructor.
  44         /// </summary>
  45         /// <param name="handle">A reference to the copied handle</param>
  46         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
  47         [EditorBrowsable(EditorBrowsableState.Never)]
  48         public PanGestureDetector(PanGestureDetector handle) : this(Interop.PanGestureDetector.NewPanGestureDetector(PanGestureDetector.getCPtr(handle)), true)
  49         {
  50             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
  51         }
  52
  53         internal PanGestureDetector(global::System.IntPtr cPtr, bool cMemoryOwn) : base(cPtr, cMemoryOwn)
  54         {
  55         }
  56
  57         private DaliEventHandler<object, DetectedEventArgs> detectedEventHandler;
  58         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
  59         private delegate void DetectedCallbackType(IntPtr actor, IntPtr panGesture);
  60         private DetectedCallbackType detectedCallback;
  61
  62         /// <summary>
  63         /// This signal is emitted when the specified pan is detected on the attached view.
  64         /// </summary>
  65         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
  66         [EditorBrowsable(EditorBrowsableState.Never)]
  67         public event DaliEventHandler<object, DetectedEventArgs> Detected
  68         {
  69             add
  70             {
  71                 if (detectedEventHandler == null)
  72                 {
  73                     detectedCallback = OnPanGestureDetected;
  74                     DetectedSignal().Connect(detectedCallback);
  75                 }
  76
  77                 detectedEventHandler += value;
  78             }
  79
  80             remove
  81             {
  82                 detectedEventHandler -= value;
  83
  84                 if (detectedEventHandler == null && DetectedSignal().Empty() == false)
  85                 {
  86                     DetectedSignal().Disconnect(detectedCallback);
  87                 }
  88             }
  89         }
  90
  91         /// <summary>
  92         /// For a left pan (-PI Radians).
  93         /// </summary>
  94         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
  95         [EditorBrowsable(EditorBrowsableState.Never)]
  96         public static Radian DirectionLeft
  97         {
  98             get
  99             {
 100                 global::System.IntPtr cPtr = Interop.PanGestureDetector.DirectionLeftGet();
 101                 Radian ret = (cPtr == global::System.IntPtr.Zero) ? null : new Radian(cPtr, false);
 102                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw new InvalidOperationException("FATAL: get Exception", NDalicPINVOKE.SWIGPendingException.Retrieve());
 103                 return ret;
 104             }
 105         }
 106
 107         /// <summary>
 108         /// For a right pan (0 Radians).
 109         /// </summary>
 110         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 111         [EditorBrowsable(EditorBrowsableState.Never)]
 112         public static Radian DirectionRight
 113         {
 114             get
 115             {
 116                 global::System.IntPtr cPtr = Interop.PanGestureDetector.DirectionRightGet();
 117                 Radian ret = (cPtr == global::System.IntPtr.Zero) ? null : new Radian(cPtr, false);
 118                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw new InvalidOperationException("FATAL: get Exception", NDalicPINVOKE.SWIGPendingException.Retrieve());
 119                 return ret;
 120             }
 121         }
 122
 123         /// <summary>
 124         /// For an up pan (-0.5 * PI Radians).
 125         /// </summary>
 126         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 127         [EditorBrowsable(EditorBrowsableState.Never)]
 128         public static Radian DirectionUp
 129         {
 130             get
 131             {
 132                 global::System.IntPtr cPtr = Interop.PanGestureDetector.DirectionUpGet();
 133                 Radian ret = (cPtr == global::System.IntPtr.Zero) ? null : new Radian(cPtr, false);
 134                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw new InvalidOperationException("FATAL: get Exception", NDalicPINVOKE.SWIGPendingException.Retrieve());
 135                 return ret;
 136             }
 137         }
 138
 139         /// <summary>
 140         /// For a down pan (0.5 * PI Radians).
 141         /// </summary>
 142         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 143         [EditorBrowsable(EditorBrowsableState.Never)]
 144         public static Radian DirectionDown
 145         {
 146             get
 147             {
 148                 global::System.IntPtr cPtr = Interop.PanGestureDetector.DirectionDownGet();
 149                 Radian ret = (cPtr == global::System.IntPtr.Zero) ? null : new Radian(cPtr, false);
 150                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw new InvalidOperationException("FATAL: get Exception", NDalicPINVOKE.SWIGPendingException.Retrieve());
 151                 return ret;
 152             }
 153         }
 154
 155         /// <summary>
 156         /// For a left and right pan (PI Radians). Useful for AddDirection().
 157         /// </summary>
 158         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 159         [EditorBrowsable(EditorBrowsableState.Never)]
 160         public static Radian DirectionHorizontal
 161         {
 162             get
 163             {
 164                 global::System.IntPtr cPtr = Interop.PanGestureDetector.DirectionHorizontalGet();
 165                 Radian ret = (cPtr == global::System.IntPtr.Zero) ? null : new Radian(cPtr, false);
 166                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw new InvalidOperationException("FATAL: get Exception", NDalicPINVOKE.SWIGPendingException.Retrieve());
 167                 return ret;
 168             }
 169         }
 170
 171         /// <summary>
 172         /// For an up and down pan (-0.5 * PI Radians). Useful for AddDirection().
 173         /// </summary>
 174         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 175         [EditorBrowsable(EditorBrowsableState.Never)]
 176         public static Radian DirectionVertical
 177         {
 178             get
 179             {
 180                 global::System.IntPtr cPtr = Interop.PanGestureDetector.DirectionVerticalGet();
 181                 Radian ret = (cPtr == global::System.IntPtr.Zero) ? null : new Radian(cPtr, false);
 182                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw new InvalidOperationException("FATAL: get Exception", NDalicPINVOKE.SWIGPendingException.Retrieve());
 183                 return ret;
 184             }
 185         }
 186
 187         /// <summary>
 188         /// The default threshold is PI * 0.25 radians (or 45 degrees).
 189         /// </summary>
 190         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 191         [EditorBrowsable(EditorBrowsableState.Never)]
 192         public static Radian DefaultThreshold
 193         {
 194             get
 195             {
 196                 global::System.IntPtr cPtr = Interop.PanGestureDetector.DefaultThresholdGet();
 197                 Radian ret = (cPtr == global::System.IntPtr.Zero) ? null : new Radian(cPtr, false);
 198                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw new InvalidOperationException("FATAL: get Exception", NDalicPINVOKE.SWIGPendingException.Retrieve());
 199                 return ret;
 200             }
 201         }
 202
 203         /// <summary>
 204         /// Retrieves the screen position.
 205         /// </summary>
 206         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 207         [EditorBrowsable(EditorBrowsableState.Never)]
 208         public Vector2 ScreenPosition
 209         {
 210             get
 211             {
 212                 Vector2 temp = new Vector2(0.0f, 0.0f);
 213                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw new InvalidOperationException("FATAL: get Exception", NDalicPINVOKE.SWIGPendingException.Retrieve());
 214                 return temp;
 215             }
 216         }
 217
 218         /// <summary>
 219         /// Retrieves the screen displacement.
 220         /// </summary>
 221         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 222         [EditorBrowsable(EditorBrowsableState.Never)]
 223         public Vector2 ScreenDisplacement
 224         {
 225             get
 226             {
 227                 Vector2 temp = new Vector2(0.0f, 0.0f);
 228                 var pValue = Tizen.NUI.Object.GetProperty(SwigCPtr, PanGestureDetector.Property.ScreenDisplacement);
 229                 pValue.Get(temp);
 230                 pValue.Dispose();
 231                 return temp;
 232             }
 233         }
 234
 235         /// <summary>
 236         /// Retrieves the screen velocity.
 237         /// </summary>
 238         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 239         [EditorBrowsable(EditorBrowsableState.Never)]
 240         public Vector2 ScreenVelocity
 241         {
 242             get
 243             {
 244                 Vector2 temp = new Vector2(0.0f, 0.0f);
 245                 var pValue = Tizen.NUI.Object.GetProperty(SwigCPtr, PanGestureDetector.Property.ScreenVelocity);
 246                 pValue.Get(temp);
 247                 pValue.Dispose();
 248                 return temp;
 249             }
 250         }
 251
 252         /// <summary>
 253         /// Retrieves the local position.
 254         /// </summary>
 255         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 256         [EditorBrowsable(EditorBrowsableState.Never)]
 257         public Vector2 LocalPosition
 258         {
 259             get
 260             {
 261                 Vector2 temp = new Vector2(0.0f, 0.0f);
 262                 var pValue = Tizen.NUI.Object.GetProperty(SwigCPtr, PanGestureDetector.Property.LocalPosition);
 263                 pValue.Get(temp);
 264                 pValue.Dispose();
 265                 return temp;
 266             }
 267         }
 268
 269         /// <summary>
 270         /// Retrieves the local displacement
 271         /// </summary>
 272         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 273         [EditorBrowsable(EditorBrowsableState.Never)]
 274         public Vector2 LocalDisplacement
 275         {
 276             get
 277             {
 278                 Vector2 temp = new Vector2(0.0f, 0.0f);
 279                 var pValue = Tizen.NUI.Object.GetProperty(SwigCPtr, PanGestureDetector.Property.LocalDisplacement);
 280                 pValue.Get(temp);
 281                 pValue.Dispose();
 282                 return temp;
 283             }
 284         }
 285
 286         /// <summary>
 287         /// Retrieves the local velocity.
 288         /// </summary>
 289         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 290         [EditorBrowsable(EditorBrowsableState.Never)]
 291         public Vector2 LocalVelocity
 292         {
 293             get
 294             {
 295                 Vector2 temp = new Vector2(0.0f, 0.0f);
 296                 var pValue = Tizen.NUI.Object.GetProperty(SwigCPtr, PanGestureDetector.Property.LocalVelocity);
 297                 pValue.Get(temp);
 298                 pValue.Dispose();
 299                 return temp;
 300             }
 301         }
 302
 303         /// <summary>
 304         /// Retrieves the panning flag.
 305         /// </summary>
 306         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 307         [EditorBrowsable(EditorBrowsableState.Never)]
 308         public bool Panning
 309         {
 310             get
 311             {
 312                 bool temp = false;
 313                 var pValue = Tizen.NUI.Object.GetProperty(SwigCPtr, PanGestureDetector.Property.PANNING);
 314                 pValue.Get(out temp);
 315                 pValue.Dispose();
 316                 return temp;
 317             }
 318         }
 319
 320         /// <summary>
 321         /// This is the minimum number of touches required for the pan gesture to be detected.
 322         /// </summary>
 323         /// <param name="minimum">Minimum touches required</param>
 324         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 325         [EditorBrowsable(EditorBrowsableState.Never)]
 326         public void SetMinimumTouchesRequired(uint minimum)
 327         {
 328             Interop.PanGestureDetector.SetMinimumTouchesRequired(SwigCPtr, minimum);
 329             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 330         }
 331
 332         /// <summary>
 333         /// This is the maximum number of touches required for the pan gesture to be detected.
 334         /// </summary>
 335         /// <param name="maximum">Maximum touches required</param>
 336         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 337         [EditorBrowsable(EditorBrowsableState.Never)]
 338         public void SetMaximumTouchesRequired(uint maximum)
 339         {
 340             Interop.PanGestureDetector.SetMaximumTouchesRequired(SwigCPtr, maximum);
 341             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 342         }
 343
 344         /// <summary>
 345         /// Retrieves the minimum number of touches required for the pan gesture to be detected.
 346         /// </summary>
 347         /// <returns>The minimum touches required</returns>
 348         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 349         [EditorBrowsable(EditorBrowsableState.Never)]
 350         public uint GetMinimumTouchesRequired()
 351         {
 352             uint ret = Interop.PanGestureDetector.GetMinimumTouchesRequired(SwigCPtr);
 353             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 354             return ret;
 355         }
 356
 357         /// <summary>
 358         /// Retrieves the maximum number of touches required for the pan gesture to be detected.
 359         /// </summary>
 360         /// <returns>The maximum touches required</returns>
 361         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 362         [EditorBrowsable(EditorBrowsableState.Never)]
 363         public uint GetMaximumTouchesRequired()
 364         {
 365             uint ret = Interop.PanGestureDetector.GetMaximumTouchesRequired(SwigCPtr);
 366             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 367             return ret;
 368         }
 369
 370         /// <summary>
 371         /// The pan gesture is only emitted if the pan occurs in the direction specified by this method with a +/- threshold allowance.<br />
 372         /// If an angle of 0.0 degrees is specified and the threshold is 45 degrees then the acceptable direction range is from -45 to 45 degrees.<br />
 373         /// The angle added using this API is only checked when the gesture first starts, after that, this detector will emit the gesture regardless of what angle the pan is moving.
 374         /// The user can add as many angles as they require.
 375         /// </summary>
 376         /// <param name="angle">The angle that pan should be allowed</param>
 377         /// <param name="threshold">The threshold around that angle</param>
 378         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 379         [EditorBrowsable(EditorBrowsableState.Never)]
 380         public void AddAngle(Radian angle, Radian threshold)
 381         {
 382             Interop.PanGestureDetector.AddAngle(SwigCPtr, Radian.getCPtr(angle), Radian.getCPtr(threshold));
 383             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 384         }
 385
 386         /// <summary>
 387         /// The pan gesture is only emitted if the pan occurs in the direction specified by this method with a +/- threshold allowance. The default threshold (PI * 0.25) is used.<br />
 388         /// The angle added using this API is only checked when the gesture first starts, after that, this detector will emit the gesture regardless of what angle the pan is moving.<br />
 389         /// The user can add as many angles as they require.<br />
 390         /// </summary>
 391         /// <param name="angle">The angle that pan should be allowed</param>
 392         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 393         [EditorBrowsable(EditorBrowsableState.Never)]
 394         public void AddAngle(Radian angle)
 395         {
 396             Interop.PanGestureDetector.AddAngle(SwigCPtr, Radian.getCPtr(angle));
 397             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 398         }
 399
 400         /// <summary>
 401         /// A helper method for adding bi-directional angles where the pan should take place.<br />
 402         /// In other words, if 0 is requested, then PI will also be added so that we have both left and right scrolling.<br />
 403         /// </summary>
 404         /// <param name="direction">The direction of panning required</param>
 405         /// <param name="threshold">The threshold</param>
 406         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 407         [EditorBrowsable(EditorBrowsableState.Never)]
 408         public void AddDirection(Radian direction, Radian threshold)
 409         {
 410             Interop.PanGestureDetector.AddDirection(SwigCPtr, Radian.getCPtr(direction), Radian.getCPtr(threshold));
 411             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 412         }
 413
 414         /// <summary>
 415         /// A helper method for adding bi-directional angles where the pan should take place.
 416         /// In other words, if 0 is requested, then PI will also be added so that we have both left and right scrolling.<br />
 417         /// The default threshold (PI * 0.25) is used.
 418         /// </summary>
 419         /// <param name="direction">The direction of panning required</param>
 420         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 421         [EditorBrowsable(EditorBrowsableState.Never)]
 422         public void AddDirection(Radian direction)
 423         {
 424             Interop.PanGestureDetector.AddDirection(SwigCPtr, Radian.getCPtr(direction));
 425             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 426         }
 427
 428         /// <summary>
 429         /// Returns the count of angles that this pan gesture detector emits a signal.
 430         /// </summary>
 431         /// <returns>The gesture detector has been initialized.</returns>
 432         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 433         [EditorBrowsable(EditorBrowsableState.Never)]
 434         public uint GetAngleCount()
 435         {
 436             uint ret = Interop.PanGestureDetector.GetAngleCount(SwigCPtr);
 437             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 438             return ret;
 439         }
 440
 441         /// <summary>
 442         /// Clears any directional angles that are used by the gesture detector.
 443         /// </summary>
 444         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 445         [EditorBrowsable(EditorBrowsableState.Never)]
 446         public void ClearAngles()
 447         {
 448             Interop.PanGestureDetector.ClearAngles(SwigCPtr);
 449             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 450         }
 451
 452         /// <summary>
 453         /// Removes the angle specified from the container. This will only remove the first instance of the angle found from the container.
 454         /// </summary>
 455         /// <param name="angle">The angle to remove</param>
 456         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 457         [EditorBrowsable(EditorBrowsableState.Never)]
 458         public void RemoveAngle(Radian angle)
 459         {
 460             Interop.PanGestureDetector.RemoveAngle(SwigCPtr, Radian.getCPtr(angle));
 461             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 462         }
 463
 464         /// <summary>
 465         /// Removes the two angles that make up the direction from the container.
 466         /// </summary>
 467         /// <param name="direction">The direction to remove</param>
 468         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 469         [EditorBrowsable(EditorBrowsableState.Never)]
 470         public void RemoveDirection(Radian direction)
 471         {
 472             Interop.PanGestureDetector.RemoveDirection(SwigCPtr, Radian.getCPtr(direction));
 473             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 474         }
 475
 476         /// <summary>
 477         /// Allows setting of the pan properties that are returned in constraints.
 478         /// </summary>
 479         /// <param name="pan">The pan gesture to set</param>
 480         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 481         [EditorBrowsable(EditorBrowsableState.Never)]
 482         public static void SetPanGestureProperties(PanGesture pan)
 483         {
 484             Interop.PanGestureDetector.SetPanGestureProperties(PanGesture.getCPtr(pan));
 485             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 486         }
 487
 488         internal static PanGestureDetector GetPanGestureDetectorFromPtr(global::System.IntPtr cPtr)
 489         {
 490             PanGestureDetector ret = new PanGestureDetector(cPtr, false);
 491             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 492             return ret;
 493         }
 494
 495         internal new static PanGestureDetector DownCast(BaseHandle handle)
 496         {
 497             PanGestureDetector ret = Registry.GetManagedBaseHandleFromNativePtr(handle) as PanGestureDetector;
 498             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 499             return ret;
 500         }
 501
 502         internal AngleThresholdPair GetAngle(uint index)
 503         {
 504             AngleThresholdPair ret = new AngleThresholdPair(Interop.PanGestureDetector.GetAngle(SwigCPtr, index), true);
 505             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 506             return ret;
 507         }
 508
 509         internal PanGestureDetector Assign(PanGestureDetector rhs)
 510         {
 511             PanGestureDetector ret = new PanGestureDetector(Interop.PanGestureDetector.Assign(SwigCPtr, PanGestureDetector.getCPtr(rhs)), false);
 512             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 513             return ret;
 514         }
 515
 516         internal PanGestureDetectedSignal DetectedSignal()
 517         {
 518             PanGestureDetectedSignal ret = new PanGestureDetectedSignal(Interop.PanGestureDetector.DetectedSignal(SwigCPtr), false);
 519             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 520             return ret;
 521         }
 522
 523         /// This will not be public opened.
 524         [EditorBrowsable(EditorBrowsableState.Never)]
 525         protected override void ReleaseSwigCPtr(System.Runtime.InteropServices.HandleRef swigCPtr)
 526         {
 527             if (detectedCallback != null)
 528             {
 529                 DetectedSignal().Disconnect(detectedCallback);
 530             }
 531
 532             Interop.PanGestureDetector.DeletePanGestureDetector(swigCPtr);
 533         }
 534
 535         private void OnPanGestureDetected(IntPtr actor, IntPtr panGesture)
 536         {
 537             if (detectedEventHandler != null)
 538             {
 539                 DetectedEventArgs e = new DetectedEventArgs();
 540
 541                 // Populate all members of "e" (PanGestureEventArgs) with real data
 542                 e.View = Registry.GetManagedBaseHandleFromNativePtr(actor) as View;
 543                 if (null == e.View)
 544                 {
 545                     e.View = Registry.GetManagedBaseHandleFromRefObject(actor) as View;
 546                 }
 547
 548                 e.PanGesture = Tizen.NUI.PanGesture.GetPanGestureFromPtr(panGesture);
 549                 detectedEventHandler(this, e);
 550             }
 551         }
 552
 553         /// <summary>
 554         /// Event arguments that are passed via the PanGestureEvent signal.
 555         /// </summary>
 556         /// <since_tizen> 5 </since_tizen>
 557         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 558         [EditorBrowsable(EditorBrowsableState.Never)]
 559         public class DetectedEventArgs : EventArgs
 560         {
 561             private View view;
 562             private PanGesture panGesture;
 563             private bool handled = true;
 564
 565             /// <summary>
 566             /// The attached view.
 567             /// </summary>
 568             /// <since_tizen> 5 </since_tizen>
 569             /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 570             [EditorBrowsable(EditorBrowsableState.Never)]
 571             public View View
 572             {
 573                 get
 574                 {
 575                     return view;
 576                 }
 577                 set
 578                 {
 579                     view = value;
 580                 }
 581             }
 582
 583             /// <summary>
 584             /// The PanGesture.
 585             /// </summary>
 586             /// <since_tizen> 5 </since_tizen>
 587             /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 588             [EditorBrowsable(EditorBrowsableState.Never)]
 589             public PanGesture PanGesture
 590             {
 591                 get
 592                 {
 593                     return panGesture;
 594                 }
 595                 set
 596                 {
 597                     panGesture = value;
 598                 }
 599             }
 600
 601             /// <summary>
 602             /// Gets or sets a value that indicates whether the event handler has completely handled the event or whether the system should continue its own processing.
 603             /// </summary>
 604             [EditorBrowsable(EditorBrowsableState.Never)]
 605             public bool Handled
 606             {
 607                 get => handled;
 608                 set
 609                 {
 610                     handled = value;
 611                     Interop.Actor.SetNeedGesturePropagation(View.getCPtr(view), !value);
 612                     if (NDalicPINVOKE.SWIGPendingException.Pending)
 613                         throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 614                 }
 615             }
 616         }
 617
 618         internal class Property
 619         {
 620             internal static readonly int ScreenPosition = Interop.PanGestureDetector.ScreenPositionGet();
 621             internal static readonly int ScreenDisplacement = Interop.PanGestureDetector.ScreenDisplacementGet();
 622             internal static readonly int ScreenVelocity = Interop.PanGestureDetector.ScreenVelocityGet();
 623             internal static readonly int LocalPosition = Interop.PanGestureDetector.LocalPositionGet();
 624             internal static readonly int LocalDisplacement = Interop.PanGestureDetector.LocalDisplacementGet();
 625             internal static readonly int LocalVelocity = Interop.PanGestureDetector.LocalVelocityGet();
 626             internal static readonly int PANNING = Interop.PanGestureDetector.PanningGet();
 627         }
 628     }
 629 }