UDreamScrollBox

Declared in Public/Controls/DreamScrollBox.h.

A scroll box whose hierarchy is code, not an asset.

Three nodes and a bar: a face that carries the box's look, a viewport clipped inside it that holds the scrolling behaviour, and the content stack that slides within the viewport. It is the dropdown list's arrangement -- a UUIScrollView on a clipping node with one scrolled column under it -- generalised until the column is anyone's to fill.

BP_HorizontalScrollView and BP_VerticalScrollView are two assets because an asset cannot branch on a property. Orientation is the branch: it picks the scrolling axis, the direction the content stacks, and which edge the bar sits on. Deliberately not a third "both" case -- there is no such preset, a content stack has one direction, and one axis means one bar that can actually reach everything.

The bar is a real UDreamScrollBar rather than a track and a handle rebuilt here, so the handle geometry that the anchor-resolution rule dictates exists once. The box only tells it which view to follow; the two-way link lives in the bar.

Properties

Name	Type	Category	In the details panel	From Blueprint	Description
`Style`	`FDreamScrollBoxStyle`	Scroll Box	yes	`GetStyle` / `SetStyle`	This instance's own look. The project sheet wins while StyleSource says so AND a sheet actually exists; with no sheet in the project this IS the look in effect -- which is why it stays editable instead of being gated on the enum.
`Orientation`	`EDreamPanelOrientation`	Scroll Box	yes	`GetOrientation` / `SetOrientation`	Which way it scrolls, and which way its content stacks. One property instead of two Blueprint assets.
`bShowScrollBar`	`bool`	Scroll Box	yes	`GetShowScrollBar` / `SetShowScrollBar`	Off means no bar at all, and the viewport keeps the gutter it would have cost.
`ScrollBarVisibility`	`EDreamScrollBoxScrollbarVisibility`	Scroll Box	yes	`GetScrollBarVisibility` / `SetScrollBarVisibility`	Whether the bar stays put or disappears while the content already fits. AutoHide follows the content at run time: every re-measure (AddContent, RefreshContentExtent, a resize) asks again, so a box that starts or stops overflowing brings its bar out or puts it away, as UMG's does -- the bar and its gutter both collapse while nothing scrolls. Hidden never draws the bar but keeps its gutter while there is something to scroll, as a Hidden Slate bar keeps its slot; Permanent is UMG's AlwaysShowScrollbar.
`ScrollSensitivity`	`float`	Scroll Box	yes	`GetScrollSensitivity` / `SetScrollSensitivity`	Local units travelled per mouse-wheel notch. It used to be documented as a MULTIPLIER and pushed straight into a view that multiplied the raw axis by it, so the default of 1 moved the content one unit a notch -- a wheel that visibly did nothing. 40 is what UDreamLayoutContainerScrollBox already uses for the same gesture.
`DecelerateRate`	`float`	Scroll Box	yes	`GetDecelerateRate` / `SetDecelerateRate`	How quickly a flick stops. Zero never slows down; larger stops sooner.
`bAnimateWheelScrolling`	`bool`	Scroll Box	yes	`GetAnimateWheelScrolling` / `SetAnimateWheelScrolling`	A wheel notch GLIDES instead of teleporting -- UMG's AnimateWheelScrolling. Off by default, which is what every existing box already does.
`WheelScrollAnimationDuration`	`float`	Scroll Box	yes	`GetWheelScrollAnimationDuration` / `SetWheelScrollAnimationDuration`	How long one animated notch takes. Ignored while bAnimateWheelScrolling is off.
`WheelScrollMultiplier`	`float`	Scroll Box	yes	`GetWheelScrollMultiplier` / `SetWheelScrollMultiplier`	A plain multiplier on whatever one wheel notch already travels -- UMG's name, and the list controls' too, so the three agree.
`ConsumeMouseWheel`	`EDreamScrollBoxConsumeMouseWheel`	Scroll Box	yes	`GetConsumeMouseWheel` / `SetConsumeMouseWheel`	Whether the wheel is swallowed here or handed to an outer scrolling ancestor at a limit.
`bAlwaysShowScrollbarTrack`	`bool`	Scroll Box	yes	`IsAlwaysShowScrollbarTrack` / `SetAlwaysShowScrollbarTrack`	Whether the bar's TRACK is drawn while the bar is idle -- UMG's AlwaysShowScrollbarTrack, which raises an idle track from invisible to half its alpha (SScrollBar::GetTrackOpacity). Hovering or dragging the bar draws the track at full alpha whatever this says, and Permanent draws an idle one at half.
`bAllowOverscroll`	`bool`	Scroll Box	yes	`GetAllowOverscroll` / `SetAllowOverscroll`	Let the content be pulled past an end and spring back -- UMG's AllowOverscroll.
`bBackPadScrolling`	`bool`	Scroll Box	yes	`GetBackPadScrolling` / `SetBackPadScrolling`	A whole window of empty space BEFORE the content, so the first item can be scrolled all the way to the trailing edge -- UMG's BackPadScrolling. A window, not half of one, which is Slate's arithmetic.
`bFrontPadScrolling`	`bool`	Scroll Box	yes	`GetFrontPadScrolling` / `SetFrontPadScrolling`	A whole window of empty space AFTER the content -- UMG's FrontPadScrolling.
`bEnableTouchScrolling`	`bool`	Scroll Box	yes	`GetEnableTouchScrolling` / `SetEnableTouchScrolling`	Whether a TOUCH drag scrolls this box -- UMG's bEnableTouchScrolling. A mouse drag is unaffected.
`bAllowRightClickDragScrolling`	`bool`	Scroll Box	yes	`GetAllowRightClickDragScrolling` / `SetAllowRightClickDragScrolling`	Whether a drag with the RIGHT button scrolls it -- UMG's bAllowRightClickDragScrolling. The drag scrolls from the press, the move that crossed the drag threshold included, as SScrollBox's does, so the content stays under the pointer that grabbed it. Over the content only: a right drag that starts on the box's own bar is the bar's, and the bar answers the left button alone (see UDreamScrollBar::AcceptedMouseButtons), so it scrolls nothing.
`bConsumePointerInput`	`bool`	Scroll Box	yes	`GetConsumePointerInput` / `SetConsumePointerInput`	Whether a pointer event this box acted on is swallowed -- UMG's bConsumePointerInput. Off lets it reach whatever is drawn behind the box.
`AnalogMouseWheelKey`	`FKey`	Scroll Box	yes	`GetAnalogMouseWheelKey` / `SetAnalogMouseWheelKey`	The analog key that acts as this box's mouse wheel -- UMG's AnalogMouseWheelKey. Invalid (the default) means "whatever the input preset already routes here", which is the right stick and therefore exactly what every existing box does.
`ScrollWhenFocusChanges`	`EDreamUIScrollWhenFocusChanges`	Scroll Box	yes	`GetScrollWhenFocusChanges` / `SetScrollWhenFocusChanges`	What this box does when user focus lands inside it -- UMG's ScrollWhenFocusChanges.
`NavigationDestination`	`EDreamUIScrollDestination`	Scroll Box	yes	`GetNavigationDestination` / `SetNavigationDestination`	Where a widget revealed by NAVIGATION ends up -- UMG's NavigationDestination. IntoView moves the least distance that shows it; the other two always frame it the same way.
`NavigationScrollPadding`	`float`	Scroll Box	yes	`GetNavigationScrollPadding` / `SetNavigationScrollPadding`	How much of the window to keep clear around it -- UMG's NavigationScrollPadding.
`ScrollProgress`	`float`	Scroll Box	yes	`GetScrollProgress` / `SetScrollProgress`	Position along the scrolling axis, 0 to 1. Authored in; mirror of the behaviour's out, so a `.dui` binding and the designer can both see it.
`FaceNode`	`TObjectPtr<UDreamWidget>`	Scroll Box	-	read only
`ViewportNode`	`TObjectPtr<UDreamWidget>`	Scroll Box	-	read only
`ContentNode`	`TObjectPtr<UDreamWidget>`	Scroll Box	-	read only
`ScrollBarNode`	`TObjectPtr<UDreamScrollBar>`	Scroll Box	-	read only
`ScrollView`	`TObjectPtr<UUIScrollView>`	Scroll Box	-	read only
`ContentStack`	`TObjectPtr<UDreamLayoutContainerStackBox>`	Scroll Box	-	read only

