src/Tizen.NUI/src/public/BaseComponents/Scrollable.cs

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