src/Tizen.NUI.Components/Controls/ScrollableBase.cs

   1 /* Copyright (c) 2021 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 using System;
  17 using Tizen.NUI.BaseComponents;
  18 using System.Collections.Generic;
  19 using System.ComponentModel;
  20 using System.Diagnostics;
  21 using System.Runtime.InteropServices;
  22 using Tizen.NUI.Accessibility;
  23
  24 namespace Tizen.NUI.Components
  25 {
  26     /// <summary>
  27     /// ScrollEventArgs is a class to record scroll event arguments which will sent to user.
  28     /// </summary>
  29     /// <since_tizen> 8 </since_tizen>
  30     [global::System.Diagnostics.CodeAnalysis.SuppressMessage("Design", "CA1001: Types that own disposable fields should be disposable.", Justification = "Scroll event is temporarily used for notifying scroll position update, so position will not be disposed during the event processing.")]
  31     public class ScrollEventArgs : EventArgs
  32     {
  33         // Position class is derived class of Disposable class and they will be implicitly disposed by DisposeQueue,
  34         // so that there will be no memory leak.
  35         private Position position;
  36         private Position scrollPosition;
  37
  38         /// <summary>
  39         /// Default constructor.
  40         /// </summary>
  41         /// <param name="position">Current container position</param>
  42         /// <since_tizen> 8 </since_tizen>
  43         public ScrollEventArgs(Position position)
  44         {
  45             this.position = position;
  46             this.scrollPosition = new Position(-position);
  47         }
  48
  49         /// <summary>
  50         /// Current position of ContentContainer.
  51         /// </summary>
  52         /// <since_tizen> 8 </since_tizen>
  53         public Position Position
  54         {
  55             get
  56             {
  57                 return position;
  58             }
  59         }
  60         /// <summary>
  61         /// Current scroll position of scrollableBase pan.
  62         /// This is the position in the opposite direction to the current position of ContentContainer.
  63         /// </summary>
  64         [EditorBrowsable(EditorBrowsableState.Never)]
  65         public Position ScrollPosition
  66         {
  67             get
  68             {
  69                 return scrollPosition;
  70             }
  71         }
  72     }
  73
  74     /// <summary>
  75     /// ScrollOutofBoundEventArgs is to record scroll out-of-bound event arguments which will be sent to user.
  76     /// </summary>
  77     [EditorBrowsable(EditorBrowsableState.Never)]
  78     public class ScrollOutOfBoundEventArgs : EventArgs
  79     {
  80         /// <summary>
  81         /// The direction to be touched.
  82         /// </summary>
  83         [EditorBrowsable(EditorBrowsableState.Never)]
  84         public enum Direction
  85         {
  86             /// <summary>
  87             /// Upwards.
  88             /// </summary>
  89             [EditorBrowsable(EditorBrowsableState.Never)]
  90             Up,
  91
  92             /// <summary>
  93             /// Downwards.
  94             /// </summary>
  95             [EditorBrowsable(EditorBrowsableState.Never)]
  96             Down,
  97
  98             /// <summary>
  99             /// Left bound.
 100             /// </summary>
 101             [EditorBrowsable(EditorBrowsableState.Never)]
 102             Left,
 103
 104             /// <summary>
 105             /// Right bound.
 106             /// </summary>
 107             [EditorBrowsable(EditorBrowsableState.Never)]
 108             Right,
 109         }
 110
 111         /// <summary>
 112         /// Constructor.
 113         /// </summary>
 114         /// <param name="direction">Current pan direction</param>
 115         /// <param name="displacement">Current total displacement</param>
 116         [EditorBrowsable(EditorBrowsableState.Never)]
 117         public ScrollOutOfBoundEventArgs(Direction direction, float displacement)
 118         {
 119             PanDirection = direction;
 120             Displacement = displacement;
 121         }
 122
 123         /// <summary>
 124         /// Current pan direction of ContentContainer.
 125         /// </summary>
 126         [EditorBrowsable(EditorBrowsableState.Never)]
 127         public Direction PanDirection
 128         {
 129             get;
 130         }
 131
 132         /// <summary>
 133         /// Current total displacement of ContentContainer.
 134         /// if its value is greater than 0, it is at the top/left;
 135         /// if less than 0, it is at the bottom/right.
 136         /// </summary>
 137         [EditorBrowsable(EditorBrowsableState.Never)]
 138         public float Displacement
 139         {
 140             get;
 141         }
 142     }
 143
 144     /// <summary>
 145     /// This class provides a View that can scroll a single View with a layout. This View can be a nest of Views.
 146     /// </summary>
 147     /// <since_tizen> 8 </since_tizen>
 148     public partial class ScrollableBase : Control
 149     {
 150         static bool LayoutDebugScrollableBase = false; // Debug flag
 151         static bool focusDebugScrollableBase = false; // Debug flag
 152         private Direction mScrollingDirection = Direction.Vertical;
 153         private bool mScrollEnabled = true;
 154         private int mScrollDuration = 125;
 155         private int mPageWidth = 0;
 156         private float mPageFlickThreshold = 0.4f;
 157         private float mScrollingEventThreshold = 0.001f;
 158         private bool fadeScrollbar = true;
 159
 160         private class ScrollableBaseCustomLayout : AbsoluteLayout
 161         {
 162             protected override void OnMeasure(MeasureSpecification widthMeasureSpec, MeasureSpecification heightMeasureSpec)
 163             {
 164                 MeasuredSize.StateType childWidthState = MeasuredSize.StateType.MeasuredSizeOK;
 165                 MeasuredSize.StateType childHeightState = MeasuredSize.StateType.MeasuredSizeOK;
 166
 167                 Direction scrollingDirection = Direction.Vertical;
 168                 ScrollableBase scrollableBase = this.Owner as ScrollableBase;
 169                 if (scrollableBase != null)
 170                 {
 171                     scrollingDirection = scrollableBase.ScrollingDirection;
 172                 }
 173
 174                 float totalWidth = 0.0f;
 175                 float totalHeight = 0.0f;
 176
 177                 // measure child, should be a single scrolling child
 178                 foreach (LayoutItem childLayout in LayoutChildren)
 179                 {
 180                     if (childLayout != null && childLayout.Owner.Name == "ContentContainer")
 181                     {
 182                         // Get size of child
 183                         // Use an Unspecified MeasureSpecification mode so scrolling child is not restricted to it's parents size in Height (for vertical scrolling)
 184                         // or Width for horizontal scrolling
 185                         if (scrollingDirection == Direction.Vertical)
 186                         {
 187                             MeasureSpecification unrestrictedMeasureSpec = new MeasureSpecification(heightMeasureSpec.Size, MeasureSpecification.ModeType.Unspecified);
 188                             MeasureChildWithMargins(childLayout, widthMeasureSpec, new LayoutLength(0), unrestrictedMeasureSpec, new LayoutLength(0)); // Height unrestricted by parent
 189                         }
 190                         else
 191                         {
 192                             MeasureSpecification unrestrictedMeasureSpec = new MeasureSpecification(widthMeasureSpec.Size, MeasureSpecification.ModeType.Unspecified);
 193                             MeasureChildWithMargins(childLayout, unrestrictedMeasureSpec, new LayoutLength(0), heightMeasureSpec, new LayoutLength(0)); // Width unrestricted by parent
 194                         }
 195
 196                         totalWidth = (childLayout.MeasuredWidth.Size + (childLayout.Padding.Start + childLayout.Padding.End)).AsDecimal();
 197                         totalHeight = (childLayout.MeasuredHeight.Size + (childLayout.Padding.Top + childLayout.Padding.Bottom)).AsDecimal();
 198
 199                         if (childLayout.MeasuredWidth.State == MeasuredSize.StateType.MeasuredSizeTooSmall)
 200                         {
 201                             childWidthState = MeasuredSize.StateType.MeasuredSizeTooSmall;
 202                         }
 203                         if (childLayout.MeasuredHeight.State == MeasuredSize.StateType.MeasuredSizeTooSmall)
 204                         {
 205                             childHeightState = MeasuredSize.StateType.MeasuredSizeTooSmall;
 206                         }
 207                     }
 208                 }
 209
 210                 MeasuredSize widthSizeAndState = ResolveSizeAndState(new LayoutLength(totalWidth), widthMeasureSpec, MeasuredSize.StateType.MeasuredSizeOK);
 211                 MeasuredSize heightSizeAndState = ResolveSizeAndState(new LayoutLength(totalHeight), heightMeasureSpec, MeasuredSize.StateType.MeasuredSizeOK);
 212                 totalWidth = widthSizeAndState.Size.AsDecimal();
 213                 totalHeight = heightSizeAndState.Size.AsDecimal();
 214
 215                 // Ensure layout respects it's given minimum size
 216                 totalWidth = Math.Max(totalWidth, SuggestedMinimumWidth.AsDecimal());
 217                 totalHeight = Math.Max(totalHeight, SuggestedMinimumHeight.AsDecimal());
 218
 219                 widthSizeAndState.State = childWidthState;
 220                 heightSizeAndState.State = childHeightState;
 221
 222                 SetMeasuredDimensions(ResolveSizeAndState(new LayoutLength(totalWidth), widthMeasureSpec, childWidthState),
 223                     ResolveSizeAndState(new LayoutLength(totalHeight), heightMeasureSpec, childHeightState));
 224
 225                 // Size of ScrollableBase is changed. Change Page width too.
 226                 if (scrollableBase != null)
 227                 {
 228                     scrollableBase.mPageWidth = (int)MeasuredWidth.Size.AsRoundedValue();
 229                     scrollableBase.OnScrollingChildRelayout(null, null);
 230                 }
 231             }
 232         } //  ScrollableBaseCustomLayout
 233
 234         /// <summary>
 235         /// The direction axis to scroll.
 236         /// </summary>
 237         /// <since_tizen> 8 </since_tizen>
 238         public enum Direction
 239         {
 240             /// <summary>
 241             /// Horizontal axis.
 242             /// </summary>
 243             /// <since_tizen> 8 </since_tizen>
 244             Horizontal,
 245
 246             /// <summary>
 247             /// Vertical axis.
 248             /// </summary>
 249             /// <since_tizen> 8 </since_tizen>
 250             Vertical
 251         }
 252
 253         /// <summary>
 254         /// Scrolling direction mode.
 255         /// Default is Vertical scrolling.
 256         /// </summary>
 257         /// <since_tizen> 8 </since_tizen>
 258         public Direction ScrollingDirection
 259         {
 260             get
 261             {
 262                 return (Direction)GetValue(ScrollingDirectionProperty);
 263             }
 264             set
 265             {
 266                 SetValue(ScrollingDirectionProperty, value);
 267                 NotifyPropertyChanged();
 268             }
 269         }
 270         private Direction InternalScrollingDirection
 271         {
 272             get
 273             {
 274                 return mScrollingDirection;
 275             }
 276             set
 277             {
 278                 if (value != mScrollingDirection)
 279                 {
 280                     //Reset scroll position and stop scroll animation
 281                     ScrollTo(0, false);
 282
 283                     mScrollingDirection = value;
 284                     mPanGestureDetector.ClearAngles();
 285                     mPanGestureDetector.AddDirection(value == Direction.Horizontal ?
 286                         PanGestureDetector.DirectionHorizontal : PanGestureDetector.DirectionVertical);
 287
 288                     ContentContainer.WidthSpecification = ScrollingDirection == Direction.Vertical ? LayoutParamPolicies.MatchParent : LayoutParamPolicies.WrapContent;
 289                     ContentContainer.HeightSpecification = ScrollingDirection == Direction.Vertical ? LayoutParamPolicies.WrapContent : LayoutParamPolicies.MatchParent;
 290                     SetScrollbar();
 291                 }
 292             }
 293         }
 294
 295         /// <summary>
 296         /// Enable or disable scrolling.
 297         /// </summary>
 298         /// <since_tizen> 8 </since_tizen>
 299         public bool ScrollEnabled
 300         {
 301             get
 302             {
 303                 return (bool)GetValue(ScrollEnabledProperty);
 304             }
 305             set
 306             {
 307                 SetValue(ScrollEnabledProperty, value);
 308                 NotifyPropertyChanged();
 309             }
 310         }
 311         private bool InternalScrollEnabled
 312         {
 313             get
 314             {
 315                 return mScrollEnabled;
 316             }
 317             set
 318             {
 319                 if (value != mScrollEnabled)
 320                 {
 321                     mScrollEnabled = value;
 322                     if (mScrollEnabled)
 323                     {
 324                         mPanGestureDetector.Detected += OnPanGestureDetected;
 325                     }
 326                     else
 327                     {
 328                         mPanGestureDetector.Detected -= OnPanGestureDetected;
 329                     }
 330                 }
 331             }
 332         }
 333
 334         /// <summary>
 335         /// Gets scrollable status.
 336         /// </summary>
 337         [EditorBrowsable(EditorBrowsableState.Never)]
 338         protected override bool AccessibilityIsScrollable()
 339         {
 340             return true;
 341         }
 342
 343         /// <summary>
 344         /// Pages mode, enables moving to the next or return to current page depending on pan displacement.
 345         /// Default is false.
 346         /// </summary>
 347         /// <since_tizen> 8 </since_tizen>
 348         public bool SnapToPage
 349         {
 350             get
 351             {
 352                 return (bool)GetValue(SnapToPageProperty);
 353             }
 354             set
 355             {
 356                 SetValue(SnapToPageProperty, value);
 357                 NotifyPropertyChanged();
 358             }
 359         }
 360         private bool InternalSnapToPage { set; get; } = false;
 361
 362         /// <summary>
 363         /// Get current page.
 364         /// Working property with SnapToPage property.
 365         /// </summary>
 366         /// <since_tizen> 8 </since_tizen>
 367         public int CurrentPage { get; private set; } = 0;
 368
 369         /// <summary>
 370         /// Duration of scroll animation.
 371         /// Default value is 125ms.
 372         /// </summary>
 373         /// <since_tizen> 8 </since_tizen>
 374         public int ScrollDuration
 375         {
 376             get
 377             {
 378                 return (int)GetValue(ScrollDurationProperty);
 379             }
 380             set
 381             {
 382                 SetValue(ScrollDurationProperty, value);
 383                 NotifyPropertyChanged();
 384             }
 385         }
 386         private int InternalScrollDuration
 387         {
 388             set
 389             {
 390                 mScrollDuration = value >= 0 ? value : mScrollDuration;
 391             }
 392             get
 393             {
 394                 return mScrollDuration;
 395             }
 396         }
 397
 398         /// <summary>
 399         /// Scroll Available area.
 400         /// </summary>
 401         /// <since_tizen> 8 </since_tizen>
 402         public Vector2 ScrollAvailableArea
 403         {
 404             get
 405             {
 406                 return GetValue(ScrollAvailableAreaProperty) as Vector2;
 407             }
 408             set
 409             {
 410                 SetValue(ScrollAvailableAreaProperty, value);
 411                 NotifyPropertyChanged();
 412             }
 413         }
 414         private Vector2 InternalScrollAvailableArea { set; get; }
 415
 416         /// <summary>
 417         /// An event emitted when user starts dragging ScrollableBase, user can subscribe or unsubscribe to this event handler.<br />
 418         /// </summary>
 419         /// <since_tizen> 8 </since_tizen>
 420         public event EventHandler<ScrollEventArgs> ScrollDragStarted;
 421
 422         /// <summary>
 423         /// An event emitted when user stops dragging ScrollableBase, user can subscribe or unsubscribe to this event handler.<br />
 424         /// </summary>
 425         /// <since_tizen> 8 </since_tizen>
 426         public event EventHandler<ScrollEventArgs> ScrollDragEnded;
 427
 428         /// <summary>
 429         /// An event emitted when the scrolling slide animation starts, user can subscribe or unsubscribe to this event handler.<br />
 430         /// </summary>
 431         /// <since_tizen> 8 </since_tizen>
 432         public event EventHandler<ScrollEventArgs> ScrollAnimationStarted;
 433
 434         /// <summary>
 435         /// An event emitted when the scrolling slide animation ends, user can subscribe or unsubscribe to this event handler.<br />
 436         /// </summary>
 437         /// <since_tizen> 8 </since_tizen>
 438         public event EventHandler<ScrollEventArgs> ScrollAnimationEnded;
 439
 440         /// <summary>
 441         /// An event emitted when scrolling, user can subscribe or unsubscribe to this event handler.<br />
 442         /// </summary>
 443         /// <since_tizen> 8 </since_tizen>
 444         public event EventHandler<ScrollEventArgs> Scrolling;
 445
 446         /// <summary>
 447         /// An event emitted when scrolling out of bound, user can subscribe or unsubscribe to this event handler.<br />
 448         /// </summary>
 449         [EditorBrowsable(EditorBrowsableState.Never)]
 450         public event EventHandler<ScrollOutOfBoundEventArgs> ScrollOutOfBound;
 451
 452         /// <summary>
 453         /// Scrollbar for ScrollableBase.
 454         /// </summary>
 455         /// <since_tizen> 8 </since_tizen>
 456         public ScrollbarBase Scrollbar
 457         {
 458             get
 459             {
 460                 return GetValue(ScrollbarProperty) as ScrollbarBase;
 461             }
 462             set
 463             {
 464                 SetValue(ScrollbarProperty, value);
 465                 NotifyPropertyChanged();
 466             }
 467         }
 468         private ScrollbarBase InternalScrollbar
 469         {
 470             get
 471             {
 472                 return scrollBar;
 473             }
 474             set
 475             {
 476                 if (scrollBar)
 477                 {
 478                     base.Remove(scrollBar);
 479                 }
 480                 scrollBar = value;
 481
 482                 if (scrollBar != null)
 483                 {
 484                     scrollBar.Name = "ScrollBar";
 485                     base.Add(scrollBar);
 486
 487                     if (hideScrollbar)
 488                     {
 489                         scrollBar.Hide();
 490                     }
 491                     else
 492                     {
 493                         scrollBar.Show();
 494                     }
 495
 496                     SetScrollbar();
 497                 }
 498             }
 499         }
 500
 501         /// <summary>
 502         /// Always hide Scrollbar.
 503         /// </summary>
 504         /// <since_tizen> 8 </since_tizen>
 505         public bool HideScrollbar
 506         {
 507             get
 508             {
 509                 return (bool)GetValue(HideScrollbarProperty);
 510             }
 511             set
 512             {
 513                 SetValue(HideScrollbarProperty, value);
 514                 NotifyPropertyChanged();
 515             }
 516         }
 517         private bool InternalHideScrollbar
 518         {
 519             get
 520             {
 521                 return hideScrollbar;
 522             }
 523             set
 524             {
 525                 hideScrollbar = value;
 526
 527                 if (scrollBar)
 528                 {
 529                     if (value)
 530                     {
 531                         scrollBar.Hide();
 532                     }
 533                     else
 534                     {
 535                         scrollBar.Show();
 536                         if (fadeScrollbar)
 537                         {
 538                             scrollBar.Opacity = 1.0f;
 539                             scrollBar.FadeOut();
 540                         }
 541                     }
 542                 }
 543             }
 544         }
 545
 546         /// <summary>
 547         /// The boolean flag for automatic fading Scrollbar.
 548         /// Scrollbar will be faded out when scroll stay in certain position longer than the threshold.
 549         /// Scrollbar will be faded in scroll position changes.
 550         /// </summary>
 551         [EditorBrowsable(EditorBrowsableState.Never)]
 552         public bool FadeScrollbar
 553         {
 554             get => (bool)GetValue(FadeScrollbarProperty);
 555             set => SetValue(FadeScrollbarProperty, value);
 556         }
 557
 558         private bool InternalFadeScrollbar
 559         {
 560             get
 561             {
 562                 return fadeScrollbar;
 563             }
 564             set
 565             {
 566                 fadeScrollbar = value;
 567
 568                 if (scrollBar != null && !hideScrollbar)
 569                 {
 570                     if (value)
 571                     {
 572                         scrollBar.FadeOut();
 573                     }
 574                     else
 575                     {
 576                         scrollBar.Opacity = 1.0f;
 577                         // Removing fadeout timer and animation.
 578                         scrollBar.FadeIn();
 579                     }
 580                 }
 581             }
 582         }
 583
 584         /// <summary>
 585         /// Container which has content of ScrollableBase.
 586         /// </summary>
 587         /// <since_tizen> 8 </since_tizen>
 588         public View ContentContainer { get; private set; }
 589
 590         /// <summary>
 591         /// Set the layout on this View. Replaces any existing Layout.
 592         /// </summary>
 593         /// <since_tizen> 8 </since_tizen>
 594         public new LayoutItem Layout
 595         {
 596             get
 597             {
 598                 return GetValue(LayoutProperty) as LayoutItem;
 599             }
 600             set
 601             {
 602                 SetValue(LayoutProperty, value);
 603                 NotifyPropertyChanged();
 604             }
 605         }
 606         private LayoutItem InternalLayout
 607         {
 608             get
 609             {
 610                 return ContentContainer.Layout;
 611             }
 612             set
 613             {
 614                 ContentContainer.Layout = value;
 615             }
 616         }
 617
 618         /// <summary>
 619         /// List of children of Container.
 620         /// </summary>
 621         /// <since_tizen> 8 </since_tizen>
 622         public new List<View> Children
 623         {
 624             get
 625             {
 626                 return ContentContainer.Children;
 627             }
 628         }
 629
 630         /// <summary>
 631         /// Deceleration rate of scrolling by finger.
 632         /// Rate should be bigger than 0 and smaller than 1.
 633         /// Default value is 0.998f;
 634         /// </summary>
 635         /// <since_tizen> 8 </since_tizen>
 636         public float DecelerationRate
 637         {
 638             get
 639             {
 640                 return (float)GetValue(DecelerationRateProperty);
 641             }
 642             set
 643             {
 644                 SetValue(DecelerationRateProperty, value);
 645                 NotifyPropertyChanged();
 646             }
 647         }
 648         private float InternalDecelerationRate
 649         {
 650             get
 651             {
 652                 return decelerationRate;
 653             }
 654             set
 655             {
 656                 decelerationRate = (value < 1 && value > 0) ? value : decelerationRate;
 657                 logValueOfDeceleration = (float)Math.Log(value);
 658             }
 659         }
 660
 661         /// <summary>
 662         /// Threshold not to go infinite at the end of scrolling animation.
 663         /// </summary>
 664         [EditorBrowsable(EditorBrowsableState.Never)]
 665         public float DecelerationThreshold
 666         {
 667             get
 668             {
 669                 return (float)GetValue(DecelerationThresholdProperty);
 670             }
 671             set
 672             {
 673                 SetValue(DecelerationThresholdProperty, value);
 674                 NotifyPropertyChanged();
 675             }
 676         }
 677         private float InternalDecelerationThreshold { get; set; } = 0.1f;
 678
 679         /// <summary>
 680         /// Scrolling event will be thrown when this amount of scroll position is changed.
 681         /// If this threshold becomes smaller, the tracking detail increases but the scrolling range that can be tracked becomes smaller.
 682         /// If large sized ContentContainer is required, please use larger threshold value.
 683         /// Default ScrollingEventThreshold value is 0.001f.
 684         /// </summary>
 685         [EditorBrowsable(EditorBrowsableState.Never)]
 686         public float ScrollingEventThreshold
 687         {
 688             get
 689             {
 690                 return (float)GetValue(ScrollingEventThresholdProperty);
 691             }
 692             set
 693             {
 694                 SetValue(ScrollingEventThresholdProperty, value);
 695                 NotifyPropertyChanged();
 696             }
 697         }
 698         private float InternalScrollingEventThreshold
 699         {
 700             get
 701             {
 702                 return mScrollingEventThreshold;
 703             }
 704             set
 705             {
 706                 if (mScrollingEventThreshold != value && value > 0)
 707                 {
 708                     ContentContainer.RemovePropertyNotification(propertyNotification);
 709                     propertyNotification = ContentContainer.AddPropertyNotification("position", PropertyCondition.Step(value));
 710                     propertyNotification.Notified += OnPropertyChanged;
 711                     mScrollingEventThreshold = value;
 712                 }
 713             }
 714         }
 715
 716         /// <summary>
 717         /// Page will be changed when velocity of panning is over threshold.
 718         /// The unit of threshold is pixel per millisecond.
 719         /// </summary>
 720         /// <since_tizen> 8 </since_tizen>
 721         public float PageFlickThreshold
 722         {
 723             get
 724             {
 725                 return (float)GetValue(PageFlickThresholdProperty);
 726             }
 727             set
 728             {
 729                 SetValue(PageFlickThresholdProperty, value);
 730                 NotifyPropertyChanged();
 731             }
 732         }
 733         private float InternalPageFlickThreshold
 734         {
 735             get
 736             {
 737                 return mPageFlickThreshold;
 738             }
 739             set
 740             {
 741                 mPageFlickThreshold = value >= 0f ? value : mPageFlickThreshold;
 742             }
 743         }
 744
 745         /// <summary>
 746         /// Padding for the ScrollableBase
 747         /// </summary>
 748         [EditorBrowsable(EditorBrowsableState.Never)]
 749         public new Extents Padding
 750         {
 751             get
 752             {
 753                 return GetValue(PaddingProperty) as Extents;
 754             }
 755             set
 756             {
 757                 SetValue(PaddingProperty, value);
 758                 NotifyPropertyChanged();
 759             }
 760         }
 761         private Extents InternalPadding
 762         {
 763             get
 764             {
 765                 return ContentContainer.Padding;
 766             }
 767             set
 768             {
 769                 ContentContainer.Padding = value;
 770             }
 771         }
 772
 773         /// <summary>
 774         /// Alphafunction for scroll animation.
 775         /// </summary>
 776         [EditorBrowsable(EditorBrowsableState.Never)]
 777         public AlphaFunction ScrollAlphaFunction
 778         {
 779             get
 780             {
 781                 return GetValue(ScrollAlphaFunctionProperty) as AlphaFunction;
 782             }
 783             set
 784             {
 785                 SetValue(ScrollAlphaFunctionProperty, value);
 786                 NotifyPropertyChanged();
 787             }
 788         }
 789         private AlphaFunction InternalScrollAlphaFunction { get; set; } = new AlphaFunction(AlphaFunction.BuiltinFunctions.Linear);
 790
 791         private bool hideScrollbar = true;
 792         private float maxScrollDistance;
 793         private float childTargetPosition = 0.0f;
 794         private PanGestureDetector mPanGestureDetector;
 795         private ScrollbarBase scrollBar;
 796         private bool scrolling = false;
 797         private float ratioOfScreenWidthToCompleteScroll = 0.5f;
 798         private float totalDisplacementForPan = 0.0f;
 799         private Size previousContainerSize = new Size();
 800         private Size previousSize = new Size();
 801         private PropertyNotification propertyNotification;
 802         private float noticeAnimationEndBeforePosition = 0.0f;
 803         private bool readyToNotice = false;
 804
 805         /// <summary>
 806         /// Notice before animation is finished.
 807         /// </summary>
 808         [EditorBrowsable(EditorBrowsableState.Never)]
 809         // Let's consider more whether this needs to be set as protected.
 810         public float NoticeAnimationEndBeforePosition
 811         {
 812             get
 813             {
 814                 return (float)GetValue(NoticeAnimationEndBeforePositionProperty);
 815             }
 816             set
 817             {
 818                 SetValue(NoticeAnimationEndBeforePositionProperty, value);
 819                 NotifyPropertyChanged();
 820             }
 821         }
 822         private float InternalNoticeAnimationEndBeforePosition
 823         {
 824             get => noticeAnimationEndBeforePosition;
 825             set => noticeAnimationEndBeforePosition = value;
 826         }
 827
 828         /// <summary>
 829         /// Step scroll move distance.
 830         /// Key focus originally moves focusable objects, but in ScrollableBase,
 831         /// if focusable object is too far or un-exist and ScrollableBase is focusable,
 832         /// it can scroll move itself by key input.
 833         /// this value decide how long distance will it moves in one step.
 834         /// if any value is not set, step will be moved quater size of ScrollableBase length.
 835         /// </summary>
 836         [EditorBrowsable(EditorBrowsableState.Never)]
 837         public float StepScrollDistance
 838         {
 839             get
 840             {
 841                 return (float)GetValue(StepScrollDistanceProperty);
 842             }
 843             set
 844             {
 845                 SetValue(StepScrollDistanceProperty, value);
 846                 NotifyPropertyChanged();
 847             }
 848         }
 849         private float stepScrollDistance = 0f;
 850
 851         /// <summary>
 852         /// Wheel scroll move distance.
 853         /// This value decide how long distance will it moves in wheel event.
 854         /// </summary>
 855         [EditorBrowsable(EditorBrowsableState.Never)]
 856         public float WheelScrollDistance
 857         {
 858             get
 859             {
 860                 return (float)GetValue(WheelScrollDistanceProperty);
 861             }
 862             set
 863             {
 864                 SetValue(WheelScrollDistanceProperty, value);
 865                 NotifyPropertyChanged();
 866             }
 867         }
 868         private float wheelScrollDistance = 50f;
 869
 870
 871         // Let's consider more whether this needs to be set as protected.
 872         private float finalTargetPosition;
 873
 874         private Animation scrollAnimation;
 875         // Declare user alpha function delegate
 876         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 877         private delegate float UserAlphaFunctionDelegate(float progress);
 878         private UserAlphaFunctionDelegate customScrollAlphaFunction;
 879         private float velocityOfLastPan = 0.0f;
 880         private float panAnimationDuration = 0.0f;
 881         private float panAnimationDelta = 0.0f;
 882         private float logValueOfDeceleration = 0.0f;
 883         private float decelerationRate = 0.0f;
 884
 885         private View topOverShootingShadowView;
 886         private View bottomOverShootingShadowView;
 887         private View leftOverShootingShadowView;
 888         private View rightOverShootingShadowView;
 889         private const int overShootingShadowScaleHeightLimit = 64 * 3;
 890         private const int overShootingShadowAnimationDuration = 300;
 891         private Animation overShootingShadowAnimation;
 892         private bool isOverShootingShadowShown = false;
 893         private float startShowShadowDisplacement;
 894
 895         private void Initialize()
 896         {
 897             DecelerationRate = 0.998f;
 898
 899             base.Layout = new ScrollableBaseCustomLayout();
 900             mPanGestureDetector = new PanGestureDetector();
 901             mPanGestureDetector.Attach(this);
 902             mPanGestureDetector.AddDirection(PanGestureDetector.DirectionVertical);
 903             if (mPanGestureDetector.GetMaximumTouchesRequired() < 2) mPanGestureDetector.SetMaximumTouchesRequired(2);
 904             mPanGestureDetector.Detected += OnPanGestureDetected;
 905
 906             ClippingMode = ClippingModeType.ClipToBoundingBox;
 907
 908             //Default Scrolling child
 909             ContentContainer = new View()
 910             {
 911                 Name = "ContentContainer",
 912                 WidthSpecification = ScrollingDirection == Direction.Vertical ? LayoutParamPolicies.MatchParent : LayoutParamPolicies.WrapContent,
 913                 HeightSpecification = ScrollingDirection == Direction.Vertical ? LayoutParamPolicies.WrapContent : LayoutParamPolicies.MatchParent,
 914             };
 915             // Check if children's sizes change to update Scrollbar
 916             ContentContainer.Relayout += OnScrollingChildRelayout;
 917             propertyNotification = ContentContainer.AddPropertyNotification("position", PropertyCondition.Step(mScrollingEventThreshold));
 918             propertyNotification.Notified += OnPropertyChanged;
 919             base.Add(ContentContainer);
 920             // Check if ScrollableBase's size changes to update Scrollbar
 921             base.Relayout += OnScrollingChildRelayout;
 922
 923             Scrollbar = new Scrollbar();
 924
 925             //Show vertical shadow on the top (or bottom) of the scrollable when panning down (or up).
 926             topOverShootingShadowView = new View
 927             {
 928                 BackgroundImage = FrameworkInformation.ResourcePath + "nui_component_default_scroll_over_shooting_top.png",
 929                 Opacity = 1.0f,
 930                 SizeHeight = 0.0f,
 931                 PositionUsesPivotPoint = true,
 932                 ParentOrigin = NUI.ParentOrigin.TopCenter,
 933                 PivotPoint = NUI.PivotPoint.TopCenter,
 934             };
 935             bottomOverShootingShadowView = new View
 936             {
 937                 BackgroundImage = FrameworkInformation.ResourcePath + "nui_component_default_scroll_over_shooting_bottom.png",
 938                 Opacity = 1.0f,
 939                 SizeHeight = 0.0f,
 940                 PositionUsesPivotPoint = true,
 941                 ParentOrigin = NUI.ParentOrigin.BottomCenter,
 942                 PivotPoint = NUI.PivotPoint.BottomCenter,
 943             };
 944             //Show horizontal shadow on the left (or right) of the scrollable when panning down (or up).
 945             leftOverShootingShadowView = new View
 946             {
 947                 BackgroundImage = FrameworkInformation.ResourcePath + "nui_component_default_scroll_over_shooting_left.png",
 948                 Opacity = 1.0f,
 949                 SizeWidth = 0.0f,
 950                 PositionUsesPivotPoint = true,
 951                 ParentOrigin = NUI.ParentOrigin.CenterLeft,
 952                 PivotPoint = NUI.PivotPoint.CenterLeft,
 953             };
 954             rightOverShootingShadowView = new View
 955             {
 956                 BackgroundImage = FrameworkInformation.ResourcePath + "nui_component_default_scroll_over_shooting_right.png",
 957                 Opacity = 1.0f,
 958                 SizeWidth = 0.0f,
 959                 PositionUsesPivotPoint = true,
 960                 ParentOrigin = NUI.ParentOrigin.CenterRight,
 961                 PivotPoint = NUI.PivotPoint.CenterRight,
 962             };
 963
 964             WheelEvent += OnWheelEvent;
 965
 966             AccessibilityManager.Instance.SetAccessibilityAttribute(this, AccessibilityManager.AccessibilityAttribute.Trait, "ScrollableBase");
 967
 968             SetKeyboardNavigationSupport(true);
 969         }
 970
 971         /// <summary>
 972         /// Default Constructor
 973         /// </summary>
 974         /// <since_tizen> 8 </since_tizen>
 975         public ScrollableBase() : base()
 976         {
 977             Initialize();
 978         }
 979
 980         /// <summary>
 981         /// Creates a new instance of a ScrollableBase with style.
 982         /// </summary>
 983         /// <param name="style">Creates ScrollableBase by special style defined in UX.</param>
 984         [EditorBrowsable(EditorBrowsableState.Never)]
 985         public ScrollableBase(string style) : base(style)
 986         {
 987             Initialize();
 988         }
 989
 990         /// <summary>
 991         /// Creates a new instance of a ScrollableBase with style.
 992         /// </summary>
 993         /// <param name="style">A style applied to the newly created ScrollableBase.</param>
 994         [EditorBrowsable(EditorBrowsableState.Never)]
 995         public ScrollableBase(ControlStyle style) : base(style)
 996         {
 997             Initialize();
 998         }
 999
1000         private bool OnInterruptTouchingChildTouched(object source, View.TouchEventArgs args)
1001         {
1002             if (args.Touch.GetState(0) == PointStateType.Down)
1003             {
1004                 if (scrolling && !SnapToPage)
1005                 {
1006                     StopScroll();
1007                 }
1008             }
1009             return true;
1010         }
1011
1012         private void OnPropertyChanged(object source, PropertyNotification.NotifyEventArgs args)
1013         {
1014             OnScroll();
1015         }
1016
1017         /// <summary>
1018         /// Called after a child has been added to the owning view.
1019         /// </summary>
1020         /// <param name="view">The child which has been added.</param>
1021         /// <since_tizen> 8 </since_tizen>
1022         public override void Add(View view)
1023         {
1024             ContentContainer.Add(view);
1025         }
1026
1027         /// <summary>
1028         /// Called after a child has been removed from the owning view.
1029         /// </summary>
1030         /// <param name="view">The child which has been removed.</param>
1031         /// <since_tizen> 8 </since_tizen>
1032         public override void Remove(View view)
1033         {
1034             if (SnapToPage && CurrentPage == Children.IndexOf(view) && CurrentPage == Children.Count - 1 && Children.Count > 1)
1035             {
1036                 // Target View is current page and also last child.
1037                 // CurrentPage should be changed to previous page.
1038                 ScrollToIndex(CurrentPage - 1);
1039             }
1040
1041             ContentContainer.Remove(view);
1042         }
1043
1044         private void OnScrollingChildRelayout(object source, EventArgs args)
1045         {
1046             // Size is changed. Calculate maxScrollDistance.
1047             bool isSizeChanged = previousContainerSize.Width != ContentContainer.Size.Width || previousContainerSize.Height != ContentContainer.Size.Height ||
1048                 previousSize.Width != Size.Width || previousSize.Height != Size.Height;
1049
1050             if (isSizeChanged)
1051             {
1052                 maxScrollDistance = CalculateMaximumScrollDistance();
1053                 if (!ReviseContainerPositionIfNeed())
1054                 {
1055                     UpdateScrollbar();
1056                 }
1057             }
1058
1059             previousContainerSize = new Size(ContentContainer.Size);
1060             previousSize = new Size(Size);
1061         }
1062
1063         private bool ReviseContainerPositionIfNeed()
1064         {
1065             bool isHorizontal = ScrollingDirection == Direction.Horizontal;
1066             float currentPosition = isHorizontal ? ContentContainer.CurrentPosition.X : ContentContainer.CurrentPosition.Y;
1067
1068             if (Math.Abs(currentPosition) > maxScrollDistance)
1069             {
1070                 StopScroll();
1071                 var targetPosition = BoundScrollPosition(-maxScrollDistance);
1072                 if (isHorizontal) ContentContainer.PositionX = targetPosition;
1073                 else ContentContainer.PositionY = targetPosition;
1074                 return true;
1075             }
1076
1077             return false;
1078         }
1079
1080         /// <summary>
1081         /// The composition of a Scrollbar can vary depending on how you use ScrollableBase.
1082         /// Set the composition that will go into the ScrollableBase according to your ScrollableBase.
1083         /// </summary>
1084         /// <since_tizen> 8 </since_tizen>
1085         [EditorBrowsable(EditorBrowsableState.Never)]
1086         protected virtual void SetScrollbar()
1087         {
1088             if (Scrollbar)
1089             {
1090                 bool isHorizontal = ScrollingDirection == Direction.Horizontal;
1091                 float contentLength = isHorizontal ? ContentContainer.Size.Width : ContentContainer.Size.Height;
1092                 float viewportLength = isHorizontal ? Size.Width : Size.Height;
1093                 float currentPosition = isHorizontal ? ContentContainer.CurrentPosition.X : ContentContainer.CurrentPosition.Y;
1094                 Scrollbar.Initialize(contentLength, viewportLength, -currentPosition, isHorizontal);
1095             }
1096         }
1097
1098         /// Update scrollbar position and size.
1099         [EditorBrowsable(EditorBrowsableState.Never)]
1100         protected virtual void UpdateScrollbar()
1101         {
1102             if (Scrollbar)
1103             {
1104                 bool isHorizontal = ScrollingDirection == Direction.Horizontal;
1105                 float contentLength = isHorizontal ? ContentContainer.Size.Width : ContentContainer.Size.Height;
1106                 float viewportLength = isHorizontal ? Size.Width : Size.Height;
1107                 float currentPosition = isHorizontal ? ContentContainer.CurrentPosition.X : ContentContainer.CurrentPosition.Y;
1108                 Scrollbar.Update(contentLength, viewportLength, -currentPosition);
1109
1110                 if (!hideScrollbar && fadeScrollbar)
1111                 {
1112                     Scrollbar.FadeOut();
1113                 }
1114             }
1115         }
1116
1117         /// <summary>
1118         /// return the children of ContentContainer when user try to get the children of ScrollableBase.
1119         /// </summary>
1120         /// <returns></returns>
1121         [EditorBrowsable(EditorBrowsableState.Never)]
1122         protected override List<View> GetChildren()
1123         {
1124             return ContentContainer.Children;
1125         }
1126
1127         /// <summary>
1128         /// Scrolls to the item at the specified index.
1129         /// </summary>
1130         /// <param name="index">Index of item.</param>
1131         /// <since_tizen> 8 </since_tizen>
1132         public void ScrollToIndex(int index)
1133         {
1134             if (ContentContainer.ChildCount - 1 < index || index < 0)
1135             {
1136                 return;
1137             }
1138
1139             if (SnapToPage)
1140             {
1141                 CurrentPage = index;
1142             }
1143
1144             float targetPosition = Math.Min(ScrollingDirection == Direction.Vertical ? Children[index].Position.Y : Children[index].Position.X, maxScrollDistance);
1145             AnimateChildTo(ScrollDuration, -targetPosition);
1146         }
1147
1148         internal void ScrollToChild(View child, bool anim = false)
1149         {
1150             if (null == FindDescendantByID(child.ID)) return;
1151
1152             bool isHorizontal = (ScrollingDirection == Direction.Horizontal);
1153
1154             float viewScreenPosition = (isHorizontal ? ScreenPosition.X : ScreenPosition.Y);
1155             float childScreenPosition = (isHorizontal ? child.ScreenPosition.X : child.ScreenPosition.Y);
1156             float scrollPosition = (isHorizontal ? ScrollPosition.X : ScrollPosition.Y);
1157             float viewSize = (isHorizontal ? SizeWidth : SizeHeight);
1158             float childSize = (isHorizontal ? child.SizeWidth : child.SizeHeight);
1159
1160             if (viewScreenPosition > childScreenPosition ||
1161                 viewScreenPosition + viewSize < childScreenPosition + childSize)
1162             {// if object is outside
1163                 float targetPosition;
1164                 float dist = viewScreenPosition - childScreenPosition;
1165                 if (dist > 0)
1166                 {// if object is upper side
1167                     targetPosition = scrollPosition - dist;
1168                 }
1169                 else
1170                 {// if object is down side
1171                     targetPosition = scrollPosition - dist + childSize - viewSize;
1172                 }
1173                 ScrollTo(targetPosition, anim);
1174             }
1175         }
1176
1177         private void OnScrollDragStarted()
1178         {
1179             ScrollEventArgs eventArgs = new ScrollEventArgs(ContentContainer.CurrentPosition);
1180             ScrollDragStarted?.Invoke(this, eventArgs);
1181             EmitScrollStartedEvent();
1182
1183             if (!hideScrollbar && fadeScrollbar)
1184             {
1185                 scrollBar?.FadeIn();
1186             }
1187         }
1188
1189         private void OnScrollDragEnded()
1190         {
1191             ScrollEventArgs eventArgs = new ScrollEventArgs(ContentContainer.CurrentPosition);
1192             ScrollDragEnded?.Invoke(this, eventArgs);
1193             EmitScrollFinishedEvent();
1194
1195             if (!hideScrollbar && fadeScrollbar)
1196             {
1197                 scrollBar?.FadeOut();
1198             }
1199         }
1200
1201         private void OnScrollAnimationStarted()
1202         {
1203             ScrollEventArgs eventArgs = new ScrollEventArgs(ContentContainer.CurrentPosition);
1204             ScrollAnimationStarted?.Invoke(this, eventArgs);
1205             EmitScrollStartedEvent();
1206
1207             if (!hideScrollbar && fadeScrollbar)
1208             {
1209                 scrollBar?.FadeIn();
1210             }
1211         }
1212
1213         private void OnScrollAnimationEnded()
1214         {
1215             scrolling = false;
1216             this.InterceptTouchEvent -= OnInterruptTouchingChildTouched;
1217
1218             ScrollEventArgs eventArgs = new ScrollEventArgs(ContentContainer.CurrentPosition);
1219             ScrollAnimationEnded?.Invoke(this, eventArgs);
1220             EmitScrollFinishedEvent();
1221
1222             if (!hideScrollbar && fadeScrollbar)
1223             {
1224                 scrollBar?.FadeOut();
1225             }
1226         }
1227
1228         private void OnScroll()
1229         {
1230             ScrollEventArgs eventArgs = new ScrollEventArgs(ContentContainer.CurrentPosition);
1231             Scrolling?.Invoke(this, eventArgs);
1232
1233             bool isHorizontal = ScrollingDirection == Direction.Horizontal;
1234             float contentLength = isHorizontal ? ContentContainer.Size.Width : ContentContainer.Size.Height;
1235             float currentPosition = isHorizontal ? ContentContainer.CurrentPosition.X : ContentContainer.CurrentPosition.Y;
1236
1237             scrollBar?.Update(contentLength, Math.Abs(currentPosition));
1238             CheckPreReachedTargetPosition();
1239         }
1240
1241         private void CheckPreReachedTargetPosition()
1242         {
1243             // Check whether we reached pre-reached target position
1244             if (readyToNotice &&
1245                 ContentContainer.CurrentPosition.Y <= finalTargetPosition + NoticeAnimationEndBeforePosition &&
1246                 ContentContainer.CurrentPosition.Y >= finalTargetPosition - NoticeAnimationEndBeforePosition)
1247             {
1248                 //Notice first
1249                 readyToNotice = false;
1250                 OnPreReachedTargetPosition(finalTargetPosition);
1251             }
1252         }
1253
1254         /// <summary>
1255         /// This helps developer who wants to know before scroll is reaching target position.
1256         /// </summary>
1257         /// <param name="targetPosition">Index of item.</param>
1258         /// This may be public opened in tizen_6.0 after ACR done. Before ACR, need to be hidden as inhouse API
1259         [EditorBrowsable(EditorBrowsableState.Never)]
1260         protected virtual void OnPreReachedTargetPosition(float targetPosition)
1261         {
1262
1263         }
1264
1265         private void StopScroll()
1266         {
1267             if (scrollAnimation != null)
1268             {
1269                 if (scrollAnimation.State == Animation.States.Playing)
1270                 {
1271                     Debug.WriteLineIf(LayoutDebugScrollableBase, "StopScroll Animation Playing");
1272                     scrollAnimation.Stop(Animation.EndActions.Cancel);
1273                     OnScrollAnimationEnded();
1274                 }
1275                 scrollAnimation.Clear();
1276             }
1277         }
1278
1279         private void AnimateChildTo(int duration, float axisPosition)
1280         {
1281             Debug.WriteLineIf(LayoutDebugScrollableBase, "AnimationTo Animation Duration:" + duration + " Destination:" + axisPosition);
1282             finalTargetPosition = axisPosition;
1283
1284             StopScroll(); // Will replace previous animation so will stop existing one.
1285
1286             if (scrollAnimation == null)
1287             {
1288                 scrollAnimation = new Animation();
1289                 scrollAnimation.Finished += ScrollAnimationFinished;
1290             }
1291
1292             scrollAnimation.Duration = duration;
1293             scrollAnimation.DefaultAlphaFunction = new AlphaFunction(AlphaFunction.BuiltinFunctions.EaseOutSquare);
1294             scrollAnimation.AnimateTo(ContentContainer, (ScrollingDirection == Direction.Horizontal) ? "PositionX" : "PositionY", axisPosition, ScrollAlphaFunction);
1295             scrolling = true;
1296             OnScrollAnimationStarted();
1297             scrollAnimation.Play();
1298         }
1299
1300         /// <summary>
1301         /// Scroll to specific position with or without animation.
1302         /// </summary>
1303         /// <param name="position">Destination.</param>
1304         /// <param name="animate">Scroll with or without animation</param>
1305         /// <since_tizen> 8 </since_tizen>
1306         public void ScrollTo(float position, bool animate)
1307         {
1308             StopScroll();
1309             float currentPositionX = ContentContainer.CurrentPosition.X != 0 ? ContentContainer.CurrentPosition.X : ContentContainer.Position.X;
1310             float currentPositionY = ContentContainer.CurrentPosition.Y != 0 ? ContentContainer.CurrentPosition.Y : ContentContainer.Position.Y;
1311             float delta = ScrollingDirection == Direction.Horizontal ? currentPositionX : currentPositionY;
1312             // The argument position is the new pan position. So the new position of ScrollableBase becomes (-position).
1313             // To move ScrollableBase's position to (-position), it moves by (-position - currentPosition).
1314             delta = -position - delta;
1315
1316             ScrollBy(delta, animate);
1317         }
1318
1319         private float BoundScrollPosition(float targetPosition)
1320         {
1321             if (ScrollAvailableArea != null)
1322             {
1323                 float minScrollPosition = ScrollAvailableArea.X;
1324                 float maxScrollPosition = ScrollAvailableArea.Y;
1325
1326                 targetPosition = Math.Min(-minScrollPosition, targetPosition);
1327                 targetPosition = Math.Max(-maxScrollPosition, targetPosition);
1328             }
1329             else
1330             {
1331                 targetPosition = Math.Min(0, targetPosition);
1332                 targetPosition = Math.Max(-maxScrollDistance, targetPosition);
1333             }
1334
1335             return targetPosition;
1336         }
1337
1338         private void ScrollBy(float displacement, bool animate)
1339         {
1340             if (GetChildCount() == 0 || maxScrollDistance < 0)
1341             {
1342                 return;
1343             }
1344
1345             float childCurrentPosition = (ScrollingDirection == Direction.Horizontal) ? ContentContainer.PositionX : ContentContainer.PositionY;
1346
1347             Debug.WriteLineIf(LayoutDebugScrollableBase, "ScrollBy childCurrentPosition:" + childCurrentPosition +
1348                 " displacement:" + displacement,
1349                 " maxScrollDistance:" + maxScrollDistance);
1350
1351             childTargetPosition = childCurrentPosition + displacement; // child current position + gesture displacement
1352
1353             Debug.WriteLineIf(LayoutDebugScrollableBase, "ScrollBy currentAxisPosition:" + childCurrentPosition + "childTargetPosition:" + childTargetPosition);
1354
1355             if (animate)
1356             {
1357                 // Calculate scroll animation duration
1358                 float scrollDistance = Math.Abs(displacement);
1359                 readyToNotice = true;
1360
1361                 AnimateChildTo(ScrollDuration, BoundScrollPosition(AdjustTargetPositionOfScrollAnimation(BoundScrollPosition(childTargetPosition))));
1362             }
1363             else
1364             {
1365                 StopScroll();
1366                 finalTargetPosition = BoundScrollPosition(childTargetPosition);
1367
1368                 // Set position of scrolling child without an animation
1369                 if (ScrollingDirection == Direction.Horizontal)
1370                 {
1371                     ContentContainer.PositionX = finalTargetPosition;
1372                 }
1373                 else
1374                 {
1375                     ContentContainer.PositionY = finalTargetPosition;
1376                 }
1377             }
1378         }
1379
1380         /// <summary>
1381         /// you can override it to clean-up your own resources.
1382         /// </summary>
1383         /// <param name="type">DisposeTypes</param>
1384         /// This will be public opened in tizen_5.5 after ACR done. Before ACR, need to be hidden as inhouse API.
1385         [EditorBrowsable(EditorBrowsableState.Never)]
1386         protected override void Dispose(DisposeTypes type)
1387         {
1388             if (disposed)
1389             {
1390                 return;
1391             }
1392
1393             StopOverShootingShadowAnimation();
1394             StopScroll();
1395
1396             if (type == DisposeTypes.Explicit)
1397             {
1398                 mPanGestureDetector?.Dispose();
1399                 mPanGestureDetector = null;
1400
1401                 ContentContainer?.RemovePropertyNotification(propertyNotification);
1402                 propertyNotification?.Dispose();
1403                 propertyNotification = null;
1404             }
1405
1406             WheelEvent -= OnWheelEvent;
1407
1408             if (type == DisposeTypes.Explicit)
1409             {
1410
1411             }
1412             base.Dispose(type);
1413         }
1414
1415         private float CalculateMaximumScrollDistance()
1416         {
1417             float scrollingChildLength = 0;
1418             float scrollerLength = 0;
1419             if (ScrollingDirection == Direction.Horizontal)
1420             {
1421                 Debug.WriteLineIf(LayoutDebugScrollableBase, "Horizontal");
1422
1423                 scrollingChildLength = ContentContainer.Size.Width;
1424                 scrollerLength = Size.Width;
1425             }
1426             else
1427             {
1428                 Debug.WriteLineIf(LayoutDebugScrollableBase, "Vertical");
1429                 scrollingChildLength = ContentContainer.Size.Height;
1430                 scrollerLength = Size.Height;
1431             }
1432
1433             Debug.WriteLineIf(LayoutDebugScrollableBase, "ScrollBy maxScrollDistance:" + (scrollingChildLength - scrollerLength) +
1434                 " parent length:" + scrollerLength +
1435                 " scrolling child length:" + scrollingChildLength);
1436
1437             return Math.Max(scrollingChildLength - scrollerLength, 0);
1438         }
1439
1440         private void PageSnap(float velocity)
1441         {
1442             float destination;
1443
1444             Debug.WriteLineIf(LayoutDebugScrollableBase, "PageSnap with pan candidate totalDisplacement:" + totalDisplacementForPan +
1445                 " currentPage[" + CurrentPage + "]");
1446
1447             //Increment current page if total displacement enough to warrant a page change.
1448             if (Math.Abs(totalDisplacementForPan) > (mPageWidth * ratioOfScreenWidthToCompleteScroll))
1449             {
1450                 if (totalDisplacementForPan < 0)
1451                 {
1452                     CurrentPage = Math.Min(Math.Max(Children.Count - 1, 0), ++CurrentPage);
1453                 }
1454                 else
1455                 {
1456                     CurrentPage = Math.Max(0, --CurrentPage);
1457                 }
1458             }
1459             else if (Math.Abs(velocity) > PageFlickThreshold)
1460             {
1461                 if (velocity < 0)
1462                 {
1463                     CurrentPage = Math.Min(Math.Max(Children.Count - 1, 0), ++CurrentPage);
1464                 }
1465                 else
1466                 {
1467                     CurrentPage = Math.Max(0, --CurrentPage);
1468                 }
1469             }
1470
1471             // Animate to new page or reposition to current page
1472             if (ScrollingDirection == Direction.Horizontal)
1473                 destination = -(Children[CurrentPage].Position.X + Children[CurrentPage].CurrentSize.Width / 2 - CurrentSize.Width / 2); // set to middle of current page
1474             else
1475                 destination = -(Children[CurrentPage].Position.Y + Children[CurrentPage].CurrentSize.Height / 2 - CurrentSize.Height / 2);
1476
1477             AnimateChildTo(ScrollDuration, destination);
1478         }
1479
1480         /// <summary>
1481         /// Enable/Disable overshooting effect. default is disabled.
1482         /// </summary>
1483         [EditorBrowsable(EditorBrowsableState.Never)]
1484         public bool EnableOverShootingEffect
1485         {
1486             get
1487             {
1488                 return (bool)GetValue(EnableOverShootingEffectProperty);
1489             }
1490             set
1491             {
1492                 SetValue(EnableOverShootingEffectProperty, value);
1493                 NotifyPropertyChanged();
1494             }
1495         }
1496         private bool InternalEnableOverShootingEffect { get; set; } = false;
1497
1498         private void AttachOverShootingShadowView()
1499         {
1500             if (!EnableOverShootingEffect)
1501                 return;
1502
1503             // stop animation if necessary.
1504             StopOverShootingShadowAnimation();
1505
1506             if (ScrollingDirection == Direction.Horizontal)
1507             {
1508                 base.Add(leftOverShootingShadowView);
1509                 base.Add(rightOverShootingShadowView);
1510
1511                 leftOverShootingShadowView.Size = new Size(0.0f, SizeHeight);
1512                 leftOverShootingShadowView.Opacity = 1.0f;
1513                 leftOverShootingShadowView.RaiseToTop();
1514
1515                 rightOverShootingShadowView.Size = new Size(0.0f, SizeHeight);
1516                 rightOverShootingShadowView.Opacity = 1.0f;
1517                 rightOverShootingShadowView.RaiseToTop();
1518             }
1519             else
1520             {
1521                 base.Add(topOverShootingShadowView);
1522                 base.Add(bottomOverShootingShadowView);
1523
1524                 topOverShootingShadowView.Size = new Size(SizeWidth, 0.0f);
1525                 topOverShootingShadowView.Opacity = 1.0f;
1526                 topOverShootingShadowView.RaiseToTop();
1527
1528                 bottomOverShootingShadowView.Size = new Size(SizeWidth, 0.0f);
1529                 bottomOverShootingShadowView.Opacity = 1.0f;
1530                 bottomOverShootingShadowView.RaiseToTop();
1531             }
1532
1533             // at the beginning, height or width of overshooting shadow is 0, so it is invisible.
1534             isOverShootingShadowShown = false;
1535         }
1536
1537         private void DragOverShootingShadow(float totalPanDisplacement, float panDisplacement)
1538         {
1539             if (!EnableOverShootingEffect)
1540                 return;
1541
1542             if (totalPanDisplacement > 0) // downwards
1543             {
1544                 // check if reaching at the top / left.
1545                 if ((int)finalTargetPosition != 0)
1546                 {
1547                     isOverShootingShadowShown = false;
1548                     return;
1549                 }
1550
1551                 // save start displacement, and re-calculate displacement.
1552                 if (!isOverShootingShadowShown)
1553                 {
1554                     startShowShadowDisplacement = totalPanDisplacement;
1555                 }
1556                 isOverShootingShadowShown = true;
1557
1558                 float newDisplacement = (int)totalPanDisplacement < (int)startShowShadowDisplacement ? 0 : totalPanDisplacement - startShowShadowDisplacement;
1559
1560                 if (ScrollingDirection == Direction.Horizontal)
1561                 {
1562                     // scale limit of height is 60%.
1563                     float heightScale = newDisplacement / overShootingShadowScaleHeightLimit;
1564                     leftOverShootingShadowView.SizeHeight = heightScale > 0.6f ? SizeHeight * 0.4f : SizeHeight * (1.0f - heightScale);
1565
1566                     // scale limit of width is 300%.
1567                     leftOverShootingShadowView.SizeWidth = newDisplacement > overShootingShadowScaleHeightLimit ? overShootingShadowScaleHeightLimit : newDisplacement;
1568
1569                     // trigger event
1570                     ScrollOutOfBoundEventArgs.Direction scrollDirection = panDisplacement > 0 ?
1571                        ScrollOutOfBoundEventArgs.Direction.Right : ScrollOutOfBoundEventArgs.Direction.Left;
1572                     OnScrollOutOfBound(scrollDirection, totalPanDisplacement);
1573                 }
1574                 else
1575                 {
1576                     // scale limit of width is 60%.
1577                     float widthScale = newDisplacement / overShootingShadowScaleHeightLimit;
1578                     topOverShootingShadowView.SizeWidth = widthScale > 0.6f ? SizeWidth * 0.4f : SizeWidth * (1.0f - widthScale);
1579
1580                     // scale limit of height is 300%.
1581                     topOverShootingShadowView.SizeHeight = newDisplacement > overShootingShadowScaleHeightLimit ? overShootingShadowScaleHeightLimit : newDisplacement;
1582
1583                     // trigger event
1584                     ScrollOutOfBoundEventArgs.Direction scrollDirection = panDisplacement > 0 ?
1585                        ScrollOutOfBoundEventArgs.Direction.Down : ScrollOutOfBoundEventArgs.Direction.Up;
1586                     OnScrollOutOfBound(scrollDirection, totalPanDisplacement);
1587                 }
1588             }
1589             else if (totalPanDisplacement < 0) // upwards
1590             {
1591                 // check if reaching at the bottom.
1592                 if (-(int)finalTargetPosition != (int)maxScrollDistance)
1593                 {
1594                     isOverShootingShadowShown = false;
1595                     return;
1596                 }
1597
1598                 // save start displacement, and re-calculate displacement.
1599                 if (!isOverShootingShadowShown)
1600                 {
1601                     startShowShadowDisplacement = totalPanDisplacement;
1602                 }
1603                 isOverShootingShadowShown = true;
1604
1605                 float newDisplacement = (int)startShowShadowDisplacement < (int)totalPanDisplacement ? 0 : startShowShadowDisplacement - totalPanDisplacement;
1606
1607                 if (ScrollingDirection == Direction.Horizontal)
1608                 {
1609                     // scale limit of height is 60%.
1610                     float heightScale = newDisplacement / overShootingShadowScaleHeightLimit;
1611                     rightOverShootingShadowView.SizeHeight = heightScale > 0.6f ? SizeHeight * 0.4f : SizeHeight * (1.0f - heightScale);
1612
1613                     // scale limit of width is 300%.
1614                     rightOverShootingShadowView.SizeWidth = newDisplacement > overShootingShadowScaleHeightLimit ? overShootingShadowScaleHeightLimit : newDisplacement;
1615
1616                     // trigger event
1617                     ScrollOutOfBoundEventArgs.Direction scrollDirection = panDisplacement > 0 ?
1618                        ScrollOutOfBoundEventArgs.Direction.Right : ScrollOutOfBoundEventArgs.Direction.Left;
1619                     OnScrollOutOfBound(scrollDirection, totalPanDisplacement);
1620                 }
1621                 else
1622                 {
1623                     // scale limit of width is 60%.
1624                     float widthScale = newDisplacement / overShootingShadowScaleHeightLimit;
1625                     bottomOverShootingShadowView.SizeWidth = widthScale > 0.6f ? SizeWidth * 0.4f : SizeWidth * (1.0f - widthScale);
1626
1627                     // scale limit of height is 300%.
1628                     bottomOverShootingShadowView.SizeHeight = newDisplacement > overShootingShadowScaleHeightLimit ? overShootingShadowScaleHeightLimit : newDisplacement;
1629
1630                     // trigger event
1631                     ScrollOutOfBoundEventArgs.Direction scrollDirection = panDisplacement > 0 ?
1632                        ScrollOutOfBoundEventArgs.Direction.Down : ScrollOutOfBoundEventArgs.Direction.Up;
1633                     OnScrollOutOfBound(scrollDirection, totalPanDisplacement);
1634                 }
1635             }
1636             else
1637             {
1638                 // if total displacement is 0, shadow would become invisible.
1639                 isOverShootingShadowShown = false;
1640             }
1641         }
1642
1643         private void PlayOverShootingShadowAnimation()
1644         {
1645             if (!EnableOverShootingEffect)
1646                 return;
1647
1648             // stop animation if necessary.
1649             StopOverShootingShadowAnimation();
1650
1651             if (overShootingShadowAnimation == null)
1652             {
1653                 overShootingShadowAnimation = new Animation(overShootingShadowAnimationDuration);
1654                 overShootingShadowAnimation.Finished += OnOverShootingShadowAnimationFinished;
1655             }
1656
1657             if (ScrollingDirection == Direction.Horizontal)
1658             {
1659                 View targetView = totalDisplacementForPan < 0 ? rightOverShootingShadowView : leftOverShootingShadowView;
1660                 overShootingShadowAnimation.AnimateTo(targetView, "SizeHeight", SizeHeight);
1661                 overShootingShadowAnimation.AnimateTo(targetView, "SizeWidth", 0.0f);
1662                 overShootingShadowAnimation.AnimateTo(targetView, "Opacity", 0.0f);
1663             }
1664             else
1665             {
1666                 View targetView = totalDisplacementForPan < 0 ? bottomOverShootingShadowView : topOverShootingShadowView;
1667                 overShootingShadowAnimation.AnimateTo(targetView, "SizeWidth", SizeWidth);
1668                 overShootingShadowAnimation.AnimateTo(targetView, "SizeHeight", 0.0f);
1669                 overShootingShadowAnimation.AnimateTo(targetView, "Opacity", 0.0f);
1670             }
1671             overShootingShadowAnimation.Play();
1672         }
1673
1674         private void StopOverShootingShadowAnimation()
1675         {
1676             if (overShootingShadowAnimation == null || overShootingShadowAnimation.State != Animation.States.Playing)
1677                 return;
1678
1679             overShootingShadowAnimation.Stop(Animation.EndActions.Cancel);
1680             OnOverShootingShadowAnimationFinished(null, null);
1681             overShootingShadowAnimation.Clear();
1682         }
1683
1684         private void OnOverShootingShadowAnimationFinished(object sender, EventArgs e)
1685         {
1686             if (ScrollingDirection == Direction.Horizontal)
1687             {
1688                 base.Remove(leftOverShootingShadowView);
1689                 base.Remove(rightOverShootingShadowView);
1690
1691                 leftOverShootingShadowView.Size = new Size(0.0f, SizeHeight);
1692                 rightOverShootingShadowView.Size = new Size(0.0f, SizeHeight);
1693             }
1694             else
1695             {
1696                 base.Remove(topOverShootingShadowView);
1697                 base.Remove(bottomOverShootingShadowView);
1698
1699                 topOverShootingShadowView.Size = new Size(SizeWidth, 0.0f);
1700                 bottomOverShootingShadowView.Size = new Size(SizeWidth, 0.0f);
1701             }
1702
1703             // after animation finished, height/width & opacity of vertical shadow both are 0, so it is invisible.
1704             isOverShootingShadowShown = false;
1705         }
1706
1707         private void OnScrollOutOfBound(ScrollOutOfBoundEventArgs.Direction direction, float displacement)
1708         {
1709             ScrollOutOfBoundEventArgs args = new ScrollOutOfBoundEventArgs(direction, displacement);
1710             ScrollOutOfBound?.Invoke(this, args);
1711         }
1712
1713         private void OnPanGestureDetected(object source, PanGestureDetector.DetectedEventArgs e)
1714         {
1715             e.Handled = OnPanGesture(e.PanGesture);
1716         }
1717
1718         private bool OnPanGesture(PanGesture panGesture)
1719         {
1720             bool handled = true;
1721             if (SnapToPage && scrollAnimation != null && scrollAnimation.State == Animation.States.Playing)
1722             {
1723                 return handled;
1724             }
1725             if (panGesture.State == Gesture.StateType.Started)
1726             {
1727                 readyToNotice = false;
1728                 AttachOverShootingShadowView();
1729                 Debug.WriteLineIf(LayoutDebugScrollableBase, "Gesture Start");
1730                 if (scrolling && !SnapToPage)
1731                 {
1732                     StopScroll();
1733                 }
1734                 totalDisplacementForPan = 0.0f;
1735
1736                 // check if gesture need to propagation
1737                 var checkDisplacement = (ScrollingDirection == Direction.Horizontal) ? panGesture.Displacement.X : panGesture.Displacement.Y;
1738                 var checkChildCurrentPosition = (ScrollingDirection == Direction.Horizontal) ? ContentContainer.PositionX : ContentContainer.PositionY;
1739                 var checkChildTargetPosition = checkChildCurrentPosition + checkDisplacement;
1740                 var checkFinalTargetPosition = BoundScrollPosition(checkChildTargetPosition);
1741                 handled = !((int)checkFinalTargetPosition == 0 || -(int)checkFinalTargetPosition == (int)maxScrollDistance);
1742                 // If you propagate a gesture event, return;
1743                 if (!handled)
1744                 {
1745                     return handled;
1746                 }
1747
1748                 //Interrupt touching when panning is started
1749                 this.InterceptTouchEvent += OnInterruptTouchingChildTouched;
1750                 OnScrollDragStarted();
1751             }
1752             else if (panGesture.State == Gesture.StateType.Continuing)
1753             {
1754                 if (ScrollingDirection == Direction.Horizontal)
1755                 {
1756                     // if vertical shadow is shown, does not scroll.
1757                     if (!isOverShootingShadowShown)
1758                     {
1759                         ScrollBy(panGesture.Displacement.X, false);
1760                     }
1761                     totalDisplacementForPan += panGesture.Displacement.X;
1762                     DragOverShootingShadow(totalDisplacementForPan, panGesture.Displacement.X);
1763                 }
1764                 else
1765                 {
1766                     // if vertical shadow is shown, does not scroll.
1767                     if (!isOverShootingShadowShown)
1768                     {
1769                         ScrollBy(panGesture.Displacement.Y, false);
1770                     }
1771                     totalDisplacementForPan += panGesture.Displacement.Y;
1772                     DragOverShootingShadow(totalDisplacementForPan, panGesture.Displacement.Y);
1773                 }
1774                 Debug.WriteLineIf(LayoutDebugScrollableBase, "OnPanGestureDetected Continue totalDisplacementForPan:" + totalDisplacementForPan);
1775
1776             }
1777             else if (panGesture.State == Gesture.StateType.Finished || panGesture.State == Gesture.StateType.Cancelled)
1778             {
1779                 PlayOverShootingShadowAnimation();
1780                 OnScrollDragEnded();
1781                 StopScroll(); // Will replace previous animation so will stop existing one.
1782
1783                 if (scrollAnimation == null)
1784                 {
1785                     scrollAnimation = new Animation();
1786                     scrollAnimation.Finished += ScrollAnimationFinished;
1787                 }
1788
1789                 float panVelocity = (ScrollingDirection == Direction.Horizontal) ? panGesture.Velocity.X : panGesture.Velocity.Y;
1790
1791                 if (SnapToPage)
1792                 {
1793                     PageSnap(panVelocity);
1794                 }
1795                 else
1796                 {
1797                     if (panVelocity == 0)
1798                     {
1799                         float currentScrollPosition = (ScrollingDirection == Direction.Horizontal ? ContentContainer.CurrentPosition.X : ContentContainer.CurrentPosition.Y);
1800                         scrollAnimation.DefaultAlphaFunction = new AlphaFunction(AlphaFunction.BuiltinFunctions.Linear);
1801                         scrollAnimation.Duration = 0;
1802                         scrollAnimation.AnimateTo(ContentContainer, (ScrollingDirection == Direction.Horizontal) ? "PositionX" : "PositionY", currentScrollPosition);
1803                         scrollAnimation.Play();
1804                     }
1805                     else
1806                     {
1807                         Decelerating(panVelocity, scrollAnimation);
1808                     }
1809                 }
1810
1811                 totalDisplacementForPan = 0;
1812                 scrolling = true;
1813                 readyToNotice = true;
1814                 OnScrollAnimationStarted();
1815             }
1816             return handled;
1817         }
1818
1819         internal void BaseRemove(View view)
1820         {
1821             base.Remove(view);
1822         }
1823
1824         internal override bool OnAccessibilityPan(PanGesture gestures)
1825         {
1826             if (SnapToPage && scrollAnimation != null && scrollAnimation.State == Animation.States.Playing)
1827             {
1828                 return false;
1829             }
1830
1831             OnPanGesture(gestures);
1832             return true;
1833         }
1834
1835         private float CustomScrollAlphaFunction(float progress)
1836         {
1837             if (panAnimationDelta == 0)
1838             {
1839                 return 1.0f;
1840             }
1841             else
1842             {
1843                 // Parameter "progress" is normalized value. We need to multiply target duration to calculate distance.
1844                 // Can get real distance using equation of deceleration (check Decelerating function)
1845                 // After get real distance, normalize it
1846                 float realDuration = progress * panAnimationDuration;
1847                 float realDistance = velocityOfLastPan * ((float)Math.Pow(decelerationRate, realDuration) - 1) / logValueOfDeceleration;
1848                 float result = Math.Min(realDistance / Math.Abs(panAnimationDelta), 1.0f);
1849
1850                 // This is hot-fix for if the velocity has very small value, result is not updated even progress done.
1851                 if (progress > 0.99) result = 1.0f;
1852
1853                 return result;
1854             }
1855         }
1856
1857         /// <summary>
1858         /// you can override it to custom your decelerating
1859         /// </summary>
1860         /// <param name="velocity">Velocity of current pan.</param>
1861         /// <param name="animation">Scroll animation.</param>
1862         [EditorBrowsable(EditorBrowsableState.Never)]
1863         protected virtual void Decelerating(float velocity, Animation animation)
1864         {
1865             if (animation == null) throw new ArgumentNullException(nameof(animation));
1866             // Decelerating using deceleration equation ===========
1867             //
1868             // V   : velocity (pixel per millisecond)
1869             // V0  : initial velocity
1870             // d   : deceleration rate,
1871             // t   : time
1872             // X   : final position after decelerating
1873             // log : natural logarithm
1874             //
1875             // V(t) = V0 * d pow t;
1876             // X(t) = V0 * (d pow t - 1) / log d;  <-- Integrate the velocity function
1877             // X(∞) = V0 * d / (1 - d); <-- Result using infinite T can be final position because T is tending to infinity.
1878             //
1879             // Because of final T is tending to infinity, we should use threshold value to finish.
1880             // Final T = log(-threshold * log d / |V0| ) / log d;
1881
1882             velocityOfLastPan = Math.Abs(velocity);
1883
1884             float currentScrollPosition = -(ScrollingDirection == Direction.Horizontal ? ContentContainer.CurrentPosition.X : ContentContainer.CurrentPosition.Y);
1885             panAnimationDelta = (velocityOfLastPan * decelerationRate) / (1 - decelerationRate);
1886             panAnimationDelta = velocity > 0 ? -panAnimationDelta : panAnimationDelta;
1887
1888             float destination = -(panAnimationDelta + currentScrollPosition);
1889             float adjustDestination = AdjustTargetPositionOfScrollAnimation(destination);
1890             float maxPosition = ScrollAvailableArea != null ? ScrollAvailableArea.Y : maxScrollDistance;
1891             float minPosition = ScrollAvailableArea != null ? ScrollAvailableArea.X : 0;
1892
1893             if (destination < -maxPosition || destination > minPosition)
1894             {
1895                 panAnimationDelta = velocity > 0 ? (currentScrollPosition - minPosition) : (maxPosition - currentScrollPosition);
1896                 destination = velocity > 0 ? minPosition : -maxPosition;
1897
1898                 if (panAnimationDelta == 0)
1899                 {
1900                     panAnimationDuration = 0.0f;
1901                 }
1902                 else
1903                 {
1904                     panAnimationDuration = (float)Math.Log((panAnimationDelta * logValueOfDeceleration / velocityOfLastPan + 1), decelerationRate);
1905                 }
1906
1907                 Debug.WriteLineIf(LayoutDebugScrollableBase, "\n" +
1908                     "OverRange======================= \n" +
1909                     "[decelerationRate] " + decelerationRate + "\n" +
1910                     "[logValueOfDeceleration] " + logValueOfDeceleration + "\n" +
1911                     "[Velocity] " + velocityOfLastPan + "\n" +
1912                     "[CurrentPosition] " + currentScrollPosition + "\n" +
1913                     "[CandidateDelta] " + panAnimationDelta + "\n" +
1914                     "[Destination] " + destination + "\n" +
1915                     "[Duration] " + panAnimationDuration + "\n" +
1916                     "================================ \n"
1917                 );
1918             }
1919             else
1920             {
1921                 panAnimationDuration = (float)Math.Log(-DecelerationThreshold * logValueOfDeceleration / velocityOfLastPan) / logValueOfDeceleration;
1922
1923                 if (adjustDestination != destination)
1924                 {
1925                     destination = adjustDestination;
1926                     panAnimationDelta = destination + currentScrollPosition;
1927                     velocityOfLastPan = Math.Abs(panAnimationDelta * logValueOfDeceleration / ((float)Math.Pow(decelerationRate, panAnimationDuration) - 1));
1928                     panAnimationDuration = (float)Math.Log(-DecelerationThreshold * logValueOfDeceleration / velocityOfLastPan) / logValueOfDeceleration;
1929                 }
1930
1931                 Debug.WriteLineIf(LayoutDebugScrollableBase, "\n" +
1932                     "================================ \n" +
1933                     "[decelerationRate] " + decelerationRate + "\n" +
1934                     "[logValueOfDeceleration] " + logValueOfDeceleration + "\n" +
1935                     "[Velocity] " + velocityOfLastPan + "\n" +
1936                     "[CurrentPosition] " + currentScrollPosition + "\n" +
1937                     "[CandidateDelta] " + panAnimationDelta + "\n" +
1938                     "[Destination] " + destination + "\n" +
1939                     "[Duration] " + panAnimationDuration + "\n" +
1940                     "================================ \n"
1941                 );
1942             }
1943
1944             finalTargetPosition = destination;
1945
1946             customScrollAlphaFunction = new UserAlphaFunctionDelegate(CustomScrollAlphaFunction);
1947             animation.DefaultAlphaFunction = new AlphaFunction(customScrollAlphaFunction);
1948             GC.KeepAlive(customScrollAlphaFunction);
1949             animation.Duration = (int)panAnimationDuration;
1950             animation.AnimateTo(ContentContainer, (ScrollingDirection == Direction.Horizontal) ? "PositionX" : "PositionY", destination);
1951             animation.Play();
1952         }
1953
1954         private void ScrollAnimationFinished(object sender, EventArgs e)
1955         {
1956             OnScrollAnimationEnded();
1957         }
1958
1959         /// <summary>
1960         /// Adjust scrolling position by own scrolling rules.
1961         /// Override this function when developer wants to change destination of flicking.(e.g. always snap to center of item)
1962         /// </summary>
1963         /// This may be public opened in tizen_6.0 after ACR done. Before ACR, need to be hidden as inhouse API
1964         [EditorBrowsable(EditorBrowsableState.Never)]
1965         protected virtual float AdjustTargetPositionOfScrollAnimation(float position)
1966         {
1967             return position;
1968         }
1969
1970         /// <summary>
1971         /// Scroll position given to ScrollTo.
1972         /// This is the position in the opposite direction to the position of ContentContainer.
1973         /// </summary>
1974         /// <since_tizen> 8 </since_tizen>
1975         public Position ScrollPosition
1976         {
1977             get
1978             {
1979                 return new Position(-ContentContainer.Position);
1980             }
1981         }
1982
1983         /// <summary>
1984         /// Current scroll position in the middle of ScrollTo animation.
1985         /// This is the position in the opposite direction to the current position of ContentContainer.
1986         /// </summary>
1987         /// <since_tizen> 8 </since_tizen>
1988         public Position ScrollCurrentPosition
1989         {
1990             get
1991             {
1992                 return new Position(-ContentContainer.CurrentPosition);
1993             }
1994         }
1995
1996         /// <summary>
1997         /// Remove all children in ContentContainer.
1998         /// </summary>
1999         /// <param name="dispose">If true, removed child is disposed.</param>
2000         [EditorBrowsable(EditorBrowsableState.Never)]
2001         public void RemoveAllChildren(bool dispose = false)
2002         {
2003             RecursiveRemoveChildren(ContentContainer, dispose);
2004         }
2005
2006         private void RecursiveRemoveChildren(View parent, bool dispose)
2007         {
2008             if (parent == null)
2009             {
2010                 return;
2011             }
2012             int maxChild = (int)parent.GetChildCount();
2013             for (int i = maxChild - 1; i >= 0; --i)
2014             {
2015                 View child = parent.GetChildAt((uint)i);
2016                 if (child == null)
2017                 {
2018                     continue;
2019                 }
2020                 RecursiveRemoveChildren(child, dispose);
2021                 parent.Remove(child);
2022                 if (dispose)
2023                 {
2024                     child.Dispose();
2025                 }
2026             }
2027         }
2028
2029         internal bool IsChildNearlyVisble(View child, float offset = 0)
2030         {
2031             if (ScreenPosition.X - offset < child.ScreenPosition.X + child.SizeWidth &&
2032                 ScreenPosition.X + SizeWidth + offset > child.ScreenPosition.X &&
2033                 ScreenPosition.Y - offset < child.ScreenPosition.Y + child.SizeHeight &&
2034                 ScreenPosition.Y + SizeHeight + offset > child.ScreenPosition.Y)
2035             {
2036                 return true;
2037             }
2038             else
2039             {
2040                 return false;
2041             }
2042         }
2043
2044         /// <inheritdoc/>
2045         [EditorBrowsable(EditorBrowsableState.Never)]
2046         public override View GetNextFocusableView(View currentFocusedView, View.FocusDirection direction, bool loopEnabled)
2047         {
2048             bool isHorizontal = (ScrollingDirection == Direction.Horizontal);
2049             float targetPosition = -(ScrollingDirection == Direction.Horizontal ? ContentContainer.CurrentPosition.X : ContentContainer.CurrentPosition.Y);
2050             float stepDistance = (stepScrollDistance != 0 ? stepScrollDistance : (isHorizontal ? Size.Width * 0.25f : Size.Height * 0.25f));
2051
2052             bool forward = ((isHorizontal && direction == View.FocusDirection.Right) ||
2053                             (!isHorizontal && direction == View.FocusDirection.Down) ||
2054                             (direction == View.FocusDirection.Clockwise));
2055             bool backward = ((isHorizontal && direction == View.FocusDirection.Left) ||
2056                              (!isHorizontal && direction == View.FocusDirection.Up) ||
2057                              (direction == View.FocusDirection.CounterClockwise));
2058
2059             View nextFocusedView = FocusManager.Instance.GetNearestFocusableActor(this, currentFocusedView, direction);
2060
2061             // Move out focus from ScrollableBase.
2062             // FIXME: Forward, Backward is unimplemented other components.
2063             if (direction == View.FocusDirection.Forward ||
2064                 direction == View.FocusDirection.Backward ||
2065                 (nextFocusedView == null &&
2066                 ((forward && maxScrollDistance - targetPosition < 0.1f) ||
2067                  (backward && targetPosition < 0.1f))))
2068             {
2069                 var next = FocusManager.Instance.GetNearestFocusableActor(this.Parent, this, direction);
2070                 Debug.WriteLineIf(focusDebugScrollableBase, $"Focus move [{direction}] out from ScrollableBase! Next focus target {next}:{next?.ID}");
2071                 return next;
2072             }
2073
2074             if (focusDebugScrollableBase)
2075             {
2076                 global::System.Text.StringBuilder debugMessage = new global::System.Text.StringBuilder("=========================================================\n");
2077                 debugMessage.Append($"GetNextFocusableView On: {this}:{this.ID}\n");
2078                 debugMessage.Append($"----------------Current: {currentFocusedView}:{currentFocusedView?.ID}\n");
2079                 debugMessage.Append($"-------------------Next: {nextFocusedView}:{nextFocusedView?.ID}\n");
2080                 debugMessage.Append($"--------------Direction: {direction}\n");
2081                 debugMessage.Append("=========================================================");
2082                 Debug.WriteLineIf(focusDebugScrollableBase, debugMessage);
2083             }
2084
2085             if (nextFocusedView != null)
2086             {
2087                 if (null != FindDescendantByID(nextFocusedView.ID))
2088                 {
2089                     if (IsChildNearlyVisble(nextFocusedView, stepDistance) == true)
2090                     {
2091                         ScrollToChild(nextFocusedView, true);
2092                         return nextFocusedView;
2093                     }
2094                 }
2095             }
2096
2097             if (forward || backward)
2098             {
2099                 // Fallback to current focus or scrollableBase till next focus visible in scrollable.
2100                 if (null != currentFocusedView && null != FindDescendantByID(currentFocusedView.ID))
2101                 {
2102                     nextFocusedView = currentFocusedView;
2103                 }
2104                 else
2105                 {
2106                     Debug.WriteLineIf(focusDebugScrollableBase, "current focus view is not decendant. return ScrollableBase!");
2107                     return this;
2108                 }
2109
2110                 if (forward)
2111                 {
2112                     targetPosition += stepDistance;
2113                     targetPosition = targetPosition > maxScrollDistance ? maxScrollDistance : targetPosition;
2114
2115                 }
2116                 else if (backward)
2117                 {
2118                     targetPosition -= stepDistance;
2119                     targetPosition = targetPosition < 0 ? 0 : targetPosition;
2120                 }
2121
2122                 ScrollTo(targetPosition, true);
2123
2124                 Debug.WriteLineIf(focusDebugScrollableBase, $"ScrollTo :({targetPosition})");
2125             }
2126
2127             Debug.WriteLineIf(focusDebugScrollableBase, $"return end : {nextFocusedView}:{nextFocusedView?.ID}");
2128             return nextFocusedView;
2129         }
2130
2131         /// <inheritdoc/>
2132         [EditorBrowsable(EditorBrowsableState.Never)]
2133         protected override bool AccessibilityScrollToChild(View child)
2134         {
2135             if (child == null)
2136             {
2137                 return false;
2138             }
2139
2140             if (ScrollingDirection == Direction.Horizontal)
2141             {
2142                 if (child.ScreenPosition.X + child.Size.Width <= this.ScreenPosition.X)
2143                 {
2144                     if (SnapToPage)
2145                     {
2146                         PageSnap(PageFlickThreshold + 1);
2147                     }
2148                     else
2149                     {
2150                         ScrollTo((float)(child.ScreenPosition.X - ContentContainer.ScreenPosition.X), false);
2151                     }
2152                 }
2153                 else if (child.ScreenPosition.X >= this.ScreenPosition.X + this.Size.Width)
2154                 {
2155                     if (SnapToPage)
2156                     {
2157                         PageSnap(-(PageFlickThreshold + 1));
2158                     }
2159                     else
2160                     {
2161                         ScrollTo((float)(child.ScreenPosition.X + child.Size.Width - ContentContainer.ScreenPosition.X - this.Size.Width), false);
2162                     }
2163                 }
2164             }
2165             else
2166             {
2167                 if (child.ScreenPosition.Y + child.Size.Height <= this.ScreenPosition.Y)
2168                 {
2169                     if (SnapToPage)
2170                     {
2171                         PageSnap(PageFlickThreshold + 1);
2172                     }
2173                     else
2174                     {
2175                         ScrollTo((float)(child.ScreenPosition.Y - ContentContainer.ScreenPosition.Y), false);
2176                     }
2177                 }
2178                 else if (child.ScreenPosition.Y >= this.ScreenPosition.Y + this.Size.Height)
2179                 {
2180                     if (SnapToPage)
2181                     {
2182                         PageSnap(-(PageFlickThreshold + 1));
2183                     }
2184                     else
2185                     {
2186                         ScrollTo((float)(child.ScreenPosition.Y + child.Size.Height - ContentContainer.ScreenPosition.Y - this.Size.Height), false);
2187                     }
2188                 }
2189             }
2190
2191             return true;
2192         }
2193
2194         /// <inheritdoc/>
2195         [EditorBrowsable(EditorBrowsableState.Never)]
2196         public override bool OnWheel(Wheel wheel)
2197         {
2198             if (wheel == null)
2199             {
2200                 return false;
2201             }
2202
2203             float currentScrollPosition = -(ScrollingDirection == Direction.Horizontal ? ContentContainer.CurrentPosition.X : ContentContainer.CurrentPosition.Y);
2204             ScrollTo(currentScrollPosition + (wheelScrollDistance * wheel.Z), false);
2205
2206             return true;
2207         }
2208
2209         private bool OnWheelEvent(object o, WheelEventArgs e)
2210         {
2211             return OnWheel(e?.Wheel);
2212         }
2213     }
2214
2215 } // namespace