src/Tizen.NUI/src/public/UIComponents/ScrollView.cs

   1 /*
   2  * Copyright(c) 2017 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
  18 namespace Tizen.NUI
  19 {
  20
  21     using System;
  22     using System.Runtime.InteropServices;
  23     using Tizen.NUI.BaseComponents;
  24
  25     /// <summary>
  26     /// ScrollView contains views that can be scrolled manually (via touch).
  27     /// </summary>
  28     /// <since_tizen> 3 </since_tizen>
  29     public class ScrollView : Scrollable
  30     {
  31         private global::System.Runtime.InteropServices.HandleRef swigCPtr;
  32
  33         internal ScrollView(global::System.IntPtr cPtr, bool cMemoryOwn) : base(NDalicPINVOKE.ScrollView_SWIGUpcast(cPtr), cMemoryOwn)
  34         {
  35             swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
  36         }
  37
  38         internal static global::System.Runtime.InteropServices.HandleRef getCPtr(ScrollView obj)
  39         {
  40             return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
  41         }
  42
  43         /// <summary>
  44         /// Dispose
  45         /// </summary>
  46         /// <param name="type">the dispose type</param>
  47         /// <since_tizen> 3 </since_tizen>
  48         protected override void Dispose(DisposeTypes type)
  49         {
  50             if (disposed)
  51             {
  52                 return;
  53             }
  54
  55             if (type == DisposeTypes.Explicit)
  56             {
  57                 //Called by User
  58                 //Release your own managed resources here.
  59                 //You should release all of your own disposable objects here.
  60
  61             }
  62
  63             //Release your own unmanaged resources here.
  64             //You should not access any managed member here except static instance.
  65             //because the execution order of Finalizes is non-deterministic.
  66
  67             if (_scrollViewSnapStartedCallbackDelegate != null)
  68             {
  69                 this.SnapStartedSignal().Disconnect(_scrollViewSnapStartedCallbackDelegate);
  70             }
  71
  72             if (swigCPtr.Handle != global::System.IntPtr.Zero)
  73             {
  74                 if (swigCMemOwn)
  75                 {
  76                     swigCMemOwn = false;
  77                     NDalicPINVOKE.delete_ScrollView(swigCPtr);
  78                 }
  79                 swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
  80             }
  81
  82             base.Dispose(type);
  83         }
  84
  85         /// <summary>
  86         /// Event arguments that passed via the SnapStarted signal.
  87         /// </summary>
  88         /// <since_tizen> 3 </since_tizen>
  89         public class SnapStartedEventArgs : EventArgs
  90         {
  91             private Tizen.NUI.ScrollView.SnapEvent _snapEvent;
  92
  93             /// <summary>
  94             /// SnapEventInfo is the SnapEvent information like snap or flick (it tells the target position, scale, rotation for the snap or flick).
  95             /// </summary>
  96             /// <since_tizen> 3 </since_tizen>
  97             public Tizen.NUI.ScrollView.SnapEvent SnapEventInfo
  98             {
  99                 get
 100                 {
 101                     return _snapEvent;
 102                 }
 103                 set
 104                 {
 105                     _snapEvent = value;
 106                 }
 107             }
 108         }
 109
 110         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 111         private delegate void SnapStartedCallbackDelegate(IntPtr data);
 112         private DaliEventHandler<object, SnapStartedEventArgs> _scrollViewSnapStartedEventHandler;
 113         private SnapStartedCallbackDelegate _scrollViewSnapStartedCallbackDelegate;
 114
 115         /// <summary>
 116         /// SnapStarted can be used to subscribe or unsubscribe the event handler
 117         /// The SnapStarted signal is emitted when the ScrollView has started to snap or flick (it tells the target
 118         ///  position, scale, rotation for the snap or flick).
 119         /// </summary>
 120         /// <since_tizen> 3 </since_tizen>
 121         public event DaliEventHandler<object, SnapStartedEventArgs> SnapStarted
 122         {
 123             add
 124             {
 125                 lock (this)
 126                 {
 127                     // Restricted to only one listener
 128                     if (_scrollViewSnapStartedEventHandler == null)
 129                     {
 130                         _scrollViewSnapStartedEventHandler += value;
 131
 132                         _scrollViewSnapStartedCallbackDelegate = new SnapStartedCallbackDelegate(OnSnapStarted);
 133                         this.SnapStartedSignal().Connect(_scrollViewSnapStartedCallbackDelegate);
 134                     }
 135                 }
 136             }
 137
 138             remove
 139             {
 140                 lock (this)
 141                 {
 142                     if (_scrollViewSnapStartedEventHandler != null)
 143                     {
 144                         this.SnapStartedSignal().Disconnect(_scrollViewSnapStartedCallbackDelegate);
 145                     }
 146
 147                     _scrollViewSnapStartedEventHandler -= value;
 148                 }
 149             }
 150         }
 151
 152         // Callback for ScrollView SnapStarted signal
 153         private void OnSnapStarted(IntPtr data)
 154         {
 155             SnapStartedEventArgs e = new SnapStartedEventArgs();
 156
 157             // Populate all members of "e" (SnapStartedEventArgs) with real data
 158             e.SnapEventInfo = SnapEvent.GetSnapEventFromPtr(data);
 159
 160             if (_scrollViewSnapStartedEventHandler != null)
 161             {
 162                 //here we send all data to user event handlers
 163                 _scrollViewSnapStartedEventHandler(this, e);
 164             }
 165         }
 166
 167         /// <summary>
 168         /// Snaps signal event's data.
 169         /// </summary>
 170         /// <since_tizen> 3 </since_tizen>
 171         public class SnapEvent : global::System.IDisposable
 172         {
 173             private global::System.Runtime.InteropServices.HandleRef swigCPtr;
 174             /// <summary>
 175             /// swigCMemOwn
 176             /// </summary>
 177             /// <since_tizen> 3 </since_tizen>
 178             protected bool swigCMemOwn;
 179
 180             internal SnapEvent(global::System.IntPtr cPtr, bool cMemoryOwn)
 181             {
 182                 swigCMemOwn = cMemoryOwn;
 183                 swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
 184             }
 185
 186             internal static global::System.Runtime.InteropServices.HandleRef getCPtr(SnapEvent obj)
 187             {
 188                 return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
 189             }
 190
 191             //A Flag to check who called Dispose(). (By User or DisposeQueue)
 192             private bool isDisposeQueued = false;
 193             /// <summary>
 194             /// A Flat to check if it is already disposed.
 195             /// </summary>
 196             /// swigCMemOwn
 197             /// <since_tizen> 3 </since_tizen>
 198             protected bool disposed = false;
 199
 200             /// <summary>
 201             /// Dispose
 202             /// </summary>
 203             /// <since_tizen> 3 </since_tizen>
 204             ~SnapEvent()
 205             {
 206                 if (!isDisposeQueued)
 207                 {
 208                     isDisposeQueued = true;
 209                     DisposeQueue.Instance.Add(this);
 210                 }
 211             }
 212
 213             /// <summary>
 214             /// Dispose.
 215             /// </summary>
 216             /// <since_tizen> 3 </since_tizen>
 217             public void Dispose()
 218             {
 219                 //Throw excpetion if Dispose() is called in separate thread.
 220                 if (!Window.IsInstalled())
 221                 {
 222                     throw new System.InvalidOperationException("This API called from separate thread. This API must be called from MainThread.");
 223                 }
 224
 225                 if (isDisposeQueued)
 226                 {
 227                     Dispose(DisposeTypes.Implicit);
 228                 }
 229                 else
 230                 {
 231                     Dispose(DisposeTypes.Explicit);
 232                     System.GC.SuppressFinalize(this);
 233                 }
 234             }
 235
 236             /// <summary>
 237             /// Dispose
 238             /// </summary>
 239             /// <param name="type">the dispose type</param>
 240             /// <since_tizen> 3 </since_tizen>
 241             protected virtual void Dispose(DisposeTypes type)
 242             {
 243                 if (disposed)
 244                 {
 245                     return;
 246                 }
 247
 248                 if (type == DisposeTypes.Explicit)
 249                 {
 250                     //Called by User
 251                     //Release your own managed resources here.
 252                     //You should release all of your own disposable objects here.
 253
 254                 }
 255
 256                 //Release your own unmanaged resources here.
 257                 //You should not access any managed member here except static instance.
 258                 //because the execution order of Finalizes is non-deterministic.
 259
 260                 if (swigCPtr.Handle != global::System.IntPtr.Zero)
 261                 {
 262                     if (swigCMemOwn)
 263                     {
 264                         swigCMemOwn = false;
 265                         NDalicPINVOKE.delete_ScrollView_SnapEvent(swigCPtr);
 266                     }
 267                     swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
 268                 }
 269
 270                 disposed = true;
 271             }
 272
 273             /// <summary>
 274             /// Get SnapEvent From Ptr
 275             /// </summary>
 276             /// <since_tizen> 3 </since_tizen>
 277             public static SnapEvent GetSnapEventFromPtr(global::System.IntPtr cPtr)
 278             {
 279                 SnapEvent ret = new SnapEvent(cPtr, false);
 280                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 281                 return ret;
 282             }
 283
 284             internal SnapType type
 285             {
 286                 set
 287                 {
 288                     NDalicPINVOKE.ScrollView_SnapEvent_type_set(swigCPtr, (int)value);
 289                     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 290                 }
 291                 get
 292                 {
 293                     SnapType ret = (SnapType)NDalicPINVOKE.ScrollView_SnapEvent_type_get(swigCPtr);
 294                     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 295                     return ret;
 296                 }
 297             }
 298
 299             /// <summary>
 300             /// Scroll position.
 301             /// </summary>
 302             /// <since_tizen> 3 </since_tizen>
 303             public Vector2 position
 304             {
 305                 set
 306                 {
 307                     NDalicPINVOKE.ScrollView_SnapEvent_position_set(swigCPtr, Vector2.getCPtr(value));
 308                     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 309                 }
 310                 get
 311                 {
 312                     global::System.IntPtr cPtr = NDalicPINVOKE.ScrollView_SnapEvent_position_get(swigCPtr);
 313                     Vector2 ret = (cPtr == global::System.IntPtr.Zero) ? null : new Vector2(cPtr, false);
 314                     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 315                     return ret;
 316                 }
 317             }
 318
 319             /// <summary>
 320             /// Scroll duration.
 321             /// </summary>
 322             /// <since_tizen> 3 </since_tizen>
 323             public float duration
 324             {
 325                 set
 326                 {
 327                     NDalicPINVOKE.ScrollView_SnapEvent_duration_set(swigCPtr, value);
 328                     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 329                 }
 330                 get
 331                 {
 332                     float ret = NDalicPINVOKE.ScrollView_SnapEvent_duration_get(swigCPtr);
 333                     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 334                     return ret;
 335                 }
 336             }
 337
 338             /// <summary>
 339             /// Create an instance of SnapEvent.
 340             /// </summary>
 341             /// <since_tizen> 3 </since_tizen>
 342             public SnapEvent() : this(NDalicPINVOKE.new_ScrollView_SnapEvent(), true)
 343             {
 344                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 345             }
 346
 347         }
 348
 349         /// <summary>
 350         /// This should be internal, please do not use.
 351         /// </summary>
 352         /// <since_tizen> 3 </since_tizen>
 353         public new class Property
 354         {
 355             /// <summary>
 356             /// This should be internal, please do not use.
 357             /// </summary>
 358             /// <since_tizen> 3 </since_tizen>
 359             public static readonly int WRAP_ENABLED = NDalicPINVOKE.ScrollView_Property_WRAP_ENABLED_get();
 360             /// <summary>
 361             /// This should be internal, please do not use.
 362             /// </summary>
 363             /// <since_tizen> 3 </since_tizen>
 364             public static readonly int PANNING_ENABLED = NDalicPINVOKE.ScrollView_Property_PANNING_ENABLED_get();
 365             /// <summary>
 366             /// This should be internal, please do not use.
 367             /// </summary>
 368             /// <since_tizen> 3 </since_tizen>
 369             public static readonly int AXIS_AUTO_LOCK_ENABLED = NDalicPINVOKE.ScrollView_Property_AXIS_AUTO_LOCK_ENABLED_get();
 370             /// <summary>
 371             /// This should be internal, please do not use.
 372             /// </summary>
 373             /// <since_tizen> 3 </since_tizen>
 374             public static readonly int WHEEL_SCROLL_DISTANCE_STEP = NDalicPINVOKE.ScrollView_Property_WHEEL_SCROLL_DISTANCE_STEP_get();
 375             /// <summary>
 376             /// This should be internal, please do not use.
 377             /// </summary>
 378             /// <since_tizen> 3 </since_tizen>
 379             public static readonly int SCROLL_MODE = NDalicPINVOKE.ScrollView_Property_SCROLL_MODE_get();
 380             /// <summary>
 381             /// This should be internal, please do not use.
 382             /// </summary>
 383             /// <since_tizen> 3 </since_tizen>
 384             public static readonly int SCROLL_POSITION = NDalicPINVOKE.ScrollView_Property_SCROLL_POSITION_get();
 385             /// <summary>
 386             /// This should be internal, please do not use.
 387             /// </summary>
 388             /// <since_tizen> 3 </since_tizen>
 389             public static readonly int SCROLL_PRE_POSITION = NDalicPINVOKE.ScrollView_Property_SCROLL_PRE_POSITION_get();
 390             /// <summary>
 391             /// This should be internal, please do not use.
 392             /// </summary>
 393             /// <since_tizen> 3 </since_tizen>
 394             public static readonly int SCROLL_PRE_POSITION_X = NDalicPINVOKE.ScrollView_Property_SCROLL_PRE_POSITION_X_get();
 395             /// <summary>
 396             /// This should be internal, please do not use.
 397             /// </summary>
 398             /// <since_tizen> 3 </since_tizen>
 399             public static readonly int SCROLL_PRE_POSITION_Y = NDalicPINVOKE.ScrollView_Property_SCROLL_PRE_POSITION_Y_get();
 400             /// <summary>
 401             /// This should be internal, please do not use.
 402             /// </summary>
 403             /// <since_tizen> 3 </since_tizen>
 404             public static readonly int SCROLL_PRE_POSITION_MAX = NDalicPINVOKE.ScrollView_Property_SCROLL_PRE_POSITION_MAX_get();
 405             /// <summary>
 406             /// This should be internal, please do not use.
 407             /// </summary>
 408             /// <since_tizen> 3 </since_tizen>
 409             public static readonly int SCROLL_PRE_POSITION_MAX_X = NDalicPINVOKE.ScrollView_Property_SCROLL_PRE_POSITION_MAX_X_get();
 410             /// <summary>
 411             /// This should be internal, please do not use.
 412             /// </summary>
 413             /// <since_tizen> 3 </since_tizen>
 414             public static readonly int SCROLL_PRE_POSITION_MAX_Y = NDalicPINVOKE.ScrollView_Property_SCROLL_PRE_POSITION_MAX_Y_get();
 415             /// <summary>
 416             /// This should be internal, please do not use.
 417             /// </summary>
 418             /// <since_tizen> 3 </since_tizen>
 419             public static readonly int OVERSHOOT_X = NDalicPINVOKE.ScrollView_Property_OVERSHOOT_X_get();
 420             /// <summary>
 421             /// This should be internal, please do not use.
 422             /// </summary>
 423             /// <since_tizen> 3 </since_tizen>
 424             public static readonly int OVERSHOOT_Y = NDalicPINVOKE.ScrollView_Property_OVERSHOOT_Y_get();
 425             /// <summary>
 426             /// This should be internal, please do not use.
 427             /// </summary>
 428             /// <since_tizen> 3 </since_tizen>
 429             public static readonly int SCROLL_FINAL = NDalicPINVOKE.ScrollView_Property_SCROLL_FINAL_get();
 430             /// <summary>
 431             /// This should be internal, please do not use.
 432             /// </summary>
 433             /// <since_tizen> 3 </since_tizen>
 434             public static readonly int SCROLL_FINAL_X = NDalicPINVOKE.ScrollView_Property_SCROLL_FINAL_X_get();
 435             /// <summary>
 436             /// This should be internal, please do not use.
 437             /// </summary>
 438             /// <since_tizen> 3 </since_tizen>
 439             public static readonly int SCROLL_FINAL_Y = NDalicPINVOKE.ScrollView_Property_SCROLL_FINAL_Y_get();
 440             /// <summary>
 441             /// This should be internal, please do not use.
 442             /// </summary>
 443             /// <since_tizen> 3 </since_tizen>
 444             public static readonly int WRAP = NDalicPINVOKE.ScrollView_Property_WRAP_get();
 445             /// <summary>
 446             /// This should be internal, please do not use.
 447             /// </summary>
 448             /// <since_tizen> 3 </since_tizen>
 449             public static readonly int PANNING = NDalicPINVOKE.ScrollView_Property_PANNING_get();
 450             /// <summary>
 451             /// This should be internal, please do not use.
 452             /// </summary>
 453             /// <since_tizen> 3 </since_tizen>
 454             public static readonly int SCROLLING = NDalicPINVOKE.ScrollView_Property_SCROLLING_get();
 455             /// <summary>
 456             /// This should be internal, please do not use.
 457             /// </summary>
 458             /// <since_tizen> 3 </since_tizen>
 459             public static readonly int SCROLL_DOMAIN_SIZE = NDalicPINVOKE.ScrollView_Property_SCROLL_DOMAIN_SIZE_get();
 460             /// <summary>
 461             /// This should be internal, please do not use.
 462             /// </summary>
 463             /// <since_tizen> 3 </since_tizen>
 464             public static readonly int SCROLL_DOMAIN_SIZE_X = NDalicPINVOKE.ScrollView_Property_SCROLL_DOMAIN_SIZE_X_get();
 465             /// <summary>
 466             /// This should be internal, please do not use.
 467             /// </summary>
 468             /// <since_tizen> 3 </since_tizen>
 469             public static readonly int SCROLL_DOMAIN_SIZE_Y = NDalicPINVOKE.ScrollView_Property_SCROLL_DOMAIN_SIZE_Y_get();
 470             /// <summary>
 471             /// This should be internal, please do not use.
 472             /// </summary>
 473             /// <since_tizen> 3 </since_tizen>
 474             public static readonly int SCROLL_DOMAIN_OFFSET = NDalicPINVOKE.ScrollView_Property_SCROLL_DOMAIN_OFFSET_get();
 475             /// <summary>
 476             /// This should be internal, please do not use.
 477             /// </summary>
 478             /// <since_tizen> 3 </since_tizen>
 479             public static readonly int SCROLL_POSITION_DELTA = NDalicPINVOKE.ScrollView_Property_SCROLL_POSITION_DELTA_get();
 480             /// <summary>
 481             /// This should be internal, please do not use.
 482             /// </summary>
 483             /// <since_tizen> 3 </since_tizen>
 484             public static readonly int START_PAGE_POSITION = NDalicPINVOKE.ScrollView_Property_START_PAGE_POSITION_get();
 485
 486         }
 487
 488         /// <summary>
 489         /// Create an instance of ScrollView.
 490         /// </summary>
 491         /// <since_tizen> 3 </since_tizen>
 492         public ScrollView() : this(NDalicPINVOKE.ScrollView_New(), true)
 493         {
 494             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 495
 496         }
 497
 498         /// <summary>
 499         /// Gets snap-animation's AlphaFunction.
 500         /// </summary>
 501         /// <returns>Current easing alpha function of the snap animation.</returns>
 502         /// <since_tizen> 3 </since_tizen>
 503         public AlphaFunction GetScrollSnapAlphaFunction()
 504         {
 505             AlphaFunction ret = new AlphaFunction(NDalicPINVOKE.ScrollView_GetScrollSnapAlphaFunction(swigCPtr), true);
 506             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 507             return ret;
 508         }
 509
 510         /// <summary>
 511         /// Sets snap-animation's AlphaFunction.
 512         /// </summary>
 513         /// <param name="alpha">Easing alpha function of the snap animation.</param>
 514         /// <since_tizen> 3 </since_tizen>
 515         public void SetScrollSnapAlphaFunction(AlphaFunction alpha)
 516         {
 517             NDalicPINVOKE.ScrollView_SetScrollSnapAlphaFunction(swigCPtr, AlphaFunction.getCPtr(alpha));
 518             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 519         }
 520
 521         /// <summary>
 522         /// Gets flick-animation's AlphaFunction.
 523         /// </summary>
 524         /// <returns>Current easing alpha function of the flick animation.</returns>
 525         /// <since_tizen> 3 </since_tizen>
 526         public AlphaFunction GetScrollFlickAlphaFunction()
 527         {
 528             AlphaFunction ret = new AlphaFunction(NDalicPINVOKE.ScrollView_GetScrollFlickAlphaFunction(swigCPtr), true);
 529             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 530             return ret;
 531         }
 532
 533         /// <summary>
 534         /// Sets flick-animation's AlphaFunction.
 535         /// </summary>
 536         /// <param name="alpha">Easing alpha function of the flick animation.</param>
 537         /// <since_tizen> 3 </since_tizen>
 538         public void SetScrollFlickAlphaFunction(AlphaFunction alpha)
 539         {
 540             NDalicPINVOKE.ScrollView_SetScrollFlickAlphaFunction(swigCPtr, AlphaFunction.getCPtr(alpha));
 541             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 542         }
 543
 544         /// <summary>
 545         /// Gets the time for the scroll snap-animation.
 546         /// </summary>
 547         /// <returns>The time in seconds for the animation to take.</returns>
 548         /// <since_tizen> 3 </since_tizen>
 549         public float GetScrollSnapDuration()
 550         {
 551             float ret = NDalicPINVOKE.ScrollView_GetScrollSnapDuration(swigCPtr);
 552             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 553             return ret;
 554         }
 555
 556         /// <summary>
 557         /// Sets the time for the scroll snap-animation.
 558         /// </summary>
 559         /// <param name="time">The time in seconds for the animation to take.</param>
 560         /// <since_tizen> 3 </since_tizen>
 561         public void SetScrollSnapDuration(float time)
 562         {
 563             NDalicPINVOKE.ScrollView_SetScrollSnapDuration(swigCPtr, time);
 564             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 565         }
 566
 567         /// <summary>
 568         /// Gets the time for the scroll flick-animation.
 569         /// </summary>
 570         /// <returns>The time in seconds for the animation to take.</returns>
 571         /// <since_tizen> 3 </since_tizen>
 572         public float GetScrollFlickDuration()
 573         {
 574             float ret = NDalicPINVOKE.ScrollView_GetScrollFlickDuration(swigCPtr);
 575             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 576             return ret;
 577         }
 578
 579         /// <summary>
 580         /// Sets the time for the scroll snap-animation.
 581         /// </summary>
 582         /// <param name="time">The time in seconds for the animation to take.</param>
 583         /// <since_tizen> 3 </since_tizen>
 584         public void SetScrollFlickDuration(float time)
 585         {
 586             NDalicPINVOKE.ScrollView_SetScrollFlickDuration(swigCPtr, time);
 587             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 588         }
 589
 590         /// <summary>
 591         /// Sets scroll sensibility of pan gesture.
 592         /// </summary>
 593         /// <param name="sensitive">True to enable scroll, false to disable scrolling.</param>
 594         /// <since_tizen> 3 </since_tizen>
 595         public void SetScrollSensitive(bool sensitive)
 596         {
 597             NDalicPINVOKE.ScrollView_SetScrollSensitive(swigCPtr, sensitive);
 598             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 599         }
 600
 601         /// <summary>
 602         /// Sets maximum overshoot amount.
 603         /// </summary>
 604         /// <param name="overshootX">The maximum number of horizontally scrolled pixels before overshoot X reaches 1.0f.</param>
 605         /// <param name="overshootY">The maximum number of vertically scrolled pixels before overshoot X reaches 1.0f.</param>
 606         /// <since_tizen> 3 </since_tizen>
 607         public void SetMaxOvershoot(float overshootX, float overshootY)
 608         {
 609             NDalicPINVOKE.ScrollView_SetMaxOvershoot(swigCPtr, overshootX, overshootY);
 610             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 611         }
 612
 613         /// <summary>
 614         /// Sets Snap Overshoot animation's AlphaFunction.
 615         /// </summary>
 616         /// <param name="alpha">Easing alpha function of the overshoot snap animation.</param>
 617         /// <since_tizen> 3 </since_tizen>
 618         public void SetSnapOvershootAlphaFunction(AlphaFunction alpha)
 619         {
 620             NDalicPINVOKE.ScrollView_SetSnapOvershootAlphaFunction(swigCPtr, AlphaFunction.getCPtr(alpha));
 621             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 622         }
 623
 624         /// <summary>
 625         /// Sets Snap Overshoot animation's Duration.
 626         /// </summary>
 627         /// <param name="duration">duration The duration of the overshoot snap animation.</param>
 628         /// <since_tizen> 3 </since_tizen>
 629         public void SetSnapOvershootDuration(float duration)
 630         {
 631             NDalicPINVOKE.ScrollView_SetSnapOvershootDuration(swigCPtr, duration);
 632             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 633         }
 634
 635         /// <summary>
 636         /// Enables or Disables Actor Auto-Snap mode.<br />
 637         /// When Actor Auto-Snap mode has been enabled, ScrollView will automatically,
 638         /// snap to the closest actor (The closest actor will appear in the center of the ScrollView).
 639         /// </summary>
 640         /// <param name="enable">Enables (true), or disables (false) Actor AutoSnap.</param>
 641         /// <since_tizen> 3 </since_tizen>
 642         public void SetViewAutoSnap(bool enable)
 643         {
 644             NDalicPINVOKE.ScrollView_SetActorAutoSnap(swigCPtr, enable);
 645             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 646         }
 647
 648         /// <summary>
 649         /// Enables or Disables Wrap mode for ScrollView contents.<br />
 650         /// When enabled, the ScrollView contents are wrapped over the X/Y Domain.
 651         /// </summary>
 652         /// <param name="enable">Enables (true), or disables (false) Wrap Mode.</param>
 653         /// <since_tizen> 3 </since_tizen>
 654         public void SetWrapMode(bool enable)
 655         {
 656             NDalicPINVOKE.ScrollView_SetWrapMode(swigCPtr, enable);
 657             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 658         }
 659
 660         /// <summary>
 661         /// Gets the current distance needed to scroll for ScrollUpdatedSignal to be emitted.
 662         /// </summary>
 663         /// <returns>Current scroll update distance.</returns>
 664         /// <since_tizen> 3 </since_tizen>
 665         public int GetScrollUpdateDistance()
 666         {
 667             int ret = NDalicPINVOKE.ScrollView_GetScrollUpdateDistance(swigCPtr);
 668             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 669             return ret;
 670         }
 671
 672         /// <summary>
 673         /// Sets the distance needed to scroll for ScrollUpdatedSignal to be emitted.<br />
 674         /// The scroll update distance tells ScrollView how far to move before ScrollUpdatedSignal the informs application.<br />
 675         /// Each time the ScrollView crosses this distance the signal will be emitted.<br />
 676         /// </summary>
 677         /// <param name="distance">The distance for ScrollView to move before emitting update signal.</param>
 678         /// <since_tizen> 3 </since_tizen>
 679         public void SetScrollUpdateDistance(int distance)
 680         {
 681             NDalicPINVOKE.ScrollView_SetScrollUpdateDistance(swigCPtr, distance);
 682             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 683         }
 684
 685         /// <summary>
 686         /// Returns state of Axis Auto Lock mode.
 687         /// </summary>
 688         /// <returns>Whether Axis Auto Lock mode has been enabled or not.</returns>
 689         /// <since_tizen> 3 </since_tizen>
 690         public bool GetAxisAutoLock()
 691         {
 692             bool ret = NDalicPINVOKE.ScrollView_GetAxisAutoLock(swigCPtr);
 693             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 694             return ret;
 695         }
 696
 697         /// <summary>
 698         /// Enables or Disables Axis Auto Lock mode for panning within the ScrollView.<br />
 699         /// When enabled, any pan gesture that appears mostly horizontal or mostly
 700         /// vertical, will be automatically restricted to horizontal only or vertical
 701         /// only panning, until the pan gesture has completed.
 702         /// </summary>
 703         /// <param name="enable">Enables (true), or disables (false) AxisAutoLock mode.</param>
 704         /// <since_tizen> 3 </since_tizen>
 705         public void SetAxisAutoLock(bool enable)
 706         {
 707             NDalicPINVOKE.ScrollView_SetAxisAutoLock(swigCPtr, enable);
 708             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 709         }
 710
 711         /// <summary>
 712         /// Gets the gradient threshold at which a panning gesture should be locked to the Horizontal or Vertical axis.
 713         /// </summary>
 714         /// <returns>The gradient, a value between 0.0 and 1.0f.</returns>
 715         /// <since_tizen> 3 </since_tizen>
 716         public float GetAxisAutoLockGradient()
 717         {
 718             float ret = NDalicPINVOKE.ScrollView_GetAxisAutoLockGradient(swigCPtr);
 719             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 720             return ret;
 721         }
 722
 723         /// <summary>
 724         /// Sets the gradient threshold at which a panning gesture should be locked to the Horizontal or Vertical axis.<br />
 725         /// By default, this is 0.36 (0.36:1) which means angles less than 20 degrees to an axis will lock to that axis.<br />
 726         /// </summary>
 727         /// <param name="gradient">gradient A value between 0.0 and 1.0 (auto-lock for all angles).</param>
 728         /// <since_tizen> 3 </since_tizen>
 729         public void SetAxisAutoLockGradient(float gradient)
 730         {
 731             NDalicPINVOKE.ScrollView_SetAxisAutoLockGradient(swigCPtr, gradient);
 732             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 733         }
 734
 735         /// <summary>
 736         /// Gets the friction coefficient setting for ScrollView when flicking in free panning mode.
 737         /// This is a value in stage-diagonals per second^2, stage-diagonal = Length( stage.width, stage.height )
 738         /// </summary>
 739         /// <returns>Friction coefficient is returned.</returns>
 740         /// <since_tizen> 3 </since_tizen>
 741         public float GetFrictionCoefficient()
 742         {
 743             float ret = NDalicPINVOKE.ScrollView_GetFrictionCoefficient(swigCPtr);
 744             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 745             return ret;
 746         }
 747
 748         /// <summary>
 749         /// Sets the friction coefficient for ScrollView when flicking.<br />
 750         /// </summary>
 751         /// <param name="friction">Friction coefficient must be greater than 0.0 (default = 1.0).</param>
 752         /// <since_tizen> 3 </since_tizen>
 753         public void SetFrictionCoefficient(float friction)
 754         {
 755             NDalicPINVOKE.ScrollView_SetFrictionCoefficient(swigCPtr, friction);
 756             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 757         }
 758
 759         /// <summary>
 760         /// Gets the flick speed coefficient for ScrollView when flicking in free panning mode.<br />
 761         /// This is a constant which multiplies the input touch flick velocity to determine the actual velocity at which to move the scrolling area.
 762         /// </summary>
 763         /// <returns>The flick speed coefficient is returned.</returns>
 764         /// <since_tizen> 3 </since_tizen>
 765         public float GetFlickSpeedCoefficient()
 766         {
 767             float ret = NDalicPINVOKE.ScrollView_GetFlickSpeedCoefficient(swigCPtr);
 768             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 769             return ret;
 770         }
 771
 772         /// <summary>
 773         /// Sets the flick speed coefficient for ScrollView when flicking in free panning mode.<br />
 774         /// This is a constant which multiplies the input touch flick velocity to determine the actual velocity at
 775         /// which to move the scrolling area.<br />
 776         /// </summary>
 777         /// <param name="speed">The flick speed coefficient (default = 1.0).</param>
 778         /// <since_tizen> 3 </since_tizen>
 779         public void SetFlickSpeedCoefficient(float speed)
 780         {
 781             NDalicPINVOKE.ScrollView_SetFlickSpeedCoefficient(swigCPtr, speed);
 782             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 783         }
 784
 785         /// <summary>
 786         /// Gets the minimum pan distance required for a flick gesture in pixels.<br />
 787         /// </summary>
 788         /// <returns>Minimum pan distance vector with separate x and y distance.</returns>
 789         /// <since_tizen> 3 </since_tizen>
 790         public Vector2 GetMinimumDistanceForFlick()
 791         {
 792             Vector2 ret = new Vector2(NDalicPINVOKE.ScrollView_GetMinimumDistanceForFlick(swigCPtr), true);
 793             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 794             return ret;
 795         }
 796
 797         /// <summary>
 798         /// Sets the minimum pan distance required for a flick in pixels.<br />
 799         /// Takes a Vector2 containing separate x and y values. As long as the pan distance exceeds one of these axes, a flick will be allowed.
 800         /// </summary>
 801         /// <param name="distance">The flick speed coefficient (default = 1.0).</param>
 802         /// <since_tizen> 3 </since_tizen>
 803         public void SetMinimumDistanceForFlick(Vector2 distance)
 804         {
 805             NDalicPINVOKE.ScrollView_SetMinimumDistanceForFlick(swigCPtr, Vector2.getCPtr(distance));
 806             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 807         }
 808
 809         /// <summary>
 810         /// Returns the minimum pan speed required for a flick gesture in pixels per second.
 811         /// </summary>
 812         /// <returns>Minimum pan speed.</returns>
 813         /// <since_tizen> 3 </since_tizen>
 814         public float GetMinimumSpeedForFlick()
 815         {
 816             float ret = NDalicPINVOKE.ScrollView_GetMinimumSpeedForFlick(swigCPtr);
 817             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 818             return ret;
 819         }
 820
 821         /// <summary>
 822         /// Sets the minimum pan speed required for a flick in pixels per second.<br />
 823         /// </summary>
 824         /// <param name="speed">The minimum pan speed for a flick.</param>
 825         /// <since_tizen> 3 </since_tizen>
 826         public void SetMinimumSpeedForFlick(float speed)
 827         {
 828             NDalicPINVOKE.ScrollView_SetMinimumSpeedForFlick(swigCPtr, speed);
 829             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 830         }
 831
 832         /// <summary>
 833         /// Gets the maximum flick speed setting for ScrollView when flicking in free panning mode.<br />
 834         /// This is a value in stage-diagonals per second.
 835         /// </summary>
 836         /// <returns>Maximum flick speed is returned.</returns>
 837         /// <since_tizen> 3 </since_tizen>
 838         public float GetMaxFlickSpeed()
 839         {
 840             float ret = NDalicPINVOKE.ScrollView_GetMaxFlickSpeed(swigCPtr);
 841             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 842             return ret;
 843         }
 844
 845         /// <summary>
 846         /// Sets the maximum flick speed for the ScrollView when flicking in free panning mode.<br />
 847         /// This is a value in stage-diagonals per second. stage-diagonal = Length( stage.width, stage.height ).<br />
 848         /// </summary>
 849         /// <param name="speed">Maximum flick speed (default = 3.0).</param>
 850         /// <since_tizen> 3 </since_tizen>
 851         public void SetMaxFlickSpeed(float speed)
 852         {
 853             NDalicPINVOKE.ScrollView_SetMaxFlickSpeed(swigCPtr, speed);
 854             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 855         }
 856
 857         /// <summary>
 858         /// Gets the step of scroll distance in actor coordinates for each wheel event received in free panning mode.<br />
 859         /// </summary>
 860         /// <returns>The step of scroll distance(pixel) in X and Y axes.</returns>
 861         /// <since_tizen> 3 </since_tizen>
 862         public Vector2 GetWheelScrollDistanceStep()
 863         {
 864             Vector2 ret = new Vector2(NDalicPINVOKE.ScrollView_GetWheelScrollDistanceStep(swigCPtr), true);
 865             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 866             return ret;
 867         }
 868
 869         /// <summary>
 870         /// Sets the step of scroll distance in actor coordinates for each wheel event received in free panning mode.<br />
 871         /// </summary>
 872         /// <param name="step">step The step of scroll distance(pixel) in X and Y axes.</param>
 873         /// <since_tizen> 3 </since_tizen>
 874         public void SetWheelScrollDistanceStep(Vector2 step)
 875         {
 876             NDalicPINVOKE.ScrollView_SetWheelScrollDistanceStep(swigCPtr, Vector2.getCPtr(step));
 877             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 878         }
 879
 880         /// <summary>
 881         /// Retrieves current scroll position.<br />
 882         /// </summary>
 883         /// <returns>The current scroll position.</returns>
 884         /// <since_tizen> 3 </since_tizen>
 885         public Vector2 GetCurrentScrollPosition()
 886         {
 887             Vector2 ret = new Vector2(NDalicPINVOKE.ScrollView_GetCurrentScrollPosition(swigCPtr), true);
 888             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 889             return ret;
 890         }
 891
 892         /// <summary>
 893         /// Retrieves current scroll page based on ScrollView dimensions being the size of one page, and all pages laid out in<br />
 894         /// a grid fashion, increasing from left to right until the end of the X-domain.
 895         /// </summary>
 896         /// <returns>The current scroll position.</returns>
 897         /// <since_tizen> 3 </since_tizen>
 898         public uint GetCurrentPage()
 899         {
 900             uint ret = NDalicPINVOKE.ScrollView_GetCurrentPage(swigCPtr);
 901             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 902             return ret;
 903         }
 904
 905         /// <summary>
 906         /// Scrolls View to position specified (contents will scroll to this position).
 907         /// </summary>
 908         /// <param name="position">The position to scroll to.</param>
 909         /// <since_tizen> 3 </since_tizen>
 910         public void ScrollTo(Vector2 position)
 911         {
 912             NDalicPINVOKE.ScrollView_ScrollTo__SWIG_0(swigCPtr, Vector2.getCPtr(position));
 913             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 914         }
 915
 916         /// <summary>
 917         /// Scrolls View to position specified (contents will scroll to this position).
 918         /// </summary>
 919         /// <param name="position">The position to scroll to.</param>
 920         /// <param name="duration">The duration of the animation in seconds.</param>
 921         /// <since_tizen> 3 </since_tizen>
 922         public void ScrollTo(Vector2 position, float duration)
 923         {
 924             NDalicPINVOKE.ScrollView_ScrollTo__SWIG_1(swigCPtr, Vector2.getCPtr(position), duration);
 925             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 926         }
 927
 928         /// <summary>
 929         /// Scrolls View to position specified (contents will scroll to this position).
 930         /// </summary>
 931         /// <param name="position">The position to scroll to.</param>
 932         /// <param name="duration">The duration of the animation in seconds.</param>
 933         /// <param name="alpha">The alpha function to use.</param>
 934         /// <since_tizen> 3 </since_tizen>
 935         public void ScrollTo(Vector2 position, float duration, AlphaFunction alpha)
 936         {
 937             NDalicPINVOKE.ScrollView_ScrollTo__SWIG_2(swigCPtr, Vector2.getCPtr(position), duration, AlphaFunction.getCPtr(alpha));
 938             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 939         }
 940
 941         /// <summary>
 942         /// Scrolls View to position specified (contents will scroll to this position).
 943         /// </summary>
 944         /// <param name="position">The position to scroll to.</param>
 945         /// <param name="duration">The duration of the animation in seconds.</param>
 946         /// <param name="horizontalBias">Whether to bias scrolling to left or right.</param>
 947         /// <param name="verticalBias">Whether to bias scrolling to top or bottom.</param>
 948         /// <since_tizen> 3 </since_tizen>
 949         public void ScrollTo(Vector2 position, float duration, DirectionBias horizontalBias, DirectionBias verticalBias)
 950         {
 951             NDalicPINVOKE.ScrollView_ScrollTo__SWIG_3(swigCPtr, Vector2.getCPtr(position), duration, (int)horizontalBias, (int)verticalBias);
 952             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 953         }
 954
 955         /// <summary>
 956         /// Scrolls View to position specified (contents will scroll to this position).
 957         /// </summary>
 958         /// <param name="position">The position to scroll to.</param>
 959         /// <param name="duration">The duration of the animation in seconds.</param>
 960         /// <param name="alpha">Alpha function to use.</param>
 961         /// <param name="horizontalBias">Whether to bias scrolling to left or right.</param>
 962         /// <param name="verticalBias">Whether to bias scrolling to top or bottom.</param>
 963         /// <since_tizen> 3 </since_tizen>
 964         public void ScrollTo(Vector2 position, float duration, AlphaFunction alpha, DirectionBias horizontalBias, DirectionBias verticalBias)
 965         {
 966             NDalicPINVOKE.ScrollView_ScrollTo__SWIG_4(swigCPtr, Vector2.getCPtr(position), duration, AlphaFunction.getCPtr(alpha), (int)horizontalBias, (int)verticalBias);
 967             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 968         }
 969
 970         /// <summary>
 971         /// Scrolls View to position specified (contents will scroll to this position).
 972         /// </summary>
 973         /// <param name="page">The page to scroll to.</param>
 974         /// <since_tizen> 3 </since_tizen>
 975         public void ScrollTo(uint page)
 976         {
 977             NDalicPINVOKE.ScrollView_ScrollTo__SWIG_5(swigCPtr, page);
 978             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 979         }
 980
 981         /// <summary>
 982         /// Scrolls View to position specified (contents will scroll to this position).
 983         /// </summary>
 984         /// <param name="page">The page to scroll to.</param>
 985         /// <param name="duration">The duration of the animation in seconds.</param>
 986         /// <since_tizen> 3 </since_tizen>
 987         public void ScrollTo(uint page, float duration)
 988         {
 989             NDalicPINVOKE.ScrollView_ScrollTo__SWIG_6(swigCPtr, page, duration);
 990             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 991         }
 992
 993         /// <summary>
 994         /// Scrolls View to position specified (contents will scroll to this position).
 995         /// </summary>
 996         /// <param name="page">The page to scroll to.</param>
 997         /// <param name="duration">The duration of the animation in seconds.</param>
 998         /// <param name="bias">Whether to bias scrolling to left or right.</param>
 999         /// <since_tizen> 3 </since_tizen>
1000         public void ScrollTo(uint page, float duration, DirectionBias bias)
1001         {
1002             NDalicPINVOKE.ScrollView_ScrollTo__SWIG_7(swigCPtr, page, duration, (int)bias);
1003             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1004         }
1005
1006         /// <summary>
1007         /// Scrolls View to position specified (contents will scroll to this position).
1008         /// </summary>
1009         /// <param name="view">The view to center in on (via Scrolling).</param>
1010         /// <since_tizen> 3 </since_tizen>
1011         public void ScrollTo(View view)
1012         {
1013             NDalicPINVOKE.ScrollView_ScrollTo__SWIG_8(swigCPtr, View.getCPtr(view));
1014             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1015         }
1016
1017         /// <summary>
1018         /// Scrolls View to position specified (contents will scroll to this position).
1019         /// </summary>
1020         /// <param name="view">The view to center in on (via Scrolling).</param>
1021         /// <param name="duration">The duration of the animation in seconds.</param>
1022         /// <since_tizen> 3 </since_tizen>
1023         public void ScrollTo(View view, float duration)
1024         {
1025             NDalicPINVOKE.ScrollView_ScrollTo__SWIG_9(swigCPtr, View.getCPtr(view), duration);
1026             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1027         }
1028
1029         /// <summary>
1030         /// Scrolls View to the nearest snap points as specified by the Rulers.<br />
1031         /// If already at snap points, then will return false, and not scroll.<br />
1032         /// </summary>
1033         /// <returns>True if Snapping necessary.</returns>
1034         /// <since_tizen> 3 </since_tizen>
1035         public bool ScrollToSnapPoint()
1036         {
1037             bool ret = NDalicPINVOKE.ScrollView_ScrollToSnapPoint(swigCPtr);
1038             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1039             return ret;
1040         }
1041
1042         internal void ApplyConstraintToChildren(SWIGTYPE_p_Dali__Constraint constraint)
1043         {
1044             NDalicPINVOKE.ScrollView_ApplyConstraintToChildren(swigCPtr, SWIGTYPE_p_Dali__Constraint.getCPtr(constraint));
1045             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1046         }
1047
1048         /// <summary>
1049         /// Applies Effect to ScrollView.
1050         /// </summary>
1051         /// <param name="effect">The effect to apply to scroll view.</param>
1052         /// <since_tizen> 3 </since_tizen>
1053         public void ApplyEffect(ScrollViewEffect effect)
1054         {
1055             NDalicPINVOKE.ScrollView_ApplyEffect(swigCPtr, ScrollViewEffect.getCPtr(effect));
1056             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1057         }
1058
1059         /// <summary>
1060         /// Removes Effect from ScrollView.
1061         /// </summary>
1062         /// <param name="effect">The effect to remove.</param>
1063         /// <since_tizen> 3 </since_tizen>
1064         public void RemoveEffect(ScrollViewEffect effect)
1065         {
1066             NDalicPINVOKE.ScrollView_RemoveEffect(swigCPtr, ScrollViewEffect.getCPtr(effect));
1067             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1068         }
1069
1070         /// <summary>
1071         /// Remove All Effects from ScrollView.
1072         /// </summary>
1073         /// <since_tizen> 3 </since_tizen>
1074         public void RemoveAllEffects()
1075         {
1076             NDalicPINVOKE.ScrollView_RemoveAllEffects(swigCPtr);
1077             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1078         }
1079
1080         /// <summary>
1081         /// Binds view to this ScrollView.
1082         /// Once an actor is bound to a ScrollView, it will be subject to that ScrollView's properties.
1083         /// </summary>
1084         /// <param name="child">The view to add to this ScrollView.</param>
1085         /// <since_tizen> 3 </since_tizen>
1086         public void BindView(View child)
1087         {
1088             NDalicPINVOKE.ScrollView_BindActor(swigCPtr, View.getCPtr(child));
1089             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1090         }
1091
1092         /// <summary>
1093         /// Unbinds view to this ScrollView.
1094         /// Once an actor is bound to a ScrollView, it will be subject to that ScrollView's properties.
1095         /// </summary>
1096         /// <param name="child">The view to remove to this ScrollView.</param>
1097         /// <since_tizen> 3 </since_tizen>
1098         public void UnbindView(View child)
1099         {
1100             NDalicPINVOKE.ScrollView_UnbindActor(swigCPtr, View.getCPtr(child));
1101             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1102         }
1103
1104         /// <summary>
1105         /// Allows the user to constrain the scroll view in a particular direction.
1106         /// </summary>
1107         /// <param name="direction">The axis to constrain the scroll-view to.</param>
1108         /// <param name="threshold">The threshold to apply around the axis.</param>
1109         /// <since_tizen> 3 </since_tizen>
1110         public void SetScrollingDirection(Radian direction, Radian threshold)
1111         {
1112             NDalicPINVOKE.ScrollView_SetScrollingDirection__SWIG_0(swigCPtr, Radian.getCPtr(direction), Radian.getCPtr(threshold));
1113             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1114         }
1115
1116         /// <summary>
1117         /// Allows the user to constrain the scroll view in a particular direction.
1118         /// </summary>
1119         /// <param name="direction">The axis to constrain the scroll-view to.</param>
1120         /// <since_tizen> 3 </since_tizen>
1121         public void SetScrollingDirection(Radian direction)
1122         {
1123             NDalicPINVOKE.ScrollView_SetScrollingDirection__SWIG_1(swigCPtr, Radian.getCPtr(direction));
1124             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1125         }
1126
1127         /// <summary>
1128         /// Removes a direction constraint from the scroll view.
1129         /// </summary>
1130         /// <param name="direction">The axis to constrain the scroll-view to.</param>
1131         /// <since_tizen> 3 </since_tizen>
1132         public void RemoveScrollingDirection(Radian direction)
1133         {
1134             NDalicPINVOKE.ScrollView_RemoveScrollingDirection(swigCPtr, Radian.getCPtr(direction));
1135             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1136         }
1137
1138         internal ScrollViewSnapStartedSignal SnapStartedSignal()
1139         {
1140             ScrollViewSnapStartedSignal ret = new ScrollViewSnapStartedSignal(NDalicPINVOKE.ScrollView_SnapStartedSignal(swigCPtr), false);
1141             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1142             return ret;
1143         }
1144
1145         /// <summary>
1146         /// Sets and Gets WrapEnabled property.
1147         /// </summary>
1148         /// <since_tizen> 3 </since_tizen>
1149         public bool WrapEnabled
1150         {
1151             get
1152             {
1153                 bool temp = false;
1154                 GetProperty(ScrollView.Property.WRAP_ENABLED).Get(out temp);
1155                 return temp;
1156             }
1157             set
1158             {
1159                 SetProperty(ScrollView.Property.WRAP_ENABLED, new Tizen.NUI.PropertyValue(value));
1160             }
1161         }
1162
1163         /// <summary>
1164         /// Sets and Gets PanningEnabled property.
1165         /// </summary>
1166         /// <since_tizen> 3 </since_tizen>
1167         public bool PanningEnabled
1168         {
1169             get
1170             {
1171                 bool temp = false;
1172                 GetProperty(ScrollView.Property.PANNING_ENABLED).Get(out temp);
1173                 return temp;
1174             }
1175             set
1176             {
1177                 SetProperty(ScrollView.Property.PANNING_ENABLED, new Tizen.NUI.PropertyValue(value));
1178             }
1179         }
1180
1181         /// <summary>
1182         /// Sets and Gets AxisAutoLockEnabled property.
1183         /// </summary>
1184         /// <since_tizen> 3 </since_tizen>
1185         public bool AxisAutoLockEnabled
1186         {
1187             get
1188             {
1189                 bool temp = false;
1190                 GetProperty(ScrollView.Property.AXIS_AUTO_LOCK_ENABLED).Get(out temp);
1191                 return temp;
1192             }
1193             set
1194             {
1195                 SetProperty(ScrollView.Property.AXIS_AUTO_LOCK_ENABLED, new Tizen.NUI.PropertyValue(value));
1196             }
1197         }
1198
1199         /// <summary>
1200         /// Sets and Gets WheelScrollDistanceStep property.
1201         /// </summary>
1202         /// <since_tizen> 3 </since_tizen>
1203         public Vector2 WheelScrollDistanceStep
1204         {
1205             get
1206             {
1207                 Vector2 temp = new Vector2(0.0f, 0.0f);
1208                 GetProperty(ScrollView.Property.WHEEL_SCROLL_DISTANCE_STEP).Get(temp);
1209                 return temp;
1210             }
1211             set
1212             {
1213                 SetProperty(ScrollView.Property.WHEEL_SCROLL_DISTANCE_STEP, new Tizen.NUI.PropertyValue(value));
1214             }
1215         }
1216
1217         /// <summary>
1218         /// Sets and Gets ScrollPosition property.
1219         /// </summary>
1220         /// <since_tizen> 3 </since_tizen>
1221         public Vector2 ScrollPosition
1222         {
1223             get
1224             {
1225                 Vector2 temp = new Vector2(0.0f, 0.0f);
1226                 GetProperty(ScrollView.Property.SCROLL_POSITION).Get(temp);
1227                 return temp;
1228             }
1229             set
1230             {
1231                 SetProperty(ScrollView.Property.SCROLL_POSITION, new Tizen.NUI.PropertyValue(value));
1232             }
1233         }
1234
1235         /// <summary>
1236         /// Sets and Gets ScrollPrePosition property.
1237         /// </summary>
1238         /// <since_tizen> 3 </since_tizen>
1239         public Vector2 ScrollPrePosition
1240         {
1241             get
1242             {
1243                 Vector2 temp = new Vector2(0.0f, 0.0f);
1244                 GetProperty(ScrollView.Property.SCROLL_PRE_POSITION).Get(temp);
1245                 return temp;
1246             }
1247             set
1248             {
1249                 SetProperty(ScrollView.Property.SCROLL_PRE_POSITION, new Tizen.NUI.PropertyValue(value));
1250             }
1251         }
1252
1253         /// <summary>
1254         /// Sets and Gets ScrollPrePositionMax property.
1255         /// </summary>
1256         /// <since_tizen> 3 </since_tizen>
1257         public Vector2 ScrollPrePositionMax
1258         {
1259             get
1260             {
1261                 Vector2 temp = new Vector2(0.0f, 0.0f);
1262                 GetProperty(ScrollView.Property.SCROLL_PRE_POSITION_MAX).Get(temp);
1263                 return temp;
1264             }
1265             set
1266             {
1267                 SetProperty(ScrollView.Property.SCROLL_PRE_POSITION_MAX, new Tizen.NUI.PropertyValue(value));
1268             }
1269         }
1270
1271         /// <summary>
1272         /// Sets and Gets OvershootX property.
1273         /// </summary>
1274         /// <since_tizen> 3 </since_tizen>
1275         public float OvershootX
1276         {
1277             get
1278             {
1279                 float temp = 0.0f;
1280                 GetProperty(ScrollView.Property.OVERSHOOT_X).Get(out temp);
1281                 return temp;
1282             }
1283             set
1284             {
1285                 SetProperty(ScrollView.Property.OVERSHOOT_X, new Tizen.NUI.PropertyValue(value));
1286             }
1287         }
1288
1289         /// <summary>
1290         /// Sets and Gets OvershootY property.
1291         /// </summary>
1292         /// <since_tizen> 3 </since_tizen>
1293         public float OvershootY
1294         {
1295             get
1296             {
1297                 float temp = 0.0f;
1298                 GetProperty(ScrollView.Property.OVERSHOOT_Y).Get(out temp);
1299                 return temp;
1300             }
1301             set
1302             {
1303                 SetProperty(ScrollView.Property.OVERSHOOT_Y, new Tizen.NUI.PropertyValue(value));
1304             }
1305         }
1306
1307         /// <summary>
1308         /// Sets and Gets ScrollFinal property.
1309         /// </summary>
1310         /// <since_tizen> 3 </since_tizen>
1311         public Vector2 ScrollFinal
1312         {
1313             get
1314             {
1315                 Vector2 temp = new Vector2(0.0f, 0.0f);
1316                 GetProperty(ScrollView.Property.SCROLL_FINAL).Get(temp);
1317                 return temp;
1318             }
1319             set
1320             {
1321                 SetProperty(ScrollView.Property.SCROLL_FINAL, new Tizen.NUI.PropertyValue(value));
1322             }
1323         }
1324
1325         /// <summary>
1326         /// Sets and Gets Wrap property.
1327         /// </summary>
1328         /// <since_tizen> 3 </since_tizen>
1329         public bool Wrap
1330         {
1331             get
1332             {
1333                 bool temp = false;
1334                 GetProperty(ScrollView.Property.WRAP).Get(out temp);
1335                 return temp;
1336             }
1337             set
1338             {
1339                 SetProperty(ScrollView.Property.WRAP, new Tizen.NUI.PropertyValue(value));
1340             }
1341         }
1342
1343         /// <summary>
1344         /// Sets and Gets Panning property.
1345         /// </summary>
1346         /// <since_tizen> 3 </since_tizen>
1347         public bool Panning
1348         {
1349             get
1350             {
1351                 bool temp = false;
1352                 GetProperty(ScrollView.Property.PANNING).Get(out temp);
1353                 return temp;
1354             }
1355             set
1356             {
1357                 SetProperty(ScrollView.Property.PANNING, new Tizen.NUI.PropertyValue(value));
1358             }
1359         }
1360
1361         /// <summary>
1362         /// Sets and Gets Scrolling property.
1363         /// </summary>
1364         /// <since_tizen> 3 </since_tizen>
1365         public bool Scrolling
1366         {
1367             get
1368             {
1369                 bool temp = false;
1370                 GetProperty(ScrollView.Property.SCROLLING).Get(out temp);
1371                 return temp;
1372             }
1373             set
1374             {
1375                 SetProperty(ScrollView.Property.SCROLLING, new Tizen.NUI.PropertyValue(value));
1376             }
1377         }
1378
1379         /// <summary>
1380         /// Sets and Gets ScrollDomainSize property.
1381         /// </summary>
1382         /// <since_tizen> 3 </since_tizen>
1383         public Vector2 ScrollDomainSize
1384         {
1385             get
1386             {
1387                 Vector2 temp = new Vector2(0.0f, 0.0f);
1388                 GetProperty(ScrollView.Property.SCROLL_DOMAIN_SIZE).Get(temp);
1389                 return temp;
1390             }
1391             set
1392             {
1393                 SetProperty(ScrollView.Property.SCROLL_DOMAIN_SIZE, new Tizen.NUI.PropertyValue(value));
1394             }
1395         }
1396
1397         /// <summary>
1398         /// Sets and Gets ScrollDomainOffset property.
1399         /// </summary>
1400         /// <since_tizen> 3 </since_tizen>
1401         public Vector2 ScrollDomainOffset
1402         {
1403             get
1404             {
1405                 Vector2 temp = new Vector2(0.0f, 0.0f);
1406                 GetProperty(ScrollView.Property.SCROLL_DOMAIN_OFFSET).Get(temp);
1407                 return temp;
1408             }
1409             set
1410             {
1411                 SetProperty(ScrollView.Property.SCROLL_DOMAIN_OFFSET, new Tizen.NUI.PropertyValue(value));
1412             }
1413         }
1414
1415         /// <summary>
1416         /// Sets and Gets ScrollPositionDelta property.
1417         /// </summary>
1418         /// <since_tizen> 3 </since_tizen>
1419         public Vector2 ScrollPositionDelta
1420         {
1421             get
1422             {
1423                 Vector2 temp = new Vector2(0.0f, 0.0f);
1424                 GetProperty(ScrollView.Property.SCROLL_POSITION_DELTA).Get(temp);
1425                 return temp;
1426             }
1427             set
1428             {
1429                 SetProperty(ScrollView.Property.SCROLL_POSITION_DELTA, new Tizen.NUI.PropertyValue(value));
1430             }
1431         }
1432
1433         /// <summary>
1434         /// Sets and Gets StartPagePosition property.
1435         /// </summary>
1436         /// <since_tizen> 3 </since_tizen>
1437         public Vector3 StartPagePosition
1438         {
1439             get
1440             {
1441                 Vector3 temp = new Vector3(0.0f, 0.0f, 0.0f);
1442                 GetProperty(ScrollView.Property.START_PAGE_POSITION).Get(temp);
1443                 return temp;
1444             }
1445             set
1446             {
1447                 SetProperty(ScrollView.Property.START_PAGE_POSITION, new Tizen.NUI.PropertyValue(value));
1448             }
1449         }
1450
1451
1452         /// <summary>
1453         /// Sets and Gets ScrollMode property.
1454         /// </summary>
1455         /// <since_tizen> 3 </since_tizen>
1456         public PropertyMap ScrollMode
1457         {
1458             get
1459             {
1460                 PropertyValue value = GetProperty( ScrollView.Property.SCROLL_MODE );
1461                 PropertyMap map = new PropertyMap();
1462                 value.Get( map );
1463                 return map;
1464             }
1465             set
1466             {
1467                 SetProperty( ScrollView.Property.SCROLL_MODE, new PropertyValue( value ) );
1468             }
1469         }
1470
1471     }
1472
1473 }