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