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