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

   1 /* Copyright (c) 2019 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.ComponentModel;
  19 using System.Diagnostics;
  20
  21 namespace Tizen.NUI.Components
  22 {
  23     /// <summary>
  24     /// [Draft] This class provides a View that can scroll a single View with a layout. This View can be a nest of Views.
  25     /// </summary>
  26     /// This may be public opened in tizen_6.0 after ACR done. Before ACR, need to be hidden as inhouse API.
  27     [EditorBrowsable(EditorBrowsableState.Never)]
  28     public class ScrollableBase : Control
  29     {
  30             static bool LayoutDebugScrollableBase = false; // Debug flag
  31         private Direction mScrollingDirection = Direction.Vertical;
  32         private bool mScrollEnabled = true;
  33         private int mPageWidth = 0;
  34
  35         private class ScrollableBaseCustomLayout : LayoutGroup
  36         {
  37             protected override void OnMeasure(MeasureSpecification widthMeasureSpec, MeasureSpecification heightMeasureSpec)
  38             {
  39                 Extents padding = Padding;
  40                 float totalHeight = padding.Top + padding.Bottom;
  41                 float totalWidth = padding.Start + padding.End;
  42
  43                 MeasuredSize.StateType childWidthState = MeasuredSize.StateType.MeasuredSizeOK;
  44                 MeasuredSize.StateType childHeightState = MeasuredSize.StateType.MeasuredSizeOK;
  45
  46                 Direction scrollingDirection = Direction.Vertical;
  47                 ScrollableBase scrollableBase = this.Owner as ScrollableBase;
  48                 if (scrollableBase)
  49                 {
  50                    scrollingDirection = scrollableBase.ScrollingDirection;
  51                 }
  52
  53                 // measure child, should be a single scrolling child
  54                 foreach( LayoutItem childLayout in LayoutChildren )
  55                 {
  56                     if (childLayout != null)
  57                     {
  58                         // Get size of child
  59                         // Use an Unspecified MeasureSpecification mode so scrolling child is not restricted to it's parents size in Height (for vertical scrolling)
  60                         // or Width for horizontal scrolling
  61                         MeasureSpecification unrestrictedMeasureSpec = new MeasureSpecification( heightMeasureSpec.Size, MeasureSpecification.ModeType.Unspecified);
  62
  63                         if (scrollingDirection == Direction.Vertical)
  64                         {
  65                             MeasureChild( childLayout, widthMeasureSpec, unrestrictedMeasureSpec );  // Height unrestricted by parent
  66                         }
  67                         else
  68                         {
  69                             MeasureChild( childLayout, unrestrictedMeasureSpec, heightMeasureSpec );  // Width unrestricted by parent
  70                         }
  71
  72                         float childWidth = childLayout.MeasuredWidth.Size.AsDecimal();
  73                         float childHeight = childLayout.MeasuredHeight.Size.AsDecimal();
  74
  75                         // Determine the width and height needed by the children using their given position and size.
  76                         // Children could overlap so find the left most and right most child.
  77                         Position2D childPosition = childLayout.Owner.Position2D;
  78                         float childLeft = childPosition.X;
  79                         float childTop = childPosition.Y;
  80
  81                         // Store current width and height needed to contain all children.
  82                         Extents childMargin = childLayout.Margin;
  83                         totalWidth = childWidth + childMargin.Start + childMargin.End;
  84                         totalHeight = childHeight + childMargin.Top + childMargin.Bottom;
  85
  86                         if (childLayout.MeasuredWidth.State == MeasuredSize.StateType.MeasuredSizeTooSmall)
  87                         {
  88                             childWidthState = MeasuredSize.StateType.MeasuredSizeTooSmall;
  89                         }
  90                         if (childLayout.MeasuredWidth.State == MeasuredSize.StateType.MeasuredSizeTooSmall)
  91                         {
  92                             childHeightState = MeasuredSize.StateType.MeasuredSizeTooSmall;
  93                         }
  94                     }
  95                 }
  96
  97
  98                 MeasuredSize widthSizeAndState = ResolveSizeAndState(new LayoutLength(totalWidth + Padding.Start + Padding.End), widthMeasureSpec, MeasuredSize.StateType.MeasuredSizeOK);
  99                 MeasuredSize heightSizeAndState = ResolveSizeAndState(new LayoutLength(totalHeight + Padding.Top + Padding.Bottom), heightMeasureSpec, MeasuredSize.StateType.MeasuredSizeOK);
 100                 totalWidth = widthSizeAndState.Size.AsDecimal();
 101                 totalHeight = heightSizeAndState.Size.AsDecimal();
 102
 103                 // Ensure layout respects it's given minimum size
 104                 totalWidth = Math.Max( totalWidth, SuggestedMinimumWidth.AsDecimal() );
 105                 totalHeight = Math.Max( totalHeight, SuggestedMinimumHeight.AsDecimal() );
 106
 107                 widthSizeAndState.State = childWidthState;
 108                 heightSizeAndState.State = childHeightState;
 109
 110                 SetMeasuredDimensions( ResolveSizeAndState( new LayoutLength(totalWidth + Padding.Start + Padding.End), widthMeasureSpec, childWidthState ),
 111                                        ResolveSizeAndState( new LayoutLength(totalHeight + Padding.Top + Padding.Bottom), heightMeasureSpec, childHeightState ) );
 112
 113                 // Size of ScrollableBase is changed. Change Page width too.
 114                 scrollableBase.mPageWidth = (int)MeasuredWidth.Size.AsRoundedValue();
 115             }
 116
 117             protected override void OnLayout(bool changed, LayoutLength left, LayoutLength top, LayoutLength right, LayoutLength bottom)
 118             {
 119                 foreach( LayoutItem childLayout in LayoutChildren )
 120                 {
 121                     if( childLayout != null )
 122                     {
 123                         LayoutLength childWidth = childLayout.MeasuredWidth.Size;
 124                         LayoutLength childHeight = childLayout.MeasuredHeight.Size;
 125
 126                         Position2D childPosition = childLayout.Owner.Position2D;
 127                         Extents padding = Padding;
 128                         Extents childMargin = childLayout.Margin;
 129
 130                         LayoutLength childLeft = new LayoutLength(childPosition.X + childMargin.Start + padding.Start);
 131                         LayoutLength childTop = new LayoutLength(childPosition.Y + childMargin.Top + padding.Top);
 132
 133                         childLayout.Layout( childLeft, childTop, childLeft + childWidth, childTop + childHeight );
 134                     }
 135                 }
 136             }
 137         } //  ScrollableBaseCustomLayout
 138
 139         /// <summary>
 140         /// The direction axis to scroll.
 141         /// </summary>
 142         /// <since_tizen> 6 </since_tizen>
 143         /// This may be public opened in tizen_6.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 144         [EditorBrowsable(EditorBrowsableState.Never)]
 145         public enum Direction
 146         {
 147             /// <summary>
 148             /// Horizontal axis.
 149             /// </summary>
 150             /// <since_tizen> 6 </since_tizen>
 151             Horizontal,
 152
 153             /// <summary>
 154             /// Vertical axis.
 155             /// </summary>
 156             /// <since_tizen> 6 </since_tizen>
 157             Vertical
 158         }
 159
 160         /// <summary>
 161         /// [Draft] Configurable speed threshold that register the gestures as a flick.
 162         /// If the flick speed less than the threshold then will not be considered a flick.
 163         /// </summary>
 164         /// This may be public opened in tizen_6.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 165         [EditorBrowsable(EditorBrowsableState.Never)]
 166         public float FlickThreshold { get; set; } = 0.2f;
 167
 168         /// <summary>
 169         /// [Draft] Configurable duration modifer for the flick animation.
 170         /// Determines the speed of the scroll, large value results in a longer flick animation. Range (0.1 - 1.0)
 171         /// </summary>
 172         /// This may be public opened in tizen_6.0 after ACR done. Before ACR, need to be hidden as inhouse API
 173         [EditorBrowsable(EditorBrowsableState.Never)]
 174         public float FlickAnimationSpeed { get; set; } = 0.4f;
 175
 176         /// <summary>
 177         /// [Draft] Configurable modifer for the distance to be scrolled when flicked detected.
 178         /// It a ratio of the ScrollableBase's length. (not child's length).
 179         /// First value is the ratio of the distance to scroll with the weakest flick.
 180         /// Second value is the ratio of the distance to scroll with the strongest flick.
 181         /// Second > First.
 182         /// </summary>
 183         /// This may be public opened in tizen_6.0 after ACR done. Before ACR, need to be hidden as inhouse API
 184         [EditorBrowsable(EditorBrowsableState.Never)]
 185         public Vector2 FlickDistanceMultiplierRange { get; set; } = new Vector2(0.6f, 1.8f);
 186
 187         /// <summary>
 188         /// [Draft] Scrolling direction mode.
 189         /// Default is Vertical scrolling.
 190         /// </summary>
 191         /// This may be public opened in tizen_6.0 after ACR done. Before ACR, need to be hidden as inhouse API
 192         [EditorBrowsable(EditorBrowsableState.Never)]
 193         public Direction ScrollingDirection
 194         {
 195             get
 196             {
 197                 return mScrollingDirection;
 198             }
 199             set
 200             {
 201                 if(value != mScrollingDirection)
 202                 {
 203                     mScrollingDirection = value;
 204                     mPanGestureDetector.RemoveDirection(value == Direction.Horizontal ? PanGestureDetector.DirectionVertical : PanGestureDetector.DirectionHorizontal);
 205                     mPanGestureDetector.AddDirection(value == Direction.Horizontal ? PanGestureDetector.DirectionHorizontal : PanGestureDetector.DirectionVertical);
 206                 }
 207             }
 208         }
 209
 210         /// <summary>
 211         /// [Draft] Enable or disable scrolling.
 212         /// </summary>
 213         /// This may be public opened in tizen_6.0 after ACR done. Before ACR, need to be hidden as inhouse API
 214         [EditorBrowsable(EditorBrowsableState.Never)]
 215         public bool ScrollEnabled
 216         {
 217             get
 218             {
 219                 return mScrollEnabled;
 220             }
 221             set
 222             {
 223                 if (value != mScrollEnabled)
 224                 {
 225                     mScrollEnabled = value;
 226                     if(mScrollEnabled)
 227                     {
 228                         mPanGestureDetector.Detected += OnPanGestureDetected;
 229                         mTapGestureDetector.Detected += OnTapGestureDetected;
 230                     }
 231                     else
 232                     {
 233                         mPanGestureDetector.Detected -= OnPanGestureDetected;
 234                         mTapGestureDetector.Detected -= OnTapGestureDetected;
 235                     }
 236                 }
 237             }
 238         }
 239
 240         /// <summary>
 241         /// [Draft] Pages mode, enables moving to the next or return to current page depending on pan displacement.
 242         /// Default is false.
 243         /// </summary>
 244         /// This may be public opened in tizen_6.0 after ACR done. Before ACR, need to be hidden as inhouse API
 245         [EditorBrowsable(EditorBrowsableState.Never)]
 246         public bool SnapToPage { set; get; } = false;
 247
 248         /// <summary>
 249         /// [Draft] Get current page.
 250         /// Working propery with SnapToPage property.
 251         /// </summary>
 252         /// This may be public opened in tizen_6.0 after ACR done. Before ACR, need to be hidden as inhouse API
 253         [EditorBrowsable(EditorBrowsableState.Never)]
 254         public int CurrentPage { get; private set; } = 0;
 255
 256         /// <summary>
 257         /// [Draft] Duration of scroll animation.
 258         /// </summary>
 259         /// This may be public opened in tizen_6.0 after ACR done. Before ACR, need to be hidden as inhouse API
 260         [EditorBrowsable(EditorBrowsableState.Never)]
 261
 262         public int ScrollDuration { set; get; } = 125;
 263         /// <summary>
 264         /// [Draft] Scroll Available area.
 265         /// </summary>
 266         /// This may be public opened in tizen_6.0 after ACR done. Before ACR, need to be hidden as inhouse API
 267         [EditorBrowsable(EditorBrowsableState.Never)]
 268         public Rectangle ScrollAvailableArea { set; get; }
 269
 270         /// <summary>
 271         /// ScrollEventArgs is a class to record scroll event arguments which will sent to user.
 272         /// </summary>
 273         /// <since_tizen> 6 </since_tizen>
 274         /// This may be public opened in tizen_6.0 after ACR done. Before ACR, need to be hidden as inhouse API
 275         [EditorBrowsable(EditorBrowsableState.Never)]
 276         public class ScrollEventArgs : EventArgs
 277         {
 278             Position position;
 279
 280             /// <summary>
 281             /// Default constructor.
 282             /// </summary>
 283             /// <param name="position">Current scroll position</param>
 284             /// <since_tizen> 6 </since_tizen>
 285             /// This may be public opened in tizen_6.0 after ACR done. Before ACR, need to be hidden as inhouse API
 286             public ScrollEventArgs(Position position)
 287             {
 288                 this.position = position;
 289             }
 290
 291             /// <summary>
 292             /// [Draft] Current scroll position.
 293             /// </summary>
 294             /// This may be public opened in tizen_6.0 after ACR done. Before ACR, need to be hidden as inhouse API
 295             [EditorBrowsable(EditorBrowsableState.Never)]
 296             public Position Position
 297             {
 298                 get
 299                 {
 300                     return position;
 301                 }
 302             }
 303         }
 304
 305         /// <summary>
 306         /// An event emitted when user starts dragging ScrollableBase, user can subscribe or unsubscribe to this event handler.<br />
 307         /// </summary>
 308         /// <since_tizen> 6 </since_tizen>
 309         /// This may be public opened in tizen_6.0 after ACR done. Before ACR, need to be hidden as inhouse API
 310         [EditorBrowsable(EditorBrowsableState.Never)]
 311         public event EventHandler<ScrollEventArgs> ScrollDragStartEvent;
 312
 313         /// <summary>
 314         /// An event emitted when user stops dragging ScrollableBase, user can subscribe or unsubscribe to this event handler.<br />
 315         /// </summary>
 316         /// <since_tizen> 6 </since_tizen>
 317         /// This may be public opened in tizen_6.0 after ACR done. Before ACR, need to be hidden as inhouse API
 318         [EditorBrowsable(EditorBrowsableState.Never)]
 319         public event EventHandler<ScrollEventArgs> ScrollDragEndEvent;
 320
 321
 322         /// <summary>
 323         /// An event emitted when the scrolling slide animation starts, user can subscribe or unsubscribe to this event handler.<br />
 324         /// </summary>
 325         /// <since_tizen> 6 </since_tizen>
 326         /// This may be public opened in tizen_6.0 after ACR done. Before ACR, need to be hidden as inhouse API
 327         [EditorBrowsable(EditorBrowsableState.Never)]
 328         public event EventHandler<ScrollEventArgs> ScrollAnimationStartEvent;
 329
 330         /// <summary>
 331         /// An event emitted when the scrolling slide animation ends, user can subscribe or unsubscribe to this event handler.<br />
 332         /// </summary>
 333         /// <since_tizen> 6 </since_tizen>
 334         /// This may be public opened in tizen_6.0 after ACR done. Before ACR, need to be hidden as inhouse API
 335         [EditorBrowsable(EditorBrowsableState.Never)]
 336         public event EventHandler<ScrollEventArgs> ScrollAnimationEndEvent;
 337
 338
 339         /// <summary>
 340         /// An event emitted when scrolling, user can subscribe or unsubscribe to this event handler.<br />
 341         /// </summary>
 342         /// <since_tizen> 6 </since_tizen>
 343         /// This may be public opened in tizen_6.0 after ACR done. Before ACR, need to be hidden as inhouse API
 344         [EditorBrowsable(EditorBrowsableState.Never)]
 345         public event EventHandler<ScrollEventArgs> ScrollEvent;
 346
 347         private Animation scrollAnimation;
 348         private float maxScrollDistance;
 349         private float childTargetPosition = 0.0f;
 350         private PanGestureDetector mPanGestureDetector;
 351         private TapGestureDetector mTapGestureDetector;
 352         private View mScrollingChild;
 353         private View mInterruptTouchingChild;
 354         private float multiplier =1.0f;
 355         private bool scrolling = false;
 356         private float ratioOfScreenWidthToCompleteScroll = 0.5f;
 357         private float totalDisplacementForPan = 0.0f;
 358
 359         // If false then can only flick pages when the current animation/scroll as ended.
 360         private bool flickWhenAnimating = false;
 361         private PropertyNotification propertyNotification;
 362
 363         /// <summary>
 364         /// [Draft] Constructor
 365         /// </summary>
 366         /// <since_tizen> 6 </since_tizen>
 367         /// This may be public opened in tizen_6.0 after ACR done. Before ACR, need to be hidden as inhouse API
 368         [EditorBrowsable(EditorBrowsableState.Never)]
 369         public ScrollableBase() : base()
 370         {
 371             mPanGestureDetector = new PanGestureDetector();
 372             mPanGestureDetector.Attach(this);
 373             mPanGestureDetector.AddDirection(PanGestureDetector.DirectionVertical);
 374             mPanGestureDetector.Detected += OnPanGestureDetected;
 375
 376             mTapGestureDetector = new TapGestureDetector();
 377             mTapGestureDetector.Attach(this);
 378             mTapGestureDetector.Detected += OnTapGestureDetected;
 379
 380
 381             ClippingMode = ClippingModeType.ClipToBoundingBox;
 382
 383             mScrollingChild = new View();
 384             mScrollingChild.Name = "DefaultScrollingChild";
 385
 386             //Interrupt touching when panning is started;
 387             mInterruptTouchingChild = new View()
 388             {
 389                 Name = "InterruptTouchingChild",
 390                 Size = new Size(Window.Instance.WindowSize),
 391                 BackgroundColor = Color.Transparent,
 392             };
 393
 394             mInterruptTouchingChild.TouchEvent += (object source, View.TouchEventArgs args) => {
 395                 return true;
 396             };
 397
 398             Layout = new ScrollableBaseCustomLayout();
 399         }
 400
 401         private void OnPropertyChanged(object source, PropertyNotification.NotifyEventArgs args)
 402         {
 403             OnScroll();
 404         }
 405
 406         /// <summary>
 407         /// Called after a child has been added to the owning view.
 408         /// </summary>
 409         /// <param name="view">The child which has been added.</param>
 410         /// <since_tizen> 6 </since_tizen>
 411         /// This may be public opened in tizen_6.0 after ACR done. Before ACR, need to be hidden as inhouse API
 412         [EditorBrowsable(EditorBrowsableState.Never)]
 413         public override void OnChildAdd(View view)
 414         {
 415             if(view.Name != "InterruptTouchingChild")
 416             {
 417                 if(mScrollingChild.Name != "DefaultScrollingChild")
 418                 {
 419                     propertyNotification.Notified -= OnPropertyChanged;
 420                     mScrollingChild.RemovePropertyNotification(propertyNotification);
 421                 }
 422
 423                 mScrollingChild = view;
 424                 propertyNotification = mScrollingChild?.AddPropertyNotification("position", PropertyCondition.Step(1.0f));
 425                 propertyNotification.Notified += OnPropertyChanged;
 426             }
 427         }
 428
 429         /// <summary>
 430         /// Called after a child has been removed from the owning view.
 431         /// </summary>
 432         /// <param name="view">The child which has been removed.</param>
 433         /// <since_tizen> 6 </since_tizen>
 434         /// This may be public opened in tizen_6.0 after ACR done. Before ACR, need to be hidden as inhouse API
 435         [EditorBrowsable(EditorBrowsableState.Never)]
 436         public override void OnChildRemove(View view)
 437         {
 438             if(view.Name != "InterruptTouchingChild")
 439             {
 440                 propertyNotification.Notified -= OnPropertyChanged;
 441                 mScrollingChild.RemovePropertyNotification(propertyNotification);
 442
 443                 mScrollingChild = new View();
 444             }
 445         }
 446
 447
 448         /// <summary>
 449         /// Scrolls to the item at the specified index.
 450         /// </summary>
 451         /// <param name="index">Index of item.</param>
 452         /// <since_tizen> 6 </since_tizen>
 453         /// This may be public opened in tizen_6.0 after ACR done. Before ACR, need to be hidden as inhouse API
 454         [EditorBrowsable(EditorBrowsableState.Never)]
 455         public void ScrollToIndex(int index)
 456         {
 457             if(mScrollingChild.ChildCount-1 < index || index < 0)
 458             {
 459                 return;
 460             }
 461
 462             if(SnapToPage)
 463             {
 464                 CurrentPage = index;
 465             }
 466
 467             maxScrollDistance = CalculateMaximumScrollDistance();
 468
 469             float targetPosition = Math.Min(ScrollingDirection == Direction.Vertical ? mScrollingChild.Children[index].Position.Y : mScrollingChild.Children[index].Position.X, maxScrollDistance);
 470             AnimateChildTo(ScrollDuration, -targetPosition);
 471         }
 472
 473         private void OnScrollDragStart()
 474         {
 475             ScrollEventArgs eventArgs = new ScrollEventArgs(mScrollingChild.CurrentPosition);
 476             ScrollDragStartEvent?.Invoke(this, eventArgs);
 477         }
 478
 479         private void OnScrollDragEnd()
 480         {
 481             ScrollEventArgs eventArgs = new ScrollEventArgs(mScrollingChild.CurrentPosition);
 482             ScrollDragEndEvent?.Invoke(this, eventArgs);
 483         }
 484
 485         private void OnScrollAnimationStart()
 486         {
 487             ScrollEventArgs eventArgs = new ScrollEventArgs(mScrollingChild.CurrentPosition);
 488             ScrollAnimationStartEvent?.Invoke(this, eventArgs);
 489         }
 490
 491         private void OnScrollAnimationEnd()
 492         {
 493             ScrollEventArgs eventArgs = new ScrollEventArgs(mScrollingChild.CurrentPosition);
 494             ScrollAnimationEndEvent?.Invoke(this, eventArgs);
 495         }
 496
 497         private void OnScroll()
 498         {
 499             ScrollEventArgs eventArgs = new ScrollEventArgs(mScrollingChild.CurrentPosition);
 500             ScrollEvent?.Invoke(this, eventArgs);
 501         }
 502
 503         private void StopScroll()
 504         {
 505             if (scrollAnimation != null)
 506             {
 507                 if (scrollAnimation.State == Animation.States.Playing)
 508                 {
 509                     Debug.WriteLineIf(LayoutDebugScrollableBase, "StopScroll Animation Playing");
 510                     scrollAnimation.Stop(Animation.EndActions.Cancel);
 511                     OnScrollAnimationEnd();
 512                 }
 513                 scrollAnimation.Clear();
 514             }
 515         }
 516
 517         // static constructor registers the control type
 518         static ScrollableBase()
 519         {
 520             // ViewRegistry registers control type with DALi type registry
 521             // also uses introspection to find any properties that need to be registered with type registry
 522             CustomViewRegistry.Instance.Register(CreateInstance, typeof(ScrollableBase));
 523         }
 524
 525         internal static CustomView CreateInstance()
 526         {
 527             return new ScrollableBase();
 528         }
 529
 530         private void AnimateChildTo(int duration, float axisPosition)
 531         {
 532             Debug.WriteLineIf(LayoutDebugScrollableBase, "AnimationTo Animation Duration:" + duration + " Destination:" + axisPosition);
 533
 534             StopScroll(); // Will replace previous animation so will stop existing one.
 535
 536             if (scrollAnimation == null)
 537             {
 538                 scrollAnimation = new Animation();
 539                 scrollAnimation.Finished += ScrollAnimationFinished;
 540             }
 541
 542             scrollAnimation.Duration = duration;
 543             scrollAnimation.DefaultAlphaFunction = new AlphaFunction(AlphaFunction.BuiltinFunctions.EaseOutSine);
 544             scrollAnimation.AnimateTo(mScrollingChild, (ScrollingDirection == Direction.Horizontal) ? "PositionX" : "PositionY", axisPosition);
 545             scrolling = true;
 546             OnScrollAnimationStart();
 547             scrollAnimation.Play();
 548         }
 549
 550         private void ScrollBy(float displacement, bool animate)
 551         {
 552             if (GetChildCount() == 0 || displacement == 0 || maxScrollDistance < 0)
 553             {
 554                 return;
 555             }
 556
 557             float childCurrentPosition = (ScrollingDirection == Direction.Horizontal) ? mScrollingChild.PositionX: mScrollingChild.PositionY;
 558
 559             Debug.WriteLineIf(LayoutDebugScrollableBase, "ScrollBy childCurrentPosition:" + childCurrentPosition +
 560                                                    " displacement:" + displacement,
 561                                                    " maxScrollDistance:" + maxScrollDistance );
 562
 563             childTargetPosition = childCurrentPosition + displacement; // child current position + gesture displacement
 564
 565             if(ScrollAvailableArea != null)
 566             {
 567                 float minScrollPosition = ScrollingDirection == Direction.Horizontal? ScrollAvailableArea.X:ScrollAvailableArea.Y;
 568                 float maxScrollPosition = ScrollingDirection == Direction.Horizontal?
 569                                         ScrollAvailableArea.X + ScrollAvailableArea.Width:
 570                                         ScrollAvailableArea.Y + ScrollAvailableArea.Height;
 571
 572                 childTargetPosition = Math.Min( -minScrollPosition, childTargetPosition );
 573                 childTargetPosition = Math.Max( -maxScrollPosition, childTargetPosition );
 574             }
 575             else
 576             {
 577                 childTargetPosition = Math.Min(0, childTargetPosition);
 578                 childTargetPosition = Math.Max(-maxScrollDistance, childTargetPosition);
 579             }
 580
 581             Debug.WriteLineIf( LayoutDebugScrollableBase, "ScrollBy currentAxisPosition:" + childCurrentPosition + "childTargetPosition:" + childTargetPosition);
 582
 583             if (animate)
 584             {
 585                 // Calculate scroll animaton duration
 586                 float scrollDistance = Math.Abs(displacement);
 587                 int duration = (int)((320*FlickAnimationSpeed) + (scrollDistance * FlickAnimationSpeed));
 588                 Debug.WriteLineIf(LayoutDebugScrollableBase, "Scroll Animation Duration:" + duration + " Distance:" + scrollDistance);
 589
 590                 AnimateChildTo(duration, childTargetPosition);
 591             }
 592             else
 593             {
 594                 // Set position of scrolling child without an animation
 595                 if (ScrollingDirection == Direction.Horizontal)
 596                 {
 597                     mScrollingChild.PositionX = childTargetPosition;
 598                 }
 599                 else
 600                 {
 601                     mScrollingChild.PositionY = childTargetPosition;
 602                 }
 603             }
 604         }
 605
 606         /// <summary>
 607         /// you can override it to clean-up your own resources.
 608         /// </summary>
 609         /// <param name="type">DisposeTypes</param>
 610         /// <since_tizen> 6 </since_tizen>
 611         /// This will be public opened in tizen_5.5 after ACR done. Before ACR, need to be hidden as inhouse API.
 612         [EditorBrowsable(EditorBrowsableState.Never)]
 613         protected override void Dispose(DisposeTypes type)
 614         {
 615             if (disposed)
 616             {
 617                 return;
 618             }
 619
 620             if (type == DisposeTypes.Explicit)
 621             {
 622                 StopScroll();
 623
 624                 if (mPanGestureDetector != null)
 625                 {
 626                     mPanGestureDetector.Detected -= OnPanGestureDetected;
 627                     mPanGestureDetector.Dispose();
 628                     mPanGestureDetector = null;
 629                 }
 630
 631                 if (mTapGestureDetector != null)
 632                 {
 633                     mTapGestureDetector.Detected -= OnTapGestureDetected;
 634                     mTapGestureDetector.Dispose();
 635                     mTapGestureDetector = null;
 636                 }
 637             }
 638             base.Dispose(type);
 639         }
 640
 641         private float CalculateDisplacementFromVelocity(float axisVelocity)
 642         {
 643             // Map: flick speed of range (2.0 - 6.0) to flick multiplier of range (0.7 - 1.6)
 644             float speedMinimum = FlickThreshold;
 645             float speedMaximum = FlickThreshold + 6.0f;
 646             float multiplierMinimum = FlickDistanceMultiplierRange.X;
 647             float multiplierMaximum = FlickDistanceMultiplierRange.Y;
 648
 649             float flickDisplacement = 0.0f;
 650
 651             float speed = Math.Min(4.0f,Math.Abs(axisVelocity));
 652
 653             Debug.WriteLineIf(LayoutDebugScrollableBase, "ScrollableBase Candidate Flick speed:" + speed);
 654
 655             if (speed > FlickThreshold)
 656             {
 657                 // Flick length is the length of the ScrollableBase.
 658                 float flickLength = (ScrollingDirection == Direction.Horizontal) ?CurrentSize.Width:CurrentSize.Height;
 659
 660                 // Calculate multiplier by mapping speed between the multiplier minimum and maximum.
 661                 multiplier =( (speed - speedMinimum) / ( (speedMaximum - speedMinimum) * (multiplierMaximum - multiplierMinimum) ) )+ multiplierMinimum;
 662
 663                 // flick displacement is the product of the flick length and multiplier
 664                 flickDisplacement = ((flickLength * multiplier) * speed) / axisVelocity;  // *speed and /velocity to perserve sign.
 665
 666                 Debug.WriteLineIf(LayoutDebugScrollableBase, "Calculated FlickDisplacement[" + flickDisplacement +"] from speed[" + speed + "] multiplier:"
 667                                                         + multiplier);
 668             }
 669             return flickDisplacement;
 670         }
 671
 672         private float CalculateMaximumScrollDistance()
 673         {
 674             int scrollingChildLength = 0;
 675             int scrollerLength = 0;
 676             if (ScrollingDirection == Direction.Horizontal)
 677             {
 678                 Debug.WriteLineIf(LayoutDebugScrollableBase, "Horizontal");
 679
 680                 scrollingChildLength = (int)mScrollingChild.Layout.MeasuredWidth.Size.AsRoundedValue();
 681                 scrollerLength = CurrentSize.Width;
 682             }
 683             else
 684             {
 685                 Debug.WriteLineIf(LayoutDebugScrollableBase, "Vertical");
 686                 scrollingChildLength = (int)mScrollingChild.Layout.MeasuredHeight.Size.AsRoundedValue();
 687                 scrollerLength = CurrentSize.Height;
 688             }
 689
 690             Debug.WriteLineIf(LayoutDebugScrollableBase, "ScrollBy maxScrollDistance:" + (scrollingChildLength - scrollerLength) +
 691                                                    " parent length:" + scrollerLength +
 692                                                    " scrolling child length:" + scrollingChildLength);
 693
 694             return Math.Max(scrollingChildLength - scrollerLength,0);
 695         }
 696
 697         private void PageSnap()
 698         {
 699             Debug.WriteLineIf(LayoutDebugScrollableBase, "PageSnap with pan candidate totalDisplacement:" + totalDisplacementForPan +
 700                                                                 " currentPage[" + CurrentPage + "]" );
 701
 702             //Increment current page if total displacement enough to warrant a page change.
 703             if (Math.Abs(totalDisplacementForPan) > (mPageWidth * ratioOfScreenWidthToCompleteScroll))
 704             {
 705                 if (totalDisplacementForPan < 0)
 706                 {
 707                     CurrentPage = Math.Min(Math.Max(mScrollingChild.Children.Count - 1,0), ++CurrentPage);
 708                 }
 709                 else
 710                 {
 711                     CurrentPage = Math.Max(0, --CurrentPage);
 712                 }
 713             }
 714
 715             // Animate to new page or reposition to current page
 716             float destinationX = -(mScrollingChild.Children[CurrentPage].Position.X + mScrollingChild.Children[CurrentPage].CurrentSize.Width/2 - CurrentSize.Width/2); // set to middle of current page
 717             Debug.WriteLineIf(LayoutDebugScrollableBase, "Snapping to page[" + CurrentPage + "] to:" + destinationX + " from:" + mScrollingChild.PositionX);
 718             AnimateChildTo(ScrollDuration, destinationX);
 719         }
 720
 721         private void Flick(float flickDisplacement)
 722         {
 723           if (SnapToPage)
 724           {
 725               if ( ( flickWhenAnimating && scrolling == true) || ( scrolling == false) )
 726               {
 727                   if(flickDisplacement < 0)
 728                   {
 729                       CurrentPage = Math.Min(Math.Max(mScrollingChild.Children.Count - 1,0), CurrentPage + 1);
 730                       Debug.WriteLineIf(LayoutDebugScrollableBase, "Snap - to page:" + CurrentPage);
 731                   }
 732                   else
 733                   {
 734                       CurrentPage = Math.Max(0, CurrentPage - 1);
 735                       Debug.WriteLineIf(LayoutDebugScrollableBase, "Snap + to page:" + CurrentPage);
 736                   }
 737
 738                   float destinationX = -(mScrollingChild.Children[CurrentPage].Position.X + mScrollingChild.Children[CurrentPage].CurrentSize.Width/2.0f - CurrentSize.Width/2.0f); // set to middle of current page
 739                   Debug.WriteLineIf(LayoutDebugScrollableBase, "Snapping to :" + destinationX);
 740                   AnimateChildTo(ScrollDuration, destinationX);
 741               }
 742           }
 743           else
 744           {
 745               ScrollBy(flickDisplacement, true); // Animate flickDisplacement.
 746           }
 747         }
 748
 749         private void OnPanGestureDetected(object source, PanGestureDetector.DetectedEventArgs e)
 750         {
 751             if (e.PanGesture.State == Gesture.StateType.Started)
 752             {
 753                 Add(mInterruptTouchingChild);
 754                 Debug.WriteLineIf(LayoutDebugScrollableBase, "Gesture Start");
 755                 if (scrolling && !SnapToPage)
 756                 {
 757                     StopScroll();
 758                 }
 759                 maxScrollDistance = CalculateMaximumScrollDistance();
 760                 totalDisplacementForPan = 0.0f;
 761                 OnScrollDragStart();
 762             }
 763             else if (e.PanGesture.State == Gesture.StateType.Continuing)
 764             {
 765                 if (ScrollingDirection == Direction.Horizontal)
 766                 {
 767                     ScrollBy(e.PanGesture.Displacement.X, false);
 768                     totalDisplacementForPan += e.PanGesture.Displacement.X;
 769                 }
 770                 else
 771                 {
 772                     ScrollBy(e.PanGesture.Displacement.Y, false);
 773                     totalDisplacementForPan += e.PanGesture.Displacement.Y;
 774                 }
 775                 Debug.WriteLineIf(LayoutDebugScrollableBase, "OnPanGestureDetected Continue totalDisplacementForPan:" + totalDisplacementForPan);
 776             }
 777             else if (e.PanGesture.State == Gesture.StateType.Finished)
 778             {
 779                 float axisVelocity = (ScrollingDirection == Direction.Horizontal) ? e.PanGesture.Velocity.X : e.PanGesture.Velocity.Y;
 780                 float flickDisplacement = CalculateDisplacementFromVelocity(axisVelocity);
 781
 782                 Debug.WriteLineIf(LayoutDebugScrollableBase, "FlickDisplacement:" + flickDisplacement + "TotalDisplacementForPan:" + totalDisplacementForPan);
 783                 OnScrollDragEnd();
 784
 785                 if (flickDisplacement > 0 | flickDisplacement < 0)// Flick detected
 786                 {
 787                     Flick(flickDisplacement);
 788                 }
 789                 else
 790                 {
 791                     // End of panning gesture but was not a flick
 792                     if (SnapToPage)
 793                     {
 794                         PageSnap();
 795                     }
 796                 }
 797                 totalDisplacementForPan = 0;
 798
 799                 Remove(mInterruptTouchingChild);
 800             }
 801         }
 802
 803         private new void OnTapGestureDetected(object source, TapGestureDetector.DetectedEventArgs e)
 804         {
 805             if (e.TapGesture.Type == Gesture.GestureType.Tap)
 806             {
 807                 // Stop scrolling if tap detected (press then relase).
 808                 // Unless in Pages mode, do not want a page change to stop part way.
 809                 if(scrolling && !SnapToPage)
 810                 {
 811                     StopScroll();
 812                 }
 813             }
 814         }
 815
 816         private void ScrollAnimationFinished(object sender, EventArgs e)
 817         {
 818             scrolling = false;
 819             OnScrollAnimationEnd();
 820         }
 821     }
 822
 823 } // namespace