src/Tizen.NUI/src/public/BaseComponents/Scrollable.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.Binding;
  21
  22 namespace Tizen.NUI.BaseComponents
  23 {
  24     /// <summary>
  25     /// Base class for derived Scrollables that contains actors that can be scrolled manually
  26     /// (via touch) or automatically.
  27     /// </summary>
  28     /// <since_tizen> 3 </since_tizen>
  29     public class Scrollable : View
  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 OvershootEffectColorProperty = BindableProperty.Create("OvershootEffectColor", typeof(Vector4), typeof(Scrollable), Vector4.Zero, propertyChanged: (bindable, oldValue, newValue) =>
  34         {
  35             var scrollable = (Scrollable)bindable;
  36             if (newValue != null)
  37             {
  38                 Tizen.NUI.Object.SetProperty(scrollable.swigCPtr, Scrollable.Property.OVERSHOOT_EFFECT_COLOR, new Tizen.NUI.PropertyValue((Vector4)newValue));
  39             }
  40         },
  41         defaultValueCreator:(bindable) =>
  42         {
  43             var scrollable = (Scrollable)bindable;
  44             Vector4 temp = new Vector4(0.0f, 0.0f, 0.0f, 0.0f);
  45             Tizen.NUI.Object.GetProperty(scrollable.swigCPtr, Scrollable.Property.OVERSHOOT_EFFECT_COLOR).Get(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 OvershootAnimationSpeedProperty = BindableProperty.Create("OvershootAnimationSpeed", typeof(float), typeof(Scrollable), default(float), propertyChanged: (bindable, oldValue, newValue) =>
  51         {
  52             var scrollable = (Scrollable)bindable;
  53             if (newValue != null)
  54             {
  55                 Tizen.NUI.Object.SetProperty(scrollable.swigCPtr, Scrollable.Property.OVERSHOOT_ANIMATION_SPEED, new Tizen.NUI.PropertyValue((float)newValue));
  56             }
  57         },
  58         defaultValueCreator:(bindable) =>
  59         {
  60             var scrollable = (Scrollable)bindable;
  61             float temp = 0.0f;
  62             Tizen.NUI.Object.GetProperty(scrollable.swigCPtr, Scrollable.Property.OVERSHOOT_ANIMATION_SPEED).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 OvershootEnabledProperty = BindableProperty.Create("OvershootEnabled", typeof(bool), typeof(Scrollable), false, propertyChanged: (bindable, oldValue, newValue) =>
  68         {
  69             var scrollable = (Scrollable)bindable;
  70             if (newValue != null)
  71             {
  72                 Tizen.NUI.Object.SetProperty(scrollable.swigCPtr, Scrollable.Property.OVERSHOOT_ENABLED, new Tizen.NUI.PropertyValue((bool)newValue));
  73             }
  74         },
  75         defaultValueCreator:(bindable) =>
  76         {
  77             var scrollable = (Scrollable)bindable;
  78             bool temp = false;
  79             Tizen.NUI.Object.GetProperty(scrollable.swigCPtr, Scrollable.Property.OVERSHOOT_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 OvershootSizeProperty = BindableProperty.Create("OvershootSize", typeof(Vector2), typeof(Scrollable), Vector2.Zero, propertyChanged: (bindable, oldValue, newValue) =>
  85         {
  86             var scrollable = (Scrollable)bindable;
  87             if (newValue != null)
  88             {
  89                 Tizen.NUI.Object.SetProperty(scrollable.swigCPtr, Scrollable.Property.OVERSHOOT_SIZE, new Tizen.NUI.PropertyValue((Vector2)newValue));
  90             }
  91         },
  92         defaultValueCreator:(bindable) =>
  93         {
  94             var scrollable = (Scrollable)bindable;
  95             Vector2 temp = new Vector2(0.0f, 0.0f);
  96             Tizen.NUI.Object.GetProperty(scrollable.swigCPtr, Scrollable.Property.OVERSHOOT_SIZE).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 ScrollToAlphaFunctionProperty = BindableProperty.Create("ScrollToAlphaFunction", typeof(int), typeof(Scrollable), default(int), propertyChanged: (bindable, oldValue, newValue) =>
 102         {
 103             var scrollable = (Scrollable)bindable;
 104             if (newValue != null)
 105             {
 106                 Tizen.NUI.Object.SetProperty(scrollable.swigCPtr, Scrollable.Property.SCROLL_TO_ALPHA_FUNCTION, new Tizen.NUI.PropertyValue((int)newValue));
 107             }
 108         },
 109         defaultValueCreator:(bindable) =>
 110         {
 111             var scrollable = (Scrollable)bindable;
 112             int temp = 0;
 113             Tizen.NUI.Object.GetProperty(scrollable.swigCPtr, Scrollable.Property.SCROLL_TO_ALPHA_FUNCTION).Get(out 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 ScrollRelativePositionProperty = BindableProperty.Create("ScrollRelativePosition", typeof(Vector2), typeof(Scrollable), Vector2.Zero, propertyChanged: (bindable, oldValue, newValue) =>
 119         {
 120             var scrollable = (Scrollable)bindable;
 121             if (newValue != null)
 122             {
 123                 Tizen.NUI.Object.SetProperty(scrollable.swigCPtr, Scrollable.Property.SCROLL_RELATIVE_POSITION, new Tizen.NUI.PropertyValue((Vector2)newValue));
 124             }
 125         },
 126         defaultValueCreator:(bindable) =>
 127         {
 128             var scrollable = (Scrollable)bindable;
 129             Vector2 temp = new Vector2(0.0f, 0.0f);
 130             Tizen.NUI.Object.GetProperty(scrollable.swigCPtr, Scrollable.Property.SCROLL_RELATIVE_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 ScrollPositionMinProperty = BindableProperty.Create("ScrollPositionMin", typeof(Vector2), typeof(Scrollable), Vector2.Zero, propertyChanged: (bindable, oldValue, newValue) =>
 136         {
 137             var scrollable = (Scrollable)bindable;
 138             if (newValue != null)
 139             {
 140                 Tizen.NUI.Object.SetProperty(scrollable.swigCPtr, Scrollable.Property.SCROLL_POSITION_MIN, new Tizen.NUI.PropertyValue((Vector2)newValue));
 141             }
 142         },
 143         defaultValueCreator:(bindable) =>
 144         {
 145             var scrollable = (Scrollable)bindable;
 146             Vector2 temp = new Vector2(0.0f, 0.0f);
 147             Tizen.NUI.Object.GetProperty(scrollable.swigCPtr, Scrollable.Property.SCROLL_POSITION_MIN).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 ScrollPositionMaxProperty = BindableProperty.Create("ScrollPositionMax", typeof(Vector2), typeof(Scrollable), Vector2.Zero, propertyChanged: (bindable, oldValue, newValue) =>
 153         {
 154             var scrollable = (Scrollable)bindable;
 155             if (newValue != null)
 156             {
 157                 Tizen.NUI.Object.SetProperty(scrollable.swigCPtr, Scrollable.Property.SCROLL_POSITION_MAX, new Tizen.NUI.PropertyValue((Vector2)newValue));
 158             }
 159         },
 160         defaultValueCreator:(bindable) =>
 161         {
 162             var scrollable = (Scrollable)bindable;
 163             Vector2 temp = new Vector2(0.0f, 0.0f);
 164             Tizen.NUI.Object.GetProperty(scrollable.swigCPtr, Scrollable.Property.SCROLL_POSITION_MAX).Get(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 CanScrollVerticalProperty = BindableProperty.Create("CanScrollVertical", typeof(bool), typeof(Scrollable), false, propertyChanged: (bindable, oldValue, newValue) =>
 170         {
 171             var scrollable = (Scrollable)bindable;
 172             if (newValue != null)
 173             {
 174                 Tizen.NUI.Object.SetProperty(scrollable.swigCPtr, Scrollable.Property.CAN_SCROLL_VERTICAL, new Tizen.NUI.PropertyValue((bool)newValue));
 175             }
 176         },
 177         defaultValueCreator:(bindable) =>
 178         {
 179             var scrollable = (Scrollable)bindable;
 180             bool temp = false;
 181             Tizen.NUI.Object.GetProperty(scrollable.swigCPtr, Scrollable.Property.CAN_SCROLL_VERTICAL).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 CanScrollHorizontalProperty = BindableProperty.Create("CanScrollHorizontal", typeof(bool), typeof(Scrollable), false, propertyChanged: (bindable, oldValue, newValue) =>
 187         {
 188             var scrollable = (Scrollable)bindable;
 189             if (newValue != null)
 190             {
 191                 Tizen.NUI.Object.SetProperty(scrollable.swigCPtr, Scrollable.Property.CAN_SCROLL_HORIZONTAL, new Tizen.NUI.PropertyValue((bool)newValue));
 192             }
 193         },
 194         defaultValueCreator:(bindable) =>
 195         {
 196             var scrollable = (Scrollable)bindable;
 197             bool temp = false;
 198             Tizen.NUI.Object.GetProperty(scrollable.swigCPtr, Scrollable.Property.CAN_SCROLL_HORIZONTAL).Get(out temp);
 199             return temp;
 200         });
 201
 202         private global::System.Runtime.InteropServices.HandleRef swigCPtr;
 203
 204         internal Scrollable(global::System.IntPtr cPtr, bool cMemoryOwn) : base(NDalicPINVOKE.Scrollable_SWIGUpcast(cPtr), cMemoryOwn)
 205         {
 206             swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
 207         }
 208
 209         internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Scrollable obj)
 210         {
 211             return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
 212         }
 213
 214         /// <summary>
 215         /// you can override it to clean-up your own resources.
 216         /// </summary>
 217         /// <param name="type">DisposeTypes</param>
 218         /// <since_tizen> 3 </since_tizen>
 219         protected override void Dispose(DisposeTypes type)
 220         {
 221             if (disposed)
 222             {
 223                 return;
 224             }
 225
 226             if (type == DisposeTypes.Explicit)
 227             {
 228                 //Called by User
 229                 //Release your own managed resources here.
 230                 //You should release all of your own disposable objects here.
 231
 232             }
 233
 234             //Release your own unmanaged resources here.
 235             //You should not access any managed member here except static instance.
 236             //because the execution order of Finalizes is non-deterministic.
 237             if (this != null)
 238             {
 239                 DisConnectFromSignals();
 240             }
 241
 242             if (swigCPtr.Handle != global::System.IntPtr.Zero)
 243             {
 244                 if (swigCMemOwn)
 245                 {
 246                     swigCMemOwn = false;
 247                     NDalicPINVOKE.delete_Scrollable(swigCPtr);
 248                 }
 249                 swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
 250             }
 251
 252             base.Dispose(type);
 253         }
 254
 255         private void DisConnectFromSignals()
 256         {
 257             // Save current CPtr.
 258             global::System.Runtime.InteropServices.HandleRef currentCPtr = swigCPtr;
 259
 260             // Use BaseHandle CPtr as current might have been deleted already in derived classes.
 261             swigCPtr = GetBaseHandleCPtrHandleRef;
 262
 263             if (_scrollableCompletedCallbackDelegate != null)
 264             {
 265                 this.ScrollCompletedSignal().Disconnect(_scrollableCompletedCallbackDelegate);
 266             }
 267
 268             if (_scrollableUpdatedCallbackDelegate != null)
 269             {
 270                 this.ScrollUpdatedSignal().Disconnect(_scrollableUpdatedCallbackDelegate);
 271             }
 272
 273             if (_scrollableStartedCallbackDelegate != null)
 274             {
 275                 this.ScrollStartedSignal().Disconnect(_scrollableStartedCallbackDelegate);
 276             }
 277
 278             // BaseHandle CPtr is used in Registry and there is danger of deletion if we keep using it here.
 279             // Restore current CPtr.
 280             swigCPtr = currentCPtr;
 281         }
 282
 283         /// <summary>
 284         /// The scroll animation started event arguments.
 285         /// </summary>
 286         /// <since_tizen> 3 </since_tizen>
 287         public class StartedEventArgs : EventArgs
 288         {
 289             private Vector2 _vector2;
 290
 291             /// <summary>
 292             /// Vector2.
 293             /// </summary>
 294             /// <since_tizen> 3 </since_tizen>
 295             public Vector2 Vector2
 296             {
 297                 get
 298                 {
 299                     return _vector2;
 300                 }
 301                 set
 302                 {
 303                     _vector2 = value;
 304                 }
 305             }
 306         }
 307
 308         /// <summary>
 309         /// The scrollable updated event arguments.
 310         /// </summary>
 311         /// <since_tizen> 3 </since_tizen>
 312         public class UpdatedEventArgs : EventArgs
 313         {
 314             private Vector2 _vector2;
 315
 316             /// <summary>
 317             /// Vector2.
 318             /// </summary>
 319             /// <since_tizen> 3 </since_tizen>
 320             public Vector2 Vector2
 321             {
 322                 get
 323                 {
 324                     return _vector2;
 325                 }
 326                 set
 327                 {
 328                     _vector2 = value;
 329                 }
 330             }
 331         }
 332
 333         /// <summary>
 334         /// The scroll animation completed event arguments.
 335         /// </summary>
 336         /// <since_tizen> 3 </since_tizen>
 337         public class CompletedEventArgs : EventArgs
 338         {
 339             private Vector2 _vector2;
 340
 341             /// <summary>
 342             /// Vector2.
 343             /// </summary>
 344             /// <since_tizen> 3 </since_tizen>
 345             public Vector2 Vector2
 346             {
 347                 get
 348                 {
 349                     return _vector2;
 350                 }
 351                 set
 352                 {
 353                     _vector2 = value;
 354                 }
 355             }
 356         }
 357
 358         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 359         private delegate void StartedCallbackDelegate(IntPtr vector2);
 360         private DaliEventHandler<object, StartedEventArgs> _scrollableStartedEventHandler;
 361         private StartedCallbackDelegate _scrollableStartedCallbackDelegate;
 362
 363         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 364         private delegate void UpdatedCallbackDelegate(IntPtr vector2);
 365         private DaliEventHandler<object, UpdatedEventArgs> _scrollableUpdatedEventHandler;
 366         private UpdatedCallbackDelegate _scrollableUpdatedCallbackDelegate;
 367
 368         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 369         private delegate void CompletedCallbackDelegate(IntPtr vector2);
 370         private DaliEventHandler<object, CompletedEventArgs> _scrollableCompletedEventHandler;
 371         private CompletedCallbackDelegate _scrollableCompletedCallbackDelegate;
 372
 373         /// <summary>
 374         /// The ScrollStarted event emitted when the Scrollable has moved (whether by touch or animation).
 375         /// </summary>
 376         /// <since_tizen> 3 </since_tizen>
 377         public event DaliEventHandler<object, StartedEventArgs> ScrollStarted
 378         {
 379             add
 380             {
 381                 lock (this)
 382                 {
 383                     // Restricted to only one listener
 384                     if (_scrollableStartedEventHandler == null)
 385                     {
 386                         _scrollableStartedEventHandler += value;
 387
 388                         _scrollableStartedCallbackDelegate = new StartedCallbackDelegate(OnStarted);
 389                         this.ScrollStartedSignal().Connect(_scrollableStartedCallbackDelegate);
 390                     }
 391                 }
 392             }
 393
 394             remove
 395             {
 396                 lock (this)
 397                 {
 398                     if (_scrollableStartedEventHandler != null)
 399                     {
 400                         this.ScrollStartedSignal().Disconnect(_scrollableStartedCallbackDelegate);
 401                     }
 402
 403                     _scrollableStartedEventHandler -= value;
 404                 }
 405             }
 406         }
 407
 408         private void OnStarted(IntPtr vector2)
 409         {
 410             StartedEventArgs e = new StartedEventArgs();
 411
 412             // Populate all members of "e" (StartedEventArgs) with real data
 413             e.Vector2 = Tizen.NUI.Vector2.GetVector2FromPtr(vector2);
 414
 415             if (_scrollableStartedEventHandler != null)
 416             {
 417                 //here we send all data to user event handlers
 418                 _scrollableStartedEventHandler(this, e);
 419             }
 420
 421         }
 422
 423         /// <summary>
 424         /// The ScrollUpdated event emitted when the Scrollable has moved (whether by touch or animation).
 425         /// </summary>
 426         /// <since_tizen> 3 </since_tizen>
 427         public event DaliEventHandler<object, UpdatedEventArgs> ScrollUpdated
 428         {
 429             add
 430             {
 431                 lock (this)
 432                 {
 433                     // Restricted to only one listener
 434                     if (_scrollableUpdatedEventHandler == null)
 435                     {
 436                         _scrollableUpdatedEventHandler += value;
 437
 438                         _scrollableUpdatedCallbackDelegate = new UpdatedCallbackDelegate(OnUpdated);
 439                         this.ScrollUpdatedSignal().Connect(_scrollableUpdatedCallbackDelegate);
 440                     }
 441                 }
 442             }
 443
 444             remove
 445             {
 446                 lock (this)
 447                 {
 448                     if (_scrollableUpdatedEventHandler != null)
 449                     {
 450                         this.ScrollUpdatedSignal().Disconnect(_scrollableUpdatedCallbackDelegate);
 451                     }
 452
 453                     _scrollableUpdatedEventHandler -= value;
 454                 }
 455             }
 456         }
 457
 458         private void OnUpdated(IntPtr vector2)
 459         {
 460             UpdatedEventArgs e = new UpdatedEventArgs();
 461
 462             // Populate all members of "e" (UpdatedEventArgs) with real data
 463             e.Vector2 = Tizen.NUI.Vector2.GetVector2FromPtr(vector2);
 464
 465             if (_scrollableUpdatedEventHandler != null)
 466             {
 467                 //here we send all data to user event handlers
 468                 _scrollableUpdatedEventHandler(this, e);
 469             }
 470
 471         }
 472
 473         /// <summary>
 474         /// The ScrollCompleted event emitted when the Scrollable has completed movement
 475         /// (whether by touch or animation).
 476         /// </summary>
 477         /// <since_tizen> 3 </since_tizen>
 478         public event DaliEventHandler<object, CompletedEventArgs> ScrollCompleted
 479         {
 480             add
 481             {
 482                 lock (this)
 483                 {
 484                     // Restricted to only one listener
 485                     if (_scrollableCompletedEventHandler == null)
 486                     {
 487                         _scrollableCompletedEventHandler += value;
 488
 489                         _scrollableCompletedCallbackDelegate = new CompletedCallbackDelegate(OnCompleted);
 490                         this.ScrollCompletedSignal().Connect(_scrollableCompletedCallbackDelegate);
 491                     }
 492                 }
 493             }
 494
 495             remove
 496             {
 497                 lock (this)
 498                 {
 499                     if (_scrollableCompletedEventHandler != null)
 500                     {
 501                         this.ScrollCompletedSignal().Disconnect(_scrollableCompletedCallbackDelegate);
 502                     }
 503
 504                     _scrollableCompletedEventHandler -= value;
 505                 }
 506             }
 507         }
 508
 509         private void OnCompleted(IntPtr vector2)
 510         {
 511             CompletedEventArgs e = new CompletedEventArgs();
 512
 513             // Populate all members of "e" (CompletedEventArgs) with real data
 514             e.Vector2 = Tizen.NUI.Vector2.GetVector2FromPtr(vector2);
 515
 516             if (_scrollableCompletedEventHandler != null)
 517             {
 518                 //here we send all data to user event handlers
 519                 _scrollableCompletedEventHandler(this, e);
 520             }
 521
 522         }
 523
 524         /// <summary>
 525         /// Enumeration for the instance of properties belonging to the Scrollable class.
 526         /// </summary>
 527         /// <since_tizen> 3 </since_tizen>
 528         public new class Property
 529         {
 530             /// <summary>
 531             /// The color of the overshoot effect.
 532             /// </summary>
 533             /// <since_tizen> 3 </since_tizen>
 534             public static readonly int OVERSHOOT_EFFECT_COLOR = NDalicPINVOKE.Scrollable_Property_OVERSHOOT_EFFECT_COLOR_get();
 535             /// <summary>
 536             /// The speed of overshoot animation in pixels per second.
 537             /// </summary>
 538             /// <since_tizen> 3 </since_tizen>
 539             public static readonly int OVERSHOOT_ANIMATION_SPEED = NDalicPINVOKE.Scrollable_Property_OVERSHOOT_ANIMATION_SPEED_get();
 540             /// <summary>
 541             /// Whether to enables or disable scroll overshoot.
 542             /// </summary>
 543             /// <since_tizen> 3 </since_tizen>
 544             public static readonly int OVERSHOOT_ENABLED = NDalicPINVOKE.Scrollable_Property_OVERSHOOT_ENABLED_get();
 545             /// <summary>
 546             /// The size of the overshoot.
 547             /// </summary>
 548             /// <since_tizen> 3 </since_tizen>
 549             public static readonly int OVERSHOOT_SIZE = NDalicPINVOKE.Scrollable_Property_OVERSHOOT_SIZE_get();
 550             /// <summary>
 551             /// scrollToAlphaFunction.
 552             /// </summary>
 553             /// <since_tizen> 3 </since_tizen>
 554             public static readonly int SCROLL_TO_ALPHA_FUNCTION = NDalicPINVOKE.Scrollable_Property_SCROLL_TO_ALPHA_FUNCTION_get();
 555             /// <summary>
 556             /// scrollRelativePosition
 557             /// </summary>
 558             /// <since_tizen> 3 </since_tizen>
 559             public static readonly int SCROLL_RELATIVE_POSITION = NDalicPINVOKE.Scrollable_Property_SCROLL_RELATIVE_POSITION_get();
 560             /// <summary>
 561             /// scrollPositionMin
 562             /// </summary>
 563             /// <since_tizen> 3 </since_tizen>
 564             public static readonly int SCROLL_POSITION_MIN = NDalicPINVOKE.Scrollable_Property_SCROLL_POSITION_MIN_get();
 565             /// <summary>
 566             /// scrollPositionMinX.
 567             /// </summary>
 568             /// <since_tizen> 3 </since_tizen>
 569             public static readonly int SCROLL_POSITION_MIN_X = NDalicPINVOKE.Scrollable_Property_SCROLL_POSITION_MIN_X_get();
 570             /// <summary>
 571             /// scrollPositionMinY.
 572             /// </summary>
 573             /// <since_tizen> 3 </since_tizen>
 574             public static readonly int SCROLL_POSITION_MIN_Y = NDalicPINVOKE.Scrollable_Property_SCROLL_POSITION_MIN_Y_get();
 575             /// <summary>
 576             /// scrollPositionMax.
 577             /// </summary>
 578             /// <since_tizen> 3 </since_tizen>
 579             public static readonly int SCROLL_POSITION_MAX = NDalicPINVOKE.Scrollable_Property_SCROLL_POSITION_MAX_get();
 580             /// <summary>
 581             /// scrollPositionMaxX.
 582             /// </summary>
 583             /// <since_tizen> 3 </since_tizen>
 584             public static readonly int SCROLL_POSITION_MAX_X = NDalicPINVOKE.Scrollable_Property_SCROLL_POSITION_MAX_X_get();
 585             /// <summary>
 586             /// scrollPositionMaxY.
 587             /// </summary>
 588             /// <since_tizen> 3 </since_tizen>
 589             public static readonly int SCROLL_POSITION_MAX_Y = NDalicPINVOKE.Scrollable_Property_SCROLL_POSITION_MAX_Y_get();
 590             /// <summary>
 591             /// canScrollVertical
 592             /// </summary>
 593             /// <since_tizen> 3 </since_tizen>
 594             public static readonly int CAN_SCROLL_VERTICAL = NDalicPINVOKE.Scrollable_Property_CAN_SCROLL_VERTICAL_get();
 595             /// <summary>
 596             /// canScrollHorizontal.
 597             /// </summary>
 598             /// <since_tizen> 3 </since_tizen>
 599             public static readonly int CAN_SCROLL_HORIZONTAL = NDalicPINVOKE.Scrollable_Property_CAN_SCROLL_HORIZONTAL_get();
 600
 601         }
 602
 603         /// <summary>
 604         /// Create an instance of scrollable.
 605         /// </summary>
 606         /// <since_tizen> 3 </since_tizen>
 607         public Scrollable() : this(NDalicPINVOKE.new_Scrollable__SWIG_0(), true)
 608         {
 609             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 610         }
 611
 612         private bool IsOvershootEnabled()
 613         {
 614             bool ret = NDalicPINVOKE.Scrollable_IsOvershootEnabled(swigCPtr);
 615             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 616             return ret;
 617         }
 618
 619         private void SetOvershootEnabled(bool enable)
 620         {
 621             NDalicPINVOKE.Scrollable_SetOvershootEnabled(swigCPtr, enable);
 622             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 623         }
 624
 625         private void SetOvershootEffectColor(Vector4 color)
 626         {
 627             NDalicPINVOKE.Scrollable_SetOvershootEffectColor(swigCPtr, Vector4.getCPtr(color));
 628             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 629         }
 630
 631         private Vector4 GetOvershootEffectColor()
 632         {
 633             Vector4 ret = new Vector4(NDalicPINVOKE.Scrollable_GetOvershootEffectColor(swigCPtr), true);
 634             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 635             return ret;
 636         }
 637
 638         private void SetOvershootAnimationSpeed(float pixelsPerSecond)
 639         {
 640             NDalicPINVOKE.Scrollable_SetOvershootAnimationSpeed(swigCPtr, pixelsPerSecond);
 641             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 642         }
 643
 644         private float GetOvershootAnimationSpeed()
 645         {
 646             float ret = NDalicPINVOKE.Scrollable_GetOvershootAnimationSpeed(swigCPtr);
 647             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 648             return ret;
 649         }
 650
 651         internal ScrollableSignal ScrollStartedSignal()
 652         {
 653             ScrollableSignal ret = new ScrollableSignal(NDalicPINVOKE.Scrollable_ScrollStartedSignal(swigCPtr), false);
 654             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 655             return ret;
 656         }
 657
 658         internal ScrollableSignal ScrollUpdatedSignal()
 659         {
 660             ScrollableSignal ret = new ScrollableSignal(NDalicPINVOKE.Scrollable_ScrollUpdatedSignal(swigCPtr), false);
 661             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 662             return ret;
 663         }
 664
 665         internal ScrollableSignal ScrollCompletedSignal()
 666         {
 667             ScrollableSignal ret = new ScrollableSignal(NDalicPINVOKE.Scrollable_ScrollCompletedSignal(swigCPtr), false);
 668             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 669             return ret;
 670         }
 671
 672         /// <summary>
 673         /// Sets and Gets the color of the overshoot effect.
 674         /// </summary>
 675         /// <since_tizen> 3 </since_tizen>
 676         public Vector4 OvershootEffectColor
 677         {
 678             get
 679             {
 680                 return (Vector4)GetValue(OvershootEffectColorProperty);
 681             }
 682             set
 683             {
 684                 SetValue(OvershootEffectColorProperty, value);
 685                 NotifyPropertyChanged();
 686             }
 687         }
 688
 689         /// <summary>
 690         /// Sets and Gets the speed of overshoot animation in pixels per second.
 691         /// </summary>
 692         /// <since_tizen> 3 </since_tizen>
 693         public float OvershootAnimationSpeed
 694         {
 695             get
 696             {
 697                 return (float)GetValue(OvershootAnimationSpeedProperty);
 698             }
 699             set
 700             {
 701                 SetValue(OvershootAnimationSpeedProperty, value);
 702                 NotifyPropertyChanged();
 703             }
 704         }
 705
 706         /// <summary>
 707         /// Checks if scroll overshoot has been enabled or not.
 708         /// </summary>
 709         /// <since_tizen> 3 </since_tizen>
 710         public bool OvershootEnabled
 711         {
 712             get
 713             {
 714                 return (bool)GetValue(OvershootEnabledProperty);
 715             }
 716             set
 717             {
 718                 SetValue(OvershootEnabledProperty, value);
 719                 NotifyPropertyChanged();
 720             }
 721         }
 722
 723         /// <summary>
 724         /// Gets and Sets OvershootSize property.
 725         /// </summary>
 726         /// <since_tizen> 3 </since_tizen>
 727         public Vector2 OvershootSize
 728         {
 729             get
 730             {
 731                 return (Vector2)GetValue(OvershootSizeProperty);
 732             }
 733             set
 734             {
 735                 SetValue(OvershootSizeProperty, value);
 736                 NotifyPropertyChanged();
 737             }
 738         }
 739
 740         /// <summary>
 741         /// Gets and Sets ScrollToAlphaFunction property.
 742         /// </summary>
 743         /// <since_tizen> 3 </since_tizen>
 744         public int ScrollToAlphaFunction
 745         {
 746             get
 747             {
 748                 return (int)GetValue(ScrollToAlphaFunctionProperty);
 749             }
 750             set
 751             {
 752                 SetValue(ScrollToAlphaFunctionProperty, value);
 753                 NotifyPropertyChanged();
 754             }
 755         }
 756
 757         /// <summary>
 758         /// Gets and Sets ScrollRelativePosition property.
 759         /// </summary>
 760         /// <since_tizen> 3 </since_tizen>
 761         public Vector2 ScrollRelativePosition
 762         {
 763             get
 764             {
 765                 return (Vector2)GetValue(ScrollRelativePositionProperty);
 766             }
 767             set
 768             {
 769                 SetValue(ScrollRelativePositionProperty, value);
 770                 NotifyPropertyChanged();
 771             }
 772         }
 773
 774         /// <summary>
 775         /// Gets and Sets ScrollPositionMin property.
 776         /// </summary>
 777         /// <since_tizen> 3 </since_tizen>
 778         public Vector2 ScrollPositionMin
 779         {
 780             get
 781             {
 782                 return (Vector2)GetValue(ScrollPositionMinProperty);
 783             }
 784             set
 785             {
 786                 SetValue(ScrollPositionMinProperty, value);
 787                 NotifyPropertyChanged();
 788             }
 789         }
 790
 791         /// <summary>
 792         /// Gets and Sets ScrollPositionMax property.
 793         /// </summary>
 794         /// <since_tizen> 3 </since_tizen>
 795         public Vector2 ScrollPositionMax
 796         {
 797             get
 798             {
 799                 return (Vector2)GetValue(ScrollPositionMaxProperty);
 800             }
 801             set
 802             {
 803                 SetValue(ScrollPositionMaxProperty, value);
 804                 NotifyPropertyChanged();
 805             }
 806         }
 807
 808         /// <summary>
 809         /// Gets and Sets CanScrollVertical property.
 810         /// </summary>
 811         /// <since_tizen> 3 </since_tizen>
 812         public bool CanScrollVertical
 813         {
 814             get
 815             {
 816                 return (bool)GetValue(CanScrollVerticalProperty);
 817             }
 818             set
 819             {
 820                 SetValue(CanScrollVerticalProperty, value);
 821                 NotifyPropertyChanged();
 822             }
 823         }
 824
 825         /// <summary>
 826         /// Gets and Sets CanScrollHorizontal property.
 827         /// </summary>
 828         /// <since_tizen> 3 </since_tizen>
 829         public bool CanScrollHorizontal
 830         {
 831             get
 832             {
 833                 return (bool)GetValue(CanScrollHorizontalProperty);
 834             }
 835             set
 836             {
 837                 SetValue(CanScrollHorizontalProperty, value);
 838                 NotifyPropertyChanged();
 839             }
 840         }
 841
 842     }
 843
 844 }