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             }
 517         }
 518
 519         /// <summary>
 520         /// Sets and Gets the speed of overshoot animation in pixels per second.
 521         /// </summary>
 522         /// <since_tizen> 3 </since_tizen>
 523         public float OvershootAnimationSpeed
 524         {
 525             get
 526             {
 527                 float temp = 0.0f;
 528                 GetProperty(Scrollable.Property.OVERSHOOT_ANIMATION_SPEED).Get(out temp);
 529                 return temp;
 530             }
 531             set
 532             {
 533                 SetProperty(Scrollable.Property.OVERSHOOT_ANIMATION_SPEED, new Tizen.NUI.PropertyValue(value));
 534             }
 535         }
 536
 537         /// <summary>
 538         /// Checks if scroll overshoot has been enabled or not.
 539         /// </summary>
 540         /// <since_tizen> 3 </since_tizen>
 541         public bool OvershootEnabled
 542         {
 543             get
 544             {
 545                 bool temp = false;
 546                 GetProperty(Scrollable.Property.OVERSHOOT_ENABLED).Get(out temp);
 547                 return temp;
 548             }
 549             set
 550             {
 551                 SetProperty(Scrollable.Property.OVERSHOOT_ENABLED, new Tizen.NUI.PropertyValue(value));
 552             }
 553         }
 554
 555         /// <summary>
 556         /// Gets and Sets OvershootSize property.
 557         /// </summary>
 558         /// <since_tizen> 3 </since_tizen>
 559         public Vector2 OvershootSize
 560         {
 561             get
 562             {
 563                 Vector2 temp = new Vector2(0.0f, 0.0f);
 564                 GetProperty(Scrollable.Property.OVERSHOOT_SIZE).Get(temp);
 565                 return temp;
 566             }
 567             set
 568             {
 569                 SetProperty(Scrollable.Property.OVERSHOOT_SIZE, new Tizen.NUI.PropertyValue(value));
 570             }
 571         }
 572
 573         /// <summary>
 574         /// Gets and Sets ScrollToAlphaFunction property.
 575         /// </summary>
 576         /// <since_tizen> 3 </since_tizen>
 577         public int ScrollToAlphaFunction
 578         {
 579             get
 580             {
 581                 int temp = 0;
 582                 GetProperty(Scrollable.Property.SCROLL_TO_ALPHA_FUNCTION).Get(out temp);
 583                 return temp;
 584             }
 585             set
 586             {
 587                 SetProperty(Scrollable.Property.SCROLL_TO_ALPHA_FUNCTION, new Tizen.NUI.PropertyValue(value));
 588             }
 589         }
 590
 591         /// <summary>
 592         /// Gets and Sets ScrollRelativePosition property.
 593         /// </summary>
 594         /// <since_tizen> 3 </since_tizen>
 595         public Vector2 ScrollRelativePosition
 596         {
 597             get
 598             {
 599                 Vector2 temp = new Vector2(0.0f, 0.0f);
 600                 GetProperty(Scrollable.Property.SCROLL_RELATIVE_POSITION).Get(temp);
 601                 return temp;
 602             }
 603             set
 604             {
 605                 SetProperty(Scrollable.Property.SCROLL_RELATIVE_POSITION, new Tizen.NUI.PropertyValue(value));
 606             }
 607         }
 608
 609         /// <summary>
 610         /// Gets and Sets ScrollPositionMin property.
 611         /// </summary>
 612         /// <since_tizen> 3 </since_tizen>
 613         public Vector2 ScrollPositionMin
 614         {
 615             get
 616             {
 617                 Vector2 temp = new Vector2(0.0f, 0.0f);
 618                 GetProperty(Scrollable.Property.SCROLL_POSITION_MIN).Get(temp);
 619                 return temp;
 620             }
 621             set
 622             {
 623                 SetProperty(Scrollable.Property.SCROLL_POSITION_MIN, new Tizen.NUI.PropertyValue(value));
 624             }
 625         }
 626
 627         /// <summary>
 628         /// Gets and Sets ScrollPositionMax property.
 629         /// </summary>
 630         /// <since_tizen> 3 </since_tizen>
 631         public Vector2 ScrollPositionMax
 632         {
 633             get
 634             {
 635                 Vector2 temp = new Vector2(0.0f, 0.0f);
 636                 GetProperty(Scrollable.Property.SCROLL_POSITION_MAX).Get(temp);
 637                 return temp;
 638             }
 639             set
 640             {
 641                 SetProperty(Scrollable.Property.SCROLL_POSITION_MAX, new Tizen.NUI.PropertyValue(value));
 642             }
 643         }
 644
 645         /// <summary>
 646         /// Gets and Sets CanScrollVertical property.
 647         /// </summary>
 648         /// <since_tizen> 3 </since_tizen>
 649         public bool CanScrollVertical
 650         {
 651             get
 652             {
 653                 bool temp = false;
 654                 GetProperty(Scrollable.Property.CAN_SCROLL_VERTICAL).Get(out temp);
 655                 return temp;
 656             }
 657             set
 658             {
 659                 SetProperty(Scrollable.Property.CAN_SCROLL_VERTICAL, new Tizen.NUI.PropertyValue(value));
 660             }
 661         }
 662
 663         /// <summary>
 664         /// Gets and Sets CanScrollHorizontal property.
 665         /// </summary>
 666         /// <since_tizen> 3 </since_tizen>
 667         public bool CanScrollHorizontal
 668         {
 669             get
 670             {
 671                 bool temp = false;
 672                 GetProperty(Scrollable.Property.CAN_SCROLL_HORIZONTAL).Get(out temp);
 673                 return temp;
 674             }
 675             set
 676             {
 677                 SetProperty(Scrollable.Property.CAN_SCROLL_HORIZONTAL, new Tizen.NUI.PropertyValue(value));
 678             }
 679         }
 680
 681     }
 682
 683 }