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