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

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