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 SetScrollPositionIntervals(VectorFloat positions)
 363         {
 364             NDalicPINVOKE.ScrollBar_SetScrollPositionIntervals(swigCPtr, VectorFloat.getCPtr(positions));
 365             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 366         }
 367
 368         internal VectorFloat GetScrollPositionIntervals()
 369         {
 370             VectorFloat ret = new VectorFloat(NDalicPINVOKE.ScrollBar_GetScrollPositionIntervals(swigCPtr), true);
 371             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 372             return ret;
 373         }
 374
 375         internal void SetScrollDirection(ScrollBar.Direction direction)
 376         {
 377             NDalicPINVOKE.ScrollBar_SetScrollDirection(swigCPtr, (int)direction);
 378             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 379         }
 380
 381         internal ScrollBar.Direction GetScrollDirection()
 382         {
 383             ScrollBar.Direction ret = (ScrollBar.Direction)NDalicPINVOKE.ScrollBar_GetScrollDirection(swigCPtr);
 384             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 385             return ret;
 386         }
 387
 388         internal void SetIndicatorHeightPolicy(ScrollBar.IndicatorHeightPolicyType policy)
 389         {
 390             NDalicPINVOKE.ScrollBar_SetIndicatorHeightPolicy(swigCPtr, (int)policy);
 391             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 392         }
 393
 394         internal ScrollBar.IndicatorHeightPolicyType GetIndicatorHeightPolicy()
 395         {
 396             ScrollBar.IndicatorHeightPolicyType ret = (ScrollBar.IndicatorHeightPolicyType)NDalicPINVOKE.ScrollBar_GetIndicatorHeightPolicy(swigCPtr);
 397             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 398             return ret;
 399         }
 400
 401         internal void SetIndicatorFixedHeight(float height)
 402         {
 403             NDalicPINVOKE.ScrollBar_SetIndicatorFixedHeight(swigCPtr, height);
 404             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 405         }
 406
 407         internal float GetIndicatorFixedHeight()
 408         {
 409             float ret = NDalicPINVOKE.ScrollBar_GetIndicatorFixedHeight(swigCPtr);
 410             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 411             return ret;
 412         }
 413
 414         internal void SetIndicatorShowDuration(float durationSeconds)
 415         {
 416             NDalicPINVOKE.ScrollBar_SetIndicatorShowDuration(swigCPtr, durationSeconds);
 417             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 418         }
 419
 420         internal float GetIndicatorShowDuration()
 421         {
 422             float ret = NDalicPINVOKE.ScrollBar_GetIndicatorShowDuration(swigCPtr);
 423             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 424             return ret;
 425         }
 426
 427         internal void SetIndicatorHideDuration(float durationSeconds)
 428         {
 429             NDalicPINVOKE.ScrollBar_SetIndicatorHideDuration(swigCPtr, durationSeconds);
 430             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 431         }
 432
 433         internal float GetIndicatorHideDuration()
 434         {
 435             float ret = NDalicPINVOKE.ScrollBar_GetIndicatorHideDuration(swigCPtr);
 436             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 437             return ret;
 438         }
 439
 440         internal void ShowIndicator()
 441         {
 442             NDalicPINVOKE.ScrollBar_ShowIndicator(swigCPtr);
 443             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 444         }
 445
 446         internal void HideIndicator()
 447         {
 448             NDalicPINVOKE.ScrollBar_HideIndicator(swigCPtr);
 449             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 450         }
 451
 452         internal VoidSignal PanFinishedSignal()
 453         {
 454             VoidSignal ret = new VoidSignal(NDalicPINVOKE.ScrollBar_PanFinishedSignal(swigCPtr), false);
 455             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 456             return ret;
 457         }
 458
 459         internal FloatSignal ScrollPositionIntervalReachedSignal()
 460         {
 461             FloatSignal ret = new FloatSignal(NDalicPINVOKE.ScrollBar_ScrollPositionIntervalReachedSignal(swigCPtr), false);
 462             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 463             return ret;
 464         }
 465
 466         internal enum PropertyRange
 467         {
 468             PROPERTY_START_INDEX = PropertyRanges.PROPERTY_REGISTRATION_START_INDEX,
 469             PROPERTY_END_INDEX = View.PropertyRange.PROPERTY_START_INDEX + 1000
 470         }
 471
 472         /// <summary>
 473         /// Direction of scroll bar
 474         /// </summary>
 475         public enum Direction
 476         {
 477             Vertical = 0,
 478             Horizontal
 479         }
 480
 481         /// <summary>
 482         /// Indicator height policy.
 483         /// </summary>
 484         public enum IndicatorHeightPolicyType
 485         {
 486             Variable = 0,
 487             Fixed
 488         }
 489
 490         /// <summary>
 491         /// Direction of scroll bar
 492         /// </summary>
 493         public Direction ScrollDirection
 494         {
 495             get
 496             {
 497                 string temp;
 498                 if (GetProperty(ScrollBar.Property.SCROLL_DIRECTION).Get(out temp) == false)
 499                 {
 500 #if DEBUG_ON
 501                     Tizen.Log.Error("NUI", "ScrollDirection get error!");
 502 #endif
 503                 }
 504
 505                 switch (temp)
 506                 {
 507                     case "Vertical":
 508                         return Direction.Vertical;
 509                     case "Horizontal":
 510                         return Direction.Horizontal;
 511                     default:
 512                         return Direction.Vertical;
 513                 }
 514             }
 515             set
 516             {
 517                 string valueToString = "";
 518                 switch (value)
 519                 {
 520                     case Direction.Vertical:
 521                     {
 522                         valueToString = "Vertical";
 523                         break;
 524                     }
 525                     case Direction.Horizontal:
 526                     {
 527                         valueToString = "Horizontal";
 528                         break;
 529                     }
 530                     default:
 531                     {
 532                         valueToString = "Vertical";
 533                         break;
 534                     }
 535                 }
 536                 SetProperty(ScrollBar.Property.SCROLL_DIRECTION, new Tizen.NUI.PropertyValue(valueToString));
 537             }
 538         }
 539
 540         /// <summary>
 541         /// Indicator height policy.
 542         /// </summary>
 543         public IndicatorHeightPolicyType IndicatorHeightPolicy
 544         {
 545             get
 546             {
 547                 string temp;
 548                 if (GetProperty(ScrollBar.Property.INDICATOR_HEIGHT_POLICY).Get(out temp) == false)
 549                 {
 550 #if DEBUG_ON
 551                     Tizen.Log.Error("NUI", "IndicatorHeightPolicy get error!");
 552 #endif
 553                 }
 554
 555                 switch (temp)
 556                 {
 557                     case "Variable":
 558                         return IndicatorHeightPolicyType.Variable;
 559                     case "Fixed":
 560                         return IndicatorHeightPolicyType.Fixed;
 561                     default:
 562                         return IndicatorHeightPolicyType.Variable;
 563                 }
 564             }
 565             set
 566             {
 567                 string valueToString = "";
 568                 switch (value)
 569                 {
 570                     case IndicatorHeightPolicyType.Variable:
 571                     {
 572                         valueToString = "Variable";
 573                         break;
 574                     }
 575                     case IndicatorHeightPolicyType.Fixed:
 576                     {
 577                         valueToString = "Fixed";
 578                         break;
 579                     }
 580                     default:
 581                     {
 582                         valueToString = "Variable";
 583                         break;
 584                     }
 585                 }
 586                 SetProperty(ScrollBar.Property.INDICATOR_HEIGHT_POLICY, new Tizen.NUI.PropertyValue(valueToString));
 587             }
 588         }
 589
 590         /// <summary>
 591         /// the fixed height of scroll indicator.
 592         /// </summary>
 593         public float IndicatorFixedHeight
 594         {
 595             get
 596             {
 597                 float temp = 0.0f;
 598                 GetProperty(ScrollBar.Property.INDICATOR_FIXED_HEIGHT).Get(ref temp);
 599                 return temp;
 600             }
 601             set
 602             {
 603                 SetProperty(ScrollBar.Property.INDICATOR_FIXED_HEIGHT, new Tizen.NUI.PropertyValue(value));
 604             }
 605         }
 606
 607         /// <summary>
 608         /// the duration in seconds for the scroll indicator to become fully visible.
 609         /// </summary>
 610         public float IndicatorShowDuration
 611         {
 612             get
 613             {
 614                 float temp = 0.0f;
 615                 GetProperty(ScrollBar.Property.INDICATOR_SHOW_DURATION).Get(ref temp);
 616                 return temp;
 617             }
 618             set
 619             {
 620                 SetProperty(ScrollBar.Property.INDICATOR_SHOW_DURATION, new Tizen.NUI.PropertyValue(value));
 621             }
 622         }
 623
 624         /// <summary>
 625         /// the duration in seconds for the scroll indicator to become fully invisible.
 626         /// </summary>
 627         public float IndicatorHideDuration
 628         {
 629             get
 630             {
 631                 float temp = 0.0f;
 632                 GetProperty(ScrollBar.Property.INDICATOR_HIDE_DURATION).Get(ref temp);
 633                 return temp;
 634             }
 635             set
 636             {
 637                 SetProperty(ScrollBar.Property.INDICATOR_HIDE_DURATION, new Tizen.NUI.PropertyValue(value));
 638             }
 639         }
 640
 641         /// <summary>
 642         /// the list of values to get notification when the current scroll position of the scrollable object goes above or below any of these values.
 643         /// </summary>
 644         public Tizen.NUI.PropertyArray ScrollPositionIntervals
 645         {
 646             get
 647             {
 648                 Tizen.NUI.PropertyArray temp = new Tizen.NUI.PropertyArray();
 649                 GetProperty(ScrollBar.Property.SCROLL_POSITION_INTERVALS).Get(temp);
 650                 return temp;
 651             }
 652             set
 653             {
 654                 SetProperty(ScrollBar.Property.SCROLL_POSITION_INTERVALS, new Tizen.NUI.PropertyValue(value));
 655             }
 656         }
 657
 658         /// <summary>
 659         /// The minimum height for a variable size indicator.
 660         /// </summary>
 661         public float IndicatorMinimumHeight
 662         {
 663             get
 664             {
 665                 float temp = 0.0f;
 666                 GetProperty(ScrollBar.Property.INDICATOR_MINIMUM_HEIGHT).Get(ref temp);
 667                 return temp;
 668             }
 669             set
 670             {
 671                 SetProperty(ScrollBar.Property.INDICATOR_MINIMUM_HEIGHT, new Tizen.NUI.PropertyValue(value));
 672             }
 673         }
 674
 675         /// <summary>
 676         /// The padding at the start of the indicator. For example, the top if scrollDirection is Vertical.
 677         /// </summary>
 678         public float IndicatorStartPadding
 679         {
 680             get
 681             {
 682                 float temp = 0.0f;
 683                 GetProperty(ScrollBar.Property.INDICATOR_START_PADDING).Get(ref temp);
 684                 return temp;
 685             }
 686             set
 687             {
 688                 SetProperty(ScrollBar.Property.INDICATOR_START_PADDING, new Tizen.NUI.PropertyValue(value));
 689             }
 690         }
 691
 692         /// <summary>
 693         /// The padding at the end of the indicator. For example, the bottom if scrollDirection is Vertical.
 694         /// </summary>
 695         public float IndicatorEndPadding
 696         {
 697             get
 698             {
 699                 float temp = 0.0f;
 700                 GetProperty(ScrollBar.Property.INDICATOR_END_PADDING).Get(ref temp);
 701                 return temp;
 702             }
 703             set
 704             {
 705                 SetProperty(ScrollBar.Property.INDICATOR_END_PADDING, new Tizen.NUI.PropertyValue(value));
 706             }
 707         }
 708
 709     }
 710
 711 }