Functions

Function	Kind	Description
`bool AddContent(UDreamWidget* InWidget)`	callable	Put a widget in the content stack and re-measure.
`void EndInertialScrolling()`	callable	Drop the fling, keeping the position -- UMG's EndInertialScrolling.
`bool GetAllowOverscroll()`	pure	Get Allow Overscroll
`bool GetAllowRightClickDragScrolling()`	pure	Get Allow Right Click Drag Scrolling
`FKey GetAnalogMouseWheelKey()`	pure	Get Analog Mouse Wheel Key
`bool GetAnimateWheelScrolling()`	pure	The four scroll commands UMG's box offers, forwarded to the behaviour.
`bool GetBackPadScrolling()`	pure	Get Back Pad Scrolling
`EDreamScrollBoxConsumeMouseWheel GetConsumeMouseWheel()`	pure	Get Consume Mouse Wheel
`bool GetConsumePointerInput()`	pure	Get Consume Pointer Input
`UDreamWidget* GetContentNode()`	pure	Where things go. Parent into this, or use AddContent, and the stack piles them up in order.
`float GetDecelerateRate()`	pure	Get Decelerate Rate
`bool GetEnableTouchScrolling()`	pure	Get Enable Touch Scrolling
`bool GetFrontPadScrolling()`	pure	Get Front Pad Scrolling
`bool GetIsScrolling()`	pure	True while momentum, a spring-back or a glide (an animated reveal or wheel notch) still has the content moving.
`EDreamUIScrollDestination GetNavigationDestination()`	pure	Get Navigation Destination
`float GetNavigationScrollPadding()`	pure	Get Navigation Scroll Padding
`EDreamPanelOrientation GetOrientation()`	pure	Get Orientation
`float GetOverscrollOffset()`	pure	Signed distance past an end, in local units; zero in range and zero while overscroll is off.
`float GetOverscrollPercentage()`	pure	The same distance as a percentage of the window -- UMG's GetOverscrollPercentage.
`FMargin GetScrollbarPadding()`	pure	The margin around the bar. The same arrangement as the thickness: the style holds it.
`float GetScrollbarThickness()`	pure	The bar's thickness, in local units. A READER of the style rather than a second copy: the number lives in FDreamScrollBarStyle::Thickness, because it is what the bar is drawn from, and a control-level field beside it would be the same measurement written twice.
`EDreamScrollBoxScrollbarVisibility GetScrollBarVisibility()`	pure	Get Scroll Bar Visibility
`float GetScrollOffset()`	pure	How far the window has travelled from the content's start edge, in local units.
`float GetScrollOffsetOfEnd()`	pure	The offset at which the END of the content is in view: the whole scrollable extent.
`float GetScrollProgress()`	pure	Get Scroll Progress
`float GetScrollSensitivity()`	pure	Get Scroll Sensitivity
`UUIScrollView* GetScrollView()`	pure	The behaviour, for anything this control does not wrap -- ScrollTo, inertia, a second bar.
`EDreamUIScrollWhenFocusChanges GetScrollWhenFocusChanges()`	pure	Get Scroll when Focus Changes
`bool GetShowScrollBar()`	pure	Get Show Scroll Bar
`FDreamScrollBoxStyle GetStyle()`	pure	By value, not by reference: a UFUNCTION return has to be a value, and a style is a small struct.
`float GetViewFraction()`	pure	Fraction of the content currently visible, 0..1. One when everything fits.
`float GetViewOffsetFraction()`	pure	How far through the scrollable range the window sits, 0..1. Zero when nothing can scroll.
`float GetWheelScrollAnimationDuration()`	pure	Get Wheel Scroll Animation Duration
`float GetWheelScrollMultiplier()`	pure	Get Wheel Scroll Multiplier
`bool IsAlwaysShowScrollbar()`	pure	Whether the bar stays put with nothing to scroll -- UMG's AlwaysShowScrollbar.
`bool IsAlwaysShowScrollbarTrack()`	pure	Is Always Show Scrollbar Track
`void RefreshContentExtent()`	callable	Re-take the content's extent from the stack and tell the behaviour its range moved -- and, when that changed whether anything overflows, bring an auto-hiding bar out or put it away.
`void ScrollToEnd()`	callable	Scroll to End
`void ScrollToStart()`	callable	Scroll to Start
`bool ScrollWidgetIntoView(UDreamWidget* InWidget, bool bInAnimate, EDreamUIScrollDestination InDestination, float InPadding)`	callable	Scroll the least distance that brings InWidget fully into view; nothing when it already is.
`void SetAllowOverscroll(bool bInAllow)`	callable	Set Allow Overscroll
`void SetAllowRightClickDragScrolling(bool bInAllow)`	callable	Set Allow Right Click Drag Scrolling
`void SetAlwaysShowScrollbar(bool bInAlwaysShow)`	callable	Set Always Show Scrollbar
`void SetAlwaysShowScrollbarTrack(bool bInAlwaysShow)`	callable	Set Always Show Scrollbar Track
`void SetAnalogMouseWheelKey(FKey InKey)`	callable	Set Analog Mouse Wheel Key
`void SetAnimateWheelScrolling(bool bInAnimate)`	callable	Set Animate Wheel Scrolling
`void SetBackPadScrolling(bool bInPad)`	callable	Changes how far there is to go, so the range is re-stated and the bar re-measured.
`void SetConsumeMouseWheel(EDreamScrollBoxConsumeMouseWheel InConsume)`	callable	Set Consume Mouse Wheel
`void SetConsumePointerInput(bool bInConsume)`	callable	Set Consume Pointer Input
`void SetDecelerateRate(float InRate)`	callable	Set Decelerate Rate
`void SetEnableTouchScrolling(bool bInEnable)`	callable	Set Enable Touch Scrolling
`void SetFrontPadScrolling(bool bInPad)`	callable	Set Front Pad Scrolling
`void SetNavigationDestination(EDreamUIScrollDestination InDestination)`	callable	Set Navigation Destination
`void SetNavigationScrollPadding(float InPadding)`	callable	Set Navigation Scroll Padding
`void SetOrientation(EDreamPanelOrientation InOrientation)`	callable	Re-states the axis on the view, the stack and the bar, and re-cuts the gutter.
`void SetScrollbarPadding(FMargin InPadding)`	callable	Set Scrollbar Padding
`void SetScrollbarThickness(float InThickness)`	callable	Writes FDreamScrollBarStyle::Thickness and re-cuts the gutter, which is what it decides.
`void SetScrollBarVisibility(EDreamScrollBoxScrollbarVisibility InVisibility)`	callable	Set Scroll Bar Visibility
`void SetScrollOffset(float InOffset)`	callable	Clamped to how far there is to go. The absolute counterpart of SetScrollProgress.
`void SetScrollProgress(float InProgress)`	callable	Set Scroll Progress
`void SetScrollSensitivity(float InSensitivity)`	callable	Set Scroll Sensitivity
`void SetScrollWhenFocusChanges(EDreamUIScrollWhenFocusChanges InRule)`	callable	Set Scroll when Focus Changes
`void SetShowScrollBar(bool bInShowScrollBar)`	callable	Set Show Scroll Bar
`void SetStyle(FDreamScrollBoxStyle InStyle)`	callable	Replace the whole look and re-push it. The one road a Blueprint write has to take.
`void SetWheelScrollAnimationDuration(float InDuration)`	callable	Set Wheel Scroll Animation Duration
`void SetWheelScrollMultiplier(float InMultiplier)`	callable	Set Wheel Scroll Multiplier

