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