raid container: compensate CENTER anchor for populated-row drift (#867)

Introduce DF:ComputeRaidContainerCompensation() which mirrors the secure
positioning snippet's populated-row math and returns an inverse offset to
shift the container by. UpdateRaidContainerPosition applies the offset
before SetPoint, so visible content's screen position stays put across
roster transitions when raidGroupAnchor == "CENTER".

Reference state is popRows=1, so existing user positions don't shift on
first load. Returns (0,0) for non-CENTER anchor, flat mode, or single-row
layouts — most users see no behaviour change.

Author: DanderBot

CHANGELOG.md

@@ -1,5 +1,11 @@
 # DandersFrames Changelog
 
+## [4.3.7] - 2026-05-02
+
+### Bug Fixes
+
+* (Raid Frames) Fix raid frames jumping upward when group composition changes with Groups Grow From set to Center. Previously the visible frames could shoot off the top of the screen each time a player joined a new group, requiring a Groups Grow From toggle to recover.
+
 ## [4.3.6] - 2026-04-30
 
 ### Improvements

Frames/Headers.lua

@@ -2191,6 +2191,111 @@ end
 -- Lua only sets attributes, secure code does all positioning
 -- ============================================================
 
+-- Compensation offset for the raid container's anchor when raidGroupAnchor == "CENTER".
+--
+-- The secure positioning snippet (below) centers the *visible* groups inside a
+-- fixed full-grid-sized container by offsetting each group by
+--     yStart = (totalHeight - populatedHeight) / 2
+-- Where totalHeight is the full 8-group grid capacity and populatedHeight grows
+-- with the number of populated rows. As popRows changes (player joins/leaves
+-- shifts a group across the groupsPerRow threshold), every visible group snaps
+-- by (deltaPopulatedDim / 2) inside the container. Container itself does not
+-- move — only the visible content. Users perceive this as the frames "jumping
+-- upward off the screen" (bug #867).
+--
+-- This helper returns the inverse offset so callers can shift the container by
+-- the same amount, keeping the visible content's screen position stable across
+-- roster transitions. The reference state is popRows=1 (one row populated) so
+-- existing user positions don't shift on first load: with one populated row,
+-- compensation is (0, 0) and the container sits exactly at db.raidAnchorX/Y
+-- — identical to current behaviour. As popRows grows beyond 1, compensation
+-- shifts the container away from the anchor by enough to cancel the snippet's
+-- upward visual snap.
+--
+-- Returns (dx, dy) to add to the container's anchor coordinates BEFORE the
+-- frameScale division. (0, 0) for any case the bug doesn't apply to:
+--   * raidGroupAnchor != "CENTER"
+--   * raidUseGroups == false (flat raid mode has its own positioning path)
+--   * No populated groups (nothing visible yet)
+--   * Single populated row (no drift)
+--   * Required handler / headers not yet created
+function DF:ComputeRaidContainerCompensation()
+    if not DF.raidPositionHandler then return 0, 0 end
+    if not DF.raidSeparatedHeaders then return 0, 0 end
+
+    local db = DF:GetRaidDB()
+    if not db then return 0, 0 end
+    if not db.raidUseGroups then return 0, 0 end
+    if (db.raidGroupAnchor or "START") ~= "CENTER" then return 0, 0 end
+
+    -- Mirror the snippet: a group is "populated" when its child count > 0.
+    -- Read counts from the same handler attributes the snippet reads, so the
+    -- compensation always agrees with the snippet's view of the world.
+    local handler = DF.raidPositionHandler
+    local numPopulated = 0
+    for i = 1, 8 do
+        local count = handler:GetAttribute("group" .. i .. "count") or 0
+        if count > 0 then numPopulated = numPopulated + 1 end
+    end
+    if numPopulated == 0 then return 0, 0 end
+
+    -- Mirror the snippet's totalHeight / populatedHeight calculation.
+    local groupsPerRow = db.raidGroupsPerRow or 8
+    if groupsPerRow < 1 then groupsPerRow = 1 end
+    if groupsPerRow > 8 then groupsPerRow = 8 end
+
+    local growDirection = db.growDirection or "HORIZONTAL"
+    local isHorizontal = (growDirection == "HORIZONTAL")
+    local frameWidth = db.frameWidth or 80
+    local frameHeight = db.frameHeight or 40
+    local spacing = db.frameSpacing or 2
+    local rowColSpacing = db.raidRowColSpacing or 30
+
+    local groupHeight, groupWidth
+    if isHorizontal then
+        groupWidth = frameWidth
+        groupHeight = 5 * frameHeight + 4 * spacing
+    else
+        groupWidth = 5 * frameWidth + 4 * spacing
+        groupHeight = frameHeight
+    end
+
+    -- popRows = ceil(numPopulated / groupsPerRow)
+    local popRem = numPopulated % groupsPerRow
+    local popRows = (numPopulated - popRem) / groupsPerRow
+    if popRem > 0 then popRows = popRows + 1 end
+
+    -- popRows == 1 is the reference state — compensation is zero there. Skip the
+    -- rest to avoid pointless arithmetic and to match existing behaviour exactly
+    -- when the bug doesn't apply.
+    if popRows <= 1 then return 0, 0 end
+
+    -- The drift dimension depends on growDirection: HORIZONTAL = vertical drift,
+    -- VERTICAL = horizontal drift. (Per the snippet's totalHeight/populatedHeight
+    -- vs totalWidth/populatedWidth selection at lines 2492-2498.)
+    local groupDim, populatedDim
+    if isHorizontal then
+        groupDim = groupHeight
+        populatedDim = popRows * groupHeight + (popRows - 1) * rowColSpacing
+    else
+        groupDim = groupWidth
+        populatedDim = popRows * groupWidth + (popRows - 1) * rowColSpacing
+    end
+
+    -- Compensation = (groupDim - populatedDim) / 2. This is yStart_now minus
+    -- yStart_at_popRows1, so popRows=1 yields zero (existing behaviour preserved)
+    -- and popRows>1 yields a negative offset that shifts the container in the
+    -- direction opposite to the snippet's content drift. Net visual: visible
+    -- content's TOP edge stays where popRows=1 layout placed it for every
+    -- larger populated count.
+    local compensation = (groupDim - populatedDim) / 2
+    if isHorizontal then
+        return 0, compensation
+    else
+        return compensation, 0
+    end
+end
+
 function DF:CreateRaidPositionHandler()
     if DF.raidPositionHandler then return end
     if not DF.raidContainer then return end

Frames/Position.lua

@@ -2145,24 +2145,42 @@ function DF:UpdateRaidContainerPosition()
     local x, y = db.raidAnchorX or 0, db.raidAnchorY or 0
     local scale = db.frameScale or 1.0
 
+    -- CENTER-anchor compensation: when raidGroupAnchor == "CENTER", the secure
+    -- positioning snippet shifts visible groups inside the container by
+    -- (totalHeight - populatedHeight) / 2 to centre the visible content. As
+    -- populated rows grow with the roster, that offset shrinks and visible
+    -- frames snap upward inside the container. We undo the visual snap by
+    -- shifting the container itself by the same magnitude. The user's saved
+    -- anchor (x, y) is preserved as the centroid of the visible content. (#867)
+    local dx, dy = 0, 0
+    if DF.ComputeRaidContainerCompensation then
+        dx, dy = DF:ComputeRaidContainerCompensation()
+    end
+    local cx, cy = x + dx, y + dy
+
     if DF.Debug then
-        DF:Debug("RAIDPOS", "UpdateRaidContainerPosition @ %s : applying (%.1f,%.1f) scale=%.3f combat=%s",
-            ShortCaller(3), x, y, scale, tostring(InCombatLockdown()))
+        if dx ~= 0 or dy ~= 0 then
+            DF:Debug("RAIDPOS", "UpdateRaidContainerPosition @ %s : applying (%.1f,%.1f) +comp(%.1f,%.1f) -> (%.1f,%.1f) scale=%.3f combat=%s",
+                ShortCaller(3), x, y, dx, dy, cx, cy, scale, tostring(InCombatLockdown()))
+        else
+            DF:Debug("RAIDPOS", "UpdateRaidContainerPosition @ %s : applying (%.1f,%.1f) scale=%.3f combat=%s",
+                ShortCaller(3), x, y, scale, tostring(InCombatLockdown()))
+        end
     end
 
     DF.raidContainer:SetScale(scale)
     DF.raidContainer:ClearAllPoints()
-    DF.raidContainer:SetPoint("CENTER", UIParent, "CENTER", x / scale, y / scale)
+    DF.raidContainer:SetPoint("CENTER", UIParent, "CENTER", cx / scale, cy / scale)
 
-    -- Also update mover if visible
-    -- Raid mover is parented to UIParent, needs explicit scale + compensation
+    -- Mover/test container do NOT get the compensation: the mover represents
+    -- the user's saved position (centroid), and the test container has no
+    -- secure snippet running so populated-row drift never happens there.
     if DF.raidMoverFrame and DF.raidMoverFrame:IsShown() then
         DF.raidMoverFrame:SetScale(scale)
         DF.raidMoverFrame:ClearAllPoints()
         DF.raidMoverFrame:SetPoint("CENTER", UIParent, "CENTER", x / scale, y / scale)
     end
 
-    -- Also update test container if visible
     if DF.testRaidContainer then
         DF.testRaidContainer:SetScale(scale)
         DF.testRaidContainer:ClearAllPoints()