Events

Event	Signature	Description
`OnScrolled`	`void DreamScrollBoxScrolledEvent__DelegateSignature(float Progress)`	Re-broadcast from the scroll behaviour, so a consumer binds to the control, not to a part of it.
`OnUserScrolled`	`void DreamScrollBoxUserScrolledOffsetEvent__DelegateSignature(float CurrentOffset)`	The USER moved it -- UMG's OnUserScrolled, and its unit, which is an OFFSET rather than a progress.
`OnScrollBarVisibilityChanged`	`void DreamScrollBoxBarVisibilityChangedEvent__DelegateSignature(bool bVisible)`	The bar appeared or went away -- UMG's OnScrollBarVisibilityChanged. Fired from the style push, which is the one place that decides, and only when the answer actually moved.
`OnFocusUpdated`	`void DreamScrollBoxFocusUpdatedEvent__DelegateSignature(UDreamWidget* FocusedWidget)`	Focus moved to something INSIDE the box -- UMG's OnFocusUpdated.
`OnValueChangedBP`	`void DreamScrollBoxScrolledEvent__DelegateSignature(float Progress)`	The `<->` convention: a two-way binding synthesizes its reverse route against this exact name. A scroll box's value is where it is scrolled to, so it carries one and fires it with OnScrolled.

