-- ------------------------------------------------------------------------- --
-- 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