|
|
主要是为了写滑动列表的扩展，然后需要引用Unity的源码，索性就在开一个Unity源码赏析的章节放置其它文章需要引用到的源码，希望能够帮助大家，毕竟学习源码，尤其是优秀的源码会对大家的思路和积累有很大的帮助。
封藏云典：滑动列表的具体实现与相关问题
为什么要学习Unity的ScrollView ，目的就是要扩展它，按我们的想法实现更多更好的功能。
友情提示：
这个脚本其实主要涉及到UI列表元素的位置排列与计算，需要重点理解的方法：
滚动相关的事件如：ScrollTo，OnScrollWheel
一些边界效果：SpringBack
以及一些其它点击事件：OnPointerMove
或者元素的offset计算。
// Decompiled with JetBrains decompiler
// Type: UnityEngine.UIElements.ScrollView
// Assembly: UnityEngine.UIElementsModule, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null
// MVID: 703EE3F4-60E4-4929-A354-68A9F14D1EEB
// Assembly location: C:\Program Files\Unity\Hub\Editor\2021.3.21f1c1\Editor\Data\Managed\UnityEngine\UnityEngine.UIElementsModule.dll
using System;
using System.Collections.Generic;
using UnityEngine.UIElements.StyleSheets;
namespace UnityEngine.UIElements
{
/// <summary>
/// <para>
/// Displays its contents inside a scrollable frame. For more information, see.
/// </para>
/// </summary>
public class ScrollView : VisualElement
{
private static readonly float k_DefaultScrollDecelerationRate = 0.135f;
private static readonly float k_DefaultElasticity = 0.1f;
/// <summary>
/// <para>
/// USS class name of elements of this type.
/// </para>
/// </summary>
public static readonly string ussClassName = &#34;unity-scroll-view&#34;;
/// <summary>
/// <para>
/// USS class name of viewport elements in elements of this type.
/// </para>
/// </summary>
public static readonly string viewportUssClassName = ScrollView.ussClassName + &#34;__content-viewport&#34;;
/// <summary>
/// <para>
/// USS class name of content elements in elements of this type.
/// </para>
/// </summary>
public static readonly string contentAndVerticalScrollUssClassName = ScrollView.ussClassName + &#34;__content-and-vertical-scroll-container&#34;;
/// <summary>
/// <para>
/// USS class name of content elements in elements of this type.
/// </para>
/// </summary>
public static readonly string contentUssClassName = ScrollView.ussClassName + &#34;__content-container&#34;;
/// <summary>
/// <para>
/// USS class name of horizontal scrollers in elements of this type.
/// </para>
/// </summary>
public static readonly string hScrollerUssClassName = ScrollView.ussClassName + &#34;__horizontal-scroller&#34;;
/// <summary>
/// <para>
/// USS class name of vertical scrollers in elements of this type.
/// </para>
/// </summary>
public static readonly string vScrollerUssClassName = ScrollView.ussClassName + &#34;__vertical-scroller&#34;;
/// <summary>
/// <para>
/// USS class name that&#39;s added when the ScrollView is in horizontal mode.
/// ScrollViewMode.Horizontal
/// </para>
/// </summary>
public static readonly string horizontalVariantUssClassName = ScrollView.ussClassName + &#34;--horizontal&#34;;
/// <summary>
/// <para>
/// USS class name that&#39;s added when the ScrollView is in vertical mode.
/// ScrollViewMode.Vertical
/// </para>
/// </summary>
public static readonly string verticalVariantUssClassName = ScrollView.ussClassName + &#34;--vertical&#34;;
/// <summary>
/// <para>
/// USS class name that&#39;s added when the ScrollView is in both horizontal and vertical mode.
/// ScrollViewMode.VerticalAndHorizontal
/// </para>
/// </summary>
public static readonly string verticalHorizontalVariantUssClassName = ScrollView.ussClassName + &#34;--vertical-horizontal&#34;;
public static readonly string scrollVariantUssClassName = ScrollView.ussClassName + &#34;--scroll&#34;;
private float m_SingleLineHeight = UIElementsUtility.singleLineHeight;
private float m_ScrollDecelerationRate = ScrollView.k_DefaultScrollDecelerationRate;
private float m_Elasticity = ScrollView.k_DefaultElasticity;
private int m_ScrollingPointerId = PointerId.invalidPointerId;
private ScrollerVisibility m_HorizontalScrollerVisibility;
private ScrollerVisibility m_VerticalScrollerVisibility;
private const float k_SizeThreshold = 0.001f;
private VisualElement m_AttachedRootVisualContainer;
private const string k_SingleLineHeightPropertyName = &#34;--unity-metrics-single_line-height&#34;;
private const float k_ScrollPageOverlapFactor = 0.1f;
internal const float k_UnsetPageSizeValue = -1f;
private float m_HorizontalPageSize;
private float m_VerticalPageSize;
private ScrollView.TouchScrollBehavior m_TouchScrollBehavior;
private ScrollView.NestedInteractionKind m_NestedInteractionKind;
private VisualElement m_ContentContainer;
private VisualElement m_ContentAndVerticalScrollContainer;
private ScrollViewMode m_Mode;
private const float k_VelocityLerpTimeFactor = 10f;
internal const float ScrollThresholdSquared = 100f;
private Vector2 m_StartPosition;
private Vector2 m_PointerStartPosition;
private Vector2 m_Velocity;
private Vector2 m_SpringBackVelocity;
private Vector2 m_LowBounds;
private Vector2 m_HighBounds;
private float m_LastVelocityLerpTime;
private bool m_StartedMoving;
private bool m_TouchStoppedVelocity;
private VisualElement m_CapturedTarget;
private EventCallback<PointerMoveEvent> m_CapturedTargetPointerMoveCallback;
private EventCallback<PointerUpEvent> m_CapturedTargetPointerUpCallback;
private IVisualElementScheduledItem m_PostPointerUpAnimation;
/// <summary>
/// <para>
/// Specifies whether the horizontal scroll bar is visible.
/// </para>
/// </summary>
public ScrollerVisibility horizontalScrollerVisibility
{
get
{
return this.m_HorizontalScrollerVisibility;
}
set
{
this.m_HorizontalScrollerVisibility = value;
this.UpdateScrollers(this.needsHorizontal, this.needsVertical);
}
}
/// <summary>
/// <para>
/// Specifies whether the vertical scroll bar is visible.
/// </para>
/// </summary>
public ScrollerVisibility verticalScrollerVisibility
{
get
{
return this.m_VerticalScrollerVisibility;
}
set
{
this.m_VerticalScrollerVisibility = value;
this.UpdateScrollers(this.needsHorizontal, this.needsVertical);
}
}
/// <summary>
/// <para>
/// Obsolete. Use ScrollView.horizontalScrollerVisibility instead.
/// </para>
/// </summary>
[Obsolete(&#34;showHorizontal is obsolete. Use horizontalScrollerVisibility instead&#34;)]
public bool showHorizontal
{
get
{
return this.horizontalScrollerVisibility == ScrollerVisibility.AlwaysVisible;
}
set
{
this.m_HorizontalScrollerVisibility = value ? ScrollerVisibility.AlwaysVisible : ScrollerVisibility.Auto;
}
}
/// <summary>
/// <para>
/// Obsolete. Use ScrollView.verticalScrollerVisibility instead.
/// </para>
/// </summary>
[Obsolete(&#34;showVertical is obsolete. Use verticalScrollerVisibility instead&#34;)]
public bool showVertical
{
get
{
return this.verticalScrollerVisibility == ScrollerVisibility.AlwaysVisible;
}
set
{
this.m_VerticalScrollerVisibility = value ? ScrollerVisibility.AlwaysVisible : ScrollerVisibility.Auto;
}
}
internal bool needsHorizontal
{
get
{
return this.horizontalScrollerVisibility == ScrollerVisibility.AlwaysVisible || this.horizontalScrollerVisibility == ScrollerVisibility.Auto && (double) this.scrollableWidth > 1.0 / 1000.0;
}
}
internal bool needsVertical
{
get
{
return this.verticalScrollerVisibility == ScrollerVisibility.AlwaysVisible || this.verticalScrollerVisibility == ScrollerVisibility.Auto && (double) this.scrollableHeight > 1.0 / 1000.0;
}
}
internal bool isVerticalScrollDisplayed
{
get
{
return this.verticalScroller.resolvedStyle.display == DisplayStyle.Flex;
}
}
internal bool isHorizontalScrollDisplayed
{
get
{
return this.horizontalScroller.resolvedStyle.display == DisplayStyle.Flex;
}
}
/// <summary>
/// <para>
/// The current scrolling position.
/// </para>
/// </summary>
public Vector2 scrollOffset
{
get
{
return new Vector2(this.horizontalScroller.value, this.verticalScroller.value);
}
set
{
if (!(value != this.scrollOffset))
return;
this.horizontalScroller.value = value.x;
this.verticalScroller.value = value.y;
this.UpdateContentViewTransform();
}
}
/// <summary>
/// <para>
/// This property is controlling the scrolling speed of the horizontal scroller.
/// </para>
/// </summary>
public float horizontalPageSize
{
get
{
return this.m_HorizontalPageSize;
}
set
{
this.m_HorizontalPageSize = value;
this.UpdateHorizontalSliderPageSize();
}
}
/// <summary>
/// <para>
/// This property is controlling the scrolling speed of the vertical scroller.
/// </para>
/// </summary>
public float verticalPageSize
{
get
{
return this.m_VerticalPageSize;
}
set
{
this.m_VerticalPageSize = value;
this.UpdateVerticalSliderPageSize();
}
}
internal float scrollableWidth
{
get
{
Rect rect = this.contentContainer.boundingBox;
double width1 = (double) rect.width;
rect = this.contentViewport.layout;
double width2 = (double) rect.width;
return (float) (width1 - width2);
}
}
internal float scrollableHeight
{
get
{
Rect rect = this.contentContainer.boundingBox;
double height1 = (double) rect.height;
rect = this.contentViewport.layout;
double height2 = (double) rect.height;
return (float) (height1 - height2);
}
}
private bool hasInertia
{
get
{
return (double) this.scrollDecelerationRate > 0.0;
}
}
/// <summary>
/// <para>
/// Controls the rate at which the scrolling movement slows after a user scrolls using a touch interaction.
/// </para>
/// </summary>
public float scrollDecelerationRate
{
get
{
return this.m_ScrollDecelerationRate;
}
set
{
this.m_ScrollDecelerationRate = Mathf.Max(0.0f, value);
}
}
/// <summary>
/// <para>
/// The amount of elasticity to use when a user tries to scroll past the boundaries of the scroll view.
/// </para>
/// </summary>
public float elasticity
{
get
{
return this.m_Elasticity;
}
set
{
this.m_Elasticity = Mathf.Max(0.0f, value);
}
}
/// <summary>
/// <para>
/// The behavior to use when a user tries to scroll past the boundaries of the ScrollView content using a touch interaction.
/// </para>
/// </summary>
public ScrollView.TouchScrollBehavior touchScrollBehavior
{
get
{
return this.m_TouchScrollBehavior;
}
set
{
this.m_TouchScrollBehavior = value;
if (this.m_TouchScrollBehavior == ScrollView.TouchScrollBehavior.Clamped)
{
this.horizontalScroller.slider.clamped = true;
this.verticalScroller.slider.clamped = true;
}
else
{
this.horizontalScroller.slider.clamped = false;
this.verticalScroller.slider.clamped = false;
}
}
}
/// <summary>
/// <para>
/// The behavior to use when scrolling reaches limits of a nested ScrollView.
/// </para>
/// </summary>
public ScrollView.NestedInteractionKind nestedInteractionKind
{
get
{
return this.m_NestedInteractionKind;
}
set
{
this.m_NestedInteractionKind = value;
}
}
private void OnHorizontalScrollDragElementChanged(GeometryChangedEvent evt)
{
Rect rect = evt.oldRect;
Vector2 size1 = rect.size;
rect = evt.newRect;
Vector2 size2 = rect.size;
if (size1 == size2)
return;
this.UpdateHorizontalSliderPageSize();
}
private void OnVerticalScrollDragElementChanged(GeometryChangedEvent evt)
{
Rect rect = evt.oldRect;
Vector2 size1 = rect.size;
rect = evt.newRect;
Vector2 size2 = rect.size;
if (size1 == size2)
return;
this.UpdateVerticalSliderPageSize();
}
private void UpdateHorizontalSliderPageSize()
{
float width = this.horizontalScroller.resolvedStyle.width;
float num = this.m_HorizontalPageSize;
if ((double) width > 0.0 && Mathf.Approximately(this.m_HorizontalPageSize, -1f))
num = this.horizontalScroller.slider.dragElement.resolvedStyle.width * 0.9f;
if ((double) num < 0.0)
return;
this.horizontalScroller.slider.pageSize = num;
}
private void UpdateVerticalSliderPageSize()
{
float height = this.verticalScroller.resolvedStyle.height;
float num = this.m_VerticalPageSize;
if ((double) height > 0.0 && Mathf.Approximately(this.m_VerticalPageSize, -1f))
num = this.verticalScroller.slider.dragElement.resolvedStyle.height * 0.9f;
if ((double) num < 0.0)
return;
this.verticalScroller.slider.pageSize = num;
}
private void UpdateContentViewTransform()
{
Vector3 position = this.contentContainer.transform.position;
Vector2 scrollOffset = this.scrollOffset;
if (this.needsVertical)
scrollOffset.y += this.contentContainer.resolvedStyle.top;
position.x = GUIUtility.RoundToPixelGrid(-scrollOffset.x);
position.y = GUIUtility.RoundToPixelGrid(-scrollOffset.y);
this.contentContainer.transform.position = position;
this.IncrementVersion(VersionChangeType.Repaint);
}
/// <summary>
/// <para>
/// Scroll to a specific child element.
/// </para>
/// </summary>
/// <param name=&#34;child&#34;>The child to scroll to.</param>
public void ScrollTo(VisualElement child)
{
if (child == null)
throw new ArgumentNullException(nameof (child));
if (!this.contentContainer.Contains(child))
throw new ArgumentException(&#34;Cannot scroll to a VisualElement that&#39;s not a child of the ScrollView content-container.&#34;);
this.m_Velocity = Vector2.zero;
float num1 = 0.0f;
float num2 = 0.0f;
if ((double) this.scrollableHeight > 0.0)
{
num1 = this.GetYDeltaOffset(child);
this.verticalScroller.value = this.scrollOffset.y + num1;
}
if ((double) this.scrollableWidth > 0.0)
{
num2 = this.GetXDeltaOffset(child);
this.horizontalScroller.value = this.scrollOffset.x + num2;
}
if ((double) num1 == 0.0 && (double) num2 == 0.0)
return;
this.UpdateContentViewTransform();
}
private float GetXDeltaOffset(VisualElement child)
{
float num1 = this.contentContainer.transform.position.x * -1f;
Rect worldBound1 = this.contentViewport.worldBound;
float viewMin = worldBound1.xMin + num1;
float viewMax = worldBound1.xMax + num1;
Rect worldBound2 = child.worldBound;
float num2 = worldBound2.xMin + num1;
float num3 = worldBound2.xMax + num1;
return (double) num2 >= (double) viewMin && (double) num3 <= (double) viewMax || float.IsNaN(num2) || float.IsNaN(num3) ? 0.0f : this.GetDeltaDistance(viewMin, viewMax, num2, num3) * this.horizontalScroller.highValue / this.scrollableWidth;
}
private float GetYDeltaOffset(VisualElement child)
{
float num1 = this.contentContainer.transform.position.y * -1f;
Rect worldBound1 = this.contentViewport.worldBound;
float viewMin = worldBound1.yMin + num1;
float viewMax = worldBound1.yMax + num1;
Rect worldBound2 = child.worldBound;
float num2 = worldBound2.yMin + num1;
float num3 = worldBound2.yMax + num1;
return (double) num2 >= (double) viewMin && (double) num3 <= (double) viewMax || float.IsNaN(num2) || float.IsNaN(num3) ? 0.0f : this.GetDeltaDistance(viewMin, viewMax, num2, num3) * this.verticalScroller.highValue / this.scrollableHeight;
}
private float GetDeltaDistance(
float viewMin,
float viewMax,
float childBoundaryMin,
float childBoundaryMax)
{
float num1 = viewMax - viewMin;
if ((double) (childBoundaryMax - childBoundaryMin) > (double) num1)
return (double) viewMin > (double) childBoundaryMin && (double) childBoundaryMax > (double) viewMax ? 0.0f : ((double) childBoundaryMin > (double) viewMin ? childBoundaryMin - viewMin : childBoundaryMax - viewMax);
float num2 = childBoundaryMax - viewMax;
if ((double) num2 < -1.0)
num2 = childBoundaryMin - viewMin;
return num2;
}
/// <summary>
/// <para>
/// Represents the visible part of contentContainer.
/// </para>
/// </summary>
public VisualElement contentViewport { get; private set; }
/// <summary>
/// <para>
/// Horizontal scrollbar.
/// </para>
/// </summary>
public Scroller horizontalScroller { get; private set; }
/// <summary>
/// <para>
/// Vertical Scrollbar.
/// </para>
/// </summary>
public Scroller verticalScroller { get; private set; }
/// <summary>
/// <para>
/// Contains full content, potentially partially visible.
/// </para>
/// </summary>
public override VisualElement contentContainer
{
get
{
return this.m_ContentContainer;
}
}
/// <summary>
/// <para>
/// Constructor.
/// </para>
/// </summary>
public ScrollView()
: this(ScrollViewMode.Vertical)
{
}
/// <summary>
/// <para>
/// Constructor.
/// </para>
/// </summary>
/// <param name=&#34;scrollViewMode&#34;></param>
public ScrollView(ScrollViewMode scrollViewMode)
{
this.AddToClassList(ScrollView.ussClassName);
this.m_ContentAndVerticalScrollContainer = new VisualElement()
{
name = &#34;unity-content-and-vertical-scroll-container&#34;
};
this.m_ContentAndVerticalScrollContainer.AddToClassList(ScrollView.contentAndVerticalScrollUssClassName);
this.hierarchy.Add(this.m_ContentAndVerticalScrollContainer);
this.contentViewport = new VisualElement()
{
name = &#34;unity-content-viewport&#34;
};
this.contentViewport.AddToClassList(ScrollView.viewportUssClassName);
this.contentViewport.RegisterCallback<GeometryChangedEvent>(new EventCallback<GeometryChangedEvent>(this.OnGeometryChanged), TrickleDown.NoTrickleDown);
this.contentViewport.pickingMode = PickingMode.Ignore;
this.m_ContentAndVerticalScrollContainer.RegisterCallback<AttachToPanelEvent>(new EventCallback<AttachToPanelEvent>(this.OnAttachToPanel), TrickleDown.NoTrickleDown);
this.m_ContentAndVerticalScrollContainer.RegisterCallback<DetachFromPanelEvent>(new EventCallback<DetachFromPanelEvent>(this.OnDetachFromPanel), TrickleDown.NoTrickleDown);
this.m_ContentAndVerticalScrollContainer.Add(this.contentViewport);
this.m_ContentContainer = new VisualElement()
{
name = &#34;unity-content-container&#34;
};
this.m_ContentContainer.disableClipping = true;
this.m_ContentContainer.RegisterCallback<GeometryChangedEvent>(new EventCallback<GeometryChangedEvent>(this.OnGeometryChanged), TrickleDown.NoTrickleDown);
this.m_ContentContainer.AddToClassList(ScrollView.contentUssClassName);
this.m_ContentContainer.usageHints = UsageHints.GroupTransform;
this.contentViewport.Add(this.m_ContentContainer);
this.SetScrollViewMode(scrollViewMode);
Scroller scroller1 = new Scroller(0.0f, (float) int.MaxValue, (Action<float>) (value =>
{
this.scrollOffset = new Vector2(value, this.scrollOffset.y);
this.UpdateContentViewTransform();
}), SliderDirection.Horizontal);
scroller1.viewDataKey = &#34;HorizontalScroller&#34;;
this.horizontalScroller = scroller1;
this.horizontalScroller.AddToClassList(ScrollView.hScrollerUssClassName);
this.horizontalScroller.style.display = (StyleEnum<DisplayStyle>) DisplayStyle.None;
this.hierarchy.Add((VisualElement) this.horizontalScroller);
Scroller scroller2 = new Scroller(0.0f, (float) int.MaxValue, (Action<float>) (value =>
{
this.scrollOffset = new Vector2(this.scrollOffset.x, value);
this.UpdateContentViewTransform();
}), SliderDirection.Vertical);
scroller2.viewDataKey = &#34;VerticalScroller&#34;;
this.verticalScroller = scroller2;
this.verticalScroller.AddToClassList(ScrollView.vScrollerUssClassName);
this.verticalScroller.style.display = (StyleEnum<DisplayStyle>) DisplayStyle.None;
this.m_ContentAndVerticalScrollContainer.Add((VisualElement) this.verticalScroller);
this.touchScrollBehavior = ScrollView.TouchScrollBehavior.Clamped;
this.RegisterCallback<WheelEvent>(new EventCallback<WheelEvent>(this.OnScrollWheel), TrickleDown.NoTrickleDown);
this.verticalScroller.RegisterCallback<GeometryChangedEvent>(new EventCallback<GeometryChangedEvent>(this.OnScrollersGeometryChanged), TrickleDown.NoTrickleDown);
this.horizontalScroller.RegisterCallback<GeometryChangedEvent>(new EventCallback<GeometryChangedEvent>(this.OnScrollersGeometryChanged), TrickleDown.NoTrickleDown);
this.horizontalPageSize = -1f;
this.verticalPageSize = -1f;
this.horizontalScroller.slider.dragElement.RegisterCallback<GeometryChangedEvent>(new EventCallback<GeometryChangedEvent>(this.OnHorizontalScrollDragElementChanged), TrickleDown.NoTrickleDown);
this.verticalScroller.slider.dragElement.RegisterCallback<GeometryChangedEvent>(new EventCallback<GeometryChangedEvent>(this.OnVerticalScrollDragElementChanged), TrickleDown.NoTrickleDown);
this.m_CapturedTargetPointerMoveCallback = new EventCallback<PointerMoveEvent>(this.OnPointerMove);
this.m_CapturedTargetPointerUpCallback = new EventCallback<PointerUpEvent>(this.OnPointerUp);
this.scrollOffset = Vector2.zero;
}
/// <summary>
/// <para>
/// Controls how the ScrollView allows the user to scroll the contents.
/// ScrollViewMode
/// </para>
/// </summary>
public ScrollViewMode mode
{
get
{
return this.m_Mode;
}
set
{
if (this.m_Mode == value)
return;
this.SetScrollViewMode(value);
}
}
private void SetScrollViewMode(ScrollViewMode mode)
{
this.m_Mode = mode;
this.RemoveFromClassList(ScrollView.verticalVariantUssClassName);
this.RemoveFromClassList(ScrollView.horizontalVariantUssClassName);
this.RemoveFromClassList(ScrollView.verticalHorizontalVariantUssClassName);
this.RemoveFromClassList(ScrollView.scrollVariantUssClassName);
switch (mode)
{
case ScrollViewMode.Vertical:
this.AddToClassList(ScrollView.verticalVariantUssClassName);
this.AddToClassList(ScrollView.scrollVariantUssClassName);
break;
case ScrollViewMode.Horizontal:
this.AddToClassList(ScrollView.horizontalVariantUssClassName);
this.AddToClassList(ScrollView.scrollVariantUssClassName);
break;
case ScrollViewMode.VerticalAndHorizontal:
this.AddToClassList(ScrollView.scrollVariantUssClassName);
this.AddToClassList(ScrollView.verticalHorizontalVariantUssClassName);
break;
}
}
private void OnAttachToPanel(AttachToPanelEvent evt)
{
if (evt.destinationPanel == null)
return;
this.m_AttachedRootVisualContainer = this.GetRootVisualContainer();
this.m_AttachedRootVisualContainer?.RegisterCallback<CustomStyleResolvedEvent>(new EventCallback<CustomStyleResolvedEvent>(this.OnRootCustomStyleResolved), TrickleDown.NoTrickleDown);
this.ReadSingleLineHeight();
if (evt.destinationPanel.contextType != ContextType.Player)
return;
this.m_ContentAndVerticalScrollContainer.RegisterCallback<PointerMoveEvent>(new EventCallback<PointerMoveEvent>(this.OnPointerMove), TrickleDown.NoTrickleDown);
this.contentContainer.RegisterCallback<PointerDownEvent>(new EventCallback<PointerDownEvent>(this.OnPointerDown), TrickleDown.TrickleDown);
this.contentContainer.RegisterCallback<PointerCancelEvent>(new EventCallback<PointerCancelEvent>(this.OnPointerCancel), TrickleDown.NoTrickleDown);
this.contentContainer.RegisterCallback<PointerUpEvent>(new EventCallback<PointerUpEvent>(this.OnPointerUp), TrickleDown.TrickleDown);
this.contentContainer.RegisterCallback<PointerCaptureEvent>(new EventCallback<PointerCaptureEvent>(this.OnPointerCapture), TrickleDown.NoTrickleDown);
this.contentContainer.RegisterCallback<PointerCaptureOutEvent>(new EventCallback<PointerCaptureOutEvent>(this.OnPointerCaptureOut), TrickleDown.NoTrickleDown);
}
private void OnDetachFromPanel(DetachFromPanelEvent evt)
{
if (evt.originPanel == null)
return;
this.m_AttachedRootVisualContainer?.UnregisterCallback<CustomStyleResolvedEvent>(new EventCallback<CustomStyleResolvedEvent>(this.OnRootCustomStyleResolved), TrickleDown.NoTrickleDown);
this.m_AttachedRootVisualContainer = (VisualElement) null;
if (evt.originPanel.contextType != ContextType.Player)
return;
this.m_ContentAndVerticalScrollContainer.UnregisterCallback<PointerDownEvent>(new EventCallback<PointerDownEvent>(this.OnPointerDown), TrickleDown.TrickleDown);
this.m_ContentAndVerticalScrollContainer.UnregisterCallback<PointerMoveEvent>(new EventCallback<PointerMoveEvent>(this.OnPointerMove), TrickleDown.NoTrickleDown);
this.m_ContentAndVerticalScrollContainer.UnregisterCallback<PointerCancelEvent>(new EventCallback<PointerCancelEvent>(this.OnPointerCancel), TrickleDown.NoTrickleDown);
this.m_ContentAndVerticalScrollContainer.UnregisterCallback<PointerUpEvent>(new EventCallback<PointerUpEvent>(this.OnPointerUp), TrickleDown.TrickleDown);
this.contentContainer.UnregisterCallback<PointerCaptureEvent>(new EventCallback<PointerCaptureEvent>(this.OnPointerCapture), TrickleDown.NoTrickleDown);
this.contentContainer.UnregisterCallback<PointerCaptureOutEvent>(new EventCallback<PointerCaptureOutEvent>(this.OnPointerCaptureOut), TrickleDown.NoTrickleDown);
}
private void OnPointerCapture(PointerCaptureEvent evt)
{
this.m_CapturedTarget = evt.target as VisualElement;
if (this.m_CapturedTarget == null)
return;
this.m_ScrollingPointerId = evt.pointerId;
this.m_CapturedTarget.RegisterCallback<PointerMoveEvent>(this.m_CapturedTargetPointerMoveCallback, TrickleDown.NoTrickleDown);
this.m_CapturedTarget.RegisterCallback<PointerUpEvent>(this.m_CapturedTargetPointerUpCallback, TrickleDown.NoTrickleDown);
}
private void OnPointerCaptureOut(PointerCaptureOutEvent evt)
{
this.ReleaseScrolling(evt.pointerId, evt.target);
if (this.m_CapturedTarget == null)
return;
this.m_CapturedTarget.UnregisterCallback<PointerMoveEvent>(this.m_CapturedTargetPointerMoveCallback, TrickleDown.NoTrickleDown);
this.m_CapturedTarget.UnregisterCallback<PointerUpEvent>(this.m_CapturedTargetPointerUpCallback, TrickleDown.NoTrickleDown);
this.m_CapturedTarget = (VisualElement) null;
}
private void OnGeometryChanged(GeometryChangedEvent evt)
{
Rect rect = evt.oldRect;
Vector2 size1 = rect.size;
rect = evt.newRect;
Vector2 size2 = rect.size;
if (size1 == size2)
return;
bool displayVertical = this.needsVertical;
bool displayHorizontal = this.needsHorizontal;
if (evt.layoutPass > 0)
{
displayVertical = displayVertical || this.isVerticalScrollDisplayed;
displayHorizontal = displayHorizontal || this.isHorizontalScrollDisplayed;
}
this.UpdateScrollers(displayHorizontal, displayVertical);
this.UpdateContentViewTransform();
}
private static float ComputeElasticOffset(
float deltaPointer,
float initialScrollOffset,
float lowLimit,
float hardLowLimit,
float highLimit,
float hardHighLimit)
{
initialScrollOffset = Mathf.Max(initialScrollOffset, hardLowLimit * 0.95f);
initialScrollOffset = Mathf.Min(initialScrollOffset, hardHighLimit * 0.95f);
float num1;
if ((double) initialScrollOffset < (double) lowLimit && (double) hardLowLimit < (double) lowLimit)
{
float num2 = lowLimit - hardLowLimit;
float num3 = (lowLimit - initialScrollOffset) / num2;
num1 = (float) ((double) num3 * (double) num2 / (1.0 - (double) num3)) + deltaPointer;
initialScrollOffset = lowLimit;
}
else if ((double) initialScrollOffset > (double) highLimit && (double) hardHighLimit > (double) highLimit)
{
float num2 = hardHighLimit - highLimit;
float num3 = (initialScrollOffset - highLimit) / num2;
num1 = (float) (-1.0 * (double) num3 * (double) num2 / (1.0 - (double) num3)) + deltaPointer;
initialScrollOffset = highLimit;
}
else
num1 = deltaPointer;
float num4 = initialScrollOffset - num1;
float f;
float num5;
float num6;
if ((double) num4 < (double) lowLimit)
{
f = lowLimit - num4;
initialScrollOffset = lowLimit;
num5 = lowLimit - hardLowLimit;
num6 = 1f;
}
else
{
if ((double) num4 <= (double) highLimit)
return num4;
f = num4 - highLimit;
initialScrollOffset = highLimit;
num5 = hardHighLimit - highLimit;
num6 = -1f;
}
if ((double) Mathf.Abs(f) < 1.00000000317108E-30)
return initialScrollOffset;
float num7 = f / (f + num5) * num5 * num6;
return initialScrollOffset - num7;
}
private void ComputeInitialSpringBackVelocity()
{
if (this.touchScrollBehavior != ScrollView.TouchScrollBehavior.Elastic)
{
this.m_SpringBackVelocity = Vector2.zero;
}
else
{
this.m_SpringBackVelocity.x = (double) this.scrollOffset.x >= (double) this.m_LowBounds.x ? ((double) this.scrollOffset.x <= (double) this.m_HighBounds.x ? 0.0f : this.m_HighBounds.x - this.scrollOffset.x) : this.m_LowBounds.x - this.scrollOffset.x;
if ((double) this.scrollOffset.y < (double) this.m_LowBounds.y)
this.m_SpringBackVelocity.y = this.m_LowBounds.y - this.scrollOffset.y;
else if ((double) this.scrollOffset.y > (double) this.m_HighBounds.y)
this.m_SpringBackVelocity.y = this.m_HighBounds.y - this.scrollOffset.y;
else
this.m_SpringBackVelocity.y = 0.0f;
}
}
private void SpringBack()
{
if (this.touchScrollBehavior != ScrollView.TouchScrollBehavior.Elastic)
{
this.m_SpringBackVelocity = Vector2.zero;
}
else
{
Vector2 scrollOffset = this.scrollOffset;
if ((double) scrollOffset.x < (double) this.m_LowBounds.x)
{
scrollOffset.x = Mathf.SmoothDamp(scrollOffset.x, this.m_LowBounds.x, ref this.m_SpringBackVelocity.x, this.elasticity, float.PositiveInfinity, Time.unscaledDeltaTime);
if ((double) Mathf.Abs(this.m_SpringBackVelocity.x) < 1.0)
this.m_SpringBackVelocity.x = 0.0f;
}
else if ((double) scrollOffset.x > (double) this.m_HighBounds.x)
{
scrollOffset.x = Mathf.SmoothDamp(scrollOffset.x, this.m_HighBounds.x, ref this.m_SpringBackVelocity.x, this.elasticity, float.PositiveInfinity, Time.unscaledDeltaTime);
if ((double) Mathf.Abs(this.m_SpringBackVelocity.x) < 1.0)
this.m_SpringBackVelocity.x = 0.0f;
}
else
this.m_SpringBackVelocity.x = 0.0f;
if ((double) scrollOffset.y < (double) this.m_LowBounds.y)
{
scrollOffset.y = Mathf.SmoothDamp(scrollOffset.y, this.m_LowBounds.y, ref this.m_SpringBackVelocity.y, this.elasticity, float.PositiveInfinity, Time.unscaledDeltaTime);
if ((double) Mathf.Abs(this.m_SpringBackVelocity.y) < 1.0)
this.m_SpringBackVelocity.y = 0.0f;
}
else if ((double) scrollOffset.y > (double) this.m_HighBounds.y)
{
scrollOffset.y = Mathf.SmoothDamp(scrollOffset.y, this.m_HighBounds.y, ref this.m_SpringBackVelocity.y, this.elasticity, float.PositiveInfinity, Time.unscaledDeltaTime);
if ((double) Mathf.Abs(this.m_SpringBackVelocity.y) < 1.0)
this.m_SpringBackVelocity.y = 0.0f;
}
else
this.m_SpringBackVelocity.y = 0.0f;
this.scrollOffset = scrollOffset;
}
}
internal void ApplyScrollInertia()
{
if (this.hasInertia && this.m_Velocity != Vector2.zero)
{
this.m_Velocity *= Mathf.Pow(this.scrollDecelerationRate, Time.unscaledDeltaTime);
if ((double) Mathf.Abs(this.m_Velocity.x) < 1.0 || this.touchScrollBehavior == ScrollView.TouchScrollBehavior.Elastic && ((double) this.scrollOffset.x < (double) this.m_LowBounds.x || (double) this.scrollOffset.x > (double) this.m_HighBounds.x))
this.m_Velocity.x = 0.0f;
if ((double) Mathf.Abs(this.m_Velocity.y) < 1.0 || this.touchScrollBehavior == ScrollView.TouchScrollBehavior.Elastic && ((double) this.scrollOffset.y < (double) this.m_LowBounds.y || (double) this.scrollOffset.y > (double) this.m_HighBounds.y))
this.m_Velocity.y = 0.0f;
this.scrollOffset += this.m_Velocity * Time.unscaledDeltaTime;
}
else
this.m_Velocity = Vector2.zero;
}
private void PostPointerUpAnimation()
{
this.ApplyScrollInertia();
this.SpringBack();
if (!(this.m_SpringBackVelocity == Vector2.zero) || !(this.m_Velocity == Vector2.zero))
return;
this.m_PostPointerUpAnimation.Pause();
}
private void OnPointerDown(PointerDownEvent evt)
{
if (evt.pointerType == PointerType.mouse || !evt.isPrimary)
return;
if (this.m_ScrollingPointerId != PointerId.invalidPointerId)
this.ReleaseScrolling(this.m_ScrollingPointerId, evt.target);
this.m_PostPointerUpAnimation?.Pause();
bool flag = (double) Mathf.Abs(this.m_Velocity.x) > 10.0 || (double) Mathf.Abs(this.m_Velocity.y) > 10.0;
this.m_ScrollingPointerId = evt.pointerId;
this.m_StartedMoving = false;
this.InitTouchScrolling((Vector2) evt.position);
if (!flag)
return;
this.contentContainer.CapturePointer(evt.pointerId);
this.contentContainer.panel.PreventCompatibilityMouseEvents(evt.pointerId);
evt.StopPropagation();
this.m_TouchStoppedVelocity = true;
}
private void OnPointerMove(PointerMoveEvent evt)
{
if (evt.pointerType == PointerType.mouse || !evt.isPrimary || evt.pointerId != this.m_ScrollingPointerId)
return;
if (evt.isHandledByDraggable)
{
this.m_PointerStartPosition = (Vector2) evt.position;
this.m_StartPosition = this.scrollOffset;
}
else
{
Vector2 vector2 = (Vector2) evt.position - this.m_PointerStartPosition;
if (this.mode == ScrollViewMode.Horizontal)
vector2.y = 0.0f;
else if (this.mode == ScrollViewMode.Vertical)
vector2.x = 0.0f;
if (!this.m_TouchStoppedVelocity && !this.m_StartedMoving && (double) vector2.sqrMagnitude < 100.0)
return;
if (this.ComputeTouchScrolling((Vector2) evt.position) != ScrollView.TouchScrollingResult.Forward)
{
evt.isHandledByDraggable = true;
evt.StopPropagation();
if (this.contentContainer.HasPointerCapture(evt.pointerId))
return;
this.contentContainer.CapturePointer(evt.pointerId);
}
else
this.m_Velocity = Vector2.zero;
}
}
private void OnPointerCancel(PointerCancelEvent evt)
{
this.ReleaseScrolling(evt.pointerId, evt.target);
}
private void OnPointerUp(PointerUpEvent evt)
{
if (!this.ReleaseScrolling(evt.pointerId, evt.target))
return;
this.contentContainer.panel.PreventCompatibilityMouseEvents(evt.pointerId);
evt.StopPropagation();
}
internal void InitTouchScrolling(Vector2 position)
{
this.m_PointerStartPosition = position;
this.m_StartPosition = this.scrollOffset;
this.m_Velocity = Vector2.zero;
this.m_SpringBackVelocity = Vector2.zero;
this.m_LowBounds = new Vector2(Mathf.Min(this.horizontalScroller.lowValue, this.horizontalScroller.highValue), Mathf.Min(this.verticalScroller.lowValue, this.verticalScroller.highValue));
this.m_HighBounds = new Vector2(Mathf.Max(this.horizontalScroller.lowValue, this.horizontalScroller.highValue), Mathf.Max(this.verticalScroller.lowValue, this.verticalScroller.highValue));
}
internal ScrollView.TouchScrollingResult ComputeTouchScrolling(Vector2 position)
{
Vector2 newScrollOffset;
if (this.touchScrollBehavior == ScrollView.TouchScrollBehavior.Clamped)
newScrollOffset = Vector2.Min(Vector2.Max(this.m_StartPosition - (position - this.m_PointerStartPosition), this.m_LowBounds), this.m_HighBounds);
else if (this.touchScrollBehavior == ScrollView.TouchScrollBehavior.Elastic)
{
Vector2 vector2 = position - this.m_PointerStartPosition;
newScrollOffset.x = ScrollView.ComputeElasticOffset(vector2.x, this.m_StartPosition.x, this.m_LowBounds.x, this.m_LowBounds.x - this.contentViewport.resolvedStyle.width, this.m_HighBounds.x, this.m_HighBounds.x + this.contentViewport.resolvedStyle.width);
newScrollOffset.y = ScrollView.ComputeElasticOffset(vector2.y, this.m_StartPosition.y, this.m_LowBounds.y, this.m_LowBounds.y - this.contentViewport.resolvedStyle.height, this.m_HighBounds.y, this.m_HighBounds.y + this.contentViewport.resolvedStyle.height);
}
else
newScrollOffset = this.m_StartPosition - (position - this.m_PointerStartPosition);
if (this.mode == ScrollViewMode.Vertical)
newScrollOffset.x = this.m_LowBounds.x;
else if (this.mode == ScrollViewMode.Horizontal)
newScrollOffset.y = this.m_LowBounds.y;
return this.scrollOffset != newScrollOffset ? (this.ApplyTouchScrolling(newScrollOffset) ? ScrollView.TouchScrollingResult.Apply : ScrollView.TouchScrollingResult.Forward) : (this.m_StartedMoving && this.nestedInteractionKind != ScrollView.NestedInteractionKind.ForwardScrolling ? ScrollView.TouchScrollingResult.Block : ScrollView.TouchScrollingResult.Forward);
}
private bool ApplyTouchScrolling(Vector2 newScrollOffset)
{
this.m_StartedMoving = true;
if (this.hasInertia)
{
if (newScrollOffset == this.m_LowBounds || newScrollOffset == this.m_HighBounds)
{
this.m_Velocity = Vector2.zero;
this.scrollOffset = newScrollOffset;
return false;
}
if ((double) this.m_LastVelocityLerpTime > 0.0)
this.m_Velocity = Vector2.Lerp(this.m_Velocity, Vector2.zero, (Time.unscaledTime - this.m_LastVelocityLerpTime) * 10f);
this.m_LastVelocityLerpTime = Time.unscaledTime;
float unscaledDeltaTime = Time.unscaledDeltaTime;
this.m_Velocity = Vector2.Lerp(this.m_Velocity, (newScrollOffset - this.scrollOffset) / unscaledDeltaTime, unscaledDeltaTime * 10f);
}
bool flag = this.scrollOffset != newScrollOffset;
this.scrollOffset = newScrollOffset;
return flag;
}
private bool ReleaseScrolling(int pointerId, IEventHandler target)
{
if (pointerId != this.m_ScrollingPointerId)
return false;
this.m_ScrollingPointerId = PointerId.invalidPointerId;
this.m_TouchStoppedVelocity = false;
this.m_StartedMoving = false;
if (target != this.contentContainer || !this.contentContainer.HasPointerCapture(pointerId))
return false;
if (this.touchScrollBehavior == ScrollView.TouchScrollBehavior.Elastic || this.hasInertia)
{
this.ComputeInitialSpringBackVelocity();
if (this.m_PostPointerUpAnimation == null)
this.m_PostPointerUpAnimation = this.schedule.Execute(new Action(this.PostPointerUpAnimation)).Every(30L);
else
this.m_PostPointerUpAnimation.Resume();
}
this.contentContainer.ReleasePointer(pointerId);
return true;
}
private void AdjustScrollers()
{
Rect rect;
double num1;
if ((double) this.contentContainer.boundingBox.width <= 1.00000000317108E-30)
{
num1 = 1.0;
}
else
{
rect = this.contentViewport.layout;
double width1 = (double) rect.width;
rect = this.contentContainer.boundingBox;
double width2 = (double) rect.width;
num1 = width1 / width2;
}
float factor1 = (float) num1;
rect = this.contentContainer.boundingBox;
double num2;
if ((double) rect.height <= 1.00000000317108E-30)
{
num2 = 1.0;
}
else
{
rect = this.contentViewport.layout;
double height1 = (double) rect.height;
rect = this.contentContainer.boundingBox;
double height2 = (double) rect.height;
num2 = height1 / height2;
}
float factor2 = (float) num2;
this.horizontalScroller.Adjust(factor1);
this.verticalScroller.Adjust(factor2);
}
internal void UpdateScrollers(bool displayHorizontal, bool displayVertical)
{
this.AdjustScrollers();
Scroller horizontalScroller = this.horizontalScroller;
Rect rect1 = this.contentContainer.boundingBox;
double width1 = (double) rect1.width;
rect1 = this.contentViewport.layout;
double width2 = (double) rect1.width;
int num1 = width1 - width2 > 0.0 ? 1 : 0;
horizontalScroller.SetEnabled(num1 != 0);
Scroller verticalScroller = this.verticalScroller;
Rect rect2 = this.contentContainer.boundingBox;
double height1 = (double) rect2.height;
rect2 = this.contentViewport.layout;
double height2 = (double) rect2.height;
int num2 = height1 - height2 > 0.0 ? 1 : 0;
verticalScroller.SetEnabled(num2 != 0);
bool flag1 = displayHorizontal && this.m_HorizontalScrollerVisibility != ScrollerVisibility.Hidden;
bool flag2 = displayVertical && this.m_VerticalScrollerVisibility != ScrollerVisibility.Hidden;
DisplayStyle displayStyle1 = flag1 ? DisplayStyle.Flex : DisplayStyle.None;
DisplayStyle displayStyle2 = flag2 ? DisplayStyle.Flex : DisplayStyle.None;
if ((StyleEnum<DisplayStyle>) displayStyle1 != this.horizontalScroller.style.display)
this.horizontalScroller.style.display = (StyleEnum<DisplayStyle>) displayStyle1;
if ((StyleEnum<DisplayStyle>) displayStyle2 != this.verticalScroller.style.display)
this.verticalScroller.style.display = (StyleEnum<DisplayStyle>) displayStyle2;
this.verticalScroller.lowValue = 0.0f;
this.verticalScroller.highValue = this.scrollableHeight;
this.horizontalScroller.lowValue = 0.0f;
this.horizontalScroller.highValue = this.scrollableWidth;
if (!this.needsVertical || (double) this.scrollableHeight <= 0.0)
this.verticalScroller.value = 0.0f;
if (this.needsHorizontal && (double) this.scrollableWidth > 0.0)
return;
this.horizontalScroller.value = 0.0f;
}
private void OnScrollersGeometryChanged(GeometryChangedEvent evt)
{
Rect rect = evt.oldRect;
Vector2 size1 = rect.size;
rect = evt.newRect;
Vector2 size2 = rect.size;
if (size1 == size2)
return;
if (this.needsHorizontal && this.m_HorizontalScrollerVisibility != ScrollerVisibility.Hidden)
this.horizontalScroller.style.marginRight = (StyleLength) this.verticalScroller.layout.width;
this.AdjustScrollers();
}
private void OnScrollWheel(WheelEvent evt)
{
bool flag1 = false;
Rect rect1 = this.contentContainer.boundingBox;
double height1 = (double) rect1.height;
rect1 = this.layout;
double height2 = (double) rect1.height;
bool flag2 = height1 - height2 > 0.0;
Rect rect2 = this.contentContainer.boundingBox;
double width1 = (double) rect2.width;
rect2 = this.layout;
double width2 = (double) rect2.width;
bool flag3 = width1 - width2 > 0.0;
float num = !flag3 || flag2 ? evt.delta.x : evt.delta.y;
if (flag2)
{
float b = this.verticalScroller.value;
this.verticalScroller.value += evt.delta.y * ((double) this.verticalScroller.lowValue < (double) this.verticalScroller.highValue ? 1f : -1f) * this.m_SingleLineHeight;
if (this.nestedInteractionKind == ScrollView.NestedInteractionKind.StopScrolling || !Mathf.Approximately(this.verticalScroller.value, b))
{
evt.StopPropagation();
flag1 = true;
}
}
if (flag3)
{
float b = this.horizontalScroller.value;
this.horizontalScroller.value += num * ((double) this.horizontalScroller.lowValue < (double) this.horizontalScroller.highValue ? 1f : -1f) * this.m_SingleLineHeight;
if (this.nestedInteractionKind == ScrollView.NestedInteractionKind.StopScrolling || !Mathf.Approximately(this.horizontalScroller.value, b))
{
evt.StopPropagation();
flag1 = true;
}
}
if (!flag1)
return;
this.UpdateContentViewTransform();
}
private void OnRootCustomStyleResolved(CustomStyleResolvedEvent evt)
{
this.ReadSingleLineHeight();
}
private void ReadSingleLineHeight()
{
VisualElement rootVisualContainer = this.m_AttachedRootVisualContainer;
StylePropertyValue stylePropertyValue;
if ((rootVisualContainer != null ? rootVisualContainer.computedStyle.customProperties : (Dictionary<string, StylePropertyValue>) null) != null && this.m_AttachedRootVisualContainer.computedStyle.customProperties.TryGetValue(&#34;--unity-metrics-single_line-height&#34;, out stylePropertyValue))
{
Dimension dimension;
if (!stylePropertyValue.sheet.TryReadDimension(stylePropertyValue.handle, out dimension))
return;
this.m_SingleLineHeight = dimension.value;
}
else
this.m_SingleLineHeight = UIElementsUtility.singleLineHeight;
}
/// <summary>
/// <para>
/// Instantiates a ScrollView using the data read from a UXML file.
/// </para>
/// </summary>
public class UxmlFactory : UnityEngine.UIElements.UxmlFactory<ScrollView, ScrollView.UxmlTraits>
{
}
/// <summary>
/// <para>
/// Defines UxmlTraits for the ScrollView.
/// </para>
/// </summary>
public class UxmlTraits : VisualElement.UxmlTraits
{
private UxmlEnumAttributeDescription<ScrollViewMode> m_ScrollViewMode;
private UxmlEnumAttributeDescription<ScrollView.NestedInteractionKind> m_NestedInteractionKind;
private UxmlBoolAttributeDescription m_ShowHorizontal;
private UxmlBoolAttributeDescription m_ShowVertical;
private UxmlEnumAttributeDescription<ScrollerVisibility> m_HorizontalScrollerVisibility;
private UxmlEnumAttributeDescription<ScrollerVisibility> m_VerticalScrollerVisibility;
private UxmlFloatAttributeDescription m_HorizontalPageSize;
private UxmlFloatAttributeDescription m_VerticalPageSize;
private UxmlEnumAttributeDescription<ScrollView.TouchScrollBehavior> m_TouchScrollBehavior;
private UxmlFloatAttributeDescription m_ScrollDecelerationRate;
private UxmlFloatAttributeDescription m_Elasticity;
/// <summary>
/// <para>
/// Initialize ScrollView properties using values from the attribute bag.
/// </para>
/// </summary>
/// <param name=&#34;ve&#34;>The object to initialize.</param>
/// <param name=&#34;bag&#34;>The attribute bag.</param>
/// <param name=&#34;cc&#34;>The creation context; unused.</param>
public override void Init(VisualElement ve, IUxmlAttributes bag, CreationContext cc)
{
base.Init(ve, bag, cc);
ScrollView scrollView = (ScrollView) ve;
scrollView.mode = this.m_ScrollViewMode.GetValueFromBag(bag, cc);
ScrollerVisibility scrollerVisibility1 = ScrollerVisibility.Auto;
if (this.m_HorizontalScrollerVisibility.TryGetValueFromBag(bag, cc, ref scrollerVisibility1))
scrollView.horizontalScrollerVisibility = scrollerVisibility1;
else
scrollView.showHorizontal = this.m_ShowHorizontal.GetValueFromBag(bag, cc);
ScrollerVisibility scrollerVisibility2 = ScrollerVisibility.Auto;
if (this.m_VerticalScrollerVisibility.TryGetValueFromBag(bag, cc, ref scrollerVisibility2))
scrollView.verticalScrollerVisibility = scrollerVisibility2;
else
scrollView.showVertical = this.m_ShowVertical.GetValueFromBag(bag, cc);
scrollView.nestedInteractionKind = this.m_NestedInteractionKind.GetValueFromBag(bag, cc);
scrollView.horizontalPageSize = this.m_HorizontalPageSize.GetValueFromBag(bag, cc);
scrollView.verticalPageSize = this.m_VerticalPageSize.GetValueFromBag(bag, cc);
scrollView.scrollDecelerationRate = this.m_ScrollDecelerationRate.GetValueFromBag(bag, cc);
scrollView.touchScrollBehavior = this.m_TouchScrollBehavior.GetValueFromBag(bag, cc);
scrollView.elasticity = this.m_Elasticity.GetValueFromBag(bag, cc);
}
public UxmlTraits()
{
UxmlEnumAttributeDescription<ScrollViewMode> attributeDescription1 = new UxmlEnumAttributeDescription<ScrollViewMode>();
attributeDescription1.name = &#34;mode&#34;;
attributeDescription1.defaultValue = ScrollViewMode.Vertical;
this.m_ScrollViewMode = attributeDescription1;
UxmlEnumAttributeDescription<ScrollView.NestedInteractionKind> attributeDescription2 = new UxmlEnumAttributeDescription<ScrollView.NestedInteractionKind>();
attributeDescription2.name = &#34;nested-interaction-kind&#34;;
attributeDescription2.defaultValue = ScrollView.NestedInteractionKind.Default;
this.m_NestedInteractionKind = attributeDescription2;
UxmlBoolAttributeDescription attributeDescription3 = new UxmlBoolAttributeDescription();
attributeDescription3.name = &#34;show-horizontal-scroller&#34;;
this.m_ShowHorizontal = attributeDescription3;
UxmlBoolAttributeDescription attributeDescription4 = new UxmlBoolAttributeDescription();
attributeDescription4.name = &#34;show-vertical-scroller&#34;;
this.m_ShowVertical = attributeDescription4;
UxmlEnumAttributeDescription<ScrollerVisibility> attributeDescription5 = new UxmlEnumAttributeDescription<ScrollerVisibility>();
attributeDescription5.name = &#34;horizontal-scroller-visibility&#34;;
this.m_HorizontalScrollerVisibility = attributeDescription5;
UxmlEnumAttributeDescription<ScrollerVisibility> attributeDescription6 = new UxmlEnumAttributeDescription<ScrollerVisibility>();
attributeDescription6.name = &#34;vertical-scroller-visibility&#34;;
this.m_VerticalScrollerVisibility = attributeDescription6;
UxmlFloatAttributeDescription attributeDescription7 = new UxmlFloatAttributeDescription();
attributeDescription7.name = &#34;horizontal-page-size&#34;;
attributeDescription7.defaultValue = -1f;
this.m_HorizontalPageSize = attributeDescription7;
UxmlFloatAttributeDescription attributeDescription8 = new UxmlFloatAttributeDescription();
attributeDescription8.name = &#34;vertical-page-size&#34;;
attributeDescription8.defaultValue = -1f;
this.m_VerticalPageSize = attributeDescription8;
UxmlEnumAttributeDescription<ScrollView.TouchScrollBehavior> attributeDescription9 = new UxmlEnumAttributeDescription<ScrollView.TouchScrollBehavior>();
attributeDescription9.name = &#34;touch-scroll-type&#34;;
attributeDescription9.defaultValue = ScrollView.TouchScrollBehavior.Clamped;
this.m_TouchScrollBehavior = attributeDescription9;
UxmlFloatAttributeDescription attributeDescription10 = new UxmlFloatAttributeDescription();
attributeDescription10.name = &#34;scroll-deceleration-rate&#34;;
attributeDescription10.defaultValue = ScrollView.k_DefaultScrollDecelerationRate;
this.m_ScrollDecelerationRate = attributeDescription10;
UxmlFloatAttributeDescription attributeDescription11 = new UxmlFloatAttributeDescription();
attributeDescription11.name = &#34;elasticity&#34;;
attributeDescription11.defaultValue = ScrollView.k_DefaultElasticity;
this.m_Elasticity = attributeDescription11;
// ISSUE: explicit constructor call
base.\u002Ector();
}
}
/// <summary>
/// <para>
/// The behavior to use when a user tries to scroll past the end of the ScrollView content using a touch interaction.
/// </para>
/// </summary>
public enum TouchScrollBehavior
{
/// <summary>
/// <para>
/// The content position can move past the ScrollView boundaries.
/// </para>
/// </summary>
Unrestricted,
/// <summary>
/// <para>
/// The content position can overshoot the ScrollView boundaries, but then &#34;snaps&#34; back within them.
/// </para>
/// </summary>
Elastic,
/// <summary>
/// <para>
/// The content position is clamped to the ScrollView boundaries.
/// </para>
/// </summary>
Clamped,
}
/// <summary>
/// <para>
/// Options for controlling how nested ScrollView handles scrolling when reaching
/// the limits of the scrollable area.
/// </para>
/// </summary>
public enum NestedInteractionKind
{
/// <summary>
/// <para>
/// Automatically selects the behavior according to the context in which the UI runs. For touch input, typically mobile devices,
/// NestedInteractionKind.StopScrolling is used. For scroll wheel input, NestedInteractionKind.ForwardScrolling is used.
/// </para>
/// </summary>
Default,
/// <summary>
/// <para>
/// Scrolling capture will remain in the scroll view if it initiated the drag.
/// </para>
/// </summary>
StopScrolling,
/// <summary>
/// <para>
/// Scrolling will continue to the parent when no movement is possible in the scrolled direction.
/// </para>
/// </summary>
ForwardScrolling,
}
internal enum TouchScrollingResult
{
Apply,
Forward,
Block,
}
}
}
|
本帖子中包含更多资源
您需要 登录 才可以下载或查看，没有账号？立即注册
×
|
窥视卡
雷达卡
发表于 2023-11-3 11:07
提升卡
置顶卡
沉默卡
喧嚣卡
变色卡
千斤顶
显身卡