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
  18 namespace Tizen.NUI.BaseComponents
  19 {
  20
  21     using System;
  22     using System.Runtime.InteropServices;
  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         private global::System.Runtime.InteropServices.HandleRef swigCPtr;
  32
  33         internal Scrollable(global::System.IntPtr cPtr, bool cMemoryOwn) : base(NDalicPINVOKE.Scrollable_SWIGUpcast(cPtr), cMemoryOwn)
  34         {
  35             swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
  36         }
  37
  38         internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Scrollable obj)
  39         {
  40             return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
  41         }
  42
  43         /// <summary>
  44         /// you can override it to clean-up your own resources.
  45         /// </summary>
  46         /// <param name="type">DisposeTypes</param>
  47         /// <since_tizen> 3 </since_tizen>
  48         protected override void Dispose(DisposeTypes type)
  49         {
  50             if (disposed)
  51             {
  52                 return;
  53             }
  54
  55             if (type == DisposeTypes.Explicit)
  56             {
  57                 //Called by User
  58                 //Release your own managed resources here.
  59                 //You should release all of your own disposable objects here.
  60
  61             }
  62
  63             //Release your own unmanaged resources here.
  64             //You should not access any managed member here except static instance.
  65             //because the execution order of Finalizes is non-deterministic.
  66             if (this != null)
  67             {
  68                 DisConnectFromSignals();
  69             }
  70
  71             if (swigCPtr.Handle != global::System.IntPtr.Zero)
  72             {
  73                 if (swigCMemOwn)
  74                 {
  75                     swigCMemOwn = false;
  76                     NDalicPINVOKE.delete_Scrollable(swigCPtr);
  77                 }
  78                 swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
  79             }
  80
  81             base.Dispose(type);
  82         }
  83
  84         private void DisConnectFromSignals()
  85         {
  86             // Save current CPtr.
  87             global::System.Runtime.InteropServices.HandleRef currentCPtr = swigCPtr;
  88
  89             // Use BaseHandle CPtr as current might have been deleted already in derived classes.
  90             swigCPtr = GetBaseHandleCPtrHandleRef;
  91
  92             if (_scrollableCompletedCallbackDelegate != null)
  93             {
  94                 this.ScrollCompletedSignal().Disconnect(_scrollableCompletedCallbackDelegate);
  95             }
  96
  97             if (_scrollableUpdatedCallbackDelegate != null)
  98             {
  99                 this.ScrollUpdatedSignal().Disconnect(_scrollableUpdatedCallbackDelegate);
 100             }
 101
 102             if (_scrollableStartedCallbackDelegate != null)
 103             {
 104                 this.ScrollStartedSignal().Disconnect(_scrollableStartedCallbackDelegate);
 105             }
 106
 107             // BaseHandle CPtr is used in Registry and there is danger of deletion if we keep using it here.
 108             // Restore current CPtr.
 109             swigCPtr = currentCPtr;
 110         }
 111
 112         /// <summary>
 113         /// The scroll animation started event arguments.
 114         /// </summary>
 115         /// <since_tizen> 3 </since_tizen>
 116         public class StartedEventArgs : EventArgs
 117         {
 118             private Vector2 _vector2;
 119
 120             /// <summary>
 121             /// Vector2.
 122             /// </summary>
 123             /// <since_tizen> 3 </since_tizen>
 124             public Vector2 Vector2
 125             {
 126                 get
 127                 {
 128                     return _vector2;
 129                 }
 130                 set
 131                 {
 132                     _vector2 = value;
 133                 }
 134             }
 135         }
 136
 137         /// <summary>
 138         /// The scrollable updated event arguments.
 139         /// </summary>
 140         /// <since_tizen> 3 </since_tizen>
 141         public class UpdatedEventArgs : EventArgs
 142         {
 143             private Vector2 _vector2;
 144
 145             /// <summary>
 146             /// Vector2.
 147             /// </summary>
 148             /// <since_tizen> 3 </since_tizen>
 149             public Vector2 Vector2
 150             {
 151                 get
 152                 {
 153                     return _vector2;
 154                 }
 155                 set
 156                 {
 157                     _vector2 = value;
 158                 }
 159             }
 160         }
 161
 162         /// <summary>
 163         /// The scroll animation completed event arguments.
 164         /// </summary>
 165         /// <since_tizen> 3 </since_tizen>
 166         public class CompletedEventArgs : EventArgs
 167         {
 168             private Vector2 _vector2;
 169
 170             /// <summary>
 171             /// Vector2.
 172             /// </summary>
 173             /// <since_tizen> 3 </since_tizen>
 174             public Vector2 Vector2
 175             {
 176                 get
 177                 {
 178                     return _vector2;
 179                 }
 180                 set
 181                 {
 182                     _vector2 = value;
 183                 }
 184             }
 185         }
 186
 187         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 188         private delegate void StartedCallbackDelegate(IntPtr vector2);
 189         private DaliEventHandler<object, StartedEventArgs> _scrollableStartedEventHandler;
 190         private StartedCallbackDelegate _scrollableStartedCallbackDelegate;
 191
 192         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 193         private delegate void UpdatedCallbackDelegate(IntPtr vector2);
 194         private DaliEventHandler<object, UpdatedEventArgs> _scrollableUpdatedEventHandler;
 195         private UpdatedCallbackDelegate _scrollableUpdatedCallbackDelegate;
 196
 197         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 198         private delegate void CompletedCallbackDelegate(IntPtr vector2);
 199         private DaliEventHandler<object, CompletedEventArgs> _scrollableCompletedEventHandler;
 200         private CompletedCallbackDelegate _scrollableCompletedCallbackDelegate;
 201
 202         /// <summary>
 203         /// The ScrollStarted event emitted when the Scrollable has moved (whether by touch or animation).
 204         /// </summary>
 205         /// <since_tizen> 3 </since_tizen>
 206         public event DaliEventHandler<object, StartedEventArgs> ScrollStarted
 207         {
 208             add
 209             {
 210                 lock (this)
 211                 {
 212                     // Restricted to only one listener
 213                     if (_scrollableStartedEventHandler == null)
 214                     {
 215                         _scrollableStartedEventHandler += value;
 216
 217                         _scrollableStartedCallbackDelegate = new StartedCallbackDelegate(OnStarted);
 218                         this.ScrollStartedSignal().Connect(_scrollableStartedCallbackDelegate);
 219                     }
 220                 }
 221             }
 222
 223             remove
 224             {
 225                 lock (this)
 226                 {
 227                     if (_scrollableStartedEventHandler != null)
 228                     {
 229                         this.ScrollStartedSignal().Disconnect(_scrollableStartedCallbackDelegate);
 230                     }
 231
 232                     _scrollableStartedEventHandler -= value;
 233                 }
 234             }
 235         }
 236
 237         private void OnStarted(IntPtr vector2)
 238         {
 239             StartedEventArgs e = new StartedEventArgs();
 240
 241             // Populate all members of "e" (StartedEventArgs) with real data
 242             e.Vector2 = Tizen.NUI.Vector2.GetVector2FromPtr(vector2);
 243
 244             if (_scrollableStartedEventHandler != null)
 245             {
 246                 //here we send all data to user event handlers
 247                 _scrollableStartedEventHandler(this, e);
 248             }
 249
 250         }
 251
 252         /// <summary>
 253         /// The ScrollUpdated event emitted when the Scrollable has moved (whether by touch or animation).
 254         /// </summary>
 255         /// <since_tizen> 3 </since_tizen>
 256         public event DaliEventHandler<object, UpdatedEventArgs> ScrollUpdated
 257         {
 258             add
 259             {
 260                 lock (this)
 261                 {
 262                     // Restricted to only one listener
 263                     if (_scrollableUpdatedEventHandler == null)
 264                     {
 265                         _scrollableUpdatedEventHandler += value;
 266
 267                         _scrollableUpdatedCallbackDelegate = new UpdatedCallbackDelegate(OnUpdated);
 268                         this.ScrollUpdatedSignal().Connect(_scrollableUpdatedCallbackDelegate);
 269                     }
 270                 }
 271             }
 272
 273             remove
 274             {
 275                 lock (this)
 276                 {
 277                     if (_scrollableUpdatedEventHandler != null)
 278                     {
 279                         this.ScrollUpdatedSignal().Disconnect(_scrollableUpdatedCallbackDelegate);
 280                     }
 281
 282                     _scrollableUpdatedEventHandler -= value;
 283                 }
 284             }
 285         }
 286
 287         private void OnUpdated(IntPtr vector2)
 288         {
 289             UpdatedEventArgs e = new UpdatedEventArgs();
 290
 291             // Populate all members of "e" (UpdatedEventArgs) with real data
 292             e.Vector2 = Tizen.NUI.Vector2.GetVector2FromPtr(vector2);
 293
 294             if (_scrollableUpdatedEventHandler != null)
 295             {
 296                 //here we send all data to user event handlers
 297                 _scrollableUpdatedEventHandler(this, e);
 298             }
 299
 300         }
 301
 302         /// <summary>
 303         /// The ScrollCompleted event emitted when the Scrollable has completed movement
 304         /// (whether by touch or animation).
 305         /// </summary>
 306         /// <since_tizen> 3 </since_tizen>
 307         public event DaliEventHandler<object, CompletedEventArgs> ScrollCompleted
 308         {
 309             add
 310             {
 311                 lock (this)
 312                 {
 313                     // Restricted to only one listener
 314                     if (_scrollableCompletedEventHandler == null)
 315                     {
 316                         _scrollableCompletedEventHandler += value;
 317
 318                         _scrollableCompletedCallbackDelegate = new CompletedCallbackDelegate(OnCompleted);
 319                         this.ScrollCompletedSignal().Connect(_scrollableCompletedCallbackDelegate);
 320                     }
 321                 }
 322             }
 323
 324             remove
 325             {
 326                 lock (this)
 327                 {
 328                     if (_scrollableCompletedEventHandler != null)
 329                     {
 330                         this.ScrollCompletedSignal().Disconnect(_scrollableCompletedCallbackDelegate);
 331                     }
 332
 333                     _scrollableCompletedEventHandler -= value;
 334                 }
 335             }
 336         }
 337
 338         private void OnCompleted(IntPtr vector2)
 339         {
 340             CompletedEventArgs e = new CompletedEventArgs();
 341
 342             // Populate all members of "e" (CompletedEventArgs) with real data
 343             e.Vector2 = Tizen.NUI.Vector2.GetVector2FromPtr(vector2);
 344
 345             if (_scrollableCompletedEventHandler != null)
 346             {
 347                 //here we send all data to user event handlers
 348                 _scrollableCompletedEventHandler(this, e);
 349             }
 350
 351         }
 352
 353         /// <summary>
 354         /// Enumeration for the instance of properties belonging to the Scrollable class.
 355         /// </summary>
 356         /// <since_tizen> 3 </since_tizen>
 357         public new class Property
 358         {
 359             /// <summary>
 360             /// The color of the overshoot effect.
 361             /// </summary>
 362             /// <since_tizen> 3 </since_tizen>
 363             public static readonly int OVERSHOOT_EFFECT_COLOR = NDalicPINVOKE.Scrollable_Property_OVERSHOOT_EFFECT_COLOR_get();
 364             /// <summary>
 365             /// The speed of overshoot animation in pixels per second.
 366             /// </summary>
 367             /// <since_tizen> 3 </since_tizen>
 368             public static readonly int OVERSHOOT_ANIMATION_SPEED = NDalicPINVOKE.Scrollable_Property_OVERSHOOT_ANIMATION_SPEED_get();
 369             /// <summary>
 370             /// Whether to enables or disable scroll overshoot.
 371             /// </summary>
 372             /// <since_tizen> 3 </since_tizen>
 373             public static readonly int OVERSHOOT_ENABLED = NDalicPINVOKE.Scrollable_Property_OVERSHOOT_ENABLED_get();
 374             /// <summary>
 375             /// The size of the overshoot.
 376             /// </summary>
 377             /// <since_tizen> 3 </since_tizen>
 378             public static readonly int OVERSHOOT_SIZE = NDalicPINVOKE.Scrollable_Property_OVERSHOOT_SIZE_get();
 379             /// <summary>
 380             /// scrollToAlphaFunction.
 381             /// </summary>
 382             /// <since_tizen> 3 </since_tizen>
 383             public static readonly int SCROLL_TO_ALPHA_FUNCTION = NDalicPINVOKE.Scrollable_Property_SCROLL_TO_ALPHA_FUNCTION_get();
 384             /// <summary>
 385             /// scrollRelativePosition
 386             /// </summary>
 387             /// <since_tizen> 3 </since_tizen>
 388             public static readonly int SCROLL_RELATIVE_POSITION = NDalicPINVOKE.Scrollable_Property_SCROLL_RELATIVE_POSITION_get();
 389             /// <summary>
 390             /// scrollPositionMin
 391             /// </summary>
 392             /// <since_tizen> 3 </since_tizen>
 393             public static readonly int SCROLL_POSITION_MIN = NDalicPINVOKE.Scrollable_Property_SCROLL_POSITION_MIN_get();
 394             /// <summary>
 395             /// scrollPositionMinX.
 396             /// </summary>
 397             /// <since_tizen> 3 </since_tizen>
 398             public static readonly int SCROLL_POSITION_MIN_X = NDalicPINVOKE.Scrollable_Property_SCROLL_POSITION_MIN_X_get();
 399             /// <summary>
 400             /// scrollPositionMinY.
 401             /// </summary>
 402             /// <since_tizen> 3 </since_tizen>
 403             public static readonly int SCROLL_POSITION_MIN_Y = NDalicPINVOKE.Scrollable_Property_SCROLL_POSITION_MIN_Y_get();
 404             /// <summary>
 405             /// scrollPositionMax.
 406             /// </summary>
 407             /// <since_tizen> 3 </since_tizen>
 408             public static readonly int SCROLL_POSITION_MAX = NDalicPINVOKE.Scrollable_Property_SCROLL_POSITION_MAX_get();
 409             /// <summary>
 410             /// scrollPositionMaxX.
 411             /// </summary>
 412             /// <since_tizen> 3 </since_tizen>
 413             public static readonly int SCROLL_POSITION_MAX_X = NDalicPINVOKE.Scrollable_Property_SCROLL_POSITION_MAX_X_get();
 414             /// <summary>
 415             /// scrollPositionMaxY.
 416             /// </summary>
 417             /// <since_tizen> 3 </since_tizen>
 418             public static readonly int SCROLL_POSITION_MAX_Y = NDalicPINVOKE.Scrollable_Property_SCROLL_POSITION_MAX_Y_get();
 419             /// <summary>
 420             /// canScrollVertical
 421             /// </summary>
 422             /// <since_tizen> 3 </since_tizen>
 423             public static readonly int CAN_SCROLL_VERTICAL = NDalicPINVOKE.Scrollable_Property_CAN_SCROLL_VERTICAL_get();
 424             /// <summary>
 425             /// canScrollHorizontal.
 426             /// </summary>
 427             /// <since_tizen> 3 </since_tizen>
 428             public static readonly int CAN_SCROLL_HORIZONTAL = NDalicPINVOKE.Scrollable_Property_CAN_SCROLL_HORIZONTAL_get();
 429
 430         }
 431
 432         /// <summary>
 433         /// Create an instance of scrollable.
 434         /// </summary>
 435         /// <since_tizen> 3 </since_tizen>
 436         public Scrollable() : this(NDalicPINVOKE.new_Scrollable__SWIG_0(), true)
 437         {
 438             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 439         }
 440
 441         private bool IsOvershootEnabled()
 442         {
 443             bool ret = NDalicPINVOKE.Scrollable_IsOvershootEnabled(swigCPtr);
 444             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 445             return ret;
 446         }
 447
 448         private void SetOvershootEnabled(bool enable)
 449         {
 450             NDalicPINVOKE.Scrollable_SetOvershootEnabled(swigCPtr, enable);
 451             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 452         }
 453
 454         private void SetOvershootEffectColor(Vector4 color)
 455         {
 456             NDalicPINVOKE.Scrollable_SetOvershootEffectColor(swigCPtr, Vector4.getCPtr(color));
 457             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 458         }
 459
 460         private Vector4 GetOvershootEffectColor()
 461         {
 462             Vector4 ret = new Vector4(NDalicPINVOKE.Scrollable_GetOvershootEffectColor(swigCPtr), true);
 463             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 464             return ret;
 465         }
 466
 467         private void SetOvershootAnimationSpeed(float pixelsPerSecond)
 468         {
 469             NDalicPINVOKE.Scrollable_SetOvershootAnimationSpeed(swigCPtr, pixelsPerSecond);
 470             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 471         }
 472
 473         private float GetOvershootAnimationSpeed()
 474         {
 475             float ret = NDalicPINVOKE.Scrollable_GetOvershootAnimationSpeed(swigCPtr);
 476             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 477             return ret;
 478         }
 479
 480         internal ScrollableSignal ScrollStartedSignal()
 481         {
 482             ScrollableSignal ret = new ScrollableSignal(NDalicPINVOKE.Scrollable_ScrollStartedSignal(swigCPtr), false);
 483             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 484             return ret;
 485         }
 486
 487         internal ScrollableSignal ScrollUpdatedSignal()
 488         {
 489             ScrollableSignal ret = new ScrollableSignal(NDalicPINVOKE.Scrollable_ScrollUpdatedSignal(swigCPtr), false);
 490             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 491             return ret;
 492         }
 493
 494         internal ScrollableSignal ScrollCompletedSignal()
 495         {
 496             ScrollableSignal ret = new ScrollableSignal(NDalicPINVOKE.Scrollable_ScrollCompletedSignal(swigCPtr), false);
 497             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 498             return ret;
 499         }
 500
 501         /// <summary>
 502         /// Sets and Gets the color of the overshoot effect.
 503         /// </summary>
 504         /// <since_tizen> 3 </since_tizen>
 505         public Vector4 OvershootEffectColor
 506         {
 507             get
 508             {
 509                 Vector4 temp = new Vector4(0.0f, 0.0f, 0.0f, 0.0f);
 510                 GetProperty(Scrollable.Property.OVERSHOOT_EFFECT_COLOR).Get(temp);
 511                 return temp;
 512             }
 513             set
 514             {
 515                 SetProperty(Scrollable.Property.OVERSHOOT_EFFECT_COLOR, new Tizen.NUI.PropertyValue(value));
 516                 NotifyPropertyChanged();
 517             }
 518         }
 519
 520         /// <summary>
 521         /// Sets and Gets the speed of overshoot animation in pixels per second.
 522         /// </summary>
 523         /// <since_tizen> 3 </since_tizen>
 524         public float OvershootAnimationSpeed
 525         {
 526             get
 527             {
 528                 float temp = 0.0f;
 529                 GetProperty(Scrollable.Property.OVERSHOOT_ANIMATION_SPEED).Get(out temp);
 530                 return temp;
 531             }
 532             set
 533             {
 534                 SetProperty(Scrollable.Property.OVERSHOOT_ANIMATION_SPEED, new Tizen.NUI.PropertyValue(value));
 535                 NotifyPropertyChanged();
 536             }
 537         }
 538
 539         /// <summary>
 540         /// Checks if scroll overshoot has been enabled or not.
 541         /// </summary>
 542         /// <since_tizen> 3 </since_tizen>
 543         public bool OvershootEnabled
 544         {
 545             get
 546             {
 547                 bool temp = false;
 548                 GetProperty(Scrollable.Property.OVERSHOOT_ENABLED).Get(out temp);
 549                 return temp;
 550             }
 551             set
 552             {
 553                 SetProperty(Scrollable.Property.OVERSHOOT_ENABLED, new Tizen.NUI.PropertyValue(value));
 554                 NotifyPropertyChanged();
 555             }
 556         }
 557
 558         /// <summary>
 559         /// Gets and Sets OvershootSize property.
 560         /// </summary>
 561         /// <since_tizen> 3 </since_tizen>
 562         public Vector2 OvershootSize
 563         {
 564             get
 565             {
 566                 Vector2 temp = new Vector2(0.0f, 0.0f);
 567                 GetProperty(Scrollable.Property.OVERSHOOT_SIZE).Get(temp);
 568                 return temp;
 569             }
 570             set
 571             {
 572                 SetProperty(Scrollable.Property.OVERSHOOT_SIZE, new Tizen.NUI.PropertyValue(value));
 573                 NotifyPropertyChanged();
 574             }
 575         }
 576
 577         /// <summary>
 578         /// Gets and Sets ScrollToAlphaFunction property.
 579         /// </summary>
 580         /// <since_tizen> 3 </since_tizen>
 581         public int ScrollToAlphaFunction
 582         {
 583             get
 584             {
 585                 int temp = 0;
 586                 GetProperty(Scrollable.Property.SCROLL_TO_ALPHA_FUNCTION).Get(out temp);
 587                 return temp;
 588             }
 589             set
 590             {
 591                 SetProperty(Scrollable.Property.SCROLL_TO_ALPHA_FUNCTION, new Tizen.NUI.PropertyValue(value));
 592                 NotifyPropertyChanged();
 593             }
 594         }
 595
 596         /// <summary>
 597         /// Gets and Sets ScrollRelativePosition property.
 598         /// </summary>
 599         /// <since_tizen> 3 </since_tizen>
 600         public Vector2 ScrollRelativePosition
 601         {
 602             get
 603             {
 604                 Vector2 temp = new Vector2(0.0f, 0.0f);
 605                 GetProperty(Scrollable.Property.SCROLL_RELATIVE_POSITION).Get(temp);
 606                 return temp;
 607             }
 608             set
 609             {
 610                 SetProperty(Scrollable.Property.SCROLL_RELATIVE_POSITION, new Tizen.NUI.PropertyValue(value));
 611                 NotifyPropertyChanged();
 612             }
 613         }
 614
 615         /// <summary>
 616         /// Gets and Sets ScrollPositionMin property.
 617         /// </summary>
 618         /// <since_tizen> 3 </since_tizen>
 619         public Vector2 ScrollPositionMin
 620         {
 621             get
 622             {
 623                 Vector2 temp = new Vector2(0.0f, 0.0f);
 624                 GetProperty(Scrollable.Property.SCROLL_POSITION_MIN).Get(temp);
 625                 return temp;
 626             }
 627             set
 628             {
 629                 SetProperty(Scrollable.Property.SCROLL_POSITION_MIN, new Tizen.NUI.PropertyValue(value));
 630                 NotifyPropertyChanged();
 631             }
 632         }
 633
 634         /// <summary>
 635         /// Gets and Sets ScrollPositionMax property.
 636         /// </summary>
 637         /// <since_tizen> 3 </since_tizen>
 638         public Vector2 ScrollPositionMax
 639         {
 640             get
 641             {
 642                 Vector2 temp = new Vector2(0.0f, 0.0f);
 643                 GetProperty(Scrollable.Property.SCROLL_POSITION_MAX).Get(temp);
 644                 return temp;
 645             }
 646             set
 647             {
 648                 SetProperty(Scrollable.Property.SCROLL_POSITION_MAX, new Tizen.NUI.PropertyValue(value));
 649                 NotifyPropertyChanged();
 650             }
 651         }
 652
 653         /// <summary>
 654         /// Gets and Sets CanScrollVertical property.
 655         /// </summary>
 656         /// <since_tizen> 3 </since_tizen>
 657         public bool CanScrollVertical
 658         {
 659             get
 660             {
 661                 bool temp = false;
 662                 GetProperty(Scrollable.Property.CAN_SCROLL_VERTICAL).Get(out temp);
 663                 return temp;
 664             }
 665             set
 666             {
 667                 SetProperty(Scrollable.Property.CAN_SCROLL_VERTICAL, new Tizen.NUI.PropertyValue(value));
 668                 NotifyPropertyChanged();
 669             }
 670         }
 671
 672         /// <summary>
 673         /// Gets and Sets CanScrollHorizontal property.
 674         /// </summary>
 675         /// <since_tizen> 3 </since_tizen>
 676         public bool CanScrollHorizontal
 677         {
 678             get
 679             {
 680                 bool temp = false;
 681                 GetProperty(Scrollable.Property.CAN_SCROLL_HORIZONTAL).Get(out temp);
 682                 return temp;
 683             }
 684             set
 685             {
 686                 SetProperty(Scrollable.Property.CAN_SCROLL_HORIZONTAL, new Tizen.NUI.PropertyValue(value));
 687                 NotifyPropertyChanged();
 688             }
 689         }
 690
 691     }
 692
 693 }