Compared with UMG

Every Blueprint-facing member of the UMG class, and where it went. adopt: same name, same meaning. map: here under another name or on another type. reject: deliberately absent, with the reason.

UMG	Member	Status	Here	Note
`UScrollBox`	`ScrollAnimationInterpolationSpeed`	map	`WheelScrollAnimationDuration`	An eased scroll here glides over a fixed DURATION rather than interpolating at a fixed speed, so the knob is a duration. Same feel, different parameterisation; UDreamLayoutContainerScrollBox carries the speed-based form under UMG's name for the layout road.
`UScrollBox`	`bEnableTouchScrolling`	adopt	`bEnableTouchScrolling`	Pushed to UUIScrollView::bEnableTouchScrolling; the gate is the event system's current input device, because a finger and a mouse both arrive as pointer 0.
`UScrollBox`	`bConsumePointerInput`	adopt	`bConsumePointerInput`	One stored bit: UUIScrollView::AllowEventBubbleUp, asked the other way round. Get/SetConsumePointerInput on the behaviour is the inverse view of it.
`UScrollBox`	`AnalogMouseWheelKey`	adopt	`AnalogMouseWheelKey`	Invalid by default = whatever the input preset routes here (the right stick), which is today's behaviour. A named key narrows it; the preset only binds the right stick's two axes, so any other key needs a project binding.
`UScrollBox`	`bIsFocusable`	map	`UDreamWidget::bIsFocusable`	Already on the base of every widget; a second one on this control would shadow it (UHT error) and be a second answer.
`UScrollBox`	`WidgetStyle`	map	`Style`	FDreamScrollBoxStyle, resolved against the project style sheet. Get/SetStyle.
`UScrollBox`	`WidgetBarStyle`	map	`FDreamScrollBoxStyle::Bar`	The box's style carries the bar's whole style, so one edit dresses the box and its bar together.
`UScrollBox`	`Orientation`	map	`Orientation`	Same name and meaning; the type is EDreamPanelOrientation rather than TEnumAsByte<EOrientation>, which is this library's own two-value spelling.
`UScrollBox`	`ScrollBarVisibility`	map	`ScrollBarVisibility`	EDreamScrollBoxScrollbarVisibility (Permanent / AutoHide / Hidden) plus bShowScrollBar for 'no bar at all', instead of UMG's ESlateVisibility. This library has no Slate visibility enum. AutoHide follows the content: every re-measure (AddContent, RefreshContentExtent, a resize) asks again, so the bar comes out or goes away -- its gutter with it -- when the content starts or stops overflowing, as SScrollBar's does. Hidden never draws the bar and keeps its gutter while there is something to scroll, as a Hidden Slate bar keeps its slot; the box still scrolls by wheel, drag and code.
`UScrollBox`	`ConsumeMouseWheel`	adopt	`ConsumeMouseWheel`	EDreamScrollBoxConsumeMouseWheel, the same three answers; pushed to UUIScrollView.
`UScrollBox`	`ScrollbarThickness`	map	`FDreamScrollBarStyle::Thickness`	A reader/writer pair on the control (Get/SetScrollbarThickness), not a second field: the style is the one truth. A float, because a bar has one thickness across its own axis; UMG's FVector2D spells a second number nothing here uses.
`UScrollBox`	`ScrollbarPadding`	map	`FDreamScrollBarStyle::BarPadding`	New style field, default FMargin(0) = what every bar has drawn. Counted into the gutter, because the gutter is everything the viewport gives up for the bar.
`UScrollBox`	`AlwaysShowScrollbar`	map	`ScrollBarVisibility`	Permanent IS always-show, so IsAlwaysShowScrollbar / SetAlwaysShowScrollbar read and write that enum rather than a flag beside it.
`UScrollBox`	`AlwaysShowScrollbarTrack`	adopt	`bAlwaysShowScrollbarTrack`	Only the idle track's opacity, as in UMG (SScrollBar::GetTrackOpacity): with it an idle track is drawn at half its alpha, without it not at all, and hovered or dragged it is drawn whole either way; Permanent draws an idle one at half too. It keeps neither the bar nor its gutter while nothing scrolls -- only ScrollBarVisibility Permanent does.
`UScrollBox`	`AllowOverscroll`	adopt	`bAllowOverscroll`	Pushed to UUIScrollView::bAllowOverscroll, which gates the out-of-range damper rather than zeroing the author's number.
`UScrollBox`	`BackPadScrolling`	adopt	`bBackPadScrolling`	A whole window of leading space, as Slate spends (not the half window the plan sketched). Writable at runtime here; UMG's is construction-only.
`UScrollBox`	`FrontPadScrolling`	adopt	`bFrontPadScrolling`	A whole window of trailing space. Writable at runtime, unlike UMG's.
`UScrollBox`	`bAnimateWheelScrolling`	adopt	`bAnimateWheelScrolling`
`UScrollBox`	`NavigationDestination`	adopt	`NavigationDestination`	EDreamUIScrollDestination, now with BottomOrRight so all four of UMG's answers exist.
`UScrollBox`	`NavigationScrollPadding`	adopt	`NavigationScrollPadding`	Writable at runtime here; UMG's is construction-only.
`UScrollBox`	`ScrollWhenFocusChanges`	adopt	`ScrollWhenFocusChanges`	Default AnimatedScroll, not UMG's NoScroll: navigation here has always revealed its target, and NoScroll would stop every existing gamepad-driven list from following focus.
`UScrollBox`	`bAllowRightClickDragScrolling`	adopt	`bAllowRightClickDragScrolling`	Asked once at drag-begin, so a gesture that was refused stays refused for its whole length -- and a right drag is refused while there is nothing to scroll whatever this says, as SScrollBox takes one only while its bar IsNeeded. The drag scrolls from the press, the move that crossed the drag threshold included, as SScrollBox's does, so the content stays under the pointer that grabbed it. A right drag that starts on the box's own bar scrolls nothing: the bar answers the left button only (UDreamScrollBar::AcceptedMouseButtons, SScrollBar's rule) and the view that drags the content sits on the viewport beside the bar, so the gesture reaches neither -- where SScrollBox, which the unanswered press bubbles up to, would drag the content with it.
`UScrollBox`	`WheelScrollMultiplier`	adopt	`WheelScrollMultiplier`	Scales ScrollSensitivity, which is the DISTANCE one notch covers. Same name and meaning as the list controls'.
`UScrollBox`	`SetConsumeMouseWheel`	adopt	`SetConsumeMouseWheel`
`UScrollBox`	`SetOrientation`	adopt	`SetOrientation`
`UScrollBox`	`SetScrollBarVisibility`	adopt	`SetScrollBarVisibility`
`UScrollBox`	`SetScrollbarThickness`	adopt	`SetScrollbarThickness`	Takes a float; writes the style and switches StyleSource to Inline, so the next style push does not throw the number away.
`UScrollBox`	`SetScrollbarPadding`	adopt	`SetScrollbarPadding`
`UScrollBox`	`SetAlwaysShowScrollbar`	adopt	`SetAlwaysShowScrollbar`
`UScrollBox`	`SetAllowOverscroll`	adopt	`SetAllowOverscroll`
`UScrollBox`	`SetAnimateWheelScrolling`	adopt	`SetAnimateWheelScrolling`
`UScrollBox`	`SetScrollAnimationInterpolationSpeed`	map	`SetWheelScrollAnimationDuration`	See the property row: this library's eased scroll is duration-based.
`UScrollBox`	`SetWheelScrollMultiplier`	adopt	`SetWheelScrollMultiplier`
`UScrollBox`	`GetConsumePointerInput`	adopt	`GetConsumePointerInput`
`UScrollBox`	`SetConsumePointerInput`	adopt	`SetConsumePointerInput`
`UScrollBox`	`SetScrollWhenFocusChanges`	adopt	`SetScrollWhenFocusChanges`
`UScrollBox`	`SetNavigationDestination`	adopt	`SetNavigationDestination`
`UScrollBox`	`EndInertialScrolling`	adopt	`EndInertialScrolling`	Drops the fling and leaves any open rubber band to spring shut, which is not inertia.
`UScrollBox`	`GetAnalogMouseWheelKey`	adopt	`GetAnalogMouseWheelKey`
`UScrollBox`	`SetAnalogMouseWheelKey`	adopt	`SetAnalogMouseWheelKey`
`UScrollBox`	`GetIsFocusable`	map	`UDreamWidget::GetIsFocusable`	On the base, with the property.
`UScrollBox`	`SetIsFocusable`	map	`UDreamWidget::SetIsFocusable`	On the base, with the property.
`UScrollBox`	`OnUserScrolled`	adopt	`OnUserScrolled`	An offset, as UMG reports. Fires only for changes the player made: everything this control pushes itself is flagged at the moment of the push, which is the only place the two roads are distinguishable.
`UScrollBox`	`OnScrollBarVisibilityChanged`	adopt	`OnScrollBarVisibilityChanged`	A bool rather than an ESlateVisibility, which this library has none of. Fired from the style push, and only on a change.
`UScrollBox`	`OnFocusReceived`	adopt	`OnFocusReceived`	The event is the one every widget already has, UDreamWidget::OnFocusReceived (UserIndex, PointerId); what the box adds is the relay, since the event system focuses the FACE and not the control. A UUISelectable added to the FACE on demand and gated on the base's bIsFocusable, which is off by default -- so no existing box becomes a navigation candidate. The selectable is what the event system hands focus to and what already tells a resting pointer from focus, so its state IS received and lost; only the EDGE is announced, because that state is re-applied for repaints too.
`UScrollBox`	`OnFocusLost`	adopt	`OnFocusLost`	UDreamWidget::OnFocusLost, relayed from the face: the other edge of the same subscription, under the same gate.
`UScrollBox`	`OnFocusUpdated`	adopt	`OnFocusUpdated`	Focus moving INSIDE the box, carrying the widget that took it. Not gated on bIsFocusable -- the content is focusable whether or not the box is. Raised by the navigation reveal through UUIScrollView::NotifyContentFocusMoved: that walk is the one place that knows both which widget took focus and which scrolling ancestors contain it, and polling HasFocusedDescendants would be a tick for an edge.
`UScrollBox`	`SetScrollOffset`	adopt	`SetScrollOffset`
`UScrollBox`	`GetScrollOffset`	adopt	`GetScrollOffset`
`UScrollBox`	`GetOverscrollOffset`	adopt	`GetOverscrollOffset`	Signed: negative before the start, positive past the end, zero in range and zero while overscroll is off.
`UScrollBox`	`GetOverscrollPercentage`	adopt	`GetOverscrollPercentage`	Per cent of the window, as SScrollBox reports.
`UScrollBox`	`GetScrollOffsetOfEnd`	adopt	`GetScrollOffsetOfEnd`
`UScrollBox`	`GetViewFraction`	adopt	`GetViewFraction`
`UScrollBox`	`GetViewOffsetFraction`	adopt	`GetViewOffsetFraction`	The progress the behaviour already maintains; not a second division.
`UScrollBox`	`ScrollToStart`	adopt	`ScrollToStart`
`UScrollBox`	`ScrollToEnd`	adopt	`ScrollToEnd`
`UScrollBox`	`ScrollWidgetIntoView`	adopt	`ScrollWidgetIntoView`	All four parameters, with the destination and padding appended so the old two-argument call keeps its meaning: Configured and a negative padding both mean 'whatever this box is set up with'. The same signature on UUIScrollView and UDreamLayoutContainerScrollBox.
`UScrollBox`	`GetIsScrolling`	adopt	`GetIsScrolling`

Properties

Functions

Events

Compared with UMG

On this page