You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1019 lines
50 KiB
1019 lines
50 KiB
-- ------------------------------------------------------------------------- --
|
|
-- Project: Executive Assistant - To-Do/Task List Manager
|
|
-- Author: VincentSDSH
|
|
-- ------------------------------------------------------------------------- --
|
|
local AddonName = ...
|
|
local debug = ExecAssist.debug
|
|
local LibQTip = LibStub("LibQTip-1.0.7.3.5.3ExecAssistMod")
|
|
local L = LibStub("AceLocale-3.0"):GetLocale(AddonName)
|
|
local LSM = LibStub("LibSharedMedia-3.0")
|
|
local tooltipType -- this var intentionally left nil
|
|
local EXECASSIST_TOOLTIP = AddonName.."_Tooltip"
|
|
local ttData_idx = {["TW"] = {["player"] = {}}, ["char"] = {["player"] = {}}, ["GTP"] = {}}
|
|
-- contains session-persistent collapse booleans and group-sibling data NB: char lack context in GTP (tooltip display data index)
|
|
|
|
-- helper --
|
|
function ExecAssist:pushCollapseMap()
|
|
local char = self.db.char
|
|
if self.db.global.Options.SaveCollapseMap then
|
|
if char.map.char then ttData_idx["char"][self.userCurrent] = char.map["char"] end
|
|
if char.map.TW then ttData_idx["TW"][self.userCurrent] = char.map["TW"] end
|
|
if char.map.GTP then ttData_idx["GTP"] = char.map["GTP"] end
|
|
|
|
--[[ -- Pulled this back to :GarbageCollection()
|
|
-- prune out garbage collected since last login
|
|
local aggStem, hIdx = self.db.global.groupStem.agg
|
|
local function executeHeretics(hIdx)
|
|
if hIdx then
|
|
for handle, data in pairs(hIdx) do -- note: __garden (!="garden") is nuked but it only contains a sibMap which is nuked/regened in the dataBuilder
|
|
if not aggStem[handle] then hIdx[handle] = nil end
|
|
end
|
|
end
|
|
end
|
|
|
|
if ttData_idx.TW[self.userCurrent] then hIdx = ttData_idx.TW[self.userCurrent].PGT; executeHeretics(hIdx) end -- TW
|
|
if ttData_idx.char[self.userCurrent] then hIdx = ttData_idx.char[self.userCurrent].PGT; executeHeretics(hIdx); end -- char-PGT
|
|
hIdx = ttData_idx["GTP"]; if hIdx then executeHeretics(hIdx) end -- GTP
|
|
--]]
|
|
else
|
|
if char.map then char.map = {["char"] = nil, ["TW"] = nil, ["GTP"] = nil} end -- cleanup
|
|
end
|
|
end
|
|
|
|
function ExecAssist:getCheckedState(charName, taskID) -- Task
|
|
local sdbg = ExecAssist.db.global
|
|
|
|
if sdbg.groupStem.agg[taskID].isAcctWide then
|
|
local AWagg = sdbg.acctwideStem.agg
|
|
if AWagg[taskID] and AWagg[taskID].checked then
|
|
return true
|
|
else
|
|
return false
|
|
end
|
|
else
|
|
local charStem = sdbg.charStem[charName]
|
|
if not charStem.agg then return false end -- no agg = nothing checked
|
|
if charStem.agg[taskID] and charStem.agg[taskID].checked then
|
|
return true
|
|
else
|
|
return false
|
|
end
|
|
end
|
|
end
|
|
function ExecAssist:getSnowflake()
|
|
local idxTT, hGroup = ttData_idx.TW[ExecAssist.userCurrent]["PGT"]
|
|
if idxTT.isSpecialSnowflake then
|
|
hGroup = self.db.global.groupStem.agg[ idxTT.isSpecialSnowflake ]
|
|
if not hGroup then idxTT.isSpecialSnowflake = nil end
|
|
end
|
|
return hGroup and hGroup.listName or nil
|
|
end
|
|
function ExecAssist:snowflake_putOld(listType)
|
|
local idxTT = ttData_idx[listType][ExecAssist.userCurrent]["PGT"]
|
|
if idxTT.isSpecialSnowflake and not idxTT.oldSnowflakeState then
|
|
idxTT.oldSnowflakeState = {idxTT[idxTT.isSpecialSnowflake].isCollapsed} -- kludge to get around the pairs() throwing up over a boolean
|
|
idxTT[idxTT.isSpecialSnowflake].isCollapsed = false
|
|
end
|
|
end
|
|
function ExecAssist:snowflake_getOld(listType)
|
|
local idxTT = ttData_idx[listType][ExecAssist.userCurrent]["PGT"]
|
|
if idxTT.oldSnowflakeState and idxTT.isSpecialSnowflake and idxTT[idxTT.isSpecialSnowflake] then
|
|
idxTT[idxTT.isSpecialSnowflake].isCollapsed = idxTT.oldSnowflakeState[1] -- kludge to get around the pairs() throwing up over a boolean
|
|
idxTT.oldSnowflakeState = nil
|
|
end
|
|
end
|
|
|
|
function ExecAssist:ID_isActive(user, elementID)
|
|
-- This really needs to be improved/streamlined
|
|
-- -- maybe check datatype() of elementID in getBehavior_() so h_eleID can be direct passed
|
|
local h_eleID = ExecAssist.db.global.groupStem.agg[elementID]
|
|
|
|
local x = ExecAssist:getBehavior_isEnabled_OverrideOrDefault(user, elementID)
|
|
local y = (not h_eleID.hideDays[date("*t").wday])
|
|
local z = h_eleID.resetType ~= L.optsTable_base.TaskTypes["Reminder"].name -- L.optsTable_base.ResetTypes[6]
|
|
return x and y and z
|
|
end
|
|
|
|
-- gene checker --
|
|
local function geneChecker(user, groupID)
|
|
local rc
|
|
local hGroup = ExecAssist.db.global.groupStem.agg[groupID]
|
|
|
|
if ExecAssist:ID_isActive(user, hGroup.id) then
|
|
if not (hGroup.p == "garden") then
|
|
rc = geneChecker(user, hGroup.p)
|
|
else
|
|
rc = true -- clean for char name all the way to the garden
|
|
end
|
|
else
|
|
rc = false -- group is disabled for char name
|
|
end
|
|
return rc
|
|
end
|
|
function ExecAssist:hasCleanGenes(user, taskID)
|
|
local rc
|
|
if ExecAssist:ID_isActive(user, taskID) then -- query task itself; only check lineage if active
|
|
rc = geneChecker(user, self.db.global.groupStem.agg[taskID].p)
|
|
else
|
|
rc = false -- task itself not active
|
|
end
|
|
return rc
|
|
end
|
|
|
|
-- toggles --
|
|
function ExecAssist:toggleTask(mouseButton, taskID, isCurrentUser, charName, source)
|
|
local function audioTask(isChecked)
|
|
if isChecked then PlaySound(SOUNDKIT.IG_MAINMENU_OPTION_CHECKBOX_ON)
|
|
else PlaySound(SOUNDKIT.IG_MAINMENU_OPTION_CHECKBOX_OFF)
|
|
end
|
|
end
|
|
|
|
local sdbg = self.db.global
|
|
local hTask_cS, hTask
|
|
if mouseButton == "LeftButton" then
|
|
if sdbg.groupStem.agg[taskID].isAcctWide then
|
|
local AWagg = sdbg.acctwideStem.agg
|
|
if not AWagg[taskID] then
|
|
AWagg[taskID] = {["checked"] = true}
|
|
else
|
|
AWagg[taskID].checked = not AWagg[taskID].checked
|
|
end
|
|
hTask_cS = AWagg[taskID]
|
|
audioTask(hTask_cS.checked)
|
|
else
|
|
if not isCurrentUser and not IsShiftKeyDown() then
|
|
ExecAssist:alert(L.alert_cannotToggleTask)
|
|
else
|
|
local charStem = sdbg.charStem[charName]
|
|
if not charStem.agg[taskID] then
|
|
charStem.agg[taskID] = {["checked"] = true}
|
|
hTask_cS = charStem.agg[taskID]
|
|
else
|
|
hTask_cS = charStem.agg[taskID]
|
|
hTask_cS.checked = not hTask_cS.checked
|
|
end
|
|
|
|
audioTask(hTask_cS.checked)
|
|
end
|
|
end
|
|
else
|
|
if sdbg[source].rightMouse_togglesShowChecked then sdbg[source].showChecked = not sdbg[source].showChecked end
|
|
end
|
|
|
|
-- module click handler call
|
|
hTask = sdbg.groupStem.agg[taskID]
|
|
if hTask.extCreate and self.loadedModules[hTask.extCreate] then
|
|
-- if using an external module and the module is loaded, call the clickhandler
|
|
self:GetModule(hTask.extCreate):intern_clickHandler(hTask, hTask_cS and hTask_cS.checked or nil, mouseButton)
|
|
end
|
|
--? Nil return
|
|
return hTask_cS
|
|
end
|
|
local function toggleTask(tbl, _, mouseButton) -- wrapper for self:toggleTask() to handle tooltip specific jiggery-pokery
|
|
local args = tbl._OnMouseUp_arg
|
|
local taskID = args.taskID
|
|
local sdbg = ExecAssist.db.global
|
|
local hTask_cS = ExecAssist:toggleTask(mouseButton, args.taskID, args.isCurrentUser, args.charName, args.source)
|
|
|
|
if mouseButton == "LeftButton" then
|
|
if hTask_cS then -- something modified, update Tooltip
|
|
if sdbg.tooltip.useCounts_onHeaders then
|
|
-- refresh the tooltip; trying to retrofit the counts just isn't in the cards
|
|
ExecAssist:displayTooltip(args.anchorFrame)
|
|
else -- just update the task entry directly
|
|
ExecAssist.tooltip:SetCell(args.row, args.col, hTask_cS.checked and ExecAssist:mkLink(ExecAssist.icons.ldb_Complete, 16) or ExecAssist:mkLink(ExecAssist.icons.ldb_Incomplete, 16), nil, "LEFT")
|
|
ExecAssist.tooltip:UpdateScrolling()
|
|
end
|
|
end
|
|
else
|
|
if sdbg.tooltip.rightMouse_togglesShowChecked then ExecAssist:displayTooltip(args.anchorFrame) end
|
|
end
|
|
if ExecAssist.taskWindow then ExecAssist:UpdateWindow() end -- TT and TW may have different layouts so both need to rebuild their maps
|
|
end
|
|
|
|
function ExecAssist:toggleCollapse(mouseButton, key, idxTT_key, charName )
|
|
local idxTT
|
|
if idxTT_key == "PGT" then idxTT = ttData_idx.char[charName]["PGT"]
|
|
elseif idxTT_key == "TW" then idxTT = ttData_idx.TW[charName]["PGT"]
|
|
else idxTT = ttData_idx[idxTT_key]
|
|
end
|
|
|
|
if mouseButton == "LeftButton" then
|
|
if IsControlKeyDown() then
|
|
-- swap or unset cmdline target
|
|
self:reset_CmdLineTarget(self.db.global.groupStem.agg[key])
|
|
|
|
else
|
|
-- toggle Collapse State
|
|
idxTT[key].isCollapsed = not idxTT[key].isCollapsed -- toggle
|
|
|
|
if IsShiftKeyDown() then
|
|
-- All Siblings should match
|
|
local siblings = idxTT[idxTT[key].p].sibMap
|
|
for i=1,#siblings do
|
|
idxTT[siblings[i]].isCollapsed = idxTT[key].isCollapsed
|
|
end
|
|
end
|
|
end
|
|
else -- Zoom Group
|
|
if self.userCurrent == charName then
|
|
idxTT.isSpecialSnowflake = (idxTT.isSpecialSnowflake ~= key) and key or nil -- store the groupID, update it, or remove it.
|
|
else
|
|
self:alert(L.ZoomIsLoggedInCharOnly:format( self.userCurrent:cf("EAtan")))
|
|
end
|
|
end
|
|
|
|
if self.db.global.Options.SaveCollapseMap then
|
|
if idxTT_key == "PGT" then self.db.char.map["char"] = ttData_idx["char"][self.userCurrent]
|
|
elseif idxTT_key == "TW" then self.db.char.map["TW"] = ttData_idx["TW"][self.userCurrent]
|
|
else self.db.char.map["GTP"] = ttData_idx["GTP"]
|
|
end
|
|
end
|
|
|
|
end
|
|
local function toggleCollapse(tbl, _, mouseButton) -- wrapper for self:toggleCollapse() to handle tooltip specific jiggery-pokery
|
|
local args = tbl._OnMouseUp_arg
|
|
ExecAssist:toggleCollapse(mouseButton, args.key, args.idxTT_key, args.charName )
|
|
if mouseButton == "LeftButton" and IsControlKeyDown() and ExecAssist.db.char.useTaskWindow then ExecAssist:UpdateWindow() end
|
|
ExecAssist:displayTooltip(args.anchorFrame)
|
|
end
|
|
|
|
-- special flags --
|
|
function ExecAssist:isCharIgnored(charName, charStem)
|
|
-- self.db.global.charStem[ >>charname<<].ignoreChar
|
|
-- NB: Why, if foreshortened (e.g., charStem[charName]) not just check the charStem[charName].ignore in situ?
|
|
-- Design choice to favor encapsulation over absolute efficiency (for maintenance and refactor benefits)
|
|
if not charStem or not charStem.agg then -- if not supplied or not a foreshortened call (e.g., charStem[charName])
|
|
charStem = self.db.global.charStem
|
|
return charStem[charName].ignoreChar
|
|
else -- return the tag
|
|
return charStem.ignoreChar
|
|
end
|
|
end
|
|
function ExecAssist:processIgnoredCharacters()
|
|
-- reference: sdbg.charStem[self.userConfigDisplay].ignoreChar
|
|
-- self.db.global.charStem[>>charname<<].ignoreChar
|
|
local sdbg = self.db.global
|
|
local charStem, garden = sdbg.charStem, sdbg.groupStem.agg["garden"].DO
|
|
|
|
for char, stem in pairs(charStem) do
|
|
if stem.ignoreChar then
|
|
debug("ignored", char)
|
|
|
|
local charAgg = charStem[char].agg
|
|
|
|
for i=1,#garden do
|
|
local groupID = garden[i]
|
|
debug(groupID, "groupID")
|
|
|
|
if charAgg[groupID] then charAgg[ groupID ].userOverride = 3 -- stub already in place
|
|
else charAgg[groupID] = {["userOverride"] = 3 } -- need to create new stub
|
|
end
|
|
|
|
end
|
|
end
|
|
end
|
|
|
|
|
|
end
|
|
|
|
-- local libQtip funcs
|
|
local function addSeparator(tooltip) return tooltip:AddSeparator(2, .1, .9, .9, .9) end
|
|
local function addHSeparator(tooltip) return tooltip:AddSeparator(2, 1, 1, 0, .9) end
|
|
|
|
-- tooltip driver
|
|
function ExecAssist:displayTooltip(anchorFrame)
|
|
if not ExecAssist.h_meatPopcicle and not self.db.char.useDataBrokerTooltip then return end -- LDB tooltip table is not dynamic if user changes modes mid-session
|
|
-- h_mP only set by OnClick not OnEnter so 'not clickmapped and not enabled = return'
|
|
|
|
local groupStem, charStem, tooltipStem = ExecAssist.db.global.groupStem, ExecAssist.db.global.charStem[ExecAssist.userCurrent], ExecAssist.db.global.tooltip
|
|
local tooltip = ExecAssist.tooltip
|
|
local row
|
|
if not LibQTip:IsAcquired(EXECASSIST_TOOLTIP) or not tooltip then -- Build Tooltip Base --
|
|
ExecAssist.tooltip = LibQTip:Acquire(EXECASSIST_TOOLTIP)
|
|
ExecAssist.tooltip.OnRelease = function() ExecAssist.tooltip = nil; ExecAssist.h_meatPopcicle = nil end -- bit of cleanup
|
|
tooltip = ExecAssist.tooltip
|
|
|
|
tooltip:Clear()
|
|
tooltip:SetCellMarginH(0)
|
|
tooltip:SetCellMarginV(0)
|
|
tooltip:EnableMouse(true)
|
|
|
|
local hf, sf = CreateFont("headerFont"), CreateFont("standardFont")
|
|
hf:SetFont(LSM:Fetch("font", tooltipStem.header_font), tooltipStem.header_size, "") -- hf:SetFont(LSM:Fetch("font", "Friz Quadrata TT"), 12, "")
|
|
sf:SetFont(LSM:Fetch("font", tooltipStem.standard_font), tooltipStem.standard_size, "") -- sf:SetFont(LSM:Fetch("font", "Friz Quadrata TT"), 10, "")
|
|
|
|
hf:SetShadowColor(tooltipStem.fontshadow.shadowcolor.r, tooltipStem.fontshadow.shadowcolor.g, tooltipStem.fontshadow.shadowcolor.b, tooltipStem.fontshadow.shadowcolor.a);
|
|
hf:SetShadowOffset(tooltipStem.fontshadow.offset.x, tooltipStem.fontshadow.offset.y)
|
|
sf:SetShadowColor(tooltipStem.fontshadow.shadowcolor.r, tooltipStem.fontshadow.shadowcolor.g, tooltipStem.fontshadow.shadowcolor.b, tooltipStem.fontshadow.shadowcolor.a);
|
|
sf:SetShadowOffset(tooltipStem.fontshadow.offset.x, tooltipStem.fontshadow.offset.y)
|
|
|
|
tooltip:SetHeaderFont(hf)
|
|
tooltip:SetFont(sf)
|
|
|
|
tooltip.specialSnowflake_font = CreateFont("specialSnowflake_font")
|
|
tooltip.specialSnowflake_font:SetFont(LSM:Fetch("font", tooltipStem.snowflake_font), tooltipStem.snowflake_size, "")
|
|
|
|
tooltip:SetScale(1)
|
|
if not tooltipStem.useMouseoverHighlight then tooltip:SetHighlightTexture(nil) end
|
|
if tooltipStem.tooltipStyle.useStyle then
|
|
local ttbgcolor = tooltipStem.tooltipStyle.bgcolor
|
|
tooltip:SetBackdropColor(ttbgcolor.r, ttbgcolor.g, ttbgcolor.b, ttbgcolor.a)
|
|
end
|
|
|
|
tooltip:SetAutoHideDelay( self.db.global.tooltip.AutoHideDelay or .01, anchorFrame )
|
|
end
|
|
|
|
tooltip:Clear()
|
|
|
|
-- -------------------------------------------------------------------------------------------------------------- --
|
|
if tooltipType == nil then tooltipType = tooltipStem.default_tooltipType end
|
|
local data, maxCols = self:fetchData(tooltipType)
|
|
tooltip:SetColumnLayout(maxCols)
|
|
|
|
local function tooltiptip_OnLeave() if not tooltipStem.enableTooltipTooltips then return end; ExecAssist.tooltipQ:Release("ExecAssist_TooltipTooltip"); ExecAssist.tooltipQ=nil end
|
|
local function tooltiptip_OnEnter(tbl)
|
|
if not tooltipStem.enableTooltipTooltips then return end -- done this way so that the toggle will work realtime
|
|
local args = tbl._OnEnter_arg
|
|
if not ExecAssist.tooltipQ then
|
|
ExecAssist.tooltipQ = LibQTip:Acquire("ExecAssist_TooltipTooltip")
|
|
end
|
|
tooltip = ExecAssist.tooltipQ
|
|
tooltip:Clear()
|
|
tooltip:SetCellMarginH(0); tooltip:SetCellMarginV(0)
|
|
local tf = CreateFont("tiptipFont"); tf:SetFont(LSM:Fetch("font", tooltipStem.header_font), tooltipStem.header_size, ""); tooltip:SetFont(tf)
|
|
|
|
tooltip:SetScale(1)
|
|
tooltip:SetBackdropColor(0, 0, 0, 1)
|
|
tooltip:SetAutoHideDelay(.25, ExecAssist.tooltip )
|
|
tooltip:SmartAnchorTo(ExecAssist.tooltip)
|
|
|
|
tooltip:SetColumnLayout(1)
|
|
tooltip:AddLine()
|
|
|
|
local tip = {
|
|
["PGT"] = L.tt_tt_PGT,
|
|
["GTP"] = L.tt_tt_GTP,
|
|
["1"] = (L.tt_tt_1):format( (L.leftMouse_shift):cf("cyan"), (L.leftMouse):cf("cyan"), (L.rightMouse):cf("cyan") ),
|
|
["2"] = (L.tt_tt_2):format( (L.leftMouse_shift):cf("cyan"), (L.leftMouse):cf("cyan"), (L.rightMouse):cf("cyan") ),
|
|
["3"] = (L.tt_tt_3):format( (L.leftMouse_shift):cf("cyan"), (L.leftMouse):cf("cyan"), (L.rightMouse):cf("cyan") ),
|
|
["4"] = (L.tt_tt_4):format( (L.leftMouse_shift):cf("cyan"), (L.leftMouse):cf("cyan"), (L.rightMouse):cf("cyan") ),
|
|
["occ"] = L.tt_tt_occ,
|
|
["ac"] = L.tt_tt_ac,
|
|
["s1"] = (L.tt_tt_s1):format((L.tt_tt_s1_g):cf("sunshine"), (L.rightMouse):cf("cyan"), (L.ctrl_leftMouse):cf("cyan"), (L.leftMouse_shift):cf("cyan"), (L.tt_tt_s1_ts):cf("sunshine"), (L.rightMouse):cf("cyan"), (L.tt_tt_s1f):cf("grass")),
|
|
}
|
|
|
|
local p = {
|
|
["b1"] = tooltipType ,
|
|
["b2"] = tostring(ExecAssist["mode_" .. args.tooltipType]) ,
|
|
["b3"] = tooltipStem.OnlyCurrentChar and "occ" or "ac",
|
|
["s1"] = "s1"
|
|
}
|
|
|
|
tooltip:SetCell(1, 1, tip[p[args.b]])
|
|
tooltip:UpdateScrolling()
|
|
tooltip:Show()
|
|
|
|
end
|
|
|
|
local function displayTooltipButtons() -- Tooltip Button local func
|
|
--==[ Last Row ]==-- -------------------------------------------------------------------------------------------- --
|
|
row = tooltip:AddHeader()
|
|
-- List Display Type
|
|
local function quickToggle_whoIsInChargeHere(tbl)
|
|
if tooltipType == "PGT" then tooltipType = "GTP"
|
|
else tooltipType = "PGT"
|
|
end
|
|
PlaySound(SOUNDKIT.IG_QUEST_LIST_OPEN); ExecAssist:displayTooltip(tbl._OnMouseUp_arg.anchorFrame)
|
|
end
|
|
|
|
tooltip:SetCell(row, 1, tooltipType=="PGT" and self:mkLink(self.icons.ldb_tt_PGT, 16) or self:mkLink(self.icons.ldb_tt_GTP, 16))
|
|
tooltip:SetCellScript(row, 1, "OnMouseUp", quickToggle_whoIsInChargeHere, {["anchorFrame"] = anchorFrame})
|
|
tooltip:SetCellScript(row, 1, "OnEnter", tooltiptip_OnEnter, {["b"] = "b1", ["tooltipType"] = tooltipType})
|
|
tooltip:SetCellScript(row, 1, "OnLeave", tooltiptip_OnLeave)
|
|
|
|
-- Show / Hide / Show All / Show Only Selected Groups -- advance to the next 'used' option; nb: if non are selected, the default overrides the de-selected child
|
|
local function quickToggle_neverWriteFunctionNamesAtFourThirtyAM_theyGetSilly(tbl, _, mouseButton) -- NB: tbl is passed but we don't pass anything to use
|
|
local mode = ExecAssist["mode_" .. tooltipType];
|
|
local start = mode;
|
|
|
|
if mouseButton == "LeftButton" then
|
|
PlaySound(SOUNDKIT.IG_MAINMENU_OPTION_CHECKBOX_ON)
|
|
repeat mode=mode+1; if mode>4 then mode=1 end until ( tooltipStem[ExecAssist.modePool[mode].b .. "_" .. tooltipType ] and ExecAssist.modePool[mode][tooltipType] ) or mode==start;
|
|
else
|
|
PlaySound(SOUNDKIT.IG_MAINMENU_OPTION_CHECKBOX_OFF)
|
|
repeat mode=mode-1; if mode<1 then mode=4 end until ( tooltipStem[ExecAssist.modePool[mode].b] and ExecAssist.modePool[mode][tooltipType] ) or mode==start;
|
|
end
|
|
ExecAssist["mode_" .. tooltipType] = mode
|
|
|
|
if tooltipType=="PGT" then
|
|
if start ~= 3 and mode == 3 then self:snowflake_putOld("char") -- store the state of snowflake used by other modes
|
|
elseif start == 3 and mode ~= 3 then self:snowflake_getOld("char") -- restore the other-display-mode collapsed state
|
|
end
|
|
end
|
|
|
|
ExecAssist:displayTooltip(tbl._OnMouseUp_arg.anchorFrame)
|
|
end
|
|
tooltip:SetCell(row, 2, ExecAssist.modePool[ExecAssist["mode_" .. tooltipType]].i)
|
|
|
|
tooltip:SetCellScript(row, 2, "OnMouseUp", quickToggle_neverWriteFunctionNamesAtFourThirtyAM_theyGetSilly, {["anchorFrame"] = anchorFrame})
|
|
tooltip:SetCellScript(row, 2, "OnEnter", tooltiptip_OnEnter, {["b"] = "b2", ["tooltipType"] = tooltipType})
|
|
tooltip:SetCellScript(row, 2, "OnLeave", tooltiptip_OnLeave)
|
|
|
|
-- Show Special Snowflake Tag
|
|
if ExecAssist["mode_" .. tooltipType] ~= 4 and tooltipType=="PGT" then
|
|
tooltip:SetCell(row, 3, " ", "CENTER", (maxCols - 3))
|
|
tooltip:SetCellScript(row, 3, "OnEnter", tooltiptip_OnEnter, {["b"] = "s1", ["tooltipType"] = tooltipType})
|
|
tooltip:SetCellScript(row, 3, "OnLeave", tooltiptip_OnLeave)
|
|
|
|
local idxTT, hGroup = ttData_idx.char[ExecAssist.userCurrent]["PGT"]
|
|
if idxTT.isSpecialSnowflake then
|
|
hGroup = self.db.global.groupStem.agg[ idxTT.isSpecialSnowflake ]
|
|
|
|
if not hGroup then
|
|
idxTT.isSpecialSnowflake = nil
|
|
else
|
|
tooltip:SetCell(row, 3, hGroup.listName, tooltip.specialSnowflake_font, "CENTER", (maxCols - 3))
|
|
|
|
tooltip:SetCellTextColor(row, 3, tooltipStem.SM.snowflake.color.r, tooltipStem.SM.snowflake.color.g, tooltipStem.SM.snowflake.color.b, 1)
|
|
end
|
|
end
|
|
end
|
|
|
|
-- if PGT, toggle Only Show Current Character
|
|
local function quickToggle_Highlander(tbl) tooltipStem.OnlyCurrentChar = not tooltipStem.OnlyCurrentChar; ExecAssist:displayTooltip(tbl._OnMouseUp_arg.anchorFrame) end
|
|
if tooltipType == "PGT" and ExecAssist["mode_" .. tooltipType] ~= 3 then
|
|
tooltip:SetCell(row, maxCols, (tooltipStem.OnlyCurrentChar and self:mkLink(self.icons.ldb_OneChar, 16) or self:mkLink(self.icons.ldb_AllChar, 16)) .. " ", nil, "RIGHT")
|
|
tooltip:SetCellScript(row, maxCols, "OnMouseUp", quickToggle_Highlander, {["anchorFrame"] = anchorFrame, ["txt"] = "Col "..tostring(maxCols).." was Clicked"})
|
|
tooltip:SetCellScript(row, maxCols, "OnEnter", tooltiptip_OnEnter, {["b"] = "b3", ["tooltipType"] = tooltipType})
|
|
tooltip:SetCellScript(row, maxCols, "OnLeave", tooltiptip_OnLeave)
|
|
end
|
|
-- ----------------------------------------------------------------------------------------------------------------------- --
|
|
|
|
end
|
|
|
|
-- --- -- -- --- ---- --- -- -- --- ---- --- -- -- --- ---- --- -- -- --- ---- --- -- -- --- ---- ---
|
|
local function addStyle(row, col, text, styleStem )
|
|
local l_txt, r_txt
|
|
if styleStem.useText ~= 1 then
|
|
if styleStem.useText == 2 or styleStem.useText == 4 then l_txt = styleStem.useText_text.." " end
|
|
if styleStem.useText == 3 or styleStem.useText == 4 then r_txt = " "..styleStem.useText_text end
|
|
if styleStem.useColor == 2 then
|
|
l_txt = l_txt and l_txt:cfc(ExecAssist:tbl_pcColorToHex(styleStem.color)) or nil
|
|
r_txt = r_txt and r_txt:cfc(ExecAssist:tbl_pcColorToHex(styleStem.color)) or nil
|
|
end
|
|
text = ("%s"..text.."%s"):format(true and l_txt or "", true and r_txt or "" ) -- formatted text to be returned for additive construction
|
|
tooltip:SetCell(row, col, text )
|
|
end
|
|
|
|
if styleStem.useColor > 2 then
|
|
if styleStem.useColor==3 then
|
|
tooltip:SetCellTextColor(row, col, styleStem.color.r, styleStem.color.g, styleStem.color.b)
|
|
elseif styleStem.useColor==4 then
|
|
tooltip:SetCellColor(row, col, styleStem.color.r, styleStem.color.g, styleStem.color.b)
|
|
elseif styleStem.useColor==5 then
|
|
tooltip:SetLineColor(row, styleStem.color.r, styleStem.color.g, styleStem.color.b)
|
|
end
|
|
end
|
|
return text
|
|
end
|
|
local function styleRow(row, col, text, isAcctWide, isPurgable, isCmdTarget, isHidden, isSnowflake)
|
|
-- Styles should be complimentary so text is returned (allows left/right of different types
|
|
if isAcctWide and tooltipStem.SM.acctwide.useStyle then text = addStyle(row, col, text, tooltipStem.SM.acctwide) end
|
|
if isPurgable and tooltipStem.SM.purgable.useStyle then text = addStyle(row, col, text, tooltipStem.SM.purgable) end
|
|
|
|
if isCmdTarget and tooltipStem.SM.cmdLineTarget.useStyle then text = addStyle(row, col, text, tooltipStem.SM.cmdLineTarget) end
|
|
if isHidden and tooltipStem.SM.hidden.useStyle then text = addStyle(row, col, text, tooltipStem.SM.hidden) end
|
|
if isSnowflake and tooltipStem.SM.snowflake.useStyle then text = addStyle(row, col, text, tooltipStem.SM.snowflake) end
|
|
end
|
|
-- --- -- -- --- ---- --- -- -- --- ---- --- -- -- --- ---- --- -- -- --- ---- --- -- -- --- ---- ---
|
|
|
|
if tooltipStem.tooltipButtonPos == 1 then displayTooltipButtons() end
|
|
if tooltipType == "GTP" then -- -------------------------------------------------------------------------------- --==[ GTP Layout ]==--
|
|
local function mkGroup(col, entry_isCollapsed, groupName, groupID, isTop, isCmdTarget, isHidden)
|
|
row = tooltip:AddHeader()
|
|
tooltip:SetCell(row, col, entry_isCollapsed and self:mkLink(self.icons.ldb_Collapsed_h, 16) or self:mkLink(self.icons.ldb_Expanded_h, 16))
|
|
tooltip:SetCell(row, col+1, groupName, nil, "LEFT", (maxCols-1-col) )
|
|
|
|
-- apply base color (per config) then apply styles
|
|
tooltip:SetCellTextColor(row, col+1, tooltipStem.color_Group.r, tooltipStem.color_Group.g, tooltipStem.color_Group.b, 1)
|
|
styleRow(row, col+1, groupName, nil, nil, isCmdTarget, isHidden) -- melt special snowflake
|
|
|
|
tooltip:SetLineScript(row, "OnMouseUp", toggleCollapse, {["anchorFrame"] = anchorFrame, ["key"] = groupID, ["charName"] = charName, ["idxTT_key"] = "GTP"})
|
|
if isTop then addHSeparator(tooltip) end
|
|
end
|
|
local function mkTask(col, entry_isCollapsed, taskName, taskID, resetType, isAcctWide, count)
|
|
row = tooltip:AddHeader()
|
|
|
|
tooltip:SetCell(row, col, entry_isCollapsed and self:mkLink(self.icons.ldb_Collapsed, 16) or self:mkLink(self.icons.ldb_Expanded, 16 ))
|
|
tooltip:SetCell(row, col+1, taskName, nil, "LEFT", (maxCols-1-col) )
|
|
|
|
-- apply base color (per config) then apply styles
|
|
tooltip:SetCellTextColor(row, col+1, tooltipStem.color_TaskName.r, tooltipStem.color_TaskName.g, tooltipStem.color_TaskName.b, 1)
|
|
styleRow(row, col+1, taskName, isAcctWide, resetType==L.Purgable)
|
|
|
|
tooltip:SetCell(row, maxCols, count, nil, "CENTER") -- counts
|
|
tooltip:SetCellTextColor(row, maxCols, tooltipStem.color_taskCounts.r, tooltipStem.color_taskCounts.g, tooltipStem.color_taskCounts.b, 1)
|
|
|
|
tooltip:SetLineScript(row, "OnMouseUp", toggleCollapse, {["anchorFrame"] = anchorFrame, ["key"] = taskID, ["charName"] = charName, ["idxTT_key"] = "GTP"})
|
|
end
|
|
local function mkChar(col, isChecked, charName, r, g, b, taskID, isCurrentUser)
|
|
row = tooltip:AddLine()
|
|
tooltip:SetCell(row, col, isChecked and self:mkLink(self.icons.ldb_Complete, 16) or self:mkLink(self.icons.ldb_Incomplete, 16), nil, "RIGHT")
|
|
|
|
tooltip:SetCell(row, col+1, tooltipStem.ShowServerNames and charName or charName:sub(1,string.find(charName," - ",1, true)), nil, "LEFT", (maxCols-1-col))
|
|
tooltip:SetCellTextColor(row, col+1, r, g, b, 1)
|
|
|
|
|
|
tooltip:SetLineScript(row, "OnMouseUp", toggleTask, {["anchorFrame"] = anchorFrame, ["groupID"] = groupID, ["taskID"] = taskID, ["charName"] = charName, ["isCurrentUser"] = isCurrentUser, ["source"] = "tooltip"})
|
|
end
|
|
|
|
for i=1, #data do
|
|
local d = data[i]
|
|
if d.type == "group" then mkGroup( d.col, d.groupCollapsed, d.groupName, d.groupID, d.isTop, d.isCmdTarget, d.isHidden)
|
|
elseif d.type == "task" then mkTask( d.col, d.taskCollapsed, d.taskName, d.taskID, d.resetType, d.isAcctWide, d.count)
|
|
elseif d.type == "char" then mkChar( d.col, d.isChecked, d.charName, d.r, d.g, d.b, d.taskID, d.isCurrentUser )
|
|
else self:alert("Tooltip Generator found incorrect type: "..d.type, 1, 0, 0)
|
|
end
|
|
|
|
end
|
|
elseif tooltipType == "PGT" then -- -------------------------------------------------------------------------------- --==[ PGT Layout ]==--
|
|
local function mkChar(col, entry_isCollapsed, count, charName, r, g, b)
|
|
row = tooltip:AddHeader()
|
|
tooltip:SetCell(row, col, entry_isCollapsed and self:mkLink(self.icons.ldb_Collapsed_h, 16) or self:mkLink(self.icons.ldb_Expanded_h, 16) )
|
|
tooltip:SetCell(row, col+1, tooltipStem.ShowServerNames and charName or charName:sub(1,string.find(charName," - ",1, true)), nil, "LEFT", (maxCols - 1 - col) )
|
|
tooltip:SetCellTextColor(row, col+1, r, g, b, 1)
|
|
tooltip:SetCell(row, maxCols, count, nil, "CENTER")
|
|
tooltip:SetLineScript(row, "OnMouseUp", toggleCollapse, {["anchorFrame"] = anchorFrame, ["key"] = charName, ["idxTT_key"] = "char"})
|
|
|
|
addHSeparator(tooltip)
|
|
end
|
|
local function mkGroup(col, entry_isCollapsed, count, charName, groupName, groupID, isCmdTarget, isHidden, isSpecialSnowflake)
|
|
row = tooltip:AddHeader()
|
|
tooltip:SetCell(row, col, entry_isCollapsed and self:mkLink(self.icons.ldb_Collapsed, 16) or self:mkLink(self.icons.ldb_Expanded, 16) )
|
|
tooltip:SetCell(row, col+1, groupName, nil, "LEFT", (maxCols - 1 - col), nil, 0, 0, 500, 150)
|
|
|
|
-- apply base color (per config) then apply styles
|
|
tooltip:SetCellTextColor(row, col+1, tooltipStem.color_Group.r, tooltipStem.color_Group.g, tooltipStem.color_Group.b, 1)
|
|
styleRow(row, col+1, groupName, nil, nil, isCmdTarget, isHidden, isSpecialSnowflake)
|
|
|
|
tooltip:SetCell(row, maxCols, count, nil, "CENTER")
|
|
tooltip:SetCellTextColor(row, maxCols, tooltipStem.color_taskCounts.r, tooltipStem.color_taskCounts.g, tooltipStem.color_taskCounts.b, 1)
|
|
|
|
tooltip:SetLineScript(row, "OnMouseUp", toggleCollapse, {["anchorFrame"] = anchorFrame, ["key"] = groupID, ["charName"] = charName, ["idxTT_key"] = "PGT"})
|
|
end
|
|
local function mkTask(col, isChecked, taskName, resetType, taskID, charName, isCurrentUser, isAcctWide)
|
|
row = tooltip:AddLine()
|
|
tooltip:SetCell(row, col, isChecked and self:mkLink(self.icons.ldb_Complete, 16) or self:mkLink(self.icons.ldb_Incomplete, 16), nil, "LEFT")
|
|
tooltip:SetCell(row, col+1, taskName, nil, "LEFT", (maxCols - 1 - col) ) --, nil, 0, 0, tooltipStem.TaskEntry_MaxWidth, tooltipStem.TaskEntry_MinWidth)
|
|
-- apply base color (per config) then apply styles
|
|
tooltip:SetCellTextColor(row, col+1, tooltipStem.color_TaskName.r, tooltipStem.color_TaskName.g, tooltipStem.color_TaskName.b, 1)
|
|
styleRow(row, col+1, taskName, isAcctWide, resetType==L.Purgable)
|
|
|
|
-- Reset Type...needs fleshing out
|
|
tooltip:SetCell(row, maxCols, self.taskTypes[resetType].letter:rpad(3), nil, "RIGHT")
|
|
tooltip:SetCellTextColor(row, maxCols, self.taskTypes[resetType].color.r, self.taskTypes[resetType].color.g, self.taskTypes[resetType].color.b, self.taskTypes[resetType].color.a)
|
|
|
|
tooltip:SetLineScript(row, "OnMouseUp", toggleTask, {["row"] = row, ["col"] = col, ["anchorFrame"] = anchorFrame, ["groupID"] = groupID, ["taskID"] = taskID, ["charName"] = charName, ["isCurrentUser"] = isCurrentUser, ["source"] = "tooltip"})
|
|
end
|
|
-- --- --
|
|
for i=1, #data do
|
|
local d = data[i]
|
|
if d.type == "char" then mkChar ( d.col, d.charCollapsed, tooltipStem.useCounts_onHeaders and d.count or "", d.charName, d.r, d.g, d.b )
|
|
elseif d.type == "group" then mkGroup( d.col, d.groupCollapsed, tooltipStem.useCounts_onHeaders and d.count or "", d.charName, d.groupName, d.groupID, d.isCmdTarget, d.isHidden, d.isSpecialSnowflake)
|
|
elseif d.type == "task" then mkTask ( d.col, d.isChecked, d.taskName, d.resetType, d.taskID, d.charName, d.isCurrentUser, d.isAcctWide)
|
|
else
|
|
self:alert("Data Processing Error, incorrect type: "..type, 1, 0, 0)
|
|
end
|
|
end
|
|
|
|
-- ----------------------------------------------------------------------------------------------------------------------- --
|
|
else
|
|
self:alert("Improper tooltipType: "..tooltipType, 1, 1, 0)
|
|
end
|
|
if tooltipStem.tooltipButtonPos == 2 then displayTooltipButtons() end
|
|
|
|
tooltip:SmartAnchorTo(anchorFrame) -- Use smart anchoring code to anchor the tooltip to our frame
|
|
tooltip:UpdateScrolling()
|
|
tooltip:Show()
|
|
end
|
|
|
|
-- data map builder
|
|
function ExecAssist:mkCharList() -- Alphabetize Character List
|
|
local charStem_base = self.db.global.charStem
|
|
ExecAssist.charList = {}; ExecAssist.compressed_charList = {}
|
|
local CL, CCL = ExecAssist.charList, ExecAssist.compressed_charList
|
|
for charName, charStem in pairs(charStem_base) do table.insert(CL, charName) end
|
|
|
|
if self.db.global.tooltip.AllChar_GroupCharNames then
|
|
table.sort(CL)
|
|
else
|
|
function compareCharacters(a, b)
|
|
local aServer = string.match(a, [[.* - (.*)]])
|
|
local bServer = string.match(b, [[.* - (.*)]])
|
|
if aServer ~= bServer then
|
|
return aServer < bServer
|
|
end
|
|
return a < b
|
|
end
|
|
table.sort(CL, compareCharacters)
|
|
end
|
|
|
|
for i=1,#CL do CCL[ CL[i]:gsub(" ", "") ] = CL[i] end
|
|
|
|
end
|
|
function ExecAssist:formatCountData(checked, unchecked, displayType)
|
|
if displayType == 1 then return ("%d/%d"):format(checked, checked + unchecked)
|
|
elseif displayType == 2 then return ("%d/%d"):format(checked, unchecked)
|
|
elseif displayType == 3 then return ("%d"):format(unchecked)
|
|
else return ("%d%%"):format( ((checked+unchecked) > 0) and (checked/(checked+unchecked))*100 or 0 )
|
|
end
|
|
end
|
|
function ExecAssist:fetchData(listType)
|
|
-- the fetcher context-formats the requests, overriding the user when necessary
|
|
local tooltipStem = self.db.global.tooltip
|
|
local OnlyCurrentChar = tooltipStem.OnlyCurrentChar
|
|
local HideCharHeader_OnlyCurrentChar = tooltipStem.HideCharHeader_OnlyCurrentChar
|
|
|
|
if listType == "PGT" then
|
|
-- no mod
|
|
elseif listType == "GTP" then
|
|
OnlyCurrentChar = false -- makes absolutely no sense to do this with only 1 char
|
|
elseif listType == "TW" then -- TaskWindow
|
|
OnlyCurrentChar = true
|
|
HideCharHeader_OnlyCurrentChar = true
|
|
else
|
|
self:alert(" Unrecognized fetchData listType: "..listType, 1, 1, 0)
|
|
end
|
|
-- ShowGroup Names should be redacted as a parameter
|
|
return self:getDataList(listType, tooltipStem.ShowGroupNames, OnlyCurrentChar, HideCharHeader_OnlyCurrentChar)
|
|
end
|
|
function ExecAssist:getDataList(listType, ShowGroupNames, OnlyCurrentChar, HideCharHeader_OnlyCurrentChar)
|
|
local sdbg = self.db.global
|
|
local isAvail_taskType = self.isAvail_taskType
|
|
local charStem_base, groupStem, tooltipStem, twStem = sdbg.charStem, sdbg.groupStem, sdbg.tooltip, sdbg.taskWindow
|
|
local npcColor = tooltipStem.npc.npcColor
|
|
local maxCategoryDepth, maxDepth = 0, 0
|
|
local idxTT
|
|
local rc = {} -- <-- this gets returned to the fetcher
|
|
|
|
local function formatCounts(checked, unchecked)
|
|
local displayType_onHeaders = listType == "TW" and twStem.displayType_onHeaders or tooltipStem.displayType_onHeaders
|
|
return self:formatCountData(checked, unchecked, displayType_onHeaders)
|
|
end
|
|
local function formatResetTypes(resetType)
|
|
if isAvail_taskType[resetType] then return resetType
|
|
else return L.optsTable_missingmodule_label
|
|
end
|
|
end
|
|
|
|
if listType == "GTP" then -- ------------------------------------------------------------------------------------ --==[ GTP BUILD ]==--
|
|
local HideEmptyGroups = tooltipStem.HideEmptyGroups
|
|
local checked, unchecked = 0, 0 -- counting kludge for GTP to avoid the LDB default recount
|
|
-- ------------------------------------------------------------------------------------------------
|
|
local function mkChar(rc, maxDepth, collapsed, charName, taskID, r, g, b) -- col=1 by default
|
|
local maxCat = maxDepth + 1; if maxCat > maxCategoryDepth then maxCategoryDepth = maxCat end
|
|
local isChecked = self:getCheckedState(charName, taskID)
|
|
|
|
if not collapsed then
|
|
if (not isChecked) or (isChecked and tooltipStem.showChecked) then
|
|
table.insert(rc, {["type"] = "char", ["col"] = maxCat, ["taskID"] = taskID, ["charName"] = charName,
|
|
["isChecked"] = isChecked,["isCurrentUser"] = (charName == self.userCurrent),
|
|
["charName"] = charName, ["r"] = r, ["g"] = g, ["b"] = b}) -- !! NEED CLASS COLORS
|
|
end
|
|
end
|
|
|
|
if charName == ExecAssist.userCurrent and tooltipStem.useCounts_onLDB then
|
|
if isChecked then checked=checked+1
|
|
else unchecked=unchecked+1
|
|
end
|
|
end
|
|
|
|
return isChecked
|
|
end
|
|
-- ------------------------------------------------------------------------------------------------
|
|
local function doTask(rc, taskID, maxDepth, collapsed)
|
|
local hTask = groupStem.agg[taskID]
|
|
local checked, unchecked, IDactive = 0, 0, 0
|
|
local maxCat = maxDepth + 1; if maxCat > maxCategoryDepth then maxCategoryDepth = maxCat end
|
|
local tIdx
|
|
|
|
if not collapsed then
|
|
table.insert(rc, {["type"] = "task", ["col"] = maxCat, ["taskCollapsed"] = idxTT[taskID].isCollapsed,
|
|
["taskName"] = hTask.taskName, ["taskID"] = taskID, ["resetType"] = hTask.resetType:sub(1,1),
|
|
["isAcctWide"] = hTask.isAcctWide, ["count"] = count})
|
|
tIdx = #rc
|
|
end
|
|
|
|
for i=1, #ExecAssist.charList do
|
|
local charName = ExecAssist.charList[i] -- debugging aspirin
|
|
local hChar = charStem_base[charName] -- debugging aspirin
|
|
if self:hasCleanGenes(charName, taskID) then -- replacing self:ID_isActive(charName, taskID)
|
|
IDactive=IDactive+1 -- HERE HERE HERE HERE HERE HERE HERE HERE HERE HERE HERE HERE HERE HERE HERE HERE HERE
|
|
if mkChar(rc, maxCat, true and collapsed or idxTT[taskID].isCollapsed, charName, taskID,
|
|
hChar.charClass and RAID_CLASS_COLORS[hChar.charClass].r or npcColor.r,
|
|
hChar.charClass and RAID_CLASS_COLORS[hChar.charClass].g or npcColor.g,
|
|
hChar.charClass and RAID_CLASS_COLORS[hChar.charClass].b or npcColor.b) then
|
|
checked = checked+1
|
|
else unchecked=unchecked+1
|
|
end
|
|
end
|
|
end
|
|
|
|
if not collapsed then rc[tIdx].count = formatCounts(checked, unchecked) end
|
|
if HideEmptyGroups and IDactive == 0 then
|
|
if tIdx then table.remove(rc, #rc) end -- tIdx b/c if no tIdx then no group entry to remove
|
|
IDactive = -1 -- removes count for empty group when added up the stack
|
|
else
|
|
IDactive = 0
|
|
end
|
|
return IDactive
|
|
end
|
|
-- ------------------------------------------------------------------------------------------------
|
|
local function doGroup(rc, groupID, maxDepth, collapsed) --NB: mk vs do: mk makes things, do does and makes things.
|
|
local DO = groupStem.agg[groupID].DO
|
|
local maxCat = maxDepth + 1; if maxCat > maxCategoryDepth then maxCategoryDepth = maxCat end
|
|
local IDactive, IDactive_adder = 0, 0
|
|
local modeSuppressed, gpIdx
|
|
|
|
if ExecAssist["mode_"..listType]==4 then modeSuppressed = true end -- HideGroupNames
|
|
|
|
if not collapsed and not modeSuppressed then -- write header
|
|
local hGroup = groupStem.agg[groupID]
|
|
table.insert(rc, {["type"] = "group", ["col"] = maxCat>0 and maxCat or 1, ["isTop"] = maxCat==0 and true or false, ["groupCollapsed"] = idxTT[groupID].isCollapsed,
|
|
["groupName"] = hGroup.listName, ["groupID"] = groupID, ["isCmdTarget"] = hGroup.cmdLineTarget, ["isHidden"] = hGroup.hideFromDisplay,
|
|
})
|
|
gpIdx = #rc
|
|
end
|
|
|
|
idxTT[groupID].sibMap = {} -- clear group sibling map
|
|
|
|
for n=1,#DO do
|
|
table.insert(idxTT[groupID].sibMap, DO[n]) -- insert child into Sibling Map
|
|
if not idxTT[DO[n]] then idxTT[DO[n]] = {["p"] = groupID, ["isCollapsed"] = true} end -- preloads the child's (DO[n]) parent ID
|
|
|
|
IDactive=IDactive+1
|
|
if DO[n]:isGroup() then
|
|
IDactive_adder = doGroup(rc, DO[n], maxCat, true and collapsed or idxTT[groupID].isCollapsed)
|
|
else
|
|
IDactive_adder = doTask(rc, DO[n], maxCat, true and collapsed or idxTT[groupID].isCollapsed)
|
|
end
|
|
IDactive = IDactive + IDactive_adder
|
|
end
|
|
|
|
if HideEmptyGroups and IDactive == 0 then
|
|
if gpIdx then table.remove(rc, #rc) end -- gpIdx b/c if no gpIdx then no group entry to remove
|
|
IDactive = -1 -- removes count for empty group when added up the stack
|
|
else
|
|
IDactive = 0
|
|
end
|
|
return IDactive
|
|
end
|
|
-- ------------------------------------------------------------------------------------------------
|
|
idxTT = ttData_idx["GTP"] -- contains groups and tasks, all initially closed
|
|
local hdrIndex
|
|
|
|
local garden = groupStem.agg["garden"].DO
|
|
if not idxTT["__garden"] then
|
|
idxTT["__garden"] = {["sibMap"] = {}}
|
|
else
|
|
idxTT["__garden"].sibMap = {}
|
|
end -- set / clear __garden sibling map
|
|
|
|
for j=1,#garden do -- .garden is always groups
|
|
table.insert(idxTT["__garden"].sibMap, garden[j])
|
|
if not idxTT[garden[j]] then idxTT[garden[j]] = {["p"] = "__garden", ["isCollapsed"] = true} end -- preloads the child's (DO[n]) parent ID
|
|
|
|
doGroup(rc, garden[j], maxDepth-1) -- or -1? group layout issues...
|
|
end
|
|
|
|
maxCategoryDepth = (maxCategoryDepth+2)>2 and maxCategoryDepth+2 or 3 -- adjust for additional fields
|
|
|
|
if tooltipStem.useCounts_onLDB then self:ldb_refreshCounts(checked, unchecked) end
|
|
|
|
-- ------------------------------------------------------------------------------------------------
|
|
|
|
elseif listType == "PGT" or listType == "TW" then -- ---------------------------------------------------------------- --==[ PGT BUILD ]==--
|
|
local displayMode, defaultCollapse, HideEmptyGroups
|
|
if listType == "PGT" then displayMode = ExecAssist["mode_"..listType] ; defaultCollapse = tooltipStem.defaultCollapse; HideEmptyGroups = tooltipStem.HideEmptyGroups
|
|
else displayMode = ExecAssist.twMode ; defaultCollapse = twStem.defaultCollapse; HideEmptyGroups = twStem.HideEmptyGroups
|
|
end
|
|
-- ---------------------------------------------------------------------------------------------------
|
|
local function mkChar(rc, isCollapsed, charName, count, r, g, b) -- col=1 by default
|
|
table.insert(rc, {["type"] = "char", ["col"] = 1, ["charCollapsed"] = isCollapsed,
|
|
["charName"] = charName, ["count"] = count, ["r"] = r, ["g"] = g, ["b"] = b})
|
|
end -- nothing to return
|
|
-- ---------------------------------------------------------------------------------------------------
|
|
local function mkTask(rc, col, charName, taskID, collapsed, forceDisplayTasks)
|
|
local isChecked, isDisplayed = self:getCheckedState(charName, taskID), nil
|
|
local hTask = groupStem.agg[taskID]
|
|
|
|
if (not isChecked) or (isChecked and ( (twStem.showChecked and listType == "TW") or (listType == "PGT" and tooltipStem.showChecked)) ) then
|
|
isDisplayed = true -- Evil, I know...but interior collapsing cascades need to know the response nature of the task display
|
|
-- thus a full traverse is needed even though not directly included in the data. Sometimes you can't avoid meta-constructs.
|
|
if forceDisplayTasks or not collapsed then
|
|
table.insert(rc, {["type"] = "task", ["col"] = col, ["isChecked"] = isChecked,
|
|
["taskName"] = hTask.taskName, ["resetType"] = formatResetTypes(hTask.resetType), --formatResetTypes(hTask.resetType),
|
|
["taskID"] = taskID, ["charName"] = charName,
|
|
["isCurrentUser"] = (charName == self.userCurrent),
|
|
["isAcctWide"] = hTask.isAcctWide})
|
|
end
|
|
end
|
|
|
|
return isChecked, isDisplayed
|
|
end
|
|
-- ---------------------------------------------------------------------------------------------------
|
|
local function doGroup(rc, charName, groupID, parentID, maxDepth, collapsed, forceDisplayTasks) --NB: mk vs do: mk makes things, do does things too.
|
|
local checked, unchecked, IDactive = 0, 0, 0
|
|
local adoptive_sibMapID
|
|
local DO = groupStem.agg[groupID].DO
|
|
local maxCat = maxDepth + 1; if maxCat > maxCategoryDepth then maxCategoryDepth = maxCat end
|
|
local gpIdx, modeSuppressed
|
|
|
|
if displayMode==4 then modeSuppressed = true -- only selected group / HideGroupNames
|
|
elseif (displayMode==3 and idxTT.isSpecialSnowflake == groupID ) then
|
|
-- NB: the (somewhat now misnamed) quicktoggle_ handles the idxTT[].isCollapsed capture & reset
|
|
collapsed = false
|
|
maxCat, maxCategoryDepth = 1, 1
|
|
elseif groupStem.agg[groupID].hideFromDisplay and displayMode ~= 2 then --force it open if not display 2
|
|
maxCat = maxCat-1 -- bring it down a rung
|
|
modeSuppressed = true
|
|
idxTT[groupID].isCollapsed = false
|
|
adoptive_sibMapID = parentID -- forces the parent group and not current 'hidden' group to 'adopt' the children
|
|
end
|
|
|
|
if not collapsed and not modeSuppressed then
|
|
local hGroup = groupStem.agg[groupID]
|
|
table.insert(rc, {["type"] = "group", ["col"] = maxCat, ["count"] = count,
|
|
["groupCollapsed"] = idxTT[groupID].isCollapsed, ["charName"] = charName,
|
|
["groupName"] = hGroup.listName, ["groupID"] = groupID,
|
|
["isCmdTarget"] = hGroup.cmdLineTarget, ["isHidden"] = hGroup.hideFromDisplay,
|
|
["isSpecialSnowflake"] = (idxTT.isSpecialSnowflake and idxTT.isSpecialSnowflake == groupID)
|
|
})
|
|
gpIdx = #rc
|
|
end
|
|
|
|
idxTT[groupID].sibMap = {} -- clear group sibling map
|
|
for n=1,#DO do
|
|
if self:ID_isActive(charName, DO[n]) then
|
|
IDactive=IDactive+1
|
|
if DO[n]:isGroup() then
|
|
table.insert(idxTT[true and adoptive_sibMapID or groupID].sibMap, DO[n]) -- insert child into Sibling Map
|
|
if not idxTT[DO[n]] then idxTT[DO[n]] = {
|
|
["p"] = true and adoptive_sibMapID or groupID,
|
|
["isCollapsed"] = true and ((listType == "TW" and twStem.defaultCollapse) or (listType == "PGT" and tooltipStem.defaultCollapse)) or false
|
|
} end -- preloads the child's (DO[n]) parent ID
|
|
|
|
local rc_c, rc_uc, IDactive_adder = doGroup(rc, charName, DO[n], groupID, maxCat, true and collapsed or idxTT[groupID].isCollapsed, forceDisplayTasks)
|
|
checked = checked+rc_c
|
|
unchecked = unchecked+rc_uc
|
|
IDactive=IDactive+IDactive_adder -- passes back the # of active down the line or -1 if empty to 'remove' the group itself
|
|
else
|
|
local isChecked, isDisplayed = mkTask(rc, maxCat+1, charName, DO[n], true and collapsed or idxTT[groupID].isCollapsed, forceDisplayTasks)
|
|
if isChecked then checked = checked+1
|
|
else unchecked = unchecked+1
|
|
end
|
|
if not isDisplayed then IDactive=IDactive-1 end
|
|
end
|
|
end
|
|
end
|
|
|
|
if not collapsed and not modeSuppressed then rc[gpIdx].count = formatCounts(checked, unchecked) end
|
|
if HideEmptyGroups and IDactive == 0 then
|
|
if gpIdx then table.remove(rc, #rc) end -- gpIdx b/c if no gpIdx then no group entry to remove
|
|
IDactive = -1 -- removes count for empty group when added up the stack
|
|
end
|
|
|
|
return checked, unchecked, IDactive
|
|
end
|
|
-- ===================================================================================================
|
|
local idxCH
|
|
if listType == "TW" then
|
|
idxCH = ttData_idx["TW"]
|
|
else
|
|
idxCH = ttData_idx["char"]
|
|
end
|
|
|
|
if idxCH.player then idxCH.player.sibMap = {} end -- clear character sibling Map
|
|
for i=1,#ExecAssist.charList do
|
|
local checked, unchecked = 0, 0
|
|
local charName, charStem = ExecAssist.charList[i], charStem_base[ExecAssist.charList[i]]
|
|
local hdrIndex
|
|
if (OnlyCurrentChar and charName == ExecAssist.userCurrent) or (not OnlyCurrentChar) then
|
|
-- Process Player
|
|
if not idxCH[charName] then
|
|
local isCollapsed
|
|
if charName == self.userCurrent then isCollapsed = (not tooltipStem.defaultExpandSelf)
|
|
else isCollapsed=true
|
|
end
|
|
idxCH[charName] = {["isCollapsed"] = isCollapsed, ["p"] = "player"}
|
|
idxCH[charName]["PGT"] = {}
|
|
end
|
|
idxTT = idxCH[charName]["PGT"] -- makes the group collapse toggle char specific
|
|
for k, v in pairs(idxTT) do if v.sibMap then v.sibMap = {} end end -- remove existing sibMaps to refresh the pattern; note: no attempt at clean up is done as any garbage is outside the sibling map
|
|
table.insert(idxCH.player.sibMap, charName)
|
|
|
|
local showCharHeader
|
|
if displayMode == 4 then maxDepth = -1 end -- this 'pulls' the checkboxes over into the otherwise empty column.
|
|
if (OnlyCurrentChar and HideCharHeader_OnlyCurrentChar) or (displayMode==3) then
|
|
showCharHeader = false
|
|
else
|
|
showCharHeader = true
|
|
end
|
|
|
|
if showCharHeader then
|
|
mkChar( rc,
|
|
idxCH[charName].isCollapsed,
|
|
charName,
|
|
nil, -- if used, 'count' will be filled in when tabulations are done
|
|
|
|
charStem.charClass and RAID_CLASS_COLORS[charStem.charClass].r or npcColor.r,
|
|
charStem.charClass and RAID_CLASS_COLORS[charStem.charClass].g or npcColor.g,
|
|
charStem.charClass and RAID_CLASS_COLORS[charStem.charClass].b or npcColor.b
|
|
)
|
|
hdrIndex = #rc
|
|
end
|
|
|
|
-- Proceess Groups and Tasks
|
|
local garden = groupStem.agg["garden"].DO
|
|
if not idxTT["__garden"] then
|
|
idxTT["__garden"] = {["sibMap"] = {}}
|
|
else
|
|
idxTT["__garden"].sibMap = {}
|
|
end -- set / clear __garden sibling map
|
|
|
|
for j=1,#garden do -- .garden is always groups
|
|
if self:ID_isActive(charName, garden[j]) then
|
|
table.insert(idxTT["__garden"].sibMap, garden[j])
|
|
if not idxTT[garden[j]] then idxTT[garden[j]] = {
|
|
["p"] = "__garden",
|
|
["isCollapsed"] = true and ((listType == "TW" and twStem.defaultCollapse) or (listType == "PGT" and tooltipStem.defaultCollapse)) or false
|
|
} end -- preloads the child's (DO[n]) parent ID
|
|
|
|
local rc_c, rc_uc = doGroup(rc, charName, garden[j], garden[j], maxDepth,
|
|
displayMode == 3 and idxTT.isSpecialSnowflake or idxCH[charName].isCollapsed,
|
|
(displayMode == 4 and not idxCH[charName].isCollapsed )
|
|
) -- (cascade 'collapse' till snowflake is found)
|
|
|
|
checked = checked+rc_c
|
|
unchecked = unchecked+rc_uc
|
|
end
|
|
end
|
|
-- ---------------------- --
|
|
if charName ~= ExecAssist.userCurrent and (
|
|
(HideEmptyGroups and (checked+unchecked) == 0) -- Hide + No Groups/Tasks Assigned
|
|
or
|
|
( (not tooltipStem.showChecked) and (tooltipStem.HideChar_ifNoIncomplete and unchecked==0) ) -- Hide Entire Char when no UNCOMPLETED tasks and not SHOW_COMPLETED
|
|
) then
|
|
for i=hdrIndex,#rc do -- pull off enteries
|
|
table.remove(rc, i)
|
|
end
|
|
elseif tooltipStem.useCounts_onHeaders and showCharHeader then
|
|
rc[hdrIndex]["count"] = formatCounts(checked, unchecked)
|
|
end
|
|
|
|
if charName == ExecAssist.userCurrent then
|
|
if tooltipStem.useCounts_onLDB then
|
|
self:ldb_refreshCounts(checked, unchecked)
|
|
else
|
|
self:queryToggleTW_zeroUncomp_whileHideCompTasks(unchecked)
|
|
end
|
|
end
|
|
end
|
|
|
|
end -- for i=1,#ExecAssist.charList do
|
|
|
|
maxCategoryDepth = (maxCategoryDepth+3)>3 and maxCategoryDepth+3 or 4 -- adjust for additional fields
|
|
-- ===================================================================================================
|
|
end
|
|
|
|
return rc, maxCategoryDepth
|
|
end
|
|
|
|
-- update LDB
|
|
function ExecAssist:ldb_refreshCounts(checked, unchecked)
|
|
local sdbg = self.db.global
|
|
if not checked then -- do count if not supplied --
|
|
local aggStem = sdbg.groupStem.agg
|
|
local garden = aggStem["garden"].DO
|
|
checked, unchecked = 0, 0
|
|
local function doGroup(charName, groupID, maxDepth)
|
|
local checked, unchecked, DO = 0, 0, aggStem[groupID].DO
|
|
for n=1,#DO do
|
|
if self:ID_isActive(charName, DO[n]) then
|
|
if DO[n]:isGroup() then local rc_c, rc_uc = doGroup(charName, DO[n], maxCat); checked = checked+rc_c; unchecked = unchecked+rc_uc
|
|
else
|
|
if self:getCheckedState(charName, DO[n]) then checked = checked+1
|
|
else unchecked = unchecked+1
|
|
end
|
|
end
|
|
end
|
|
end
|
|
return checked, unchecked
|
|
end
|
|
for j=1,#garden do if self:ID_isActive(self.userCurrent, garden[j]) then local rc_c, rc_uc = doGroup(self.userCurrent, garden[j], 0); checked = checked+rc_c; unchecked = unchecked+rc_uc end end
|
|
end -- ---------------------------
|
|
ExecAssist.meatPopcicle.text = self:formatCountData(checked, unchecked, sdbg.tooltip.displayType_onLDB)
|
|
|
|
self:queryToggleTW_zeroUncomp_whileHideCompTasks(unchecked)
|
|
end
|