I had a request to do something similar for someone else and this is what I came up with.
Lua Code:
-- Config Constants
local Aura_Size=24;
local Aura_Spacing=4;
local Aura_ShortCols=4;-- Buffs per short row
local Aura_ShortRows=2;-- Number of shortened rows
local Aura_NormalCols=6;-- Buffs per remaining rows
-- Calculated Constants
local Aura_ShortPadCols=Aura_NormalCols-Aura_ShortCols;
local Aura_GridSize=Aura_Size+Aura_Spacing;
local ProcessAuraList; do
local AuraFrameMap={};
local BuffsOnTop,IsPrimaryAuraType,OtherTypeRowCount;-- Iterator Callback Parameters
local AuraIndex,FirstAuraFrame;-- Position Tracking
local LastRowAuraFrame,RowCount;-- "Returns"
local function ProcessAura(instanceid,aurainfo)
local auraframe=AuraFrameMap[instanceid];
if auraframe then
AuraIndex,FirstAuraFrame=(AuraIndex or 0)+1,FirstAuraFrame or auraframe;
if AuraIndex>1 then
local point,relframe,relpoint,offsetx,offsety=FirstAuraFrame:GetPoint(1);
local posindex=AuraIndex-1;
if not BuffsOnTop and (IsPrimaryAuraType or OtherTypeRowCount<Aura_ShortRows) then
-- Shorten rows by adding a calculated offset to index
posindex=posindex+math.min(math.floor(posindex/Aura_ShortCols),Aura_ShortRows-(IsPrimaryAuraType and 0 or OtherTypeRowCount))*Aura_ShortPadCols;
end
local x,y=posindex%Aura_NormalCols,math.floor(posindex/Aura_NormalCols);
auraframe:SetPoint(point,relframe,relpoint
,x*Aura_GridSize+offsetx
,(BuffsOnTop and 1 or -1)*y*Aura_GridSize+offsety
);
if x==0 then RowCount,LastRowAuraFrame=y+1,auraframe; end
else RowCount,LastRowAuraFrame=1,auraframe; end
auraframe:SetSize(Aura_Size,Aura_Size);
if auraframe.Border then auraframe.Border:SetSize(Aura_Size+2,Aura_Size+2); end
end
end
function ProcessAuraList(self,auralist,isprimary,othersize,template,container)
local numauras=auralist and auralist:Size() or 0;
if numauras>0 then
for auraframe in self.auraPools:GetPool(template):EnumerateActive() do
AuraFrameMap[auraframe.auraInstanceID]=auraframe;
end
AuraIndex,FirstAuraFrame=0,nil;
BuffsOnTop,IsPrimaryAuraType=self.buffsOnTop,isprimary or othersize<=0;
OtherTypeRowCount=IsPrimaryAuraType and 0
or math.floor(((othersize-1)+math.min(math.floor((othersize-1)/Aura_ShortCols),Aura_ShortRows)*Aura_ShortPadCols)/Aura_NormalCols)+1;
auralist:Iterate(ProcessAura);
local rowcount=RowCount or 0;-- Cache for now, we're wiping the upvalues during cleanup
if LastRowAuraFrame then
if not isprimary or othersize<=0 then self.spellbarAnchor=LastRowAuraFrame; end
container:SetPoint(select(3,LastRowAuraFrame:GetPoint(1)),LastRowAuraFrame,0,self.buffsOnTop and Aura_Spacing or -Aura_Spacing);
end
-- Cleanup
AuraIndex,FirstAuraFrame=nil,nil;
BuffsOnTop,IsPrimaryAuraType,OtherTypeRowCount=nil,nil,nil;
RowCount,LastRowAuraFrame=nil,nil;
table.wipe(AuraFrameMap);
-- Return number of rows
return rowcount;
else return 0; end
end
end
local function TargetFrame_UpdateAuras(self)
local containerparent=self.TargetFrameContent.TargetFrameContentContextual;
local numrows=0;
if UnitIsFriend("player",self.unit) then
numrows=numrows+ProcessAuraList(self,self.activeBuffs,true,self.activeDebuffs:Size(),"TargetBuffFrameTemplate",containerparent.buffs);
numrows=numrows+ProcessAuraList(self,self.activeDebuffs,false,self.activeBuffs:Size(),"TargetDebuffFrameTemplate",containerparent.debuffs);
else
numrows=numrows+ProcessAuraList(self,self.activeDebuffs,true,self.activeBuffs:Size(),"TargetDebuffFrameTemplate",containerparent.debuffs);
numrows=numrows+ProcessAuraList(self,self.activeBuffs,false,self.activeDebuffs:Size(),"TargetBuffFrameTemplate",containerparent.buffs);
end
self.auraRows=numrows;
if self.spellbar then self.spellbar:AdjustPosition(); end
end
hooksecurefunc(TargetFrame,"UpdateAuras",TargetFrame_UpdateAuras);
hooksecurefunc(FocusFrame,"UpdateAuras",TargetFrame_UpdateAuras);
Blizzard's code basically runs an accumulator that adds up the frame size for each individual buff icon in a row. Ones cast by the player are larger than others. When adding an icon would result in a longer row by pixel length than configured, it's pushed to a new row. The first two rows are configured to "dodge" the ToT frame by having a shorter defined width.
At its core, this example does a simple index-to-grid calculation since all the buff icons have a uniform size.
The ToT frame "dodging" is handled by padding the index at the end of the configured rows to skip to a new row. In the end, the first buff retains its anchor while the rest copy it and apply an offset according to the prior calculation.
Two other things that added complexity to this was mapping the buff buttons to their associated entry in the presorted aura lists and carrying over the shortened row rules between the buff/debuff groups.
Looking into how this works. As configured, the ToT frame dodging has the first 2 rows configured with a row count of 4 while the rest are configured for a length of 6. If the ToT frame isn't shown, all rows get the length of 6. If the ToT frame is shown, it takes the zero-based index position, integer divides by 4 (the configured length of the shortened rows), clamps the result by 2 (the configured number of shortened rows), multiplies that by the pad length (configured normal minus short row lengths; 6-4=2), and adds it back into the index position. From there, both routes go through modulo and integer divide operations to convert index to (X,Y) coordinate offsets.
Linear Mode
