src/Tizen.NUI/src/public/UIComponents/ScrollBar.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.BaseComponents;
  21
  22 namespace Tizen.NUI.UIComponents
  23 {
  24     /// <summary>
  25     /// The ScrollBar is a UI component that can be linked to the scrollable objects
  26     /// indicating the current scroll position of the scrollable object.<br />
  27     /// </summary>
  28     /// <since_tizen> 3 </since_tizen>
  29     public class ScrollBar : View
  30     {
  31         private global::System.Runtime.InteropServices.HandleRef swigCPtr;
  32
  33         internal ScrollBar(global::System.IntPtr cPtr, bool cMemoryOwn) : base(NDalicPINVOKE.ScrollBar_SWIGUpcast(cPtr), cMemoryOwn)
  34         {
  35             swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
  36         }
  37
  38         internal static global::System.Runtime.InteropServices.HandleRef getCPtr(ScrollBar obj)
  39         {
  40             return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
  41         }
  42
  43         /// <summary>
  44         /// To dispose the ScrollBar instance.
  45         /// </summary>
  46         /// <since_tizen> 3 </since_tizen>
  47         protected override void Dispose(DisposeTypes type)
  48         {
  49             if (disposed)
  50             {
  51                 return;
  52             }
  53
  54             if(type == DisposeTypes.Explicit)
  55             {
  56                 //Called by User
  57                 //Release your own managed resources here.
  58                 //You should release all of your own disposable objects here.
  59             }
  60
  61             //Release your own unmanaged resources here.
  62             //You should not access any managed member here except static instance.
  63             //because the execution order of Finalizes is non-deterministic.
  64
  65             if (_scrollBarScrollPositionIntervalReachedEventCallbackDelegate != null)
  66             {
  67                 ScrollPositionIntervalReachedSignal().Disconnect(_scrollBarScrollPositionIntervalReachedEventCallbackDelegate);
  68             }
  69
  70             if (_scrollBarPanFinishedEventCallbackDelegate != null)
  71             {
  72                 PanFinishedSignal().Disconnect(_scrollBarPanFinishedEventCallbackDelegate);
  73             }
  74
  75             if (swigCPtr.Handle != global::System.IntPtr.Zero)
  76             {
  77                 if (swigCMemOwn)
  78                 {
  79                     swigCMemOwn = false;
  80                     NDalicPINVOKE.delete_ScrollBar(swigCPtr);
  81                 }
  82                 swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
  83             }
  84
  85             base.Dispose(type);
  86         }
  87
  88         /// <summary>
  89         /// Event arguments that passed via the PanFinished event.
  90         /// </summary>
  91         /// <since_tizen> 3 </since_tizen>
  92         public class PanFinishedEventArgs : EventArgs
  93         {
  94         }
  95
  96         /// <summary>
  97         /// Event arguments that passed via the ScrollPositionIntervalReached event.
  98         /// </summary>
  99         /// <since_tizen> 3 </since_tizen>
 100         public class ScrollIntervalEventArgs : EventArgs
 101         {
 102             private float _currentScrollPosition;
 103
 104             /// <summary>
 105             /// The current scroll position of the scrollable content.
 106             /// </summary>
 107             /// <since_tizen> 3 </since_tizen>
 108             public float CurrentScrollPosition
 109             {
 110                 get
 111                 {
 112                     return _currentScrollPosition;
 113                 }
 114                 set
 115                 {
 116                     _currentScrollPosition = value;
 117                 }
 118             }
 119         }
 120
 121         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 122         private delegate void PanFinishedEventCallbackDelegate();
 123         private EventHandler<PanFinishedEventArgs> _scrollBarPanFinishedEventHandler;
 124         private PanFinishedEventCallbackDelegate _scrollBarPanFinishedEventCallbackDelegate;
 125
 126         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 127         private delegate void ScrollPositionIntervalReachedEventCallbackDelegate();
 128         private EventHandler<ScrollIntervalEventArgs> _scrollBarScrollPositionIntervalReachedEventHandler;
 129         private ScrollPositionIntervalReachedEventCallbackDelegate _scrollBarScrollPositionIntervalReachedEventCallbackDelegate;
 130
 131         /// <summary>
 132         /// The event emitted when panning is finished on the scroll indicator.
 133         /// </summary>
 134         /// <since_tizen> 3 </since_tizen>
 135         public event EventHandler<PanFinishedEventArgs> PanFinished
 136         {
 137             add
 138             {
 139                 if (_scrollBarPanFinishedEventHandler == null)
 140                 {
 141                     _scrollBarPanFinishedEventCallbackDelegate = (OnScrollBarPanFinished);
 142                     PanFinishedSignal().Connect(_scrollBarPanFinishedEventCallbackDelegate);
 143                 }
 144                 _scrollBarPanFinishedEventHandler += value;
 145             }
 146             remove
 147             {
 148                 _scrollBarPanFinishedEventHandler -= value;
 149                 if (_scrollBarPanFinishedEventHandler == null && PanFinishedSignal().Empty() == false)
 150                 {
 151                     PanFinishedSignal().Disconnect(_scrollBarPanFinishedEventCallbackDelegate);
 152                 }
 153             }
 154         }
 155
 156         // Callback for ScrollBar PanFinishedSignal
 157         private void OnScrollBarPanFinished()
 158         {
 159             PanFinishedEventArgs e = new PanFinishedEventArgs();
 160
 161             if (_scrollBarPanFinishedEventHandler != null)
 162             {
 163                 //here we send all data to user event handlers
 164                 _scrollBarPanFinishedEventHandler(this, e);
 165             }
 166         }
 167
 168
 169         /// <summary>
 170         /// This is the event emitted when the current scroll position of the scrollable content.
 171         /// </summary>
 172         /// <since_tizen> 3 </since_tizen>
 173         public event EventHandler<ScrollIntervalEventArgs> ScrollInterval
 174         {
 175             add
 176             {
 177                 if (_scrollBarScrollPositionIntervalReachedEventHandler == null)
 178                 {
 179                     _scrollBarScrollPositionIntervalReachedEventCallbackDelegate = (OnScrollBarScrollPositionIntervalReached);
 180                     ScrollPositionIntervalReachedSignal().Connect(_scrollBarScrollPositionIntervalReachedEventCallbackDelegate);
 181                 }
 182                 _scrollBarScrollPositionIntervalReachedEventHandler += value;
 183             }
 184             remove
 185             {
 186                 _scrollBarScrollPositionIntervalReachedEventHandler -= value;
 187                 if (_scrollBarScrollPositionIntervalReachedEventHandler == null && ScrollPositionIntervalReachedSignal().Empty() == false)
 188                 {
 189                     ScrollPositionIntervalReachedSignal().Disconnect(_scrollBarScrollPositionIntervalReachedEventCallbackDelegate);
 190                 }
 191             }
 192         }
 193
 194         // Callback for ScrollBar ScrollPositionIntervalReachedSignal
 195         private void OnScrollBarScrollPositionIntervalReached()
 196         {
 197             ScrollIntervalEventArgs e = new ScrollIntervalEventArgs();
 198
 199             if (_scrollBarScrollPositionIntervalReachedEventHandler != null)
 200             {
 201                 //here we send all data to user event handlers
 202                 _scrollBarScrollPositionIntervalReachedEventHandler(this, e);
 203             }
 204         }
 205
 206
 207         internal new class Property
 208         {
 209             internal static readonly int SCROLL_DIRECTION = NDalicPINVOKE.ScrollBar_Property_SCROLL_DIRECTION_get();
 210             internal static readonly int INDICATOR_HEIGHT_POLICY = NDalicPINVOKE.ScrollBar_Property_INDICATOR_HEIGHT_POLICY_get();
 211             internal static readonly int INDICATOR_FIXED_HEIGHT = NDalicPINVOKE.ScrollBar_Property_INDICATOR_FIXED_HEIGHT_get();
 212             internal static readonly int INDICATOR_SHOW_DURATION = NDalicPINVOKE.ScrollBar_Property_INDICATOR_SHOW_DURATION_get();
 213             internal static readonly int INDICATOR_HIDE_DURATION = NDalicPINVOKE.ScrollBar_Property_INDICATOR_HIDE_DURATION_get();
 214             internal static readonly int SCROLL_POSITION_INTERVALS = NDalicPINVOKE.ScrollBar_Property_SCROLL_POSITION_INTERVALS_get();
 215             internal static readonly int INDICATOR_MINIMUM_HEIGHT = NDalicPINVOKE.ScrollBar_Property_INDICATOR_MINIMUM_HEIGHT_get();
 216             internal static readonly int INDICATOR_START_PADDING = NDalicPINVOKE.ScrollBar_Property_INDICATOR_START_PADDING_get();
 217             internal static readonly int INDICATOR_END_PADDING = NDalicPINVOKE.ScrollBar_Property_INDICATOR_END_PADDING_get();
 218         }
 219
 220         /// <summary>
 221         /// Creates an initialized scrollbar.
 222         /// </summary>
 223         /// <param name="direction">The direction of the scrollbar (either vertically or horizontally).</param>
 224         /// <since_tizen> 3 </since_tizen>
 225         public ScrollBar(ScrollBar.Direction direction) : this(NDalicPINVOKE.ScrollBar_New__SWIG_0((int)direction), true)
 226         {
 227             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 228         }
 229
 230         /// <summary>
 231         /// Creates an uninitialized scrollbar.
 232         /// </summary>
 233         /// <since_tizen> 3 </since_tizen>
 234         public ScrollBar() : this(NDalicPINVOKE.ScrollBar_New__SWIG_1(), true)
 235         {
 236             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 237
 238         }
 239         internal ScrollBar(ScrollBar scrollBar) : this(NDalicPINVOKE.new_ScrollBar__SWIG_1(ScrollBar.getCPtr(scrollBar)), true)
 240         {
 241             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 242         }
 243
 244         /// <summary>
 245         /// Downcasts a handle to scrollBar handle.
 246         /// </summary>
 247         /// <since_tizen> 3 </since_tizen>
 248         /// Please do not use! this will be deprecated!
 249         /// Instead please use as keyword.
 250         [Obsolete("Please do not use! This will be deprecated! Please use as keyword instead!")]
 251         [EditorBrowsable(EditorBrowsableState.Never)]
 252         public new static ScrollBar DownCast(BaseHandle handle)
 253         {
 254             ScrollBar ret =  Registry.GetManagedBaseHandleFromNativePtr(handle) as ScrollBar;
 255             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 256             return ret;
 257         }
 258
 259         internal void SetScrollPropertySource(Animatable handle, int propertyScrollPosition, int propertyMinScrollPosition, int propertyMaxScrollPosition, int propertyScrollContentSize)
 260         {
 261             NDalicPINVOKE.ScrollBar_SetScrollPropertySource(swigCPtr, Animatable.getCPtr(handle), propertyScrollPosition, propertyMinScrollPosition, propertyMaxScrollPosition, propertyScrollContentSize);
 262             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 263         }
 264
 265         internal void SetScrollIndicator(View indicator)
 266         {
 267             NDalicPINVOKE.ScrollBar_SetScrollIndicator(swigCPtr, View.getCPtr(indicator));
 268             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 269         }
 270
 271         internal View GetScrollIndicator()
 272         {
 273             View ret = new View(NDalicPINVOKE.ScrollBar_GetScrollIndicator(swigCPtr), true);
 274             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 275             return ret;
 276         }
 277
 278         internal void SetScrollDirection(ScrollBar.Direction direction)
 279         {
 280             NDalicPINVOKE.ScrollBar_SetScrollDirection(swigCPtr, (int)direction);
 281             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 282         }
 283
 284         internal ScrollBar.Direction GetScrollDirection()
 285         {
 286             ScrollBar.Direction ret = (ScrollBar.Direction)NDalicPINVOKE.ScrollBar_GetScrollDirection(swigCPtr);
 287             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 288             return ret;
 289         }
 290
 291         internal void SetIndicatorHeightPolicy(ScrollBar.IndicatorHeightPolicyType policy)
 292         {
 293             NDalicPINVOKE.ScrollBar_SetIndicatorHeightPolicy(swigCPtr, (int)policy);
 294             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 295         }
 296
 297         internal ScrollBar.IndicatorHeightPolicyType GetIndicatorHeightPolicy()
 298         {
 299             ScrollBar.IndicatorHeightPolicyType ret = (ScrollBar.IndicatorHeightPolicyType)NDalicPINVOKE.ScrollBar_GetIndicatorHeightPolicy(swigCPtr);
 300             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 301             return ret;
 302         }
 303
 304         internal void SetIndicatorFixedHeight(float height)
 305         {
 306             NDalicPINVOKE.ScrollBar_SetIndicatorFixedHeight(swigCPtr, height);
 307             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 308         }
 309
 310         internal float GetIndicatorFixedHeight()
 311         {
 312             float ret = NDalicPINVOKE.ScrollBar_GetIndicatorFixedHeight(swigCPtr);
 313             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 314             return ret;
 315         }
 316
 317         internal void SetIndicatorShowDuration(float durationSeconds)
 318         {
 319             NDalicPINVOKE.ScrollBar_SetIndicatorShowDuration(swigCPtr, durationSeconds);
 320             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 321         }
 322
 323         internal float GetIndicatorShowDuration()
 324         {
 325             float ret = NDalicPINVOKE.ScrollBar_GetIndicatorShowDuration(swigCPtr);
 326             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 327             return ret;
 328         }
 329
 330         internal void SetIndicatorHideDuration(float durationSeconds)
 331         {
 332             NDalicPINVOKE.ScrollBar_SetIndicatorHideDuration(swigCPtr, durationSeconds);
 333             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 334         }
 335
 336         internal float GetIndicatorHideDuration()
 337         {
 338             float ret = NDalicPINVOKE.ScrollBar_GetIndicatorHideDuration(swigCPtr);
 339             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 340             return ret;
 341         }
 342
 343         internal void ShowIndicator()
 344         {
 345             NDalicPINVOKE.ScrollBar_ShowIndicator(swigCPtr);
 346             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 347         }
 348
 349         internal void HideIndicator()
 350         {
 351             NDalicPINVOKE.ScrollBar_HideIndicator(swigCPtr);
 352             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 353         }
 354
 355         internal VoidSignal PanFinishedSignal()
 356         {
 357             VoidSignal ret = new VoidSignal(NDalicPINVOKE.ScrollBar_PanFinishedSignal(swigCPtr), false);
 358             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 359             return ret;
 360         }
 361
 362         internal FloatSignal ScrollPositionIntervalReachedSignal()
 363         {
 364             FloatSignal ret = new FloatSignal(NDalicPINVOKE.ScrollBar_ScrollPositionIntervalReachedSignal(swigCPtr), false);
 365             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 366             return ret;
 367         }
 368
 369         /// <summary>
 370         /// The direction of the scrollbar.
 371         /// </summary>
 372         /// <since_tizen> 3 </since_tizen>
 373         public enum Direction
 374         {
 375             /// <summary>
 376             /// Scroll in the vertical direction
 377             /// </summary>
 378             /// <since_tizen> 3 </since_tizen>
 379             Vertical = 0,
 380             /// <summary>
 381             /// Scroll in the horizontal direction
 382             /// </summary>
 383             /// <since_tizen> 3 </since_tizen>
 384             Horizontal
 385         }
 386
 387         /// <summary>
 388         /// The indicator height policy.
 389         /// </summary>
 390         /// <since_tizen> 3 </since_tizen>
 391         public enum IndicatorHeightPolicyType
 392         {
 393             /// <summary>
 394             /// Variable height changed dynamically according to the length of scroll content
 395             /// </summary>
 396             /// <since_tizen> 3 </since_tizen>
 397             Variable = 0,
 398             /// <summary>
 399             /// Fixed height regardless of the length of scroll content
 400             /// </summary>
 401             /// <since_tizen> 3 </since_tizen>
 402             Fixed
 403         }
 404
 405         /// <summary>
 406         /// The direction of the scrollbar.
 407         /// </summary>
 408         /// <since_tizen> 3 </since_tizen>
 409         public Direction ScrollDirection
 410         {
 411             get
 412             {
 413                 string temp;
 414                 if (GetProperty(ScrollBar.Property.SCROLL_DIRECTION).Get(out temp) == false)
 415                 {
 416                     NUILog.Error("ScrollDirection get error!");
 417                 }
 418
 419                 switch (temp)
 420                 {
 421                     case "Vertical":
 422                         return Direction.Vertical;
 423                     case "Horizontal":
 424                         return Direction.Horizontal;
 425                     default:
 426                         return Direction.Vertical;
 427                 }
 428             }
 429             set
 430             {
 431                 string valueToString = "";
 432                 switch (value)
 433                 {
 434                     case Direction.Vertical:
 435                     {
 436                         valueToString = "Vertical";
 437                         break;
 438                     }
 439                     case Direction.Horizontal:
 440                     {
 441                         valueToString = "Horizontal";
 442                         break;
 443                     }
 444                     default:
 445                     {
 446                         valueToString = "Vertical";
 447                         break;
 448                     }
 449                 }
 450                 SetProperty(ScrollBar.Property.SCROLL_DIRECTION, new Tizen.NUI.PropertyValue(valueToString));
 451             }
 452         }
 453
 454         /// <summary>
 455         /// The indicator height policy.
 456         /// </summary>
 457         /// <since_tizen> 3 </since_tizen>
 458         public IndicatorHeightPolicyType IndicatorHeightPolicy
 459         {
 460             get
 461             {
 462                 string temp;
 463                 if (GetProperty(ScrollBar.Property.INDICATOR_HEIGHT_POLICY).Get(out temp) == false)
 464                 {
 465                     NUILog.Error("IndicatorHeightPolicy get error!");
 466                 }
 467
 468                 switch (temp)
 469                 {
 470                     case "Variable":
 471                         return IndicatorHeightPolicyType.Variable;
 472                     case "Fixed":
 473                         return IndicatorHeightPolicyType.Fixed;
 474                     default:
 475                         return IndicatorHeightPolicyType.Variable;
 476                 }
 477             }
 478             set
 479             {
 480                 string valueToString = "";
 481                 switch (value)
 482                 {
 483                     case IndicatorHeightPolicyType.Variable:
 484                     {
 485                         valueToString = "Variable";
 486                         break;
 487                     }
 488                     case IndicatorHeightPolicyType.Fixed:
 489                     {
 490                         valueToString = "Fixed";
 491                         break;
 492                     }
 493                     default:
 494                     {
 495                         valueToString = "Variable";
 496                         break;
 497                     }
 498                 }
 499                 SetProperty(ScrollBar.Property.INDICATOR_HEIGHT_POLICY, new Tizen.NUI.PropertyValue(valueToString));
 500             }
 501         }
 502
 503         /// <summary>
 504         /// The fixed height of the scroll indicator.
 505         /// </summary>
 506         /// <since_tizen> 3 </since_tizen>
 507         public float IndicatorFixedHeight
 508         {
 509             get
 510             {
 511                 float temp = 0.0f;
 512                 GetProperty(ScrollBar.Property.INDICATOR_FIXED_HEIGHT).Get(out temp);
 513                 return temp;
 514             }
 515             set
 516             {
 517                 SetProperty(ScrollBar.Property.INDICATOR_FIXED_HEIGHT, new Tizen.NUI.PropertyValue(value));
 518             }
 519         }
 520
 521         /// <summary>
 522         /// The duration in seconds for the scroll indicator to become fully visible.
 523         /// </summary>
 524         /// <since_tizen> 3 </since_tizen>
 525         public float IndicatorShowDuration
 526         {
 527             get
 528             {
 529                 float temp = 0.0f;
 530                 GetProperty(ScrollBar.Property.INDICATOR_SHOW_DURATION).Get(out temp);
 531                 return temp;
 532             }
 533             set
 534             {
 535                 SetProperty(ScrollBar.Property.INDICATOR_SHOW_DURATION, new Tizen.NUI.PropertyValue(value));
 536             }
 537         }
 538
 539         /// <summary>
 540         /// The duration in seconds for the scroll indicator to become fully invisible.
 541         /// </summary>
 542         /// <since_tizen> 3 </since_tizen>
 543         public float IndicatorHideDuration
 544         {
 545             get
 546             {
 547                 float temp = 0.0f;
 548                 GetProperty(ScrollBar.Property.INDICATOR_HIDE_DURATION).Get(out temp);
 549                 return temp;
 550             }
 551             set
 552             {
 553                 SetProperty(ScrollBar.Property.INDICATOR_HIDE_DURATION, new Tizen.NUI.PropertyValue(value));
 554             }
 555         }
 556
 557         /// <summary>
 558         /// The list of values to get the notification when the current scroll position of the scrollable object goes above or below any of these values.
 559         /// </summary>
 560         /// <since_tizen> 3 </since_tizen>
 561         public Tizen.NUI.PropertyArray ScrollPositionIntervals
 562         {
 563             get
 564             {
 565                 Tizen.NUI.PropertyArray temp = new Tizen.NUI.PropertyArray();
 566                 GetProperty(ScrollBar.Property.SCROLL_POSITION_INTERVALS).Get(temp);
 567                 return temp;
 568             }
 569             set
 570             {
 571                 SetProperty(ScrollBar.Property.SCROLL_POSITION_INTERVALS, new Tizen.NUI.PropertyValue(value));
 572             }
 573         }
 574
 575         /// <summary>
 576         /// The minimum height for a variable size indicator.
 577         /// </summary>
 578         /// <since_tizen> 3 </since_tizen>
 579         public float IndicatorMinimumHeight
 580         {
 581             get
 582             {
 583                 float temp = 0.0f;
 584                 GetProperty(ScrollBar.Property.INDICATOR_MINIMUM_HEIGHT).Get(out temp);
 585                 return temp;
 586             }
 587             set
 588             {
 589                 SetProperty(ScrollBar.Property.INDICATOR_MINIMUM_HEIGHT, new Tizen.NUI.PropertyValue(value));
 590             }
 591         }
 592
 593         /// <summary>
 594         /// The padding at the start of the indicator. For example, the top if the scrollDirection is vertical.
 595         /// </summary>
 596         /// <since_tizen> 3 </since_tizen>
 597         public float IndicatorStartPadding
 598         {
 599             get
 600             {
 601                 float temp = 0.0f;
 602                 GetProperty(ScrollBar.Property.INDICATOR_START_PADDING).Get(out temp);
 603                 return temp;
 604             }
 605             set
 606             {
 607                 SetProperty(ScrollBar.Property.INDICATOR_START_PADDING, new Tizen.NUI.PropertyValue(value));
 608             }
 609         }
 610
 611         /// <summary>
 612         /// The padding at the end of the indicator. For example, the bottom if the scrollDirection is vertical.
 613         /// </summary>
 614         /// <since_tizen> 3 </since_tizen>
 615         public float IndicatorEndPadding
 616         {
 617             get
 618             {
 619                 float temp = 0.0f;
 620                 GetProperty(ScrollBar.Property.INDICATOR_END_PADDING).Get(out temp);
 621                 return temp;
 622             }
 623             set
 624             {
 625                 SetProperty(ScrollBar.Property.INDICATOR_END_PADDING, new Tizen.NUI.PropertyValue(value));
 626             }
 627         }
 628
 629     }
 630
 631 }