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

   1 /*
   2  * Copyright(c) 2018 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
  25     /// <summary>
  26     /// This class emits a signals when a pan gesture occurs.<br />
  27     /// </summary>
  28     /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
  29     [EditorBrowsable(EditorBrowsableState.Never)]
  30     public class PanGestureDetector : GestureDetector
  31     {
  32         private global::System.Runtime.InteropServices.HandleRef swigCPtr;
  33
  34         internal PanGestureDetector(global::System.IntPtr cPtr, bool cMemoryOwn) : base(NDalicPINVOKE.PanGestureDetector_SWIGUpcast(cPtr), cMemoryOwn)
  35         {
  36             swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
  37         }
  38
  39         internal static global::System.Runtime.InteropServices.HandleRef getCPtr(PanGestureDetector obj)
  40         {
  41             return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
  42         }
  43
  44         /// <summary>
  45         /// Dispose.
  46         /// </summary>
  47         /// <param name="type">The dispose type</param>
  48         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
  49         [EditorBrowsable(EditorBrowsableState.Never)]
  50         protected override void Dispose(DisposeTypes type)
  51         {
  52             if (disposed)
  53             {
  54                 return;
  55             }
  56
  57             if (type == DisposeTypes.Explicit)
  58             {
  59                 //Called by User
  60                 //Release your own managed resources here.
  61                 //You should release all of your own disposable objects here.
  62
  63             }
  64
  65             //Release your own unmanaged resources here.
  66             //You should not access any managed member here except static instance.
  67             //because the execution order of Finalizes is non-deterministic.
  68
  69             if (swigCPtr.Handle != global::System.IntPtr.Zero)
  70             {
  71                 if (swigCMemOwn)
  72                 {
  73                     swigCMemOwn = false;
  74                     NDalicPINVOKE.delete_PanGestureDetector(swigCPtr);
  75                 }
  76                 swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
  77             }
  78
  79             base.Dispose(type);
  80         }
  81
  82
  83         /// <summary>
  84         /// Event arguments that are passed via the PanGestureEvent signal.
  85         /// </summary>
  86         /// <since_tizen> 5 </since_tizen>
  87         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
  88         [EditorBrowsable(EditorBrowsableState.Never)]
  89         public class DetectedEventArgs : EventArgs
  90         {
  91             private View _view;
  92             private PanGesture _panGesture;
  93
  94             /// <summary>
  95             /// The attached view.
  96             /// </summary>
  97             /// <since_tizen> 5 </since_tizen>
  98             /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
  99             [EditorBrowsable(EditorBrowsableState.Never)]
 100             public View View
 101             {
 102                 get
 103                 {
 104                     return _view;
 105                 }
 106                 set
 107                 {
 108                     _view = value;
 109                 }
 110             }
 111
 112             /// <summary>
 113             /// The PanGesture.
 114             /// </summary>
 115             /// <since_tizen> 5 </since_tizen>
 116             /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 117             [EditorBrowsable(EditorBrowsableState.Never)]
 118             public PanGesture PanGesture
 119             {
 120                 get
 121                 {
 122                     return _panGesture;
 123                 }
 124                 set
 125                 {
 126                     _panGesture = value;
 127                 }
 128             }
 129         }
 130
 131         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 132         private delegate void DetectedCallbackDelegate(IntPtr actor, IntPtr panGesture);
 133         private DaliEventHandler<object, DetectedEventArgs> _panGestureEventHandler;
 134         private DetectedCallbackDelegate _panGestureCallbackDelegate;
 135
 136         /// <summary>
 137         /// This signal is emitted when the specified pan is detected on the attached view.
 138         /// </summary>
 139         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 140         [EditorBrowsable(EditorBrowsableState.Never)]
 141         public event DaliEventHandler<object, DetectedEventArgs> Detected
 142         {
 143             add
 144             {
 145                 lock (this)
 146                 {
 147                     // Restricted to only one listener
 148                     if (_panGestureEventHandler == null)
 149                     {
 150                         _panGestureEventHandler += value;
 151
 152                         _panGestureCallbackDelegate = new DetectedCallbackDelegate(OnPanGestureDetected);
 153                         this.DetectedSignal().Connect(_panGestureCallbackDelegate);
 154                     }
 155                 }
 156             }
 157
 158             remove
 159             {
 160                 lock (this)
 161                 {
 162                     if (_panGestureEventHandler != null)
 163                     {
 164                         this.DetectedSignal().Disconnect(_panGestureCallbackDelegate);
 165                     }
 166
 167                     _panGestureEventHandler -= value;
 168                 }
 169             }
 170         }
 171
 172         private void OnPanGestureDetected(IntPtr actor, IntPtr panGesture)
 173         {
 174             DetectedEventArgs e = new DetectedEventArgs();
 175
 176             // Populate all members of "e" (PanGestureEventArgs) with real data
 177             e.View = Registry.GetManagedBaseHandleFromNativePtr(actor) as View;
 178             e.PanGesture = Tizen.NUI.PanGesture.GetPanGestureFromPtr(panGesture);
 179
 180             if (_panGestureEventHandler != null)
 181             {
 182                 //here we send all data to user event handlers
 183                 _panGestureEventHandler(this, e);
 184             }
 185
 186         }
 187
 188         internal static PanGestureDetector GetPanGestureDetectorFromPtr(global::System.IntPtr cPtr)
 189         {
 190             PanGestureDetector ret = new PanGestureDetector(cPtr, false);
 191             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 192             return ret;
 193         }
 194
 195         internal class Property : global::System.IDisposable
 196         {
 197             private global::System.Runtime.InteropServices.HandleRef swigCPtr;
 198
 199             protected bool swigCMemOwn;
 200
 201             internal Property(global::System.IntPtr cPtr, bool cMemoryOwn)
 202             {
 203                 swigCMemOwn = cMemoryOwn;
 204                 swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
 205             }
 206
 207             internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Property obj)
 208             {
 209                 return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
 210             }
 211
 212             //A Flag to check who called Dispose(). (By User or DisposeQueue)
 213             private bool isDisposeQueued = false;
 214             //A Flat to check if it is already disposed.
 215
 216             protected bool disposed = false;
 217
 218
 219             ~Property()
 220             {
 221                 if (!isDisposeQueued)
 222                 {
 223                     isDisposeQueued = true;
 224                     DisposeQueue.Instance.Add(this);
 225                 }
 226             }
 227
 228
 229             public void Dispose()
 230             {
 231                 //Throw excpetion if Dispose() is called in separate thread.
 232                 if (!Window.IsInstalled())
 233                 {
 234                     throw new System.InvalidOperationException("This API called from separate thread. This API must be called from MainThread.");
 235                 }
 236
 237                 if (isDisposeQueued)
 238                 {
 239                     Dispose(DisposeTypes.Implicit);
 240                 }
 241                 else
 242                 {
 243                     Dispose(DisposeTypes.Explicit);
 244                     System.GC.SuppressFinalize(this);
 245                 }
 246             }
 247
 248
 249             protected virtual void Dispose(DisposeTypes type)
 250             {
 251                 if (disposed)
 252                 {
 253                     return;
 254                 }
 255
 256                 if (type == DisposeTypes.Explicit)
 257                 {
 258                     //Called by User
 259                     //Release your own managed resources here.
 260                     //You should release all of your own disposable objects here.
 261
 262                 }
 263
 264                 //Release your own unmanaged resources here.
 265                 //You should not access any managed member here except static instance.
 266                 //because the execution order of Finalizes is non-deterministic.
 267
 268                 if (swigCPtr.Handle != global::System.IntPtr.Zero)
 269                 {
 270                     if (swigCMemOwn)
 271                     {
 272                         swigCMemOwn = false;
 273                         NDalicPINVOKE.delete_PanGestureDetector_Property(swigCPtr);
 274                     }
 275                     swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
 276                 }
 277
 278                 disposed = true;
 279             }
 280
 281
 282             public Property() : this(NDalicPINVOKE.new_PanGestureDetector_Property(), true)
 283             {
 284                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 285             }
 286
 287
 288             public static readonly int SCREEN_POSITION = NDalicPINVOKE.PanGestureDetector_Property_SCREEN_POSITION_get();
 289
 290             public static readonly int SCREEN_DISPLACEMENT = NDalicPINVOKE.PanGestureDetector_Property_SCREEN_DISPLACEMENT_get();
 291
 292             public static readonly int SCREEN_VELOCITY = NDalicPINVOKE.PanGestureDetector_Property_SCREEN_VELOCITY_get();
 293
 294             public static readonly int LOCAL_POSITION = NDalicPINVOKE.PanGestureDetector_Property_LOCAL_POSITION_get();
 295
 296             public static readonly int LOCAL_DISPLACEMENT = NDalicPINVOKE.PanGestureDetector_Property_LOCAL_DISPLACEMENT_get();
 297
 298             public static readonly int LOCAL_VELOCITY = NDalicPINVOKE.PanGestureDetector_Property_LOCAL_VELOCITY_get();
 299
 300             public static readonly int PANNING = NDalicPINVOKE.PanGestureDetector_Property_PANNING_get();
 301
 302         }
 303
 304         /// <summary>
 305         /// For a left pan (-PI Radians).
 306         /// </summary>
 307         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 308         [EditorBrowsable(EditorBrowsableState.Never)]
 309         public static Radian DirectionLeft
 310         {
 311             get
 312             {
 313                 global::System.IntPtr cPtr = NDalicPINVOKE.PanGestureDetector_DIRECTION_LEFT_get();
 314                 Radian ret = (cPtr == global::System.IntPtr.Zero) ? null : new Radian(cPtr, false);
 315                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 316                 return ret;
 317             }
 318         }
 319
 320         /// <summary>
 321         /// For a right pan (0 Radians).
 322         /// </summary>
 323         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 324         [EditorBrowsable(EditorBrowsableState.Never)]
 325         public static Radian DirectionRight
 326         {
 327             get
 328             {
 329                 global::System.IntPtr cPtr = NDalicPINVOKE.PanGestureDetector_DIRECTION_RIGHT_get();
 330                 Radian ret = (cPtr == global::System.IntPtr.Zero) ? null : new Radian(cPtr, false);
 331                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 332                 return ret;
 333             }
 334         }
 335
 336         /// <summary>
 337         /// For an up pan (-0.5 * PI Radians).
 338         /// </summary>
 339         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 340         [EditorBrowsable(EditorBrowsableState.Never)]
 341         public static Radian DirectionUp
 342         {
 343             get
 344             {
 345                 global::System.IntPtr cPtr = NDalicPINVOKE.PanGestureDetector_DIRECTION_UP_get();
 346                 Radian ret = (cPtr == global::System.IntPtr.Zero) ? null : new Radian(cPtr, false);
 347                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 348                 return ret;
 349             }
 350         }
 351
 352         /// <summary>
 353         /// For a down pan (0.5 * PI Radians).
 354         /// </summary>
 355         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 356         [EditorBrowsable(EditorBrowsableState.Never)]
 357         public static Radian DirectionDown
 358         {
 359             get
 360             {
 361                 global::System.IntPtr cPtr = NDalicPINVOKE.PanGestureDetector_DIRECTION_DOWN_get();
 362                 Radian ret = (cPtr == global::System.IntPtr.Zero) ? null : new Radian(cPtr, false);
 363                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 364                 return ret;
 365             }
 366         }
 367
 368         /// <summary>
 369         /// For a left and right pan (PI Radians). Useful for AddDirection().
 370         /// </summary>
 371         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 372         [EditorBrowsable(EditorBrowsableState.Never)]
 373         public static Radian DirectionHorizontal
 374         {
 375             get
 376             {
 377                 global::System.IntPtr cPtr = NDalicPINVOKE.PanGestureDetector_DIRECTION_HORIZONTAL_get();
 378                 Radian ret = (cPtr == global::System.IntPtr.Zero) ? null : new Radian(cPtr, false);
 379                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 380                 return ret;
 381             }
 382         }
 383
 384         /// <summary>
 385         /// For an up and down pan (-0.5 * PI Radians). Useful for AddDirection().
 386         /// </summary>
 387         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 388         [EditorBrowsable(EditorBrowsableState.Never)]
 389         public static Radian DirectionVertical
 390         {
 391             get
 392             {
 393                 global::System.IntPtr cPtr = NDalicPINVOKE.PanGestureDetector_DIRECTION_VERTICAL_get();
 394                 Radian ret = (cPtr == global::System.IntPtr.Zero) ? null : new Radian(cPtr, false);
 395                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 396                 return ret;
 397             }
 398         }
 399
 400         /// <summary>
 401         /// The default threshold is PI * 0.25 radians (or 45 degrees).
 402         /// </summary>
 403         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 404         [EditorBrowsable(EditorBrowsableState.Never)]
 405         public static Radian DefaultThreshold
 406         {
 407             get
 408             {
 409                 global::System.IntPtr cPtr = NDalicPINVOKE.PanGestureDetector_DEFAULT_THRESHOLD_get();
 410                 Radian ret = (cPtr == global::System.IntPtr.Zero) ? null : new Radian(cPtr, false);
 411                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 412                 return ret;
 413             }
 414         }
 415
 416         /// <summary>
 417         /// Creates an initialized PanGestureDetector.
 418         /// </summary>
 419         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 420         [EditorBrowsable(EditorBrowsableState.Never)]
 421         public PanGestureDetector() : this(NDalicPINVOKE.PanGestureDetector_New(), true)
 422         {
 423             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 424
 425         }
 426
 427         internal new static PanGestureDetector DownCast(BaseHandle handle)
 428         {
 429             PanGestureDetector ret =  Registry.GetManagedBaseHandleFromNativePtr(handle) as PanGestureDetector;
 430             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 431             return ret;
 432         }
 433
 434         /// <summary>
 435         /// The copy constructor.
 436         /// </summary>
 437         /// <param name="handle">A reference to the copied handle</param>
 438         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 439         [EditorBrowsable(EditorBrowsableState.Never)]
 440         public PanGestureDetector(PanGestureDetector handle) : this(NDalicPINVOKE.new_PanGestureDetector__SWIG_1(PanGestureDetector.getCPtr(handle)), true)
 441         {
 442             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 443         }
 444
 445         internal PanGestureDetector Assign(PanGestureDetector rhs)
 446         {
 447             PanGestureDetector ret = new PanGestureDetector(NDalicPINVOKE.PanGestureDetector_Assign(swigCPtr, PanGestureDetector.getCPtr(rhs)), false);
 448             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 449             return ret;
 450         }
 451
 452         /// <summary>
 453         /// This is the minimum number of touches required for the pan gesture to be detected.
 454         /// </summary>
 455         /// <param name="minimum">Minimum touches required</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 SetMinimumTouchesRequired(uint minimum)
 459         {
 460             NDalicPINVOKE.PanGestureDetector_SetMinimumTouchesRequired(swigCPtr, minimum);
 461             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 462         }
 463
 464         /// <summary>
 465         /// This is the maximum number of touches required for the pan gesture to be detected.
 466         /// </summary>
 467         /// <param name="maximum">Maximum touches required</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 SetMaximumTouchesRequired(uint maximum)
 471         {
 472             NDalicPINVOKE.PanGestureDetector_SetMaximumTouchesRequired(swigCPtr, maximum);
 473             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 474         }
 475
 476         /// <summary>
 477         /// Retrieves the minimum number of touches required for the pan gesture to be detected.
 478         /// </summary>
 479         /// <returns>The minimum touches required</returns>
 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 uint GetMinimumTouchesRequired()
 483         {
 484             uint ret = NDalicPINVOKE.PanGestureDetector_GetMinimumTouchesRequired(swigCPtr);
 485             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 486             return ret;
 487         }
 488
 489         /// <summary>
 490         /// Retrieves the maximum number of touches required for the pan gesture to be detected.
 491         /// </summary>
 492         /// <returns>The maximum touches required</returns>
 493         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 494         [EditorBrowsable(EditorBrowsableState.Never)]
 495         public uint GetMaximumTouchesRequired()
 496         {
 497             uint ret = NDalicPINVOKE.PanGestureDetector_GetMaximumTouchesRequired(swigCPtr);
 498             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 499             return ret;
 500         }
 501
 502         /// <summary>
 503         /// The pan gesture is only emitted if the pan occurs in the direction specified by this method with a +/- threshold allowance.<br />
 504         /// 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 />
 505         /// 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.
 506         /// The user can add as many angles as they require.
 507         /// </summary>
 508         /// <param name="angle">The angle that pan should be allowed</param>
 509         /// <param name="threshold">The threshold around that angle</param>
 510         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 511         [EditorBrowsable(EditorBrowsableState.Never)]
 512         public void AddAngle(Radian angle, Radian threshold)
 513         {
 514             NDalicPINVOKE.PanGestureDetector_AddAngle__SWIG_0(swigCPtr, Radian.getCPtr(angle), Radian.getCPtr(threshold));
 515             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 516         }
 517
 518         /// <summary>
 519         /// 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 />
 520         /// 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 />
 521         /// The user can add as many angles as they require.<br />
 522         /// </summary>
 523         /// <param name="angle">The angle that pan should be allowed</param>
 524         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 525         [EditorBrowsable(EditorBrowsableState.Never)]
 526         public void AddAngle(Radian angle)
 527         {
 528             NDalicPINVOKE.PanGestureDetector_AddAngle__SWIG_1(swigCPtr, Radian.getCPtr(angle));
 529             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 530         }
 531
 532         /// <summary>
 533         /// A helper method for adding bi-directional angles where the pan should take place.<br />
 534         /// In other words, if 0 is requested, then PI will also be added so that we have both left and right scrolling.<br />
 535         /// </summary>
 536         /// <param name="direction">The direction of panning required</param>
 537         /// <param name="threshold">The threshold</param>
 538         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 539         [EditorBrowsable(EditorBrowsableState.Never)]
 540         public void AddDirection(Radian direction, Radian threshold)
 541         {
 542             NDalicPINVOKE.PanGestureDetector_AddDirection__SWIG_0(swigCPtr, Radian.getCPtr(direction), Radian.getCPtr(threshold));
 543             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 544         }
 545
 546         /// <summary>
 547         /// A helper method for adding bi-directional angles where the pan should take place.
 548         /// In other words, if 0 is requested, then PI will also be added so that we have both left and right scrolling.<br />
 549         /// The default threshold (PI * 0.25) is used.
 550         /// </summary>
 551         /// <param name="direction">The direction of panning required</param>
 552         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 553         [EditorBrowsable(EditorBrowsableState.Never)]
 554         public void AddDirection(Radian direction)
 555         {
 556             NDalicPINVOKE.PanGestureDetector_AddDirection__SWIG_1(swigCPtr, Radian.getCPtr(direction));
 557             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 558         }
 559
 560         /// <summary>
 561         /// Returns the count of angles that this pan gesture detector emits a signal.
 562         /// </summary>
 563         /// <returns>The gesture detector has been initialized.</returns>
 564         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 565         [EditorBrowsable(EditorBrowsableState.Never)]
 566         public uint GetAngleCount()
 567         {
 568             uint ret = NDalicPINVOKE.PanGestureDetector_GetAngleCount(swigCPtr);
 569             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 570             return ret;
 571         }
 572
 573         internal AngleThresholdPair GetAngle(uint index)
 574         {
 575             AngleThresholdPair ret = new AngleThresholdPair(NDalicPINVOKE.PanGestureDetector_GetAngle(swigCPtr, index), true);
 576             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 577             return ret;
 578         }
 579
 580         /// <summary>
 581         /// Clears any directional angles that are used by the gesture detector.
 582         /// </summary>
 583         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 584         [EditorBrowsable(EditorBrowsableState.Never)]
 585         public void ClearAngles()
 586         {
 587             NDalicPINVOKE.PanGestureDetector_ClearAngles(swigCPtr);
 588             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 589         }
 590
 591         /// <summary>
 592         /// Removes the angle specified from the container. This will only remove the first instance of the angle found from the container.
 593         /// </summary>
 594         /// <param name="angle">The angle to remove</param>
 595         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 596         [EditorBrowsable(EditorBrowsableState.Never)]
 597         public void RemoveAngle(Radian angle)
 598         {
 599             NDalicPINVOKE.PanGestureDetector_RemoveAngle(swigCPtr, Radian.getCPtr(angle));
 600             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 601         }
 602
 603         /// <summary>
 604         /// Removes the two angles that make up the direction from the container.
 605         /// </summary>
 606         /// <param name="direction">The direction to remove</param>
 607         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 608         [EditorBrowsable(EditorBrowsableState.Never)]
 609         public void RemoveDirection(Radian direction)
 610         {
 611             NDalicPINVOKE.PanGestureDetector_RemoveDirection(swigCPtr, Radian.getCPtr(direction));
 612             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 613         }
 614
 615         internal PanGestureDetectedSignal DetectedSignal()
 616         {
 617             PanGestureDetectedSignal ret = new PanGestureDetectedSignal(NDalicPINVOKE.PanGestureDetector_DetectedSignal(swigCPtr), false);
 618             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 619             return ret;
 620         }
 621
 622         /// <summary>
 623         /// Allows setting of the pan properties that are returned in constraints.
 624         /// </summary>
 625         /// <param name="pan">The pan gesture to set</param>
 626         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 627         [EditorBrowsable(EditorBrowsableState.Never)]
 628         public static void SetPanGestureProperties(PanGesture pan)
 629         {
 630             NDalicPINVOKE.PanGestureDetector_SetPanGestureProperties(PanGesture.getCPtr(pan));
 631             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 632         }
 633
 634         /// <summary>
 635         /// Retrieves the screen position.
 636         /// </summary>
 637         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 638         [EditorBrowsable(EditorBrowsableState.Never)]
 639         public Vector2 ScreenPosition
 640         {
 641             get
 642             {
 643                 Vector2 temp = new Vector2(0.0f, 0.0f);
 644                 Tizen.NUI.Object.GetProperty(swigCPtr, PanGestureDetector.Property.SCREEN_POSITION).Get(temp);
 645                 return temp;
 646             }
 647         }
 648
 649         /// <summary>
 650         /// Retrieves the screen displacement.
 651         /// </summary>
 652         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 653         [EditorBrowsable(EditorBrowsableState.Never)]
 654         public Vector2 ScreenDisplacement
 655         {
 656             get
 657             {
 658                 Vector2 temp = new Vector2(0.0f, 0.0f);
 659                 Tizen.NUI.Object.GetProperty(swigCPtr, PanGestureDetector.Property.SCREEN_DISPLACEMENT).Get(temp);
 660                 return temp;
 661             }
 662         }
 663
 664         /// <summary>
 665         /// Retrieves the screen velocity.
 666         /// </summary>
 667         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 668         [EditorBrowsable(EditorBrowsableState.Never)]
 669         public Vector2 ScreenVelocity
 670         {
 671             get
 672             {
 673                 Vector2 temp = new Vector2(0.0f, 0.0f);
 674                 Tizen.NUI.Object.GetProperty(swigCPtr, PanGestureDetector.Property.SCREEN_VELOCITY).Get(temp);
 675                 return temp;
 676             }
 677         }
 678
 679         /// <summary>
 680         /// Retrieves the local position.
 681         /// </summary>
 682         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 683         [EditorBrowsable(EditorBrowsableState.Never)]
 684         public Vector2 LocalPosition
 685         {
 686             get
 687             {
 688                 Vector2 temp = new Vector2(0.0f, 0.0f);
 689                 Tizen.NUI.Object.GetProperty(swigCPtr, PanGestureDetector.Property.LOCAL_POSITION).Get(temp);
 690                 return temp;
 691             }
 692         }
 693
 694         /// <summary>
 695         /// Retrieves the local displacement
 696         /// </summary>
 697         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 698         [EditorBrowsable(EditorBrowsableState.Never)]
 699         public Vector2 LocalDisplacement
 700         {
 701             get
 702             {
 703                 Vector2 temp = new Vector2(0.0f, 0.0f);
 704                 Tizen.NUI.Object.GetProperty(swigCPtr, PanGestureDetector.Property.LOCAL_DISPLACEMENT).Get(temp);
 705                 return temp;
 706             }
 707         }
 708
 709         /// <summary>
 710         /// Retrieves the local velocity.
 711         /// </summary>
 712         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 713         [EditorBrowsable(EditorBrowsableState.Never)]
 714         public Vector2 LocalVelocity
 715         {
 716             get
 717             {
 718                 Vector2 temp = new Vector2(0.0f, 0.0f);
 719                 Tizen.NUI.Object.GetProperty(swigCPtr, PanGestureDetector.Property.LOCAL_VELOCITY).Get(temp);
 720                 return temp;
 721             }
 722         }
 723
 724         /// <summary>
 725         /// Retrieves the panning flag.
 726         /// </summary>
 727         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 728         [EditorBrowsable(EditorBrowsableState.Never)]
 729         public bool Panning
 730         {
 731             get
 732             {
 733                 bool temp = false;
 734                 Tizen.NUI.Object.GetProperty(swigCPtr, PanGestureDetector.Property.PANNING).Get(out temp);
 735                 return temp;
 736             }
 737         }
 738     }
 739
 740 }