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

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