SamandClaude Fable 5
b82cc3dd4f
- the loading screen now compiles every shader the world can reach: sky, water, spell shards and model variants stop hitching the first time they appear - a locked chest's cursor carries the LOCKED word like the real client, and the lock verdict never leaks into the sent packet - enchanting asks before it acts: a bind-on-enchant item gets its confirm popup, and so does replacing an enchant that's already there - a long gossip menu scrolls like the reference with rows grown to their wrapped text, and music already playing is not restarted when the server re-sends it Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
274 lines
16 KiB
XML
274 lines
16 KiB
XML
<Ui>
|
||
<!--
|
||
benilla's reusable scroll kits — TWO of them, sharing one scrollbar and one pair of arrow
|
||
helpers. The **faux-scroll** kit (this header) re-binds a fixed set of rows to a moving data
|
||
offset; the **real-scroll** kit (second half of the script block) pans and CLIPS a
|
||
variable-height child through the engine's `<ScrollFrame>` (decision 0112) — the one a gossip
|
||
menu of wrapped options needs, since its content height isn't known until it is laid out.
|
||
Only their OnValueChanged differs, and an instance overrides the template's (the loader
|
||
SetScripts every `<Scripts>` block in order, so the instance's handler wins).
|
||
|
||
The faux kit (decisions 0247/0250/0251): a draggable scroll bar over
|
||
the `Slider` primitive (0250) plus the fixed-row "faux scroll" Lua layer — the reference's
|
||
`FauxScrollFrame`, which never really scrolls a child: it re-binds a fixed set of row buttons to
|
||
a moving data offset. First customer: the class trainer's skill-line list (TrainerFrame.xml).
|
||
The quest log's chunk-local faux-scroll upvalue is a later migration onto this.
|
||
|
||
DESIGN — collapsed from the real client's three-part decomposition (0250: FauxScrollFrame =
|
||
ScrollFrame + Slider + Lua). The real `FauxScrollFrameTemplate` routes the scrollbar's value
|
||
through its parent `ScrollFrame` (`OnValueChanged → parent:SetVerticalScroll(v)`; the
|
||
ScrollFrame's `OnVerticalScroll` then derives `offset = floor(v/itemHeight + 0.5)`). That
|
||
ScrollFrame adds exactly one thing over the Slider: a *scroll-range clamp* on the value. We
|
||
don't need it — the offset comes straight off the Slider value here — and in benilla it would be
|
||
a liability: the clamp reads the scroll child's RESOLVED height, which lags a tick behind the
|
||
`SetHeight` the faux update does, so a content resize + scroll in one tick could clamp against a
|
||
stale range. So benilla's faux frame is a plain `<Frame>` + a `Slider`: fewer moving parts, no
|
||
dependency on within-tick resolved rects, and the identical on-screen result (a smooth,
|
||
pixel-granularity thumb whose position maps 1:1 to the scroll offset). See 0251 for the full
|
||
rationale + the divergence from 0250's described (real-client) shape.
|
||
|
||
VALUE MODEL. The scrollbar's value is in PIXELS: `[0, (numItems − numToDisplay) * itemHeight]`,
|
||
`valueStep = itemHeight`. The row offset is `floor(value / itemHeight + 0.5)` — sub-pixel
|
||
rounding, so the thumb (drawn at the raw value fraction) and the list (drawn at the rounded
|
||
offset) never visibly disagree. The frame carries `frame.offset` (the top visible row, 0-based)
|
||
and `frame.updateFunc` (the owner's list-repaint, set by the owner's OnLoad).
|
||
-->
|
||
<Script><![CDATA[
|
||
-- Step the bar one row (the slider's valueStep) — the sensible step for an item list (the
|
||
-- generic ref scrollbar steps half its height; a discrete row list wants one). Silent by
|
||
-- design: the ref plays UChatScrollButton only on the arrow *buttons'* OnClick, never on the
|
||
-- wheel (ScrollFrameTemplate_OnMouseWheel is soundless). Both the wheel and the arrows call
|
||
-- this, so the click lives on the arrow OnClick, keeping wheel-scroll silent.
|
||
function BenillaScrollBar_Step(scrollBar, dir)
|
||
local step = scrollBar:GetValueStep()
|
||
if step <= 0 then step = 1 end
|
||
scrollBar:SetValue(scrollBar:GetValue() + dir * step)
|
||
end
|
||
|
||
-- Grey the up arrow at the top and the down arrow at the bottom (ref
|
||
-- ScrollFrame_OnScrollRangeChanged's arrow handling), from the slider's own value/range.
|
||
function BenillaScrollBar_UpdateArrows(scrollBar)
|
||
local minV, maxV = scrollBar:GetMinMaxValues()
|
||
local val = scrollBar:GetValue()
|
||
local up = getglobal(scrollBar:GetName() .. "ScrollUpButton")
|
||
local down = getglobal(scrollBar:GetName() .. "ScrollDownButton")
|
||
if val <= minV then up:Disable() else up:Enable() end
|
||
if val >= maxV then down:Disable() else down:Enable() end
|
||
end
|
||
|
||
-- The scrollbar's OnValueChanged: derive the row offset from the (pixel) value and, only when
|
||
-- it actually moved, repaint the owner's list. The change-gate is load-bearing: the owner's
|
||
-- repaint calls _Update below, which SetValue()s the thumb back to offset*itemHeight — a value
|
||
-- that maps to the SAME offset, so this handler no-ops and the cycle stops after one hop (the
|
||
-- Slider's own SetValue change-gate stops the value side, decision 0250).
|
||
function BenillaFauxScrollBar_OnValueChanged(scrollBar, value)
|
||
local frame = scrollBar:GetParent()
|
||
local step = scrollBar:GetValueStep()
|
||
if step <= 0 then step = 1 end
|
||
local newOffset = floor(value / step + 0.5)
|
||
if newOffset ~= frame.offset then
|
||
frame.offset = newOffset
|
||
if frame.updateFunc then frame.updateFunc() end
|
||
end
|
||
BenillaScrollBar_UpdateArrows(scrollBar)
|
||
end
|
||
|
||
-- OnLoad: a fresh faux frame is at the top with an empty range (ref ScrollFrame_OnLoad).
|
||
function BenillaFauxScrollFrame_OnLoad(frame)
|
||
frame.offset = 0
|
||
local scrollBar = getglobal(frame:GetName() .. "ScrollBar")
|
||
scrollBar:SetMinMaxValues(0, 0)
|
||
scrollBar:SetValueStep(1)
|
||
scrollBar:SetValue(0)
|
||
end
|
||
|
||
-- The offset getters/setters the owner's list code reads (ref FauxScrollFrame_GetOffset /
|
||
-- _SetOffset). _SetOffset syncs the thumb too, so a programmatic reset (top-of-list on open)
|
||
-- moves the bar.
|
||
function BenillaFauxScrollFrame_GetOffset(frame)
|
||
return frame.offset or 0
|
||
end
|
||
|
||
function BenillaFauxScrollFrame_SetOffset(frame, offset)
|
||
frame.offset = offset
|
||
local scrollBar = getglobal(frame:GetName() .. "ScrollBar")
|
||
scrollBar:SetValue(offset * scrollBar:GetValueStep())
|
||
end
|
||
|
||
-- Reconcile the bar to a freshly-sized list (ref FauxScrollFrame_Update): clamp the offset into
|
||
-- range, set the pixel range + step, seat the thumb at the current offset, and show the bar only
|
||
-- when the list overflows the visible rows. Called by the owner's list-repaint each pass.
|
||
function BenillaFauxScrollFrame_Update(frame, numItems, numToDisplay, itemHeight)
|
||
local scrollBar = getglobal(frame:GetName() .. "ScrollBar")
|
||
local maxOffset = numItems - numToDisplay
|
||
if maxOffset < 0 then maxOffset = 0 end
|
||
if not frame.offset or frame.offset > maxOffset then frame.offset = maxOffset end
|
||
if frame.offset < 0 then frame.offset = 0 end
|
||
|
||
scrollBar:SetValueStep(itemHeight)
|
||
scrollBar:SetMinMaxValues(0, maxOffset * itemHeight)
|
||
scrollBar:SetValue(frame.offset * itemHeight)
|
||
BenillaScrollBar_UpdateArrows(scrollBar)
|
||
|
||
if numItems > numToDisplay then
|
||
scrollBar:Show()
|
||
else
|
||
scrollBar:Hide()
|
||
end
|
||
end
|
||
|
||
-- A wheel spin over the list → one row (WoW convention: +1 up, −1 down). Called from the
|
||
-- owner window's OnMouseWheel (the engine bubbles the spin up the parent chain, so the handler
|
||
-- lives on the window, not a child — TrainerFrame.xml's own note).
|
||
function BenillaFauxScrollFrame_OnMouseWheel(frame, delta)
|
||
local scrollBar = getglobal(frame:GetName() .. "ScrollBar")
|
||
BenillaScrollBar_Step(scrollBar, -delta)
|
||
end
|
||
|
||
-- ══════════════════════════ The REAL-scroll kit ══════════════════════════════════════════
|
||
--
|
||
-- The other half of the file: a true `<ScrollFrame>` (engine mechanism, decision 0112) that
|
||
-- pans and CLIPS a variable-height child, as against the faux kit above (fixed rows re-bound
|
||
-- to a data offset). Windows whose content height is unknown until it is laid out — a gossip
|
||
-- menu of wrapped options, a quest's body text — need this one; a uniform list wants the faux.
|
||
--
|
||
-- SHAPE, from the reference `UIPanelScrollFrameTemplate` (Interface\FrameXML\
|
||
-- UIPanelTemplates.xml l.166-211, extracted via mpqx): the scrollbar is a SLIDER that rides
|
||
-- its ScrollFrame as a child, so `bar:GetParent()` IS the frame it scrolls — no name
|
||
-- derivation, and `$parentBar` gives SyncBar its handle. The ref's OnVerticalScroll drives
|
||
-- the bar's value and greys the two arrows at the ends; ours does the same through the
|
||
-- shared arrow helper above.
|
||
BENILLA_SCROLL_STEP = 20 -- px per arrow click / wheel notch
|
||
BENILLA_SCROLL_PAD = 20 -- breathing room under the last element in the child
|
||
|
||
-- The bar moved (drag, arrow, or SyncBar): pan the frame it rides. The loop this could form
|
||
-- (bar → scroll → OnVerticalScroll → SyncBar → bar) dead-ends in one hop — SyncBar writes the
|
||
-- value the bar already holds, and the Slider's SetValue change-gate (decision 0250) drops it.
|
||
function BenillaScrollBar_OnValueChanged(bar, value)
|
||
bar:GetParent():SetVerticalScroll(value)
|
||
BenillaScrollBar_UpdateArrows(bar)
|
||
end
|
||
|
||
-- Reconcile a ScrollFrame's bar to its live range (ref ScrollFrame_OnScrollRangeChanged):
|
||
-- the bar spans [0, range] in pixels, seats at the current scroll, and hides entirely when
|
||
-- the content fits. Wired to both OnScrollRangeChanged and OnVerticalScroll by the owner.
|
||
function BenillaScroll_SyncBar(sf)
|
||
local bar = getglobal(sf:GetName() .. "Bar")
|
||
if not bar then return end
|
||
local range = sf:GetVerticalScrollRange()
|
||
bar:SetValueStep(BENILLA_SCROLL_STEP)
|
||
bar:SetMinMaxValues(0, range)
|
||
bar:SetValue(sf:GetVerticalScroll())
|
||
BenillaScrollBar_UpdateArrows(bar)
|
||
if range > 0 then bar:Show() else bar:Hide() end
|
||
end
|
||
|
||
-- Pan by `delta` px; the engine clamps to [0, range].
|
||
function BenillaScroll_Step(sf, delta)
|
||
sf:SetVerticalScroll(sf:GetVerticalScroll() + delta)
|
||
BenillaScroll_SyncBar(sf)
|
||
end
|
||
|
||
-- WoW wheel convention: +1 per notch up, -1 down — up lifts the content.
|
||
function BenillaScroll_OnMouseWheel(sf, delta)
|
||
BenillaScroll_Step(sf, -delta * BENILLA_SCROLL_STEP)
|
||
end
|
||
|
||
-- A widget's resolved bottom edge for the content sum — nil when it isn't contributing
|
||
-- (hidden frame / blank FontString / not yet resolved this frame).
|
||
function BenillaScroll_WidgetBottom(w)
|
||
if not w then return nil end
|
||
if w.IsShown then
|
||
if not w:IsShown() then return nil end
|
||
elseif w.GetText then
|
||
local t = w:GetText()
|
||
if not t or t == "" then return nil end
|
||
end
|
||
return w:GetBottom()
|
||
end
|
||
|
||
-- Size a scroll child to its MEASURED content — the resolved bottom of the lowest visible
|
||
-- widget, plus padding — instead of a fixed budget, and tell the frame (which fires
|
||
-- OnScrollRangeChanged → the owner's SyncBar). Frame-late by nature: rects resolve after Lua
|
||
-- runs, so owners re-run this from an OnUpdate until it stops changing. Returns true when it
|
||
-- actually resized (only a real change writes: SetHeight invalidates layout, and an
|
||
-- every-frame write would fight the resolver).
|
||
function BenillaScroll_ResizeChild(scrollName, widgets)
|
||
local sf = getglobal(scrollName)
|
||
local child = getglobal(scrollName .. "Child")
|
||
local top = child:GetTop()
|
||
if not top then return false end
|
||
local bottom = nil
|
||
for i = 1, table.getn(widgets) do
|
||
local b = BenillaScroll_WidgetBottom(getglobal(widgets[i]))
|
||
if b and (not bottom or b < bottom) then bottom = b end
|
||
end
|
||
local height = 1
|
||
if bottom then height = (top - bottom) + BENILLA_SCROLL_PAD end
|
||
if height < 1 then height = 1 end
|
||
if math.abs(child:GetHeight() - height) < 1 then return false end
|
||
child:SetHeight(height)
|
||
sf:UpdateScrollChildRect()
|
||
return true
|
||
end
|
||
]]></Script>
|
||
|
||
<!--
|
||
The scroll bar: a `Slider` (0250) 16px wide, its up/down step buttons pinned above/below the
|
||
track, and the knob thumb. The value is in pixels (see the header); the thumb draws at the
|
||
value fraction along the track (engine-side, decision 0250 §4), draggable (§5). The step-button
|
||
+ knob art is the stock 1.12 scrollbar kit, each texture cropped to its centred 16px (the
|
||
`0.25..0.75` TexCoords the ref's `UIPanelScrollBarButton` applies).
|
||
-->
|
||
<Slider name="BenillaScrollBarTemplate" virtual="true">
|
||
<Size><AbsDimension x="16" y="0"/></Size>
|
||
<Frames>
|
||
<Button name="$parentScrollUpButton">
|
||
<Size><AbsDimension x="16" y="16"/></Size>
|
||
<Anchors><Anchor point="BOTTOM" relativePoint="TOP"/></Anchors>
|
||
<NormalTexture file="Interface\Buttons\UI-ScrollBar-ScrollUpButton-Up"><TexCoords left="0.25" right="0.75" top="0.25" bottom="0.75"/></NormalTexture>
|
||
<PushedTexture file="Interface\Buttons\UI-ScrollBar-ScrollUpButton-Down"><TexCoords left="0.25" right="0.75" top="0.25" bottom="0.75"/></PushedTexture>
|
||
<DisabledTexture file="Interface\Buttons\UI-ScrollBar-ScrollUpButton-Disabled"><TexCoords left="0.25" right="0.75" top="0.25" bottom="0.75"/></DisabledTexture>
|
||
<HighlightTexture file="Interface\Buttons\UI-ScrollBar-ScrollUpButton-Highlight" alphaMode="ADD"><TexCoords left="0.25" right="0.75" top="0.25" bottom="0.75"/></HighlightTexture>
|
||
<Scripts><OnClick>BenillaScrollBar_Step(this:GetParent(), -1); PlaySound("UChatScrollButton")</OnClick></Scripts>
|
||
</Button>
|
||
<Button name="$parentScrollDownButton">
|
||
<Size><AbsDimension x="16" y="16"/></Size>
|
||
<Anchors><Anchor point="TOP" relativePoint="BOTTOM"/></Anchors>
|
||
<NormalTexture file="Interface\Buttons\UI-ScrollBar-ScrollDownButton-Up"><TexCoords left="0.25" right="0.75" top="0.25" bottom="0.75"/></NormalTexture>
|
||
<PushedTexture file="Interface\Buttons\UI-ScrollBar-ScrollDownButton-Down"><TexCoords left="0.25" right="0.75" top="0.25" bottom="0.75"/></PushedTexture>
|
||
<DisabledTexture file="Interface\Buttons\UI-ScrollBar-ScrollDownButton-Disabled"><TexCoords left="0.25" right="0.75" top="0.25" bottom="0.75"/></DisabledTexture>
|
||
<HighlightTexture file="Interface\Buttons\UI-ScrollBar-ScrollDownButton-Highlight" alphaMode="ADD"><TexCoords left="0.25" right="0.75" top="0.25" bottom="0.75"/></HighlightTexture>
|
||
<Scripts><OnClick>BenillaScrollBar_Step(this:GetParent(), 1); PlaySound("UChatScrollButton")</OnClick></Scripts>
|
||
</Button>
|
||
</Frames>
|
||
<Scripts>
|
||
<OnValueChanged>BenillaFauxScrollBar_OnValueChanged(self, arg1)</OnValueChanged>
|
||
</Scripts>
|
||
<ThumbTexture name="$parentThumbTexture" file="Interface\Buttons\UI-ScrollBar-Knob">
|
||
<Size><AbsDimension x="16" y="16"/></Size>
|
||
<TexCoords left="0.25" right="0.75" top="0.25" bottom="0.75"/>
|
||
</ThumbTexture>
|
||
</Slider>
|
||
|
||
<!--
|
||
The faux-scroll container: a plain `<Frame>` carrying the offset state + a right-hand scroll bar
|
||
(inset 16px top/bottom so the arrow buttons sit inside the track span — the ref
|
||
UIPanelScrollFrameTemplate's scrollbar anchors). An owner instantiates this and, in its own
|
||
OnLoad, sets `frame.updateFunc` to its list-repaint.
|
||
-->
|
||
<Frame name="BenillaFauxScrollFrameTemplate" virtual="true">
|
||
<Frames>
|
||
<Slider name="$parentScrollBar" inherits="BenillaScrollBarTemplate">
|
||
<Anchors>
|
||
<Anchor point="TOPLEFT" relativePoint="TOPRIGHT"><Offset><AbsDimension x="6" y="-16"/></Offset></Anchor>
|
||
<Anchor point="BOTTOMLEFT" relativePoint="BOTTOMRIGHT"><Offset><AbsDimension x="6" y="16"/></Offset></Anchor>
|
||
</Anchors>
|
||
</Slider>
|
||
</Frames>
|
||
<Scripts>
|
||
<OnLoad>BenillaFauxScrollFrame_OnLoad(self)</OnLoad>
|
||
</Scripts>
|
||
</Frame>
|
||
</Ui>
|