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

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