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