Tizen.NUI/src/public/UIComponents/ScrollBar.cs

   1 /** Copyright (c) 2017 Samsung Electronics Co., Ltd.
   2 *
   3 * Licensed under the Apache License, Version 2.0 (the "License");
   4 * you may not use this file except in compliance with the License.
   5 * You may obtain a copy of the License at
   6 *
   7 * http://www.apache.org/licenses/LICENSE-2.0
   8 *
   9 * Unless required by applicable law or agreed to in writing, software
  10 * distributed under the License is distributed on an "AS IS" BASIS,
  11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 * See the License for the specific language governing permissions and
  13 * limitations under the License.
  14 *
  15 */
  16 // This File has been auto-generated by SWIG and then modified using DALi Ruby Scripts
  17 //------------------------------------------------------------------------------
  18 // <auto-generated />
  19 //
  20 // This file was automatically generated by SWIG (http://www.swig.org).
  21 // Version 3.0.9
  22 //
  23 // Do not make changes to this file unless you know what you are doing--modify
  24 // the SWIG interface file instead.
  25 //------------------------------------------------------------------------------
  26
  27 namespace Tizen.NUI.UIComponents
  28 {
  29
  30     using System;
  31     using System.Runtime.InteropServices;
  32     using Tizen.NUI.BaseComponents;
  33
  34     /// <summary>
  35     /// ScrollBar is a UI component that can be linked to the scrollable objects
  36     /// indicating the current scroll position of the scrollable object.<br>
  37     /// </summary>
  38     public class ScrollBar : View
  39     {
  40         private global::System.Runtime.InteropServices.HandleRef swigCPtr;
  41
  42         internal ScrollBar(global::System.IntPtr cPtr, bool cMemoryOwn) : base(NDalicPINVOKE.ScrollBar_SWIGUpcast(cPtr), cMemoryOwn)
  43         {
  44             swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
  45         }
  46
  47         internal static global::System.Runtime.InteropServices.HandleRef getCPtr(ScrollBar obj)
  48         {
  49             return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
  50         }
  51
  52         /// <summary>
  53         /// To make ScrollBar instance be disposed.
  54         /// </summary>
  55         public override void Dispose()
  56         {
  57             if (!Window.IsInstalled())
  58             {
  59                 DisposeQueue.Instance.Add(this);
  60                 return;
  61             }
  62
  63             lock (this)
  64             {
  65                 if (swigCPtr.Handle != global::System.IntPtr.Zero)
  66                 {
  67                     if (swigCMemOwn)
  68                     {
  69                         swigCMemOwn = false;
  70                         NDalicPINVOKE.delete_ScrollBar(swigCPtr);
  71                     }
  72                     swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
  73                 }
  74                 global::System.GC.SuppressFinalize(this);
  75                 base.Dispose();
  76             }
  77         }
  78
  79         /// <summary>
  80         /// Event arguments that passed via PanFinished event
  81         /// </summary>
  82         public class PanFinishedEventArgs : EventArgs
  83         {
  84         }
  85
  86         /// <summary>
  87         /// Event arguments that passed via ScrollPositionIntervalReached event
  88         /// </summary>
  89         public class ScrollPositionIntervalReachedEventArgs : EventArgs
  90         {
  91             private float _currentScrollPosition;
  92
  93             /// <summary>
  94             /// current scroll position of the scrollable content
  95             /// </summary>
  96             public float CurrentScrollPosition
  97             {
  98                 get
  99                 {
 100                     return _currentScrollPosition;
 101                 }
 102                 set
 103                 {
 104                     _currentScrollPosition = value;
 105                 }
 106             }
 107         }
 108
 109         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 110         private delegate void PanFinishedEventCallbackDelegate();
 111         private EventHandler<PanFinishedEventArgs> _scrollBarPanFinishedEventHandler;
 112         private PanFinishedEventCallbackDelegate _scrollBarPanFinishedEventCallbackDelegate;
 113
 114         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 115         private delegate void ScrollPositionIntervalReachedEventCallbackDelegate();
 116         private EventHandler<ScrollPositionIntervalReachedEventArgs> _scrollBarScrollPositionIntervalReachedEventHandler;
 117         private ScrollPositionIntervalReachedEventCallbackDelegate _scrollBarScrollPositionIntervalReachedEventCallbackDelegate;
 118
 119         /// <summary>
 120         /// Event emitted when panning is finished on the scroll indicator.
 121         /// </summary>
 122         public event EventHandler<PanFinishedEventArgs> PanFinished
 123         {
 124             add
 125             {
 126                 if (_scrollBarPanFinishedEventHandler == null)
 127                 {
 128                     _scrollBarPanFinishedEventCallbackDelegate = (OnScrollBarPanFinished);
 129                     PanFinishedSignal().Connect(_scrollBarPanFinishedEventCallbackDelegate);
 130                 }
 131                 _scrollBarPanFinishedEventHandler += value;
 132             }
 133             remove
 134             {
 135                 _scrollBarPanFinishedEventHandler -= value;
 136                 if (_scrollBarPanFinishedEventHandler == null && PanFinishedSignal().Empty() == false)
 137                 {
 138                     PanFinishedSignal().Disconnect(_scrollBarPanFinishedEventCallbackDelegate);
 139                 }
 140             }
 141         }
 142
 143         // Callback for ScrollBar PanFinishedSignal
 144         private void OnScrollBarPanFinished()
 145         {
 146             PanFinishedEventArgs e = new PanFinishedEventArgs();
 147
 148             if (_scrollBarPanFinishedEventHandler != null)
 149             {
 150                 //here we send all data to user event handlers
 151                 _scrollBarPanFinishedEventHandler(this, e);
 152             }
 153         }
 154
 155
 156         /// <summary>
 157         /// Event emitted when the current scroll position of the scrollable content
 158         /// </summary>
 159         public event EventHandler<ScrollPositionIntervalReachedEventArgs> ScrollPositionIntervalReached
 160         {
 161             add
 162             {
 163                 if (_scrollBarScrollPositionIntervalReachedEventHandler == null)
 164                 {
 165                     _scrollBarScrollPositionIntervalReachedEventCallbackDelegate = (OnScrollBarScrollPositionIntervalReached);
 166                     ScrollPositionIntervalReachedSignal().Connect(_scrollBarScrollPositionIntervalReachedEventCallbackDelegate);
 167                 }
 168                 _scrollBarScrollPositionIntervalReachedEventHandler += value;
 169             }
 170             remove
 171             {
 172                 _scrollBarScrollPositionIntervalReachedEventHandler -= value;
 173                 if (_scrollBarScrollPositionIntervalReachedEventHandler == null && ScrollPositionIntervalReachedSignal().Empty() == false)
 174                 {
 175                     ScrollPositionIntervalReachedSignal().Disconnect(_scrollBarScrollPositionIntervalReachedEventCallbackDelegate);
 176                 }
 177             }
 178         }
 179
 180         // Callback for ScrollBar ScrollPositionIntervalReachedSignal
 181         private void OnScrollBarScrollPositionIntervalReached()
 182         {
 183             ScrollPositionIntervalReachedEventArgs e = new ScrollPositionIntervalReachedEventArgs();
 184
 185             if (_scrollBarScrollPositionIntervalReachedEventHandler != null)
 186             {
 187                 //here we send all data to user event handlers
 188                 _scrollBarScrollPositionIntervalReachedEventHandler(this, e);
 189             }
 190         }
 191
 192
 193         internal class Property : global::System.IDisposable
 194         {
 195             private global::System.Runtime.InteropServices.HandleRef swigCPtr;
 196             protected bool swigCMemOwn;
 197
 198             internal Property(global::System.IntPtr cPtr, bool cMemoryOwn)
 199             {
 200                 swigCMemOwn = cMemoryOwn;
 201                 swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
 202             }
 203
 204             internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Property obj)
 205             {
 206                 return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
 207             }
 208
 209             ~Property()
 210             {
 211                 DisposeQueue.Instance.Add(this);
 212             }
 213
 214             public virtual void Dispose()
 215             {
 216                 if (!Window.IsInstalled()) {
 217                     DisposeQueue.Instance.Add(this);
 218                     return;
 219                 }
 220
 221                 lock (this)
 222                 {
 223                     if (swigCPtr.Handle != global::System.IntPtr.Zero)
 224                     {
 225                         if (swigCMemOwn)
 226                         {
 227                             swigCMemOwn = false;
 228                             NDalicPINVOKE.delete_ScrollBar_Property(swigCPtr);
 229                         }
 230                         swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
 231                     }
 232                     global::System.GC.SuppressFinalize(this);
 233                 }
 234             }
 235
 236             internal Property() : this(NDalicPINVOKE.new_ScrollBar_Property(), true)
 237             {
 238                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 239             }
 240
 241             internal static readonly int SCROLL_DIRECTION = NDalicPINVOKE.ScrollBar_Property_SCROLL_DIRECTION_get();
 242             internal static readonly int INDICATOR_HEIGHT_POLICY = NDalicPINVOKE.ScrollBar_Property_INDICATOR_HEIGHT_POLICY_get();
 243             internal static readonly int INDICATOR_FIXED_HEIGHT = NDalicPINVOKE.ScrollBar_Property_INDICATOR_FIXED_HEIGHT_get();
 244             internal static readonly int INDICATOR_SHOW_DURATION = NDalicPINVOKE.ScrollBar_Property_INDICATOR_SHOW_DURATION_get();
 245             internal static readonly int INDICATOR_HIDE_DURATION = NDalicPINVOKE.ScrollBar_Property_INDICATOR_HIDE_DURATION_get();
 246             internal static readonly int SCROLL_POSITION_INTERVALS = NDalicPINVOKE.ScrollBar_Property_SCROLL_POSITION_INTERVALS_get();
 247             internal static readonly int INDICATOR_MINIMUM_HEIGHT = NDalicPINVOKE.ScrollBar_Property_INDICATOR_MINIMUM_HEIGHT_get();
 248             internal static readonly int INDICATOR_START_PADDING = NDalicPINVOKE.ScrollBar_Property_INDICATOR_START_PADDING_get();
 249             internal static readonly int INDICATOR_END_PADDING = NDalicPINVOKE.ScrollBar_Property_INDICATOR_END_PADDING_get();
 250
 251         }
 252
 253         /// <summary>
 254         /// Creates an initialized ScrollBar.
 255         /// </summary>
 256         /// <param name="direction">The direction of scroll bar (either vertically or horizontally)</param>
 257         public ScrollBar(ScrollBar.Direction direction) : this(NDalicPINVOKE.ScrollBar_New__SWIG_0((int)direction), true)
 258         {
 259             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 260         }
 261
 262         /// <summary>
 263         /// Creates an uninitialized ScrollBar
 264         /// </summary>
 265         public ScrollBar() : this(NDalicPINVOKE.ScrollBar_New__SWIG_1(), true)
 266         {
 267             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 268
 269         }
 270         internal ScrollBar(ScrollBar scrollBar) : this(NDalicPINVOKE.new_ScrollBar__SWIG_1(ScrollBar.getCPtr(scrollBar)), true)
 271         {
 272             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 273         }
 274
 275         internal ScrollBar Assign(ScrollBar scrollBar)
 276         {
 277             ScrollBar ret = new ScrollBar(NDalicPINVOKE.ScrollBar_Assign(swigCPtr, ScrollBar.getCPtr(scrollBar)), false);
 278             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 279             return ret;
 280         }
 281
 282         /// <summary>
 283         /// Downcasts a handle to ScrollBar handle.<br>
 284         /// If handle points to a ScrollBar, the downcast produces valid handle.<br>
 285         /// If not, the returned handle is left uninitialized.<br>
 286         /// </summary>
 287         /// <param name="handle">Handle to an object</param>
 288         /// <returns>Handle to a ScrollBar or an uninitialized handle</returns>
 289         public new static ScrollBar DownCast(BaseHandle handle)
 290         {
 291             ScrollBar ret = new ScrollBar(NDalicPINVOKE.ScrollBar_DownCast(BaseHandle.getCPtr(handle)), true);
 292             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 293             return ret;
 294         }
 295
 296         internal void SetScrollPropertySource(Animatable handle, int propertyScrollPosition, int propertyMinScrollPosition, int propertyMaxScrollPosition, int propertyScrollContentSize)
 297         {
 298             NDalicPINVOKE.ScrollBar_SetScrollPropertySource(swigCPtr, Animatable.getCPtr(handle), propertyScrollPosition, propertyMinScrollPosition, propertyMaxScrollPosition, propertyScrollContentSize);
 299             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 300         }
 301
 302         internal void SetScrollIndicator(View indicator)
 303         {
 304             NDalicPINVOKE.ScrollBar_SetScrollIndicator(swigCPtr, View.getCPtr(indicator));
 305             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 306         }
 307
 308         internal View GetScrollIndicator()
 309         {
 310             View ret = new View(NDalicPINVOKE.ScrollBar_GetScrollIndicator(swigCPtr), true);
 311             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 312             return ret;
 313         }
 314
 315         internal void SetScrollPositionIntervals(VectorFloat positions)
 316         {
 317             NDalicPINVOKE.ScrollBar_SetScrollPositionIntervals(swigCPtr, VectorFloat.getCPtr(positions));
 318             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 319         }
 320
 321         internal VectorFloat GetScrollPositionIntervals()
 322         {
 323             VectorFloat ret = new VectorFloat(NDalicPINVOKE.ScrollBar_GetScrollPositionIntervals(swigCPtr), true);
 324             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 325             return ret;
 326         }
 327
 328         internal void SetScrollDirection(ScrollBar.Direction direction)
 329         {
 330             NDalicPINVOKE.ScrollBar_SetScrollDirection(swigCPtr, (int)direction);
 331             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 332         }
 333
 334         internal ScrollBar.Direction GetScrollDirection()
 335         {
 336             ScrollBar.Direction ret = (ScrollBar.Direction)NDalicPINVOKE.ScrollBar_GetScrollDirection(swigCPtr);
 337             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 338             return ret;
 339         }
 340
 341         internal void SetIndicatorHeightPolicy(ScrollBar.IndicatorHeightPolicyType policy)
 342         {
 343             NDalicPINVOKE.ScrollBar_SetIndicatorHeightPolicy(swigCPtr, (int)policy);
 344             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 345         }
 346
 347         internal ScrollBar.IndicatorHeightPolicyType GetIndicatorHeightPolicy()
 348         {
 349             ScrollBar.IndicatorHeightPolicyType ret = (ScrollBar.IndicatorHeightPolicyType)NDalicPINVOKE.ScrollBar_GetIndicatorHeightPolicy(swigCPtr);
 350             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 351             return ret;
 352         }
 353
 354         internal void SetIndicatorFixedHeight(float height)
 355         {
 356             NDalicPINVOKE.ScrollBar_SetIndicatorFixedHeight(swigCPtr, height);
 357             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 358         }
 359
 360         internal float GetIndicatorFixedHeight()
 361         {
 362             float ret = NDalicPINVOKE.ScrollBar_GetIndicatorFixedHeight(swigCPtr);
 363             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 364             return ret;
 365         }
 366
 367         internal void SetIndicatorShowDuration(float durationSeconds)
 368         {
 369             NDalicPINVOKE.ScrollBar_SetIndicatorShowDuration(swigCPtr, durationSeconds);
 370             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 371         }
 372
 373         internal float GetIndicatorShowDuration()
 374         {
 375             float ret = NDalicPINVOKE.ScrollBar_GetIndicatorShowDuration(swigCPtr);
 376             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 377             return ret;
 378         }
 379
 380         internal void SetIndicatorHideDuration(float durationSeconds)
 381         {
 382             NDalicPINVOKE.ScrollBar_SetIndicatorHideDuration(swigCPtr, durationSeconds);
 383             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 384         }
 385
 386         internal float GetIndicatorHideDuration()
 387         {
 388             float ret = NDalicPINVOKE.ScrollBar_GetIndicatorHideDuration(swigCPtr);
 389             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 390             return ret;
 391         }
 392
 393         internal void ShowIndicator()
 394         {
 395             NDalicPINVOKE.ScrollBar_ShowIndicator(swigCPtr);
 396             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 397         }
 398
 399         internal void HideIndicator()
 400         {
 401             NDalicPINVOKE.ScrollBar_HideIndicator(swigCPtr);
 402             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 403         }
 404
 405         internal VoidSignal PanFinishedSignal()
 406         {
 407             VoidSignal ret = new VoidSignal(NDalicPINVOKE.ScrollBar_PanFinishedSignal(swigCPtr), false);
 408             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 409             return ret;
 410         }
 411
 412         internal FloatSignal ScrollPositionIntervalReachedSignal()
 413         {
 414             FloatSignal ret = new FloatSignal(NDalicPINVOKE.ScrollBar_ScrollPositionIntervalReachedSignal(swigCPtr), false);
 415             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 416             return ret;
 417         }
 418
 419         internal enum PropertyRange
 420         {
 421             PROPERTY_START_INDEX = PropertyRanges.PROPERTY_REGISTRATION_START_INDEX,
 422             PROPERTY_END_INDEX = View.PropertyRange.PROPERTY_START_INDEX + 1000
 423         }
 424
 425         /// <summary>
 426         /// Direction of scroll bar
 427         /// </summary>
 428         public enum Direction
 429         {
 430             Vertical = 0,
 431             Horizontal
 432         }
 433
 434         /// <summary>
 435         /// Indicator height policy.
 436         /// </summary>
 437         public enum IndicatorHeightPolicyType
 438         {
 439             Variable = 0,
 440             Fixed
 441         }
 442
 443         /// <summary>
 444         /// Direction of scroll bar
 445         /// </summary>
 446         public Direction ScrollDirection
 447         {
 448             get
 449             {
 450                 string temp;
 451                 if (GetProperty(ScrollBar.Property.SCROLL_DIRECTION).Get(out temp) == false)
 452                 {
 453 #if DEBUG_ON
 454                     Tizen.Log.Error("NUI", "ScrollDirection get error!");
 455 #endif
 456                 }
 457
 458                 switch (temp)
 459                 {
 460                     case "Vertical":
 461                         return Direction.Vertical;
 462                     case "Horizontal":
 463                         return Direction.Horizontal;
 464                     default:
 465                         return Direction.Vertical;
 466                 }
 467             }
 468             set
 469             {
 470                 string valueToString = "";
 471                 switch (value)
 472                 {
 473                     case Direction.Vertical:
 474                     {
 475                         valueToString = "Vertical";
 476                         break;
 477                     }
 478                     case Direction.Horizontal:
 479                     {
 480                         valueToString = "Horizontal";
 481                         break;
 482                     }
 483                     default:
 484                     {
 485                         valueToString = "Vertical";
 486                         break;
 487                     }
 488                 }
 489                 SetProperty(ScrollBar.Property.SCROLL_DIRECTION, new Tizen.NUI.PropertyValue(valueToString));
 490             }
 491         }
 492
 493         /// <summary>
 494         /// Indicator height policy.
 495         /// </summary>
 496         public IndicatorHeightPolicyType IndicatorHeightPolicy
 497         {
 498             get
 499             {
 500                 string temp;
 501                 if (GetProperty(ScrollBar.Property.INDICATOR_HEIGHT_POLICY).Get(out temp) == false)
 502                 {
 503 #if DEBUG_ON
 504                     Tizen.Log.Error("NUI", "IndicatorHeightPolicy get error!");
 505 #endif
 506                 }
 507
 508                 switch (temp)
 509                 {
 510                     case "Variable":
 511                         return IndicatorHeightPolicyType.Variable;
 512                     case "Fixed":
 513                         return IndicatorHeightPolicyType.Fixed;
 514                     default:
 515                         return IndicatorHeightPolicyType.Variable;
 516                 }
 517             }
 518             set
 519             {
 520                 string valueToString = "";
 521                 switch (value)
 522                 {
 523                     case IndicatorHeightPolicyType.Variable:
 524                     {
 525                         valueToString = "Variable";
 526                         break;
 527                     }
 528                     case IndicatorHeightPolicyType.Fixed:
 529                     {
 530                         valueToString = "Fixed";
 531                         break;
 532                     }
 533                     default:
 534                     {
 535                         valueToString = "Variable";
 536                         break;
 537                     }
 538                 }
 539                 SetProperty(ScrollBar.Property.INDICATOR_HEIGHT_POLICY, new Tizen.NUI.PropertyValue(valueToString));
 540             }
 541         }
 542
 543         /// <summary>
 544         /// the fixed height of scroll indicator.
 545         /// </summary>
 546         public float IndicatorFixedHeight
 547         {
 548             get
 549             {
 550                 float temp = 0.0f;
 551                 GetProperty(ScrollBar.Property.INDICATOR_FIXED_HEIGHT).Get(ref temp);
 552                 return temp;
 553             }
 554             set
 555             {
 556                 SetProperty(ScrollBar.Property.INDICATOR_FIXED_HEIGHT, new Tizen.NUI.PropertyValue(value));
 557             }
 558         }
 559
 560         /// <summary>
 561         /// the duration in seconds for the scroll indicator to become fully visible.
 562         /// </summary>
 563         public float IndicatorShowDuration
 564         {
 565             get
 566             {
 567                 float temp = 0.0f;
 568                 GetProperty(ScrollBar.Property.INDICATOR_SHOW_DURATION).Get(ref temp);
 569                 return temp;
 570             }
 571             set
 572             {
 573                 SetProperty(ScrollBar.Property.INDICATOR_SHOW_DURATION, new Tizen.NUI.PropertyValue(value));
 574             }
 575         }
 576
 577         /// <summary>
 578         /// the duration in seconds for the scroll indicator to become fully invisible.
 579         /// </summary>
 580         public float IndicatorHideDuration
 581         {
 582             get
 583             {
 584                 float temp = 0.0f;
 585                 GetProperty(ScrollBar.Property.INDICATOR_HIDE_DURATION).Get(ref temp);
 586                 return temp;
 587             }
 588             set
 589             {
 590                 SetProperty(ScrollBar.Property.INDICATOR_HIDE_DURATION, new Tizen.NUI.PropertyValue(value));
 591             }
 592         }
 593
 594         /// <summary>
 595         /// the list of values to get notification when the current scroll position of the scrollable object goes above or below any of these values.
 596         /// </summary>
 597         public Tizen.NUI.PropertyArray ScrollPositionIntervals
 598         {
 599             get
 600             {
 601                 Tizen.NUI.PropertyArray temp = new Tizen.NUI.PropertyArray();
 602                 GetProperty(ScrollBar.Property.SCROLL_POSITION_INTERVALS).Get(temp);
 603                 return temp;
 604             }
 605             set
 606             {
 607                 SetProperty(ScrollBar.Property.SCROLL_POSITION_INTERVALS, new Tizen.NUI.PropertyValue(value));
 608             }
 609         }
 610
 611         /// <summary>
 612         /// The minimum height for a variable size indicator.
 613         /// </summary>
 614         public float IndicatorMinimumHeight
 615         {
 616             get
 617             {
 618                 float temp = 0.0f;
 619                 GetProperty(ScrollBar.Property.INDICATOR_MINIMUM_HEIGHT).Get(ref temp);
 620                 return temp;
 621             }
 622             set
 623             {
 624                 SetProperty(ScrollBar.Property.INDICATOR_MINIMUM_HEIGHT, new Tizen.NUI.PropertyValue(value));
 625             }
 626         }
 627
 628         /// <summary>
 629         /// The padding at the start of the indicator. For example, the top if scrollDirection is Vertical.
 630         /// </summary>
 631         public float IndicatorStartPadding
 632         {
 633             get
 634             {
 635                 float temp = 0.0f;
 636                 GetProperty(ScrollBar.Property.INDICATOR_START_PADDING).Get(ref temp);
 637                 return temp;
 638             }
 639             set
 640             {
 641                 SetProperty(ScrollBar.Property.INDICATOR_START_PADDING, new Tizen.NUI.PropertyValue(value));
 642             }
 643         }
 644
 645         /// <summary>
 646         /// The padding at the end of the indicator. For example, the bottom if scrollDirection is Vertical.
 647         /// </summary>
 648         public float IndicatorEndPadding
 649         {
 650             get
 651             {
 652                 float temp = 0.0f;
 653                 GetProperty(ScrollBar.Property.INDICATOR_END_PADDING).Get(ref temp);
 654                 return temp;
 655             }
 656             set
 657             {
 658                 SetProperty(ScrollBar.Property.INDICATOR_END_PADDING, new Tizen.NUI.PropertyValue(value));
 659             }
 660         }
 661
 662     }
 663
 664 }