src/Tizen.NUI/src/public/Utility/ScrollView.cs

   1 /*
   2  * Copyright(c) 2021 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 using System.ComponentModel;
  19 using Tizen.NUI.BaseComponents;
  20 using Tizen.NUI;
  21 using Tizen.NUI.Binding;
  22
  23 namespace Tizen.NUI
  24 {
  25     /// <summary>
  26     /// ScrollView contains views that can be scrolled manually (via touch).
  27     /// </summary>
  28     [EditorBrowsable(EditorBrowsableState.Never)]
  29     public partial class ScrollView : Scrollable
  30     {
  31
  32         static ScrollView()
  33         {
  34             if(NUIApplication.IsUsingXaml)
  35             {
  36                 WrapEnabledProperty = BindableProperty.Create(nameof(WrapEnabled), typeof(bool), typeof(ScrollView), false, propertyChanged: SetInternalWrapEnabledProperty, defaultValueCreator: GetInternalWrapEnabledProperty);
  37
  38                 PanningEnabledProperty = BindableProperty.Create(nameof(PanningEnabled), typeof(bool), typeof(ScrollView), false, propertyChanged: SetInternalPanningEnabledProperty, defaultValueCreator: GetInternalPanningEnabledProperty);
  39
  40                 AxisAutoLockEnabledProperty = BindableProperty.Create(nameof(AxisAutoLockEnabled), typeof(bool), typeof(ScrollView), false, propertyChanged: SetInternalAxisAutoLockEnabledProperty, defaultValueCreator: GetInternalAxisAutoLockEnabledProperty);
  41
  42                 WheelScrollDistanceStepProperty = BindableProperty.Create(nameof(WheelScrollDistanceStep), typeof(Vector2), typeof(ScrollView), Vector2.Zero, propertyChanged: SetInternalWheelScrollDistanceStepProperty, defaultValueCreator: GetInternalWheelScrollDistanceStepProperty);
  43
  44                 ScrollPositionProperty = BindableProperty.Create(nameof(ScrollPosition), typeof(Vector2), typeof(ScrollView), Vector2.Zero, propertyChanged: SetInternalScrollPositionProperty, defaultValueCreator: GetInternalScrollPositionProperty);
  45
  46                 ScrollPrePositionProperty = BindableProperty.Create(nameof(ScrollPrePosition), typeof(Vector2), typeof(ScrollView), Vector2.Zero, propertyChanged: SetInternalScrollPrePositionProperty, defaultValueCreator: GetInternalScrollPrePositionProperty);
  47
  48                 ScrollPrePositionMaxProperty = BindableProperty.Create(nameof(ScrollPrePositionMax), typeof(Vector2), typeof(ScrollView), Vector2.Zero, propertyChanged: SetInternalScrollPrePositionMaxProperty, defaultValueCreator: GetInternalScrollPrePositionMaxProperty);
  49
  50                 OvershootXProperty = BindableProperty.Create(nameof(OvershootX), typeof(float), typeof(ScrollView), default(float), propertyChanged: SetInternalOvershootXProperty, defaultValueCreator: GetInternalOvershootXProperty);
  51
  52                 OvershootYProperty = BindableProperty.Create(nameof(OvershootY), typeof(float), typeof(ScrollView), default(float), propertyChanged: SetInternalOvershootYProperty, defaultValueCreator: GetInternalOvershootYProperty);
  53
  54                 ScrollFinalProperty = BindableProperty.Create(nameof(ScrollFinal), typeof(Vector2), typeof(ScrollView), Vector2.Zero, propertyChanged: SetInternalScrollFinalProperty, defaultValueCreator: GetInternalScrollFinalProperty);
  55
  56                 WrapProperty = BindableProperty.Create(nameof(Wrap), typeof(bool), typeof(ScrollView), false, propertyChanged: SetInternalWrapProperty, defaultValueCreator: GetInternalWrapProperty);
  57
  58                 PanningProperty = BindableProperty.Create(nameof(Panning), typeof(bool), typeof(ScrollView), false, propertyChanged: SetInternalPanningProperty, defaultValueCreator: GetInternalPanningProperty);
  59
  60                 ScrollingProperty = BindableProperty.Create(nameof(Scrolling), typeof(bool), typeof(ScrollView), false, propertyChanged: SetInternalScrollingProperty, defaultValueCreator: GetInternalScrollingProperty);
  61
  62                 ScrollDomainSizeProperty = BindableProperty.Create(nameof(ScrollDomainSize), typeof(Vector2), typeof(ScrollView), Vector2.Zero, propertyChanged: SetInternalScrollDomainSizeProperty, defaultValueCreator: GetInternalScrollDomainSizeProperty);
  63
  64                 ScrollDomainOffsetProperty = BindableProperty.Create(nameof(ScrollDomainOffset), typeof(Vector2), typeof(ScrollView), Vector2.Zero, propertyChanged: SetInternalScrollDomainOffsetProperty, defaultValueCreator: GetInternalScrollDomainOffsetProperty);
  65
  66                 ScrollPositionDeltaProperty = BindableProperty.Create(nameof(ScrollPositionDelta), typeof(Vector2), typeof(ScrollView), Vector2.Zero, propertyChanged: SetInternalScrollPositionDeltaProperty, defaultValueCreator: GetInternalScrollPositionDeltaProperty);
  67
  68                 StartPagePositionProperty = BindableProperty.Create(nameof(StartPagePosition), typeof(Vector3), typeof(ScrollView), Vector3.Zero, propertyChanged: SetInternalStartPagePositionProperty, defaultValueCreator: GetInternalStartPagePositionProperty);
  69
  70                 ScrollModeProperty = BindableProperty.Create(nameof(ScrollMode), typeof(PropertyMap), typeof(ScrollView), new PropertyMap(), propertyChanged: SetInternalScrollModeProperty, defaultValueCreator: GetInternalScrollModeProperty);
  71
  72             }
  73         }
  74
  75         /// <summary>
  76         /// Create an instance of ScrollView.
  77         /// </summary>
  78         [EditorBrowsable(EditorBrowsableState.Never)]
  79         public ScrollView() : this(Interop.ScrollView.New(), true)
  80         {
  81             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
  82         }
  83
  84         internal ScrollView(global::System.IntPtr cPtr, bool cMemoryOwn) : base(cPtr, cMemoryOwn)
  85         {
  86         }
  87
  88         /// <summary>
  89         /// Sets and Gets WrapEnabled property.
  90         /// </summary>
  91         [EditorBrowsable(EditorBrowsableState.Never)]
  92         public bool WrapEnabled
  93         {
  94             get
  95             {
  96                 if (NUIApplication.IsUsingXaml)
  97                 {
  98                     return (bool)GetValue(WrapEnabledProperty);
  99                 }
 100                 else
 101                 {
 102                     return (bool)GetInternalWrapEnabledProperty(this);
 103                 }
 104             }
 105             set
 106             {
 107                 if (NUIApplication.IsUsingXaml)
 108                 {
 109                     SetValue(WrapEnabledProperty, value);
 110                 }
 111                 else
 112                 {
 113                     SetInternalWrapEnabledProperty(this, null, value);
 114                 }
 115             }
 116         }
 117
 118         /// <summary>
 119         /// Sets and Gets PanningEnabled property.
 120         /// </summary>
 121         [EditorBrowsable(EditorBrowsableState.Never)]
 122         public bool PanningEnabled
 123         {
 124             get
 125             {
 126                 if (NUIApplication.IsUsingXaml)
 127                 {
 128                     return (bool)GetValue(PanningEnabledProperty);
 129                 }
 130                 else
 131                 {
 132                     return (bool)GetInternalPanningEnabledProperty(this);
 133                 }
 134             }
 135             set
 136             {
 137                 if (NUIApplication.IsUsingXaml)
 138                 {
 139                     SetValue(PanningEnabledProperty, value);
 140                 }
 141                 else
 142                 {
 143                     SetInternalPanningEnabledProperty(this, null, value);
 144                 }
 145             }
 146         }
 147
 148         /// <summary>
 149         /// Sets and Gets AxisAutoLockEnabled property.
 150         /// </summary>
 151         [EditorBrowsable(EditorBrowsableState.Never)]
 152         public bool AxisAutoLockEnabled
 153         {
 154             get
 155             {
 156                 if (NUIApplication.IsUsingXaml)
 157                 {
 158                     return (bool)GetValue(AxisAutoLockEnabledProperty);
 159                 }
 160                 else
 161                 {
 162                      return (bool)GetInternalAxisAutoLockEnabledProperty(this);
 163                 }
 164             }
 165             set
 166             {
 167                 if (NUIApplication.IsUsingXaml)
 168                 {
 169                     SetValue(AxisAutoLockEnabledProperty, value);
 170                 }
 171                 else
 172                 {
 173                     SetInternalAxisAutoLockEnabledProperty(this, null, value);
 174                 }
 175             }
 176         }
 177
 178         /// <summary>
 179         /// Sets and Gets WheelScrollDistanceStep property.
 180         /// </summary>
 181         [EditorBrowsable(EditorBrowsableState.Never)]
 182         public Vector2 WheelScrollDistanceStep
 183         {
 184             get
 185             {
 186                 if (NUIApplication.IsUsingXaml)
 187                 {
 188                     return (Vector2)GetValue(WheelScrollDistanceStepProperty);
 189                 }
 190                 else
 191                 {
 192                     return (Vector2)GetInternalWheelScrollDistanceStepProperty(this);
 193                 }
 194             }
 195             set
 196             {
 197                 if (NUIApplication.IsUsingXaml)
 198                 {
 199                     SetValue(WheelScrollDistanceStepProperty, value);
 200                 }
 201                 else
 202                 {
 203                     SetInternalWheelScrollDistanceStepProperty(this, null, value);
 204                 }
 205             }
 206         }
 207
 208         /// <summary>
 209         /// Sets and Gets ScrollPosition property.
 210         /// </summary>
 211         [EditorBrowsable(EditorBrowsableState.Never)]
 212         public Vector2 ScrollPosition
 213         {
 214             get
 215             {
 216                 if (NUIApplication.IsUsingXaml)
 217                 {
 218                     return (Vector2)GetValue(ScrollPositionProperty);
 219                 }
 220                 else
 221                 {
 222                     return (Vector2)GetInternalScrollPositionProperty(this);
 223                 }
 224             }
 225             set
 226             {
 227                 if (NUIApplication.IsUsingXaml)
 228                 {
 229                     SetValue(ScrollPositionProperty, value);
 230                 }
 231                 else
 232                 {
 233                     SetInternalScrollPositionProperty(this, null, value);
 234                 }
 235             }
 236         }
 237
 238         /// <summary>
 239         /// Sets and Gets ScrollPrePosition property.
 240         /// </summary>
 241         [EditorBrowsable(EditorBrowsableState.Never)]
 242         public Vector2 ScrollPrePosition
 243         {
 244             get
 245             {
 246                 if (NUIApplication.IsUsingXaml)
 247                 {
 248                     return (Vector2)GetValue(ScrollPrePositionProperty);
 249                 }
 250                 else
 251                 {
 252                     return (Vector2)GetInternalScrollPrePositionProperty(this);
 253                 }
 254             }
 255             set
 256             {
 257                 if (NUIApplication.IsUsingXaml)
 258                 {
 259                     SetValue(ScrollPrePositionProperty, value);
 260                 }
 261                 else
 262                 {
 263                     SetInternalScrollPrePositionProperty(this, null, value);
 264                 }
 265             }
 266         }
 267
 268         /// <summary>
 269         /// Sets and Gets ScrollPrePositionMax property.
 270         /// </summary>
 271         [EditorBrowsable(EditorBrowsableState.Never)]
 272         public Vector2 ScrollPrePositionMax
 273         {
 274             get
 275             {
 276                 if (NUIApplication.IsUsingXaml)
 277                 {
 278                     return (Vector2)GetValue(ScrollPrePositionMaxProperty);
 279                 }
 280                 else
 281                 {
 282                     return (Vector2)GetInternalScrollPrePositionMaxProperty(this);
 283                 }
 284             }
 285             set
 286             {
 287                 if (NUIApplication.IsUsingXaml)
 288                 {
 289                     SetValue(ScrollPrePositionMaxProperty, value);
 290
 291                 }
 292                 else
 293                 {
 294                     SetInternalScrollPrePositionMaxProperty(this, null, value);
 295                 }
 296             }
 297         }
 298
 299         /// <summary>
 300         /// Sets and Gets OvershootX property.
 301         /// </summary>
 302         [EditorBrowsable(EditorBrowsableState.Never)]
 303         public float OvershootX
 304         {
 305             get
 306             {
 307                 if (NUIApplication.IsUsingXaml)
 308                 {
 309                     return (float)GetValue(OvershootXProperty);
 310                 }
 311                 else
 312                 {
 313                     return (float)GetInternalOvershootXProperty(this);
 314                 }
 315             }
 316             set
 317             {
 318                 if (NUIApplication.IsUsingXaml)
 319                 {
 320                     SetValue(OvershootXProperty, value);
 321                 }
 322                 else
 323                 {
 324                     SetInternalOvershootXProperty(this, null, value);
 325                 }
 326             }
 327         }
 328
 329         /// <summary>
 330         /// Sets and Gets OvershootY property.
 331         /// </summary>
 332         [EditorBrowsable(EditorBrowsableState.Never)]
 333         public float OvershootY
 334         {
 335             get
 336             {
 337                 if (NUIApplication.IsUsingXaml)
 338                 {
 339                     return (float)GetValue(OvershootYProperty);
 340                 }
 341                 else
 342                 {
 343                     return (float)GetInternalOvershootYProperty(this);
 344                 }
 345             }
 346             set
 347             {
 348                 if (NUIApplication.IsUsingXaml)
 349                 {
 350                     SetValue(OvershootYProperty, value);
 351                 }
 352                 else
 353                 {
 354                     SetInternalOvershootYProperty(this, null, value);
 355                 }
 356             }
 357         }
 358
 359         /// <summary>
 360         /// Sets and Gets ScrollFinal property.
 361         /// </summary>
 362         [EditorBrowsable(EditorBrowsableState.Never)]
 363         public Vector2 ScrollFinal
 364         {
 365             get
 366             {
 367                 if (NUIApplication.IsUsingXaml)
 368                 {
 369                     return (Vector2)GetValue(ScrollFinalProperty);
 370                 }
 371                 else
 372                 {
 373                     return (Vector2)GetInternalScrollFinalProperty(this);
 374                 }
 375             }
 376             set
 377             {
 378                 if (NUIApplication.IsUsingXaml)
 379                 {
 380                     SetValue(ScrollFinalProperty, value);
 381                 }
 382                 else
 383                 {
 384                     SetInternalScrollFinalProperty(this, null, value);
 385                 }
 386             }
 387         }
 388
 389         /// <summary>
 390         /// Sets and Gets Wrap property.
 391         /// </summary>
 392         [EditorBrowsable(EditorBrowsableState.Never)]
 393         public bool Wrap
 394         {
 395             get
 396             {
 397                 if (NUIApplication.IsUsingXaml)
 398                 {
 399                     return (bool)GetValue(WrapProperty);
 400                 }
 401                 else
 402                 {
 403                     return (bool)GetInternalWrapProperty(this);
 404                 }
 405             }
 406             set
 407             {
 408                 if (NUIApplication.IsUsingXaml)
 409                 {
 410                     SetValue(WrapProperty, value);
 411
 412                 }
 413                 else
 414                 {
 415                     SetInternalWrapProperty(this, null, value);
 416                 }
 417             }
 418         }
 419
 420         /// <summary>
 421         /// Sets and Gets Panning property.
 422         /// </summary>
 423         [EditorBrowsable(EditorBrowsableState.Never)]
 424         public bool Panning
 425         {
 426             get
 427             {
 428                 if (NUIApplication.IsUsingXaml)
 429                 {
 430                     return (bool)GetValue(PanningProperty);
 431                 }
 432                 else
 433                 {
 434                     return (bool)GetInternalPanningProperty(this);
 435                 }
 436             }
 437             set
 438             {
 439                 if (NUIApplication.IsUsingXaml)
 440                 {
 441                     SetValue(PanningProperty, value);
 442                 }
 443                 else
 444                 {
 445                     SetInternalPanningProperty(this, null, value);
 446                 }
 447             }
 448         }
 449
 450         /// <summary>
 451         /// Sets and Gets Scrolling property.
 452         /// </summary>
 453         [EditorBrowsable(EditorBrowsableState.Never)]
 454         public bool Scrolling
 455         {
 456             get
 457             {
 458                 if (NUIApplication.IsUsingXaml)
 459                 {
 460                     return (bool)GetValue(ScrollingProperty);
 461                 }
 462                 else
 463                 {
 464                     return (bool)GetInternalScrollingProperty(this);
 465                 }
 466             }
 467             set
 468             {
 469                 if (NUIApplication.IsUsingXaml)
 470                 {
 471                     SetValue(ScrollingProperty, value);
 472                 }
 473                 else
 474                 {
 475                     SetInternalScrollingProperty(this, null, value);
 476                 }
 477             }
 478         }
 479
 480         /// <summary>
 481         /// Sets and Gets ScrollDomainSize property.
 482         /// </summary>
 483         [EditorBrowsable(EditorBrowsableState.Never)]
 484         public Vector2 ScrollDomainSize
 485         {
 486             get
 487             {
 488                 if (NUIApplication.IsUsingXaml)
 489                 {
 490                     return (Vector2)GetValue(ScrollDomainSizeProperty);
 491                 }
 492                 else
 493                 {
 494                     return (Vector2)GetInternalScrollDomainSizeProperty(this);
 495                 }
 496             }
 497             set
 498             {
 499                 if (NUIApplication.IsUsingXaml)
 500                 {
 501                     SetValue(ScrollDomainSizeProperty, value);
 502                 }
 503                 else
 504                 {
 505                     SetInternalScrollDomainSizeProperty(this, null, value);
 506                 }
 507             }
 508         }
 509
 510         /// <summary>
 511         /// Sets and Gets ScrollDomainOffset property.
 512         /// </summary>
 513         [EditorBrowsable(EditorBrowsableState.Never)]
 514         public Vector2 ScrollDomainOffset
 515         {
 516             get
 517             {
 518                 if (NUIApplication.IsUsingXaml)
 519                 {
 520                     return (Vector2)GetValue(ScrollDomainOffsetProperty);
 521                 }
 522                 else
 523                 {
 524                     return (Vector2)GetInternalScrollDomainOffsetProperty(this);
 525                 }
 526             }
 527             set
 528             {
 529                 if (NUIApplication.IsUsingXaml)
 530                 {
 531                     SetValue(ScrollDomainOffsetProperty, value);
 532                 }
 533                 else
 534                 {
 535                     SetInternalScrollDomainOffsetProperty(this, null, value);
 536                 }
 537             }
 538         }
 539
 540         /// <summary>
 541         /// Sets and Gets ScrollPositionDelta property.
 542         /// </summary>
 543         [EditorBrowsable(EditorBrowsableState.Never)]
 544         public Vector2 ScrollPositionDelta
 545         {
 546             get
 547             {
 548                 if (NUIApplication.IsUsingXaml)
 549                 {
 550                     return (Vector2)GetValue(ScrollPositionDeltaProperty);
 551                 }
 552                 else
 553                 {
 554                     return (Vector2)GetInternalScrollPositionDeltaProperty(this);
 555                 }
 556             }
 557             set
 558             {
 559                 if (NUIApplication.IsUsingXaml)
 560                 {
 561                     SetValue(ScrollPositionDeltaProperty, value);
 562                 }
 563                 else
 564                 {
 565                     SetInternalScrollPositionDeltaProperty(this, null, value);
 566                 }
 567             }
 568         }
 569
 570         /// <summary>
 571         /// Sets and Gets StartPagePosition property.
 572         /// </summary>
 573         [EditorBrowsable(EditorBrowsableState.Never)]
 574         public Vector3 StartPagePosition
 575         {
 576             get
 577             {
 578                 if (NUIApplication.IsUsingXaml)
 579                 {
 580                     return (Vector3)GetValue(StartPagePositionProperty);
 581                 }
 582                 else
 583                 {
 584                     return (Vector3)GetInternalStartPagePositionProperty(this);
 585                 }
 586             }
 587             set
 588             {
 589                 if (NUIApplication.IsUsingXaml)
 590                 {
 591                     SetValue(StartPagePositionProperty, value);
 592                 }
 593                 else
 594                 {
 595                     SetInternalStartPagePositionProperty(this, null, value);
 596                 }
 597             }
 598         }
 599
 600
 601         /// <summary>
 602         /// Sets and Gets ScrollMode property.
 603         /// </summary>
 604         [EditorBrowsable(EditorBrowsableState.Never)]
 605         public PropertyMap ScrollMode
 606         {
 607             get
 608             {
 609                 if (NUIApplication.IsUsingXaml)
 610                 {
 611                     return (PropertyMap)GetValue(ScrollModeProperty);
 612                 }
 613                 else
 614                 {
 615                     return (PropertyMap)GetInternalScrollModeProperty(this);
 616                 }
 617             }
 618             set
 619             {
 620                 if (NUIApplication.IsUsingXaml)
 621                 {
 622                     SetValue(ScrollModeProperty, value);
 623                 }
 624                 else
 625                 {
 626                     SetInternalScrollModeProperty(this, null, value);
 627                 }
 628             }
 629         }
 630
 631         /// <summary>
 632         /// Gets snap-animation's AlphaFunction.
 633         /// </summary>
 634         /// <returns>Current easing alpha function of the snap animation.</returns>
 635         [EditorBrowsable(EditorBrowsableState.Never)]
 636         public AlphaFunction GetScrollSnapAlphaFunction()
 637         {
 638             AlphaFunction ret = new AlphaFunction(Interop.ScrollView.GetScrollSnapAlphaFunction(SwigCPtr), true);
 639             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 640             return ret;
 641         }
 642
 643         /// <summary>
 644         /// Sets snap-animation's AlphaFunction.
 645         /// </summary>
 646         /// <param name="alpha">Easing alpha function of the snap animation.</param>
 647         [EditorBrowsable(EditorBrowsableState.Never)]
 648         public void SetScrollSnapAlphaFunction(AlphaFunction alpha)
 649         {
 650             Interop.ScrollView.SetScrollSnapAlphaFunction(SwigCPtr, AlphaFunction.getCPtr(alpha));
 651             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 652         }
 653
 654         /// <summary>
 655         /// Gets flick-animation's AlphaFunction.
 656         /// </summary>
 657         /// <returns>Current easing alpha function of the flick animation.</returns>
 658         [EditorBrowsable(EditorBrowsableState.Never)]
 659         public AlphaFunction GetScrollFlickAlphaFunction()
 660         {
 661             AlphaFunction ret = new AlphaFunction(Interop.ScrollView.GetScrollFlickAlphaFunction(SwigCPtr), true);
 662             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 663             return ret;
 664         }
 665
 666         /// <summary>
 667         /// Sets flick-animation's AlphaFunction.
 668         /// </summary>
 669         /// <param name="alpha">Easing alpha function of the flick animation.</param>
 670         [EditorBrowsable(EditorBrowsableState.Never)]
 671         public void SetScrollFlickAlphaFunction(AlphaFunction alpha)
 672         {
 673             Interop.ScrollView.SetScrollFlickAlphaFunction(SwigCPtr, AlphaFunction.getCPtr(alpha));
 674             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 675         }
 676
 677         /// <summary>
 678         /// Gets the time for the scroll snap-animation.
 679         /// </summary>
 680         /// <returns>The time in seconds for the animation to take.</returns>
 681         [EditorBrowsable(EditorBrowsableState.Never)]
 682         public float GetScrollSnapDuration()
 683         {
 684             float ret = Interop.ScrollView.GetScrollSnapDuration(SwigCPtr);
 685             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 686             return ret;
 687         }
 688
 689         /// <summary>
 690         /// Sets the time for the scroll snap-animation.
 691         /// </summary>
 692         /// <param name="time">The time in seconds for the animation to take.</param>
 693         [EditorBrowsable(EditorBrowsableState.Never)]
 694         public void SetScrollSnapDuration(float time)
 695         {
 696             Interop.ScrollView.SetScrollSnapDuration(SwigCPtr, time);
 697             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 698         }
 699
 700         /// <summary>
 701         /// Gets the time for the scroll flick-animation.
 702         /// </summary>
 703         /// <returns>The time in seconds for the animation to take.</returns>
 704         [EditorBrowsable(EditorBrowsableState.Never)]
 705         public float GetScrollFlickDuration()
 706         {
 707             float ret = Interop.ScrollView.GetScrollFlickDuration(SwigCPtr);
 708             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 709             return ret;
 710         }
 711
 712         /// <summary>
 713         /// Sets the time for the scroll snap-animation.
 714         /// </summary>
 715         /// <param name="time">The time in seconds for the animation to take.</param>
 716         [EditorBrowsable(EditorBrowsableState.Never)]
 717         public void SetScrollFlickDuration(float time)
 718         {
 719             Interop.ScrollView.SetScrollFlickDuration(SwigCPtr, time);
 720             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 721         }
 722
 723         /// <summary>
 724         /// Sets scroll sensibility of pan gesture.
 725         /// </summary>
 726         /// <param name="sensitive">True to enable scroll, false to disable scrolling.</param>
 727         [EditorBrowsable(EditorBrowsableState.Never)]
 728         public void SetScrollSensitive(bool sensitive)
 729         {
 730             Interop.ScrollView.SetScrollSensitive(SwigCPtr, sensitive);
 731             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 732         }
 733
 734         /// <summary>
 735         /// Sets maximum overshoot amount.
 736         /// </summary>
 737         /// <param name="overshootX">The maximum number of horizontally scrolled pixels before overshoot X reaches 1.0f.</param>
 738         /// <param name="overshootY">The maximum number of vertically scrolled pixels before overshoot X reaches 1.0f.</param>
 739         [EditorBrowsable(EditorBrowsableState.Never)]
 740         public void SetMaxOvershoot(float overshootX, float overshootY)
 741         {
 742             Interop.ScrollView.SetMaxOvershoot(SwigCPtr, overshootX, overshootY);
 743             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 744         }
 745
 746         /// <summary>
 747         /// Sets Snap Overshoot animation's AlphaFunction.
 748         /// </summary>
 749         /// <param name="alpha">Easing alpha function of the overshoot snap animation.</param>
 750         [EditorBrowsable(EditorBrowsableState.Never)]
 751         public void SetSnapOvershootAlphaFunction(AlphaFunction alpha)
 752         {
 753             Interop.ScrollView.SetSnapOvershootAlphaFunction(SwigCPtr, AlphaFunction.getCPtr(alpha));
 754             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 755         }
 756
 757         /// <summary>
 758         /// Sets Snap Overshoot animation's Duration.
 759         /// </summary>
 760         /// <param name="duration">duration The duration of the overshoot snap animation.</param>
 761         [EditorBrowsable(EditorBrowsableState.Never)]
 762         public void SetSnapOvershootDuration(float duration)
 763         {
 764             Interop.ScrollView.SetSnapOvershootDuration(SwigCPtr, duration);
 765             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 766         }
 767
 768         /// <summary>
 769         /// Enables or Disables Actor Auto-Snap mode.<br />
 770         /// When Actor Auto-Snap mode has been enabled, ScrollView will automatically,
 771         /// snap to the closest actor (The closest actor will appear in the center of the ScrollView).
 772         /// </summary>
 773         /// <param name="enable">Enables (true), or disables (false) Actor AutoSnap.</param>
 774         [EditorBrowsable(EditorBrowsableState.Never)]
 775         public void SetViewAutoSnap(bool enable)
 776         {
 777             Interop.ScrollView.SetActorAutoSnap(SwigCPtr, enable);
 778             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 779         }
 780
 781         /// <summary>
 782         /// Enables or Disables Wrap mode for ScrollView contents.<br />
 783         /// When enabled, the ScrollView contents are wrapped over the X/Y Domain.
 784         /// </summary>
 785         /// <param name="enable">Enables (true), or disables (false) Wrap Mode.</param>
 786         [EditorBrowsable(EditorBrowsableState.Never)]
 787         public void SetWrapMode(bool enable)
 788         {
 789             Interop.ScrollView.SetWrapMode(SwigCPtr, enable);
 790             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 791         }
 792
 793         /// <summary>
 794         /// Gets the current distance needed to scroll for ScrollUpdatedSignal to be emitted.
 795         /// </summary>
 796         /// <returns>Current scroll update distance.</returns>
 797         [EditorBrowsable(EditorBrowsableState.Never)]
 798         public int GetScrollUpdateDistance()
 799         {
 800             int ret = Interop.ScrollView.GetScrollUpdateDistance(SwigCPtr);
 801             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 802             return ret;
 803         }
 804
 805         /// <summary>
 806         /// Sets the distance needed to scroll for ScrollUpdatedSignal to be emitted.<br />
 807         /// The scroll update distance tells ScrollView how far to move before ScrollUpdatedSignal the informs application.<br />
 808         /// Each time the ScrollView crosses this distance the signal will be emitted.<br />
 809         /// </summary>
 810         /// <param name="distance">The distance for ScrollView to move before emitting update signal.</param>
 811         [EditorBrowsable(EditorBrowsableState.Never)]
 812         public void SetScrollUpdateDistance(int distance)
 813         {
 814             Interop.ScrollView.SetScrollUpdateDistance(SwigCPtr, distance);
 815             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 816         }
 817
 818         /// <summary>
 819         /// Returns state of Axis Auto Lock mode.
 820         /// </summary>
 821         /// <returns>Whether Axis Auto Lock mode has been enabled or not.</returns>
 822         [EditorBrowsable(EditorBrowsableState.Never)]
 823         public bool GetAxisAutoLock()
 824         {
 825             bool ret = Interop.ScrollView.GetAxisAutoLock(SwigCPtr);
 826             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 827             return ret;
 828         }
 829
 830         /// <summary>
 831         /// Enables or Disables Axis Auto Lock mode for panning within the ScrollView.<br />
 832         /// When enabled, any pan gesture that appears mostly horizontal or mostly
 833         /// vertical, will be automatically restricted to horizontal only or vertical
 834         /// only panning, until the pan gesture has completed.
 835         /// </summary>
 836         /// <param name="enable">Enables (true), or disables (false) AxisAutoLock mode.</param>
 837         [EditorBrowsable(EditorBrowsableState.Never)]
 838         public void SetAxisAutoLock(bool enable)
 839         {
 840             Interop.ScrollView.SetAxisAutoLock(SwigCPtr, enable);
 841             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 842         }
 843
 844         /// <summary>
 845         /// Gets the gradient threshold at which a panning gesture should be locked to the Horizontal or Vertical axis.
 846         /// </summary>
 847         /// <returns>The gradient, a value between 0.0 and 1.0f.</returns>
 848         [EditorBrowsable(EditorBrowsableState.Never)]
 849         public float GetAxisAutoLockGradient()
 850         {
 851             float ret = Interop.ScrollView.GetAxisAutoLockGradient(SwigCPtr);
 852             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 853             return ret;
 854         }
 855
 856         /// <summary>
 857         /// Sets the gradient threshold at which a panning gesture should be locked to the Horizontal or Vertical axis.<br />
 858         /// By default, this is 0.36 (0.36:1) which means angles less than 20 degrees to an axis will lock to that axis.<br />
 859         /// </summary>
 860         /// <param name="gradient">gradient A value between 0.0 and 1.0 (auto-lock for all angles).</param>
 861         [EditorBrowsable(EditorBrowsableState.Never)]
 862         public void SetAxisAutoLockGradient(float gradient)
 863         {
 864             Interop.ScrollView.SetAxisAutoLockGradient(SwigCPtr, gradient);
 865             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 866         }
 867
 868         /// <summary>
 869         /// Gets the friction coefficient setting for ScrollView when flicking in free panning mode.
 870         /// This is a value in stage-diagonals per second^2, stage-diagonal = Length( stage.width, stage.height )
 871         /// </summary>
 872         /// <returns>Friction coefficient is returned.</returns>
 873         [EditorBrowsable(EditorBrowsableState.Never)]
 874         public float GetFrictionCoefficient()
 875         {
 876             float ret = Interop.ScrollView.GetFrictionCoefficient(SwigCPtr);
 877             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 878             return ret;
 879         }
 880
 881         /// <summary>
 882         /// Sets the friction coefficient for ScrollView when flicking.<br />
 883         /// </summary>
 884         /// <param name="friction">Friction coefficient must be greater than 0.0 (default = 1.0).</param>
 885         [EditorBrowsable(EditorBrowsableState.Never)]
 886         public void SetFrictionCoefficient(float friction)
 887         {
 888             Interop.ScrollView.SetFrictionCoefficient(SwigCPtr, friction);
 889             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 890         }
 891
 892         /// <summary>
 893         /// Gets the flick speed coefficient for ScrollView when flicking in free panning mode.<br />
 894         /// This is a constant which multiplies the input touch flick velocity to determine the actual velocity at which to move the scrolling area.
 895         /// </summary>
 896         /// <returns>The flick speed coefficient is returned.</returns>
 897         [EditorBrowsable(EditorBrowsableState.Never)]
 898         public float GetFlickSpeedCoefficient()
 899         {
 900             float ret = Interop.ScrollView.GetFlickSpeedCoefficient(SwigCPtr);
 901             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 902             return ret;
 903         }
 904
 905         /// <summary>
 906         /// Sets the flick speed coefficient for ScrollView when flicking in free panning mode.<br />
 907         /// This is a constant which multiplies the input touch flick velocity to determine the actual velocity at
 908         /// which to move the scrolling area.<br />
 909         /// </summary>
 910         /// <param name="speed">The flick speed coefficient (default = 1.0).</param>
 911         [EditorBrowsable(EditorBrowsableState.Never)]
 912         public void SetFlickSpeedCoefficient(float speed)
 913         {
 914             Interop.ScrollView.SetFlickSpeedCoefficient(SwigCPtr, speed);
 915             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 916         }
 917
 918         /// <summary>
 919         /// Gets the minimum pan distance required for a flick gesture in pixels.<br />
 920         /// </summary>
 921         /// <returns>Minimum pan distance vector with separate x and y distance.</returns>
 922         [EditorBrowsable(EditorBrowsableState.Never)]
 923         public Vector2 GetMinimumDistanceForFlick()
 924         {
 925             Vector2 ret = new Vector2(Interop.ScrollView.GetMinimumDistanceForFlick(SwigCPtr), true);
 926             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 927             return ret;
 928         }
 929
 930         /// <summary>
 931         /// Sets the minimum pan distance required for a flick in pixels.<br />
 932         /// Takes a Vector2 containing separate x and y values. As long as the pan distance exceeds one of these axes, a flick will be allowed.
 933         /// </summary>
 934         /// <param name="distance">The flick speed coefficient (default = 1.0).</param>
 935         [EditorBrowsable(EditorBrowsableState.Never)]
 936         public void SetMinimumDistanceForFlick(Vector2 distance)
 937         {
 938             Interop.ScrollView.SetMinimumDistanceForFlick(SwigCPtr, Vector2.getCPtr(distance));
 939             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 940         }
 941
 942         /// <summary>
 943         /// Returns the minimum pan speed required for a flick gesture in pixels per second.
 944         /// </summary>
 945         /// <returns>Minimum pan speed.</returns>
 946         [EditorBrowsable(EditorBrowsableState.Never)]
 947         public float GetMinimumSpeedForFlick()
 948         {
 949             float ret = Interop.ScrollView.GetMinimumSpeedForFlick(SwigCPtr);
 950             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 951             return ret;
 952         }
 953
 954         /// <summary>
 955         /// Sets the minimum pan speed required for a flick in pixels per second.<br />
 956         /// </summary>
 957         /// <param name="speed">The minimum pan speed for a flick.</param>
 958         [EditorBrowsable(EditorBrowsableState.Never)]
 959         public void SetMinimumSpeedForFlick(float speed)
 960         {
 961             Interop.ScrollView.SetMinimumSpeedForFlick(SwigCPtr, speed);
 962             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 963         }
 964
 965         /// <summary>
 966         /// Gets the maximum flick speed setting for ScrollView when flicking in free panning mode.<br />
 967         /// This is a value in stage-diagonals per second.
 968         /// </summary>
 969         /// <returns>Maximum flick speed is returned.</returns>
 970         [EditorBrowsable(EditorBrowsableState.Never)]
 971         public float GetMaxFlickSpeed()
 972         {
 973             float ret = Interop.ScrollView.GetMaxFlickSpeed(SwigCPtr);
 974             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 975             return ret;
 976         }
 977
 978         /// <summary>
 979         /// Sets the maximum flick speed for the ScrollView when flicking in free panning mode.<br />
 980         /// This is a value in stage-diagonals per second. stage-diagonal = Length( stage.width, stage.height ).<br />
 981         /// </summary>
 982         /// <param name="speed">Maximum flick speed (default = 3.0).</param>
 983         [EditorBrowsable(EditorBrowsableState.Never)]
 984         public void SetMaxFlickSpeed(float speed)
 985         {
 986             Interop.ScrollView.SetMaxFlickSpeed(SwigCPtr, speed);
 987             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 988         }
 989
 990         /// <summary>
 991         /// Retrieves current scroll position.<br />
 992         /// </summary>
 993         /// <returns>The current scroll position.</returns>
 994         [EditorBrowsable(EditorBrowsableState.Never)]
 995         public Vector2 GetCurrentScrollPosition()
 996         {
 997             Vector2 ret = new Vector2(Interop.ScrollView.GetCurrentScrollPosition(SwigCPtr), true);
 998             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 999             return ret;
1000         }
1001
1002         /// <summary>
1003         /// Retrieves current scroll page based on ScrollView dimensions being the size of one page, and all pages laid out in<br />
1004         /// a grid fashion, increasing from left to right until the end of the X-domain.
1005         /// </summary>
1006         /// <returns>The current scroll position.</returns>
1007         [EditorBrowsable(EditorBrowsableState.Never)]
1008         public uint GetCurrentPage()
1009         {
1010             uint ret = Interop.ScrollView.GetCurrentPage(SwigCPtr);
1011             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1012             return ret;
1013         }
1014
1015         /// <summary>
1016         /// Scrolls View to position specified (contents will scroll to this position).
1017         /// </summary>
1018         /// <param name="position">The position to scroll to.</param>
1019         [EditorBrowsable(EditorBrowsableState.Never)]
1020         public void ScrollTo(Vector2 position)
1021         {
1022             Interop.ScrollView.ScrollToVector2(SwigCPtr, Vector2.getCPtr(position));
1023             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1024         }
1025
1026         /// <summary>
1027         /// Scrolls View to position specified (contents will scroll to this position).
1028         /// </summary>
1029         /// <param name="position">The position to scroll to.</param>
1030         /// <param name="duration">The duration of the animation in seconds.</param>
1031         [EditorBrowsable(EditorBrowsableState.Never)]
1032         public void ScrollTo(Vector2 position, float duration)
1033         {
1034             Interop.ScrollView.ScrollTo(SwigCPtr, Vector2.getCPtr(position), duration);
1035             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1036         }
1037
1038         /// <summary>
1039         /// Scrolls View to position specified (contents will scroll to this position).
1040         /// </summary>
1041         /// <param name="position">The position to scroll to.</param>
1042         /// <param name="duration">The duration of the animation in seconds.</param>
1043         /// <param name="alpha">The alpha function to use.</param>
1044         [EditorBrowsable(EditorBrowsableState.Never)]
1045         public void ScrollTo(Vector2 position, float duration, AlphaFunction alpha)
1046         {
1047             Interop.ScrollView.ScrollTo(SwigCPtr, Vector2.getCPtr(position), duration, AlphaFunction.getCPtr(alpha));
1048             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1049         }
1050
1051         /// <summary>
1052         /// Scrolls View to position specified (contents will scroll to this position).
1053         /// </summary>
1054         /// <param name="position">The position to scroll to.</param>
1055         /// <param name="duration">The duration of the animation in seconds.</param>
1056         /// <param name="horizontalBias">Whether to bias scrolling to left or right.</param>
1057         /// <param name="verticalBias">Whether to bias scrolling to top or bottom.</param>
1058         [EditorBrowsable(EditorBrowsableState.Never)]
1059         public void ScrollTo(Vector2 position, float duration, DirectionBias horizontalBias, DirectionBias verticalBias)
1060         {
1061             Interop.ScrollView.ScrollTo(SwigCPtr, Vector2.getCPtr(position), duration, (int)horizontalBias, (int)verticalBias);
1062             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1063         }
1064
1065         /// <summary>
1066         /// Scrolls View to position specified (contents will scroll to this position).
1067         /// </summary>
1068         /// <param name="position">The position to scroll to.</param>
1069         /// <param name="duration">The duration of the animation in seconds.</param>
1070         /// <param name="alpha">Alpha function to use.</param>
1071         /// <param name="horizontalBias">Whether to bias scrolling to left or right.</param>
1072         /// <param name="verticalBias">Whether to bias scrolling to top or bottom.</param>
1073         [EditorBrowsable(EditorBrowsableState.Never)]
1074         public void ScrollTo(Vector2 position, float duration, AlphaFunction alpha, DirectionBias horizontalBias, DirectionBias verticalBias)
1075         {
1076             Interop.ScrollView.ScrollTo(SwigCPtr, Vector2.getCPtr(position), duration, AlphaFunction.getCPtr(alpha), (int)horizontalBias, (int)verticalBias);
1077             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1078         }
1079
1080         /// <summary>
1081         /// Scrolls View to position specified (contents will scroll to this position).
1082         /// </summary>
1083         /// <param name="page">The page to scroll to.</param>
1084         [EditorBrowsable(EditorBrowsableState.Never)]
1085         public void ScrollTo(uint page)
1086         {
1087             Interop.ScrollView.ScrollTo(SwigCPtr, page);
1088             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1089         }
1090
1091         /// <summary>
1092         /// Scrolls View to position specified (contents will scroll to this position).
1093         /// </summary>
1094         /// <param name="page">The page to scroll to.</param>
1095         /// <param name="duration">The duration of the animation in seconds.</param>
1096         [EditorBrowsable(EditorBrowsableState.Never)]
1097         public void ScrollTo(uint page, float duration)
1098         {
1099             Interop.ScrollView.ScrollTo(SwigCPtr, page, duration);
1100             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1101         }
1102
1103         /// <summary>
1104         /// Scrolls View to position specified (contents will scroll to this position).
1105         /// </summary>
1106         /// <param name="page">The page to scroll to.</param>
1107         /// <param name="duration">The duration of the animation in seconds.</param>
1108         /// <param name="bias">Whether to bias scrolling to left or right.</param>
1109         [EditorBrowsable(EditorBrowsableState.Never)]
1110         public void ScrollTo(uint page, float duration, DirectionBias bias)
1111         {
1112             Interop.ScrollView.ScrollTo(SwigCPtr, page, duration, (int)bias);
1113             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1114         }
1115
1116         /// <summary>
1117         /// Scrolls View to position specified (contents will scroll to this position).
1118         /// </summary>
1119         /// <param name="view">The view to center in on (via Scrolling).</param>
1120         [EditorBrowsable(EditorBrowsableState.Never)]
1121         public void ScrollTo(View view)
1122         {
1123             Interop.ScrollView.ScrollToView(SwigCPtr, View.getCPtr(view));
1124             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1125         }
1126
1127         /// <summary>
1128         /// Scrolls View to position specified (contents will scroll to this position).
1129         /// </summary>
1130         /// <param name="view">The view to center in on (via Scrolling).</param>
1131         /// <param name="duration">The duration of the animation in seconds.</param>
1132         [EditorBrowsable(EditorBrowsableState.Never)]
1133         public void ScrollTo(View view, float duration)
1134         {
1135             Interop.ScrollView.ScrollToViewDuration(SwigCPtr, View.getCPtr(view), duration);
1136             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1137         }
1138
1139         /// <summary>
1140         /// Scrolls View to the nearest snap points as specified by the Rulers.<br />
1141         /// If already at snap points, then will return false, and not scroll.<br />
1142         /// </summary>
1143         /// <returns>True if Snapping necessary.</returns>
1144         [EditorBrowsable(EditorBrowsableState.Never)]
1145         public bool ScrollToSnapPoint()
1146         {
1147             bool ret = Interop.ScrollView.ScrollToSnapPoint(SwigCPtr);
1148             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1149             return ret;
1150         }
1151
1152         /// <summary>
1153         /// Applies Effect to ScrollView.
1154         /// </summary>
1155         /// <param name="effect">The effect to apply to scroll view.</param>
1156         [EditorBrowsable(EditorBrowsableState.Never)]
1157         public void ApplyEffect(ScrollViewEffect effect)
1158         {
1159             Interop.ScrollView.ApplyEffect(SwigCPtr, ScrollViewEffect.getCPtr(effect));
1160             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1161         }
1162
1163         /// <summary>
1164         /// Removes Effect from ScrollView.
1165         /// </summary>
1166         /// <param name="effect">The effect to remove.</param>
1167         [EditorBrowsable(EditorBrowsableState.Never)]
1168         public void RemoveEffect(ScrollViewEffect effect)
1169         {
1170             Interop.ScrollView.RemoveEffect(SwigCPtr, ScrollViewEffect.getCPtr(effect));
1171             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1172         }
1173
1174         /// <summary>
1175         /// Remove All Effects from ScrollView.
1176         /// </summary>
1177         [EditorBrowsable(EditorBrowsableState.Never)]
1178         public void RemoveAllEffects()
1179         {
1180             Interop.ScrollView.RemoveAllEffects(SwigCPtr);
1181             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1182         }
1183
1184         /// <summary>
1185         /// Binds view to this ScrollView.
1186         /// Once an actor is bound to a ScrollView, it will be subject to that ScrollView's properties.
1187         /// </summary>
1188         /// <param name="child">The view to add to this ScrollView.</param>
1189         [EditorBrowsable(EditorBrowsableState.Never)]
1190         public void BindView(View child)
1191         {
1192             Interop.ScrollView.BindActor(SwigCPtr, View.getCPtr(child));
1193             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1194         }
1195
1196         /// <summary>
1197         /// Unbinds view to this ScrollView.
1198         /// Once an actor is bound to a ScrollView, it will be subject to that ScrollView's properties.
1199         /// </summary>
1200         /// <param name="child">The view to remove to this ScrollView.</param>
1201         [EditorBrowsable(EditorBrowsableState.Never)]
1202         public void UnbindView(View child)
1203         {
1204             Interop.ScrollView.UnbindActor(SwigCPtr, View.getCPtr(child));
1205             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1206         }
1207
1208         /// <summary>
1209         /// Allows the user to constrain the scroll view in a particular direction.
1210         /// </summary>
1211         /// <param name="direction">The axis to constrain the scroll-view to.</param>
1212         /// <param name="threshold">The threshold to apply around the axis.</param>
1213         [EditorBrowsable(EditorBrowsableState.Never)]
1214         public void SetScrollingDirection(Radian direction, Radian threshold)
1215         {
1216             Interop.ScrollView.SetScrollingDirection(SwigCPtr, Radian.getCPtr(direction), Radian.getCPtr(threshold));
1217             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1218         }
1219
1220         /// <summary>
1221         /// Allows the user to constrain the scroll view in a particular direction.
1222         /// </summary>
1223         /// <param name="direction">The axis to constrain the scroll-view to.</param>
1224         [EditorBrowsable(EditorBrowsableState.Never)]
1225         public void SetScrollingDirection(Radian direction)
1226         {
1227             Interop.ScrollView.SetScrollingDirection(SwigCPtr, Radian.getCPtr(direction));
1228             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1229         }
1230
1231         /// <summary>
1232         /// Removes a direction constraint from the scroll view.
1233         /// </summary>
1234         /// <param name="direction">The axis to constrain the scroll-view to.</param>
1235         [EditorBrowsable(EditorBrowsableState.Never)]
1236         public void RemoveScrollingDirection(Radian direction)
1237         {
1238             Interop.ScrollView.RemoveScrollingDirection(SwigCPtr, Radian.getCPtr(direction));
1239             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1240         }
1241
1242         /// <summary>
1243         /// Set ruler X
1244         /// </summary>
1245         /// This will be public opened in next tizen after ACR done. Before ACR, need to be hidden as inhouse API.
1246         [EditorBrowsable(EditorBrowsableState.Never)]
1247         public void SetRulerX(RulerPtr ruler)
1248         {
1249             Interop.ScrollView.SetRulerX(SwigCPtr, RulerPtr.getCPtr(ruler));
1250         }
1251
1252         /// <summary>
1253         /// Set ruler Y
1254         /// </summary>
1255         /// This will be public opened in next tizen after ACR done. Before ACR, need to be hidden as inhouse API.
1256         [EditorBrowsable(EditorBrowsableState.Never)]
1257         public void SetRulerY(RulerPtr ruler)
1258         {
1259             Interop.ScrollView.SetRulerY(SwigCPtr, RulerPtr.getCPtr(ruler));
1260         }
1261
1262         internal void ApplyConstraintToChildren(Constraint constraint)
1263         {
1264             Interop.ScrollView.ApplyConstraintToChildren(SwigCPtr, constraint.SwigCPtr);
1265             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1266         }
1267
1268         /// <summary>
1269         /// Dispose
1270         /// </summary>
1271         /// <param name="type">the dispose type</param>
1272         [EditorBrowsable(EditorBrowsableState.Never)]
1273         protected override void Dispose(DisposeTypes type)
1274         {
1275             if (disposed)
1276             {
1277                 return;
1278             }
1279
1280             //Release your own unmanaged resources here.
1281             //You should not access any managed member here except static instance.
1282             //because the execution order of Finalizes is non-deterministic.
1283
1284             if (this != null && scrollViewSnapStartedCallbackDelegate != null)
1285             {
1286                 ScrollViewSnapStartedSignal snapStarted = this.SnapStartedSignal();
1287                 snapStarted?.Disconnect(scrollViewSnapStartedCallbackDelegate);
1288                 snapStarted?.Dispose();
1289             }
1290
1291             base.Dispose(type);
1292         }
1293
1294         /// This will not be public opened.
1295         [EditorBrowsable(EditorBrowsableState.Never)]
1296         protected override void ReleaseSwigCPtr(System.Runtime.InteropServices.HandleRef swigCPtr)
1297         {
1298             Interop.ScrollView.DeleteScrollView(swigCPtr);
1299         }
1300
1301         /// <summary>
1302         /// This should be internal, do not use.
1303         /// </summary>
1304         [EditorBrowsable(EditorBrowsableState.Never)]
1305 #pragma warning disable CA1716, CA1052, CA1034 // Identifiers should not match keywords
1306         public new class Property
1307 #pragma warning restore CA1716, CA1052, CA1034 // Identifiers should not match keywords
1308         {
1309             /// <summary>
1310             /// This should be internal, do not use.
1311             /// </summary>
1312             [EditorBrowsable(EditorBrowsableState.Never)]
1313             public static readonly int WrapEnabled = Interop.ScrollView.WrapEnabledGet();
1314             /// <summary>
1315             /// This should be internal, do not use.
1316             /// </summary>
1317             [EditorBrowsable(EditorBrowsableState.Never)]
1318             public static readonly int PanningEnabled = Interop.ScrollView.PanningEnabledGet();
1319             /// <summary>
1320             /// This should be internal, do not use.
1321             /// </summary>
1322             [EditorBrowsable(EditorBrowsableState.Never)]
1323             public static readonly int AxisAutoLockEnabled = Interop.ScrollView.AxisAutoLockEnabledGet();
1324             /// <summary>
1325             /// This should be internal, do not use.
1326             /// </summary>
1327             [EditorBrowsable(EditorBrowsableState.Never)]
1328             public static readonly int WheelScrollDistanceStep = Interop.ScrollView.WheelScrollDistanceStepGet();
1329             /// <summary>
1330             /// This should be internal, do not use.
1331             /// </summary>
1332             [EditorBrowsable(EditorBrowsableState.Never)]
1333             public static readonly int ScrollMode = Interop.ScrollView.ScrollModeGet();
1334             /// <summary>
1335             /// This should be internal, do not use.
1336             /// </summary>
1337             [EditorBrowsable(EditorBrowsableState.Never)]
1338             public static readonly int ScrollPosition = Interop.ScrollView.ScrollPositionGet();
1339             /// <summary>
1340             /// This should be internal, do not use.
1341             /// </summary>
1342             [EditorBrowsable(EditorBrowsableState.Never)]
1343             public static readonly int ScrollPrePosition = Interop.ScrollView.ScrollPrePositionGet();
1344             /// <summary>
1345             /// This should be internal, do not use.
1346             /// </summary>
1347             [EditorBrowsable(EditorBrowsableState.Never)]
1348             public static readonly int ScrollPrePositionX = Interop.ScrollView.ScrollPrePositionXGet();
1349             /// <summary>
1350             /// This should be internal, do not use.
1351             /// </summary>
1352             [EditorBrowsable(EditorBrowsableState.Never)]
1353             public static readonly int ScrollPrePositionY = Interop.ScrollView.ScrollPrePositionYGet();
1354             /// <summary>
1355             /// This should be internal, do not use.
1356             /// </summary>
1357             [EditorBrowsable(EditorBrowsableState.Never)]
1358             public static readonly int ScrollPrePositionMax = Interop.ScrollView.ScrollPrePositionMaxGet();
1359             /// <summary>
1360             /// This should be internal, do not use.
1361             /// </summary>
1362             [EditorBrowsable(EditorBrowsableState.Never)]
1363             public static readonly int ScrollPrePositionMaxX = Interop.ScrollView.ScrollPrePositionMaxXGet();
1364             /// <summary>
1365             /// This should be internal, do not use.
1366             /// </summary>
1367             [EditorBrowsable(EditorBrowsableState.Never)]
1368             public static readonly int ScrollPrePositionMaxY = Interop.ScrollView.ScrollPrePositionMaxYGet();
1369             /// <summary>
1370             /// This should be internal, do not use.
1371             /// </summary>
1372             [EditorBrowsable(EditorBrowsableState.Never)]
1373             public static readonly int OvershootX = Interop.ScrollView.OvershootXGet();
1374             /// <summary>
1375             /// This should be internal, do not use.
1376             /// </summary>
1377             [EditorBrowsable(EditorBrowsableState.Never)]
1378             public static readonly int OvershootY = Interop.ScrollView.OvershootYGet();
1379             /// <summary>
1380             /// This should be internal, do not use.
1381             /// </summary>
1382             [EditorBrowsable(EditorBrowsableState.Never)]
1383             public static readonly int ScrollFinal = Interop.ScrollView.ScrollFinalGet();
1384             /// <summary>
1385             /// This should be internal, do not use.
1386             /// </summary>
1387             [EditorBrowsable(EditorBrowsableState.Never)]
1388             public static readonly int ScrollFinalX = Interop.ScrollView.ScrollFinalXGet();
1389             /// <summary>
1390             /// This should be internal, do not use.
1391             /// </summary>
1392             [EditorBrowsable(EditorBrowsableState.Never)]
1393             public static readonly int ScrollFinalY = Interop.ScrollView.ScrollFinalYGet();
1394             /// <summary>
1395             /// This should be internal, do not use.
1396             /// </summary>
1397             [EditorBrowsable(EditorBrowsableState.Never)]
1398             public static readonly int WRAP = Interop.ScrollView.WrapGet();
1399             /// <summary>
1400             /// This should be internal, do not use.
1401             /// </summary>
1402             [EditorBrowsable(EditorBrowsableState.Never)]
1403             public static readonly int PANNING = Interop.ScrollView.PanningGet();
1404             /// <summary>
1405             /// This should be internal, do not use.
1406             /// </summary>
1407             [EditorBrowsable(EditorBrowsableState.Never)]
1408             public static readonly int SCROLLING = Interop.ScrollView.ScrollingGet();
1409             /// <summary>
1410             /// This should be internal, do not use.
1411             /// </summary>
1412             [EditorBrowsable(EditorBrowsableState.Never)]
1413             public static readonly int ScrollDomainSize = Interop.ScrollView.ScrollDomainSizeGet();
1414             /// <summary>
1415             /// This should be internal, do not use.
1416             /// </summary>
1417             [EditorBrowsable(EditorBrowsableState.Never)]
1418             public static readonly int ScrollDomainSizeX = Interop.ScrollView.ScrollDomainSizeXGet();
1419             /// <summary>
1420             /// This should be internal, do not use.
1421             /// </summary>
1422             [EditorBrowsable(EditorBrowsableState.Never)]
1423             public static readonly int ScrollDomainSizeY = Interop.ScrollView.ScrollDomainSizeYGet();
1424             /// <summary>
1425             /// This should be internal, do not use.
1426             /// </summary>
1427             [EditorBrowsable(EditorBrowsableState.Never)]
1428             public static readonly int ScrollDomainOffset = Interop.ScrollView.ScrollDomainOffsetGet();
1429             /// <summary>
1430             /// This should be internal, do not use.
1431             /// </summary>
1432             [EditorBrowsable(EditorBrowsableState.Never)]
1433             public static readonly int ScrollPositionDelta = Interop.ScrollView.ScrollPositionDeltaGet();
1434             /// <summary>
1435             /// This should be internal, do not use.
1436             /// </summary>
1437             [EditorBrowsable(EditorBrowsableState.Never)]
1438             public static readonly int StartPagePosition = Interop.ScrollView.StartPagePositionGet();
1439         }
1440     }
1441 }