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