Tweaked and updated the FAQ a bit

Instead of changing a behavior that's years old out from under people, let's make it opt-in.

.pkgmeta

@@ -43,11 +43,9 @@ externals:
         url: svn://svn.wowace.com/wow/libsharedmedia-3-0/mainline/trunk
         tag: latest
     libs/LibDogTag-3.0:
-        url: svn://svn.wowace.com/wow/libdogtag-3-0/mainline/trunk
-		tag: latest
+        url: git://git.wowace.com/wow/libdogtag-3-0/mainline.git
     libs/LibDogTag-Unit-3.0:
-        url: svn://svn.wowace.com/wow/libdogtag-unit-3-0/mainline/trunk
-		tag: latest
+        url: git://git.wowace.com/wow/libdogtag-unit-3-0/mainline.git
     libs/LibDBIcon-1.0:
         url: svn://svn.wowace.com/wow/libdbicon-1-0/mainline/trunk/LibDBIcon-1.0
     libs/LibDualSpec-1.0:
@@ -62,4 +60,4 @@ move-folders:
     IceHUD/IceHUD_Options: IceHUD_Options
 
 tools-used:
-    - libdatabroker-1-1
+    - libdatabroker-1-1

IceBarElement.lua

@@ -946,6 +946,8 @@ function IceBarElement.prototype:CreateFrame()
 
 	if self.moduleSettings.rotateBar then
 		self:RotateHorizontal()
+	else
+		self:ResetRotation()
 	end
 end
 
@@ -1140,7 +1142,7 @@ function IceBarElement.prototype:Flip(side)
 end
 
 -- Rokiyo: bar is the only required argument, scale & top are optional
-function IceBarElement.prototype:SetBarCoord(barFrame, scale, top)
+function IceBarElement.prototype:SetBarCoord(barFrame, scale, top, overrideReverse)
 	if not scale then scale = 0 end
 	scale = IceHUD:Clamp(scale, 0, 1)
 
@@ -1150,7 +1152,12 @@ function IceBarElement.prototype:SetBarCoord(barFrame, scale, top)
 		local min_y, max_y
 		local offset_y = 0
 
-		if IceHUD:xor(self.moduleSettings.reverse, top) then
+		local reverse = self.moduleSettings.reverse
+		if overrideReverse then
+			reverse = false
+		end
+
+		if IceHUD:xor(reverse, top) then
 			if self.moduleSettings.inverse == "INVERSE" then
 				min_y = 1 - scale
 				max_y = 1

IceCore.lua

@@ -93,6 +93,7 @@ function IceCore.prototype:SetupDefaults()
 			TextDecoration = "Shadow",
 
 			bHideDuringPetBattles = true,
+			bHideInBarberShop = true,
 		},
 		global = {
 			lastRunVersion = 0,
@@ -141,7 +142,7 @@ function IceCore.prototype:CheckDisplayUpdateMessage()
 	thisVersion = @project-date-integer@
 --@end-non-debug@]===]
 --@debug@
-	thisVersion = 9999
+	thisVersion = 99999999999999
 --@end-debug@
 	if self.accountSettings.lastRunVersion < thisVersion then
 		if self.accountSettings.lastRunVersion < 549 then
@@ -166,6 +167,12 @@ function IceCore.prototype:CheckDisplayUpdateMessage()
 				self.settings.modules["LacerateCount"] = {}
 			end
 		end
+		if self.accountSettings.lastRunVersion <= 20160527053225 then
+			if self.settings.modules["DruidMana"] ~= nil then
+				self.settings.modules["PlayerAltMana"] = self.settings.modules["DruidMana"]
+				self.settings.modules["DruidMana"] = nil
+			end
+		end
 		self.accountSettings.lastRunVersion = thisVersion
 	end
 end
@@ -202,31 +209,25 @@ function IceCore.prototype:Enable(userToggle)
 	end
 
 	for k,v in pairs(self.settings.modules) do
+		local newModule
+
 		if self.settings.modules[k].customBarType == "Bar" and IceCustomBar ~= nil then
-			local newBar
-			newBar = IceCustomBar:new()
-			newBar.elementName = k
-			self:AddNewDynamicModule(newBar, true)
+			newModule = IceCustomBar:new()
 		elseif self.settings.modules[k].customBarType == "Counter" and IceCustomCount ~= nil then
-			local newCounter
-			newCounter = IceCustomCount:new()
-			newCounter.elementName = k
-			self:AddNewDynamicModule(newCounter, true)
+			newModule = IceCustomCount:new()
+		elseif self.settings.modules[k].customBarType == "CounterBar" and IceCustomCounterBar ~= nil then
+			newModule = IceCustomCounterBar:new()
 		elseif self.settings.modules[k].customBarType == "CD" and IceCustomCDBar ~= nil then
-			local newCD
-			newCD = IceCustomCDBar:new()
-			newCD.elementName = k
-			self:AddNewDynamicModule(newCD, true)
+			newModule = IceCustomCDBar:new()
 		elseif self.settings.modules[k].customBarType == "Health" and IceCustomHealth ~= nil then
-			local newHealth
-			newHealth = IceCustomHealth:new()
-			newHealth.elementName = k
-			self:AddNewDynamicModule(newHealth, true)
+			newModule = IceCustomHealth:new()
 		elseif self.settings.modules[k].customBarType == "Mana" and IceCustomMana ~= nil then
-			local newMana
-			newMana = IceCustomMana:new()
-			newMana.elementName = k
-			self:AddNewDynamicModule(newMana, true)
+			newModule = IceCustomMana:new()
+		end
+
+		if newModule ~= nil then
+			newModule.elementName = k
+			self:AddNewDynamicModule(newModule, true)
 		end
 	end
 
@@ -244,6 +245,8 @@ function IceCore.prototype:Enable(userToggle)
 
 	self.IceHUDFrame:RegisterEvent("PET_BATTLE_OPENING_START")
 	self.IceHUDFrame:RegisterEvent("PET_BATTLE_OVER")
+	self.IceHUDFrame:RegisterEvent("BARBER_SHOP_OPEN")
+	self.IceHUDFrame:RegisterEvent("BARBER_SHOP_CLOSE")
 	self.IceHUDFrame:SetScript("OnEvent", function(self, event, ...)
 		if (event == "PET_BATTLE_OPENING_START") then
 			if IceHUD.IceCore.settings.bHideDuringPetBattles then
@@ -253,6 +256,14 @@ function IceCore.prototype:Enable(userToggle)
 			if IceHUD.IceCore.settings.bHideDuringPetBattles then
 				self:Show()
 			end
+		elseif (event == "BARBER_SHOP_OPEN") then
+			if IceHUD.IceCore.settings.bHideInBarberShop then
+				self:Hide()
+			end
+		elseif (event == "BARBER_SHOP_CLOSE") then
+			if IceHUD.IceCore.settings.bHideInBarberShop then
+				self:Show()
+			end
 		end
 	end)
 
@@ -261,7 +272,7 @@ end
 
 function IceCore.prototype:RedirectRemovedModules()
 	local _, class = UnitClass("player")
-	if class == "WARRIOR" and self.settings.modules["SunderCount"] and IceHUD.WowVer < 60000 then
+	if class == "WARRIOR" and self.settings.modules["SunderCount"] and GetSpellInfo(SUNDER_SPELL_ID) and IceHUD.WowVer < 60000 then
 		if self.settings.modules["SunderCount"].enabled or self.settings.modules["SunderCount"].enabled == nil then
 			local bFound = false
 
@@ -298,7 +309,7 @@ function IceCore.prototype:RedirectRemovedModules()
 		self.settings.modules["SunderCount"] = nil
 	end
 
-	if class == "DRUID" and self.settings.modules["LacerateCount"] then
+	if class == "DRUID" and self.settings.modules["LacerateCount"] and GetSpellInfo(LACERATE_SPELL_ID) then
 		if self.settings.modules["LacerateCount"].enabled or self.settings.modules["LacerateCount"].enabled == nil then
 			local bFound = false
 			for k,v in pairs(self.elements) do
@@ -335,7 +346,7 @@ function IceCore.prototype:RedirectRemovedModules()
 		self.settings.modules["LacerateCount"] = nil
 	end
 
-	if class == "SHAMAN" and self.settings.modules["MaelstromCount"] then
+	if class == "SHAMAN" and self.settings.modules["MaelstromCount"] and GetSpellInfo(MAELSTROM_SPELL_ID) then
 		if self.settings.modules["MaelstromCount"].enabled or self.settings.modules["MaelstromCount"].enabled == nil then
 			local bFound = false
 			for k,v in pairs(self.elements) do
@@ -489,6 +500,8 @@ function IceCore.prototype:Disable(userToggle)
 
 	self.IceHUDFrame:UnregisterEvent("PET_BATTLE_OPENING_START")
 	self.IceHUDFrame:UnregisterEvent("PET_BATTLE_OVER")
+	self.IceHUDFrame:UnregisterEvent("BARBER_SHOP_OPEN")
+	self.IceHUDFrame:UnregisterEvent("BARBER_SHOP_CLOSE")
 	self.IceHUDFrame:SetScript("OnEvent", nil)
 
 	self.enabled = false

IceElement.lua

@@ -130,6 +130,8 @@ function IceElement.prototype:GetBarTypeDescription(barType)
 		retval = L["(De)Buff watcher"]
 	elseif barType == "Counter" then
 		retval = L["Counter"]
+	elseif barType == "CounterBar" then
+		retval = L["CounterBar"]
 	elseif barType == "Health" then
 		retval = HEALTH
 	elseif barType == "Mana" then

IceHUD.lua

@@ -20,7 +20,7 @@ IceHUD.WowVer = select(4, GetBuildInfo())
 
 IceHUD.validBarList = { "Bar", "HiBar", "RoundBar", "ColorBar", "RivetBar", "RivetBar2", "CleanCurves", "GlowArc",
 	"BloodGlaives", "ArcHUD", "FangRune", "DHUD", "CleanCurvesOut", "CleanTank", "PillTank", "GemTank" }
-IceHUD.validCustomModules = {Bar="Buff/Debuff watcher", Counter="Buff/Debuff stack counter", CD="Cooldown bar", Health="Health bar", Mana="Mana bar"}
+IceHUD.validCustomModules = {Bar="Buff/Debuff watcher", Counter="Buff/Debuff stack counter", CD="Cooldown bar", Health="Health bar", Mana="Mana bar", CounterBar="Stack count bar"}
 
 --@debug@
 IceHUD.optionsLoaded = true
@@ -78,6 +78,21 @@ StaticPopupDialogs["ICEHUD_CUSTOM_COUNTER_CREATED"] =
 	end,
 }
 
+StaticPopupDialogs["ICEHUD_CUSTOM_COUNTER_BAR_CREATED"] =
+{
+	text = L["A custom counter bar has been created and can be configured through Module Settings => MyCustomCounterBar. It is highly recommended that you change the bar name of this module so that it's easier to identify."],
+	button1 = OKAY,
+	timeout = 0,
+	whileDead = 1,
+	hideOnEscape = 0,
+	OnShow = function(self)
+		self:SetFrameStrata("TOOLTIP")
+	end,
+	OnHide = function(self)
+		self:SetFrameStrata("DIALOG")
+	end,
+}
+
 StaticPopupDialogs["ICEHUD_CUSTOM_CD_CREATED"] =
 {
 	text = L["A custom cooldown bar has been created and can be configured through Module Settings => MyCustomCD. It is highly recommended that you change the bar name of this module so that it's easier to identify."],
@@ -257,10 +272,10 @@ function IceHUD:OnEnable(isFirst)
 	IceHUD_Options:OnLoad()
 	--@end-debug@
 
-	if isFirst then
+--	if isFirst then
 		self:SetDebugging(self.IceCore:GetDebug())
-		self.debugFrame = ChatFrame2
-	end
+		self.debugFrame = ChatFrame1
+--	end
 end
 
 -- add settings changes/updates here so that existing users don't lose their settings
@@ -343,8 +358,12 @@ function IceHUD:LoadOptions()
 	return true
 end
 
-function IceHUD:Debug(msg)
+function IceHUD:Debug(...)
 	if self.debugging then
+		local msg = ""
+		for n=1,select('#', ...) do
+			msg = msg .. tostring(select(n, ...)) .. " "
+		end
 		self.debugFrame:AddMessage(msg)
 	end
 end
@@ -536,6 +555,9 @@ function IceHUD:CreateCustomModuleAndNotify(moduleKey, settings)
 	elseif moduleKey == "Counter" then -- custom counter
 		newMod = IceCustomCount:new()
 		popupMsg = "ICEHUD_CUSTOM_COUNTER_CREATED"
+	elseif moduleKey == "CounterBar" then -- custom counter bar
+		newMod = IceCustomCounterBar:new()
+		popupMsg = "ICEHUD_CUSTOM_COUNTER_BAR_CREATED"
 	elseif moduleKey == "CD" then -- cooldown bar
 		newMod = IceCustomCDBar:new()
 		popupMsg = "ICEHUD_CUSTOM_CD_CREATED"

IceHUD.toc

@@ -1,4 +1,4 @@
-## Interface: 60000
+## Interface: 70000
 ## Author: Parnic, originally created by Iceroth
 ## Name: IceHUD
 ## Title: IceHUD |cff7fff7f-Ace3-|r
@@ -6,9 +6,9 @@
 ## Version: @project-version@
 ## SavedVariables: IceCoreDB
 ## OptionalDeps: Ace3, LibSharedMedia-3.0, LibDogTag-3.0, LibDogTag-Unit-3.0, LibRangeCheck-2.0, LibDualSpec-1.0, LibDBIcon-1.0, AceGUI-3.0-SharedMediaWidgets
-## X-Compatible-With: 50400
+## X-Compatible-With: 60200
 ## X-Category: HUDs
-## X-Website: http://www.wowace.com/projects/ice-hud/
+## X-Website: http://www.wowace.com/addons/ice-hud/
 ## X-WoWI-ID: 8149
 
 #@no-lib-strip@
@@ -26,6 +26,7 @@ IceElement.lua
 IceBarElement.lua
 IceUnitBar.lua
 IceCastBar.lua
+IceStackCounter.lua
 
 # IceHUD modules
 # - Feel free to comment these out if you like
@@ -35,7 +36,6 @@ modules\TargetHealth.lua
 modules\TargetMana.lua
 modules\PetHealth.lua
 modules\PetMana.lua
-modules\DruidMana.lua
 modules\TargetInfo.lua
 modules\TargetOfTarget.lua
 modules\ComboPoints.lua
@@ -59,6 +59,7 @@ modules\FocusThreat.lua
 modules\RangeCheck.lua
 modules\CustomBar.lua
 modules\CustomCount.lua
+modules\CustomCounterBar.lua
 # - make sure PlayerInfo loads after TargetInfo since it inherits
 modules\PlayerInfo.lua
 modules\PetInfo.lua
@@ -78,13 +79,17 @@ modules\HolyPower.lua
 modules\Shards.lua
 modules\EclipseBar.lua
 modules\Vengeance.lua
+modules\Resolve.lua
 modules\PlayerAlternatePower.lua
 modules\HarmonyPower.lua
-modules\MonkManaBar.lua
 modules\ShadowOrbs.lua
 modules\TargetAbsorb.lua
 modules\PlayerAbsorb.lua
 modules\FocusAbsorb.lua
+modules\Stagger.lua
+modules\PlayerAltMana.lua
+modules\ArcaneCharges.lua
+modules\RollTheBones.lua
 
 #@do-not-package@
 IceHUD_Options\Options.lua

IceHUD_Options/IceHUD_Options.toc

@@ -1,4 +1,4 @@
-## Interface: 60000
+## Interface: 70000
 ## Title: IceHUD |cff7fff7f-Options-|r
 ## Author: Parnic
 ## Version: @project-version@

IceHUD_Options/Options.lua

@@ -65,19 +65,25 @@ Expand "|cffffdc42Module Settings|r", expand PlayerHealth (or TargetHealth for t
 Expand "|cffffdc42Module Settings|r", expand PlayerInfo (or TargetInfo for targets), select Buff Settings or Debuff Settings, and un-check "show buffs" (or "show debuffs").
 
 |cff9999ff12. How do I turn off these big huge bars that pulse whenever one of my abilities procs?|r
-This isn't |cff9999ffIceHUD|r - it's Blizzard's new Spell Alerts they added in 4.0.1. Interface options => Combat => "Show Spell Alerts" to turn them off or search for a mod to tweak their positioning/size/etc.
+This isn't |cff9999ffIceHUD|r - it's Blizzard's Spell Alerts they added in 4.0.1. Interface options => Combat => "Spell Alert Opacity" to turn them off or search for a mod to tweak their positioning/size/etc.
 
 |cff9999ff13. I don't like where some of the bars are placed. How do I put the health/mana on the left/right?|r
 Expand "|cffffdc42Module Settings|r", expand whatever module you want to move (e.g. PlayerHealth, PlayerMana), and adjust the "Side" and "Offset" settings. "Side" controls whether it's on the left or the right and "Offset" controls how far from center it is.
 
 |cff9999ff14. Which module displays Monk Chi power?|r
-This module is called HarmonyPower. Harmony was the original name for Chi back when 5.0 was in beta, so I used Blizzard's name for it while I was developing for Cataclysm. I feel like it's too late to change now that many people are familiar with the Harmony name.
+This module is called |cffdcff42HarmonyPower|r. Harmony was the original name for Chi back when 5.0 was in beta, so I used Blizzard's name for it while I was developing for Cataclysm. I feel like it's too late to change now that many people are familiar with the Harmony name.
 
 |cff9999ff15. How do I add commas/periods into big numbers like health?|r
-If you have DogTags enabled, you can open the Text Settings for the module in question and add SeparateDigits() around the tag you're trying to split up. To display Health/MaxHealth with commas, use: [(SeparateDigits(HP):HPColor "/" SeparateDigits(MaxHP):HPColor):Bracket]. To use periods instead of commas, use: [(SeparateDigits(HP, "."):HPColor "/" SeparateDigits(MaxHP, "."):HPColor):Bracket]. Use the /dog help menu to build your own similar tags for Mana, etc.
+If you have |cff42ffffDogTags|r enabled, you can open the Text Settings for the module in question and add SeparateDigits() around the tag you're trying to split up. To display Health/MaxHealth with commas, use: [(SeparateDigits(HP):HPColor "/" SeparateDigits(MaxHP):HPColor):Bracket]. To use periods instead of commas, use: [(SeparateDigits(HP, "."):HPColor "/" SeparateDigits(MaxHP, "."):HPColor):Bracket]. Use the /dog help menu to build your own similar tags for Mana, etc.
 
 |cff9999ff16. The countdown timers on buffs and debuffs completely obscure the icon. How do I disable the timer text?|r
-IceHUD is not responsible for this countdown text and cannot control it. The 6.0 patch added an option in the game client to display counts on top of cooldowns. Look at the Action Bars menu under the game's Interface options. You can turn the text on or off there. Mods like OmniCC or CooldownCount will generally give you the same feature but allow you to control when, where, and how the text shows up.]]
+|cff9999ffIceHUD|r is not responsible for this countdown text and cannot control it. The 6.0 patch added an option in the game client to display counts on top of cooldowns. Look at the Action Bars menu under the game's Interface options. You can turn the text on or off there. Mods like |cff42ffffOmniCC|r or |cff42ffffCooldownCount|r will generally give you the same feature but allow you to control when, where, and how the text shows up.
+
+|cff9999ff17. When I rotate some modules 90 degrees, such as the castbar, the bar appears to wiggle up and down as it fills or empties. How do I fix this?|r
+This is a side effect of the animation API that I'm co-opting to force a rotation without having to provide duplicates of every bar texture in the mod. Any bar moving sufficiently quickly and updating rapidly will cause this. |cff9999ffIceHUD|r is intended to be a vertically-oriented mod, so the rotation feature is there for people who are willing to accept the side effects that come with it. My suggestion is to use one of the many horizontally-oriented bar mods out there if you're wanting horizontal bars. |cff42ffffQuartz|r is a good castbar replacement that you can use and disable |cff9999ffIceHUD|r's built-in castbar, for example.
+
+|cff9999ff18. How do I get rid of the bars that showed up beneath the player in the 7.0 patch?|r
+Blizzard added a "Personal Resource Display" feature in the 7.0 game client. You can disable it in the Game options -> Interface -> Names -> Personal Resource Display.]]
 				}
 			}
 		},
@@ -374,7 +380,24 @@ IceHUD is not responsible for this countdown text and cannot control it. The 6.0
 						end
 					end,
 					order = 34,
-				}
+				},
+
+				bHideInBarberShop = {
+					type = 'toggle',
+					name = L["Hide in barbershops"],
+					desc = L["This will hide the entire mod when interacting with a barbershop."],
+					width = 'double',
+					get = function()
+						return IceHUD.IceCore.settings.bHideInBarberShop
+					end,
+					set = function(info, value)
+						IceHUD.IceCore.settings.bHideInBarberShop = value
+						if not value then
+							IceHUD.IceCore.IceHUDFrame:Show()
+						end
+					end,
+					order = 35,
+				},
 			}
 		},
 

IceStackCounter.lua

@@ -0,0 +1,175 @@
+local L = LibStub("AceLocale-3.0"):GetLocale("IceHUD", false)
+
+local validUnits = {"player", "target", "focus", "pet", "vehicle", "targettarget", "main hand weapon", "off hand weapon"}
+local buffOrDebuff = {"buff", "debuff", "charges", "spell count"}
+
+-- OVERRIDE
+function IceStackCounter_GetOptions(frame, opts)
+	opts["customHeader"] = {
+		type = 'header',
+		name = L["Aura settings"],
+		order = 30.1,
+	}
+
+	opts["auraTarget"] = {
+		type = 'select',
+		values = validUnits,
+		name = L["Unit to track"],
+		desc = L["Select which unit that this bar should be looking for buffs/debuffs on"],
+		get = function(info)
+			return IceHUD:GetSelectValue(info, frame.moduleSettings.auraTarget)
+		end,
+		set = function(info, v)
+			frame.moduleSettings.auraTarget = info.option.values[v]
+			frame.unit = info.option.values[v]
+			frame:Redraw()
+			IceHUD:NotifyOptionsChange()
+		end,
+		disabled = function()
+			return not frame.moduleSettings.enabled or frame.moduleSettings.auraType == "charges" or frame.moduleSettings.auraType == "spell count"
+		end,
+		order = 30.4,
+	}
+
+	opts["auraType"] = {
+		type = 'select',
+		values = buffOrDebuff,
+		name = L["Buff or debuff?"],
+		desc = L["Whether we are tracking a buff or debuff"],
+		get = function(info)
+			return IceHUD:GetSelectValue(info, frame.moduleSettings.auraType)
+		end,
+		set = function(info, v)
+			frame.moduleSettings.auraType = info.option.values[v]
+			frame:Redraw()
+		end,
+		disabled = function()
+			return not frame.moduleSettings.enabled or frame.unit == "main hand weapon" or frame.unit == "off hand weapon"
+		end,
+		order = 30.5,
+	}
+
+	opts["auraName"] = {
+		type = 'input',
+		name = L["Aura to track"],
+		desc = L["Which buff/debuff this counter will be tracking. \n\nRemember to press ENTER after filling out this box with the name you want or it will not save."],
+		get = function()
+			return frame.moduleSettings.auraName
+		end,
+		set = function(info, v)
+			frame.moduleSettings.auraName = v
+			frame:Redraw()
+		end,
+		disabled = function()
+			return not frame.moduleSettings.enabled or frame.unit == "main hand weapon" or frame.unit == "off hand weapon"
+		end,
+		usage = "<which aura to track>",
+		order = 30.6,
+	}
+
+	opts["trackOnlyMine"] = {
+		type = 'toggle',
+		name = L["Only track auras by me"],
+		desc = L["Checking this means that only buffs or debuffs that the player applied will trigger this bar"],
+		get = function()
+			return frame.moduleSettings.onlyMine
+		end,
+		set = function(info, v)
+			frame.moduleSettings.onlyMine = v
+			frame:Redraw()
+		end,
+		disabled = function()
+			return not frame.moduleSettings.enabled or frame.unit == "main hand weapon" or frame.unit == "off hand weapon"
+				or frame.moduleSettings.auraType == "charges" or frame.moduleSettings.auraType == "spell count"
+		end,
+		order = 30.7,
+	}
+
+	opts["maxCount"] = {
+		type = 'input',
+		name = L["Maximum applications"],
+		desc = L["How many total applications of this buff/debuff can be applied. For example, only 5 sunders can ever be on a target, so this would be set to 5 for tracking Sunder.\n\nRemember to press ENTER after filling out this box with the name you want or it will not save."],
+		get = function()
+			return tostring(frame.moduleSettings.maxCount)
+		end,
+		set = function(info, v)
+			if not v or not tonumber(v) or tonumber(v) <= 0 then
+				v = 5
+			end
+			frame.moduleSettings.maxCount = tonumber(v)
+			frame:Redraw()
+		end,
+		disabled = function()
+			return not frame.moduleSettings.enabled or frame.moduleSettings.auraType == "charges"
+		end,
+		usage = "<the maximum number of valid applications>",
+		order = 30.9,
+	}
+end
+
+function IceStackCounter_GetMaxCount(frame)
+	if frame.moduleSettings.auraType == "charges" then
+		local _, max = GetSpellCharges(frame.moduleSettings.auraName)
+		return max or 1
+	else
+		return frame.moduleSettings.maxCount
+	end
+end
+
+function IceStackCounter_GetDefaultSettings(defaults)
+	defaults["maxCount"] = 5
+	defaults["auraTarget"] = "player"
+	defaults["auraName"] = ""
+	defaults["onlyMine"] = true
+	defaults["auraType"] = "buff"
+end
+
+
+function IceStackCounter_Enable(frame)
+	frame:RegisterEvent("UNIT_AURA", "UpdateCustomCount")
+	frame:RegisterEvent("UNIT_PET", "UpdateCustomCount")
+	frame:RegisterEvent("PLAYER_PET_CHANGED", "UpdateCustomCount")
+	frame:RegisterEvent("PLAYER_FOCUS_CHANGED", "UpdateCustomCount")
+	frame:RegisterEvent("PLAYER_TARGET_CHANGED", "UpdateCustomCount")
+	frame:RegisterEvent("PLAYER_DEAD", "UpdateCustomCount")
+	frame:RegisterEvent("SPELL_UPDATE_CHARGES", "UpdateCustomCount")
+
+	frame.unit = frame.moduleSettings.auraTarget or "player"
+
+	if not tonumber(frame.moduleSettings.maxCount) or tonumber(frame.moduleSettings.maxCount) <= 0 then
+		frame.moduleSettings.maxCount = 5
+		frame:Redraw()
+	end
+end
+
+function IceStackCounter_GetCount(frame)
+	if not frame.moduleSettings.auraName then
+		return
+	end
+
+	local points
+	if IceHUD.IceCore:IsInConfigMode() then
+		points = tonumber(frame.moduleSettings.maxCount)
+	else
+		if frame.moduleSettings.auraType == "charges" then
+			points = GetSpellCharges(frame.moduleSettings.auraName) or 0
+		elseif frame.moduleSettings.auraType == "spell count" then
+			points = GetSpellCount(frame.moduleSettings.auraName) or 0
+		else
+			points = IceHUD:GetAuraCount(frame.moduleSettings.auraType == "buff" and "HELPFUL" or "HARMFUL",
+				frame.unit, frame.moduleSettings.auraName, frame.moduleSettings.onlyMine, true)
+		end
+	end
+
+	frame.lastPoints = points
+
+	if (points == 0) then
+		points = nil
+	end
+
+	return points
+end
+
+function IceStackCounter_UseTargetAlpha(frame)
+	return frame.lastPoints ~= nil and frame.lastPoints > 0
+end

IceUnitBar.lua

@@ -85,7 +85,7 @@ function IceUnitBar.prototype:GetOptions()
 		end,
 		min = 0,
 		max = 1,
-		step = 0.05,
+		step = 0.01,
 		isPercent = true,
 		order = 30.091
 	}
@@ -197,13 +197,15 @@ end
 function IceUnitBar.prototype:RotateHorizontal()
 	IceUnitBar.super.prototype.RotateHorizontal(self)
 
-	self:RotateFrame(self.flashFrame)
+	if IceHUD.WowVer < 70000 then
+		self:RotateFrame(self.flashFrame)
+	end
 end
 
 function IceUnitBar.prototype:ResetRotation()
 	IceUnitBar.super.prototype.ResetRotation(self)
 
-	if self.flashFrame.anim then
+	if IceHUD.WowVer < 70000 and self.flashFrame and self.flashFrame.anim then
 		self.flashFrame.anim:Stop()
 	end
 end
@@ -213,14 +215,18 @@ end
 function IceUnitBar.prototype:Update()
 	IceUnitBar.super.prototype.Update(self)
 
-	self.tapped = UnitIsTapped(self.unit) and (not UnitIsTappedByPlayer(self.unit))
+	if IceHUD.WowVer < 70000 then
+		self.tapped = UnitIsTapped(self.unit) and (not UnitIsTappedByPlayer(self.unit))
+	else
+		self.tapped = UnitIsTapDenied(self.unit)
+	end
 
 	self.health = UnitHealth(self.unit)
 	self.maxHealth = UnitHealthMax(self.unit)
 	self.healthPercentage = self.maxHealth ~= 0 and (self.health/self.maxHealth) or 0
 
-	self.mana = UnitPower(self.unit)
-	self.maxMana = UnitPowerMax(self.unit)
+	self.mana = UnitPower(self.unit, UnitPowerType(self.unit))
+	self.maxMana = UnitPowerMax(self.unit, UnitPowerType(self.unit))
 	self.manaPercentage = self.maxMana ~= 0 and (self.mana/self.maxMana) or 0
 
 	local locClass

modules/ArcaneCharges.lua

@@ -0,0 +1,61 @@
+local L = LibStub("AceLocale-3.0"):GetLocale("IceHUD", false)
+local ArcaneCharges = IceCore_CreateClass(IceClassPowerCounter)
+
+function ArcaneCharges.prototype:init()
+	ArcaneCharges.super.prototype.init(self, "ArcaneCharges")
+
+	self:SetDefaultColor("ArcaneChargesNumeric", 150, 150, 255)
+
+	self.unit = "player"
+	self.numericColor = "ArcaneChargesNumeric"
+	self.unitPower = SPELL_POWER_ARCANE_CHARGES
+	self.minLevel = 0
+	self.bTreatEmptyAsFull = true
+	self.runeWidth = self.runeHeight
+	self.requiredSpec = SPEC_MAGE_ARCANE
+end
+
+function ArcaneCharges.prototype:Enable(core)
+	self.numRunes = UnitPowerMax(self.unit, SPELL_POWER_ARCANE_CHARGES)
+	self.runeCoords = { }
+	for i = 1, self.numRunes do
+		self.runeCoords[#self.runeCoords + 1] = {0, 1, 0, 1}
+	end
+
+	ArcaneCharges.super.prototype.Enable(self, core)
+
+end
+
+function ArcaneCharges.prototype:GetOptions()
+	local opts = ArcaneCharges.super.prototype.GetOptions(self)
+
+	opts.hideBlizz.desc = L["Hides Blizzard Arcane Charges frame and disables all events related to it.\n\nNOTE: Blizzard attaches the arcane charges UI to the player's unitframe, so if you have that hidden in PlayerHealth, then this won't do anything."]
+
+	return opts
+end
+
+function ArcaneCharges.prototype:GetRuneAtlas(rune)
+	return "Mage-ArcaneCharge"
+end
+
+function ArcaneCharges.prototype:GetShineAtlas(rune)
+	return "Mage-ArcaneCharge-SmallSpark"
+end
+
+function ArcaneCharges.prototype:ShowBlizz()
+	MageArcaneChargesFrame:Show()
+
+	MageArcaneChargesFrame:GetScript("OnLoad")(MageArcaneChargesFrame)
+end
+
+function ArcaneCharges.prototype:HideBlizz()
+	MageArcaneChargesFrame:Hide()
+
+	MageArcaneChargesFrame:UnregisterAllEvents()
+end
+
+-- Load us up
+local _, unitClass = UnitClass("player")
+if (unitClass == "MAGE" and IceHUD.WowVer >= 70000) then
+	IceHUD.ArcaneCharges = ArcaneCharges:new()
+end

modules/CastBar.lua

@@ -1,476 +1,506 @@
-local L = LibStub("AceLocale-3.0"):GetLocale("IceHUD", false)
-local CastBar = IceCore_CreateClass(IceCastBar)
-
-local IceHUD = _G.IceHUD
-
-CastBar.prototype.lagBar = nil
-CastBar.prototype.spellCastSent = nil
-
-
--- Constructor --
-function CastBar.prototype:init()
-	CastBar.super.prototype.init(self, "CastBar")
-
-	self:SetDefaultColor("CastLag", 255, 0, 0)
-	self:SetDefaultColor("CastNotInRange", 200, 200, 200)
-
-	self.unit = "player"
-end
-
-
--- 'Public' methods -----------------------------------------------------------
-
--- OVERRIDE
-function CastBar.prototype:GetDefaultSettings()
-	local settings = CastBar.super.prototype.GetDefaultSettings(self)
-
-	settings["side"] = IceCore.Side.Left
-	settings["offset"] = 0
-	settings["flashInstants"] = "Caster"
-	settings["flashFailures"] = "Caster"
-	settings["lagAlpha"] = 0.7
-	settings["showBlizzCast"] = false
-	settings["shouldAnimate"] = false
-	settings["hideAnimationSettings"] = true
-	settings["usesDogTagStrings"] = false
-	settings["rangeColor"] = true
-	settings["bAllowExpand"] = false
-
-	return settings
-end
-
-
--- OVERRIDE
-function CastBar.prototype:GetOptions()
-	local opts = CastBar.super.prototype.GetOptions(self)
-
-	opts["flashInstants"] =
-	{
-		type = 'select',
-		name = L["Flash Instant Spells"],
-		desc = L["Defines when cast bar should flash on instant spells"],
-		get = function(info)
-			return IceHUD:GetSelectValue(info, self.moduleSettings.flashInstants)
-		end,
-		set = function(info, value)
-			self.moduleSettings.flashInstants = info.option.values[value]
-		end,
-		values = { "Always", "Caster", "Never" },
-		disabled = function()
-			return not self.moduleSettings.enabled
-		end,
-		order = 40
-	}
-
-	opts["flashFailures"] =
-	{
-		type = 'select',
-		name = L["Flash on Spell Failures"],
-		desc = L["Defines when cast bar should flash on failed spells"],
-		get = function(info)
-			return IceHUD:GetSelectValue(info, self.moduleSettings.flashFailures)
-		end,
-		set = function(info, value)
-			self.moduleSettings.flashFailures = info.option.values[value]
-		end,
-		disabled = function()
-			return not self.moduleSettings.enabled
-		end,
-		values = { "Always", "Caster", "Never" },
-		order = 41
-	}
-
-	opts["lagAlpha"] =
-	{
-		type = 'range',
-		name = L["Lag Indicator alpha"],
-		desc = L["Lag indicator alpha (0 is disabled)"],
-		min = 0,
-		max = 1,
-		step = 0.1,
-		get = function()
-			return self.moduleSettings.lagAlpha
-		end,
-		set = function(info, value)
-			self.moduleSettings.lagAlpha = value
-			self:Redraw()
-		end,
-		disabled = function()
-			return not self.moduleSettings.enabled
-		end,
-		order = 42
-	}
-
-	opts["showBlizzCast"] =
-	{
-		type = 'toggle',
-		name = L["Show default cast bar"],
-		desc = L["Whether or not to show the default cast bar."],
-		get = function()
-			return self.moduleSettings.showBlizzCast
-		end,
-		set = function(info, value)
-			self.moduleSettings.showBlizzCast = value
-			self:ToggleBlizzCast(self.moduleSettings.showBlizzCast)
-		end,
-		disabled = function()
-			return not self.moduleSettings.enabled
-		end,
-		order = 43
-	}
-
-	opts["barVisible"] = {
-		type = 'toggle',
-		name = L["Bar visible"],
-		desc = L["Toggle bar visibility"],
-		get = function()
-			return self.moduleSettings.barVisible['bar']
-		end,
-		set = function(info, v)
-			self.moduleSettings.barVisible['bar'] = v
-			if v then
-				self.barFrame:Show()
-			else
-				self.barFrame:Hide()
-			end
-		end,
-		disabled = function()
-			return not self.moduleSettings.enabled
-		end,
-		order = 28
-	}
-
-	opts["bgVisible"] = {
-		type = 'toggle',
-		name = L["Bar background visible"],
-		desc = L["Toggle bar background visibility"],
-		get = function()
-			return self.moduleSettings.barVisible['bg']
-		end,
-		set = function(info, v)
-			self.moduleSettings.barVisible['bg'] = v
-			if v then
-				self.frame.bg:Show()
-			else
-				self.frame.bg:Hide()
-			end
-		end,
-		disabled = function()
-			return not self.moduleSettings.enabled
-		end,
-		order = 29
-	}
-
-	opts["rangeColor"] = {
-		type = 'toggle',
-		name = L["Change color when not in range"],
-		desc = L["Changes the bar color to the CastNotInRange color when the target goes out of range for the current spell."],
-		width = 'double',
-		get = function()
-			return self.moduleSettings.rangeColor
-		end,
-		set = function(info, v)
-			self.moduleSettings.rangeColor = v
-		end,
-		disabled = function()
-			return not self.moduleSettings.enabled
-		end,
-		order = 30
-	}
-
-	opts["textSettings"] =
-	{
-		type = 'group',
-		name = "|c"..self.configColor..L["Text Settings"].."|r",
-		desc = L["Settings related to texts"],
-		order = 32,
-		disabled = function()
-			return not self.moduleSettings.enabled
-		end,
-		args = {
-			fontsize = {
-				type = 'range',
-				name = L["Bar Font Size"],
-				desc = L["Bar Font Size"],
-				get = function()
-					return self.moduleSettings.barFontSize
-				end,
-				set = function(info, v)
-					self.moduleSettings.barFontSize = v
-					self:Redraw()
-				end,
-				min = 8,
-				max = 20,
-				step = 1,
-				order = 11
-			},
-
-			lockFontAlpha = {
-				type = "toggle",
-				name = L["Lock Bar Text Alpha"],
-				desc = L["Locks text alpha to 100%"],
-				get = function()
-					return self.moduleSettings.lockUpperTextAlpha
-				end,
-				set = function(info, v)
-					self.moduleSettings.lockUpperTextAlpha = v
-					self:Redraw()
-				end,
-				order = 13
-			},
-
-			upperTextVisible = {
-				type = 'toggle',
-				name = L["Spell cast text visible"],
-				desc = L["Toggle spell cast text visibility"],
-				get = function()
-					return self.moduleSettings.textVisible['upper']
-				end,
-				set = function(info, v)
-					self.moduleSettings.textVisible['upper'] = v
-					self:Redraw()
-				end,
-				order = 14
-			},
-
-			textVerticalOffset = {
-				type = 'range',
-				name = L["Text Vertical Offset"],
-				desc = L["Offset of the text from the bar vertically (negative is farther below)"],
-				min = -250,
-				max = 350,
-				step = 1,
-				get = function()
-					return self.moduleSettings.textVerticalOffset
-				end,
-				set = function(info, v)
-					self.moduleSettings.textVerticalOffset = v
-					self:Redraw()
-				end,
-				disabled = function()
-					return not self.moduleSettings.enabled
-				end
-			},
-
-			textHorizontalOffset = {
-				type = 'range',
-				name = L["Text Horizontal Offset"],
-				desc = L["Offset of the text from the bar horizontally"],
-				min = -350,
-				max = 350,
-				step = 1,
-				get = function()
-					return self.moduleSettings.textHorizontalOffset
-				end,
-				set = function(info, v)
-					self.moduleSettings.textHorizontalOffset = v
-					self:Redraw()
-				end,
-				disabled = function()
-					return not self.moduleSettings.enabled
-				end
-			},
-
-			forceJustifyText = {
-				type = 'select',
-				name = L["Force Text Justification"],
-				desc = L["This sets the alignment for the text on this bar"],
-				get = function()
-					return self.moduleSettings.forceJustifyText
-				end,
-				set = function(info, value)
-					self.moduleSettings.forceJustifyText = value
-					self:Redraw()
-				end,
-				values = { NONE = "None", LEFT = "Left", RIGHT = "Right" },
-				disabled = function()
-					return not self.moduleSettings.enabled
-				end,
-			}
-		}
-	}
-
-	return opts
-end
-
-function CastBar.prototype:Enable(core)
-	CastBar.super.prototype.Enable(self, core)
-
-	self:RegisterEvent("UNIT_ENTERED_VEHICLE", "EnteringVehicle")
-	self:RegisterEvent("UNIT_EXITED_VEHICLE", "ExitingVehicle")
-	self:RegisterEvent("PLAYER_ENTERING_WORLD", "CheckVehicle")
-
-	self:RegisterEvent("CVAR_UPDATE", "CVarUpdate")
-
-	self:CVarUpdate()
-
-	if self.moduleSettings.enabled and not self.moduleSettings.showBlizzCast then
-		self:ToggleBlizzCast(false)
-	end
-
-	if self.moduleSettings.shouldAnimate then
-		self.moduleSettings.shouldAnimate = false
-	end
-end
-
-
-function CastBar.prototype:EnteringVehicle(event, unit, arg2)
-	if (self.unit == "player" and IceHUD:ShouldSwapToVehicle(unit, arg2)) then
-		self.unit = "vehicle"
-		self:Update(self.unit)
-	end
-end
-
-
-function CastBar.prototype:ExitingVehicle(event, unit)
-	if (unit == "player" and self.unit == "vehicle") then
-		self.unit = "player"
-		self:Update(self.unit)
-	end
-end
-
-
-function CastBar.prototype:CheckVehicle()
-	if UnitHasVehicleUI("player") then
-		self:EnteringVehicle(nil, "player", true)
-	else
-		self:ExitingVehicle(nil, "player")
-	end
-end
-
-function CastBar.prototype:CVarUpdate(...)
-	self.useFixedLatency = GetCVar("reducedLagTolerance") == "1"
-	self.fixedLatency = tonumber(GetCVar("maxSpellStartRecoveryoffset")) / 1000
-end
-
-function CastBar.prototype:Disable(core)
-	CastBar.super.prototype.Disable(self, core)
-
-	if self.moduleSettings.showBlizzCast then
-		self:ToggleBlizzCast(true)
-	end
-end
-
-function CastBar.prototype:ToggleBlizzCast(on)
-	if on then
-		-- restore blizz cast bar
-		CastingBarFrame:GetScript("OnLoad")(CastingBarFrame)
-		PetCastingBarFrame:GetScript("OnLoad")(PetCastingBarFrame)
-	else
-		-- remove blizz cast bar
-		CastingBarFrame:UnregisterAllEvents()
-		PetCastingBarFrame:UnregisterAllEvents()
-	end
-end
-
-
--- OVERRIDE
-function CastBar.prototype:CreateFrame()
-	CastBar.super.prototype.CreateFrame(self)
-
-	self:CreateLagBar()
-end
-
-
-function CastBar.prototype:CreateLagBar()
-	self.lagBar = self:BarFactory(self.lagBar, "LOW","BACKGROUND")
-	self:SetBarCoord(self.lagBar, 0 , true)
-
-	local r, g, b = self:GetColor("CastLag")
-	if (self.settings.backgroundToggle) then
-		r, g, b = self:GetColor("CastCasting")
-	end
-	self.lagBar.bar:SetVertexColor(r, g, b, self.moduleSettings.lagAlpha)
-
-	self.lagBar.bar:Hide()
-end
-
-
--- OVERRIDE
-function CastBar.prototype:SpellCastSent(event, unit, spell, rank, target)
-	CastBar.super.prototype.SpellCastSent(self, event, unit, spell, rank, target)
-	if (unit ~= self.unit) then return end
-
-	self.spellCastSent = GetTime()
-end
-
--- OVERRIDE
-function CastBar.prototype:SpellCastStart(event, unit, spell, rank)
-	CastBar.super.prototype.SpellCastStart(self, event, unit, spell, rank)
-	if (unit ~= self.unit) then return end
-
-	if not self:IsVisible() or not self.actionDuration then
-		return
-	end
-
-	local scale
-	if self.unit == "vehicle" then
-		scale = 0
-	elseif self.useFixedLatency then
-		scale = IceHUD:Clamp(self.fixedLatency / self.actionDuration, 0, 1)
-	else
-		local now = GetTime()
-		local lag = now - (self.spellCastSent or now)
-		scale = IceHUD:Clamp(lag / self.actionDuration, 0, 1)
-	end
-
-	self.lagBar:SetFrameStrata("BACKGROUND")
-	self:SetBarCoord(self.lagBar, scale, true)
-
-	self.spellCastSent = nil
-end
-
-
--- OVERRIDE
-function CastBar.prototype:SpellCastChannelStart(event, unit)
-	CastBar.super.prototype.SpellCastChannelStart(self, event, unit)
-	if (unit ~= self.unit) then return end
-
-	if not self:IsVisible() or not self.actionDuration then
-		return
-	end
-
-	local scale
-	if self.unit == "vehicle" then
-		scale = 0
-	elseif self.useFixedLatency then
-		scale = IceHUD:Clamp(self.fixedLatency / self.actionDuration, 0, 1)
-	else
-		local now = GetTime()
-		local lag = now - (self.spellCastSent or now)
-		scale = IceHUD:Clamp(lag / self.actionDuration, 0, 1)
-	end
-
-	local top = not self.moduleSettings.reverseChannel
-
-	self.lagBar:SetFrameStrata("MEDIUM")
-	self:SetBarCoord(self.lagBar, scale, top)
-
-	self.spellCastSent = nil
-end
-
-
-function CastBar.prototype:UpdateBar(scale, color, alpha)
-	local bCheckRange = true
-	local inRange
-
-	if not self.moduleSettings.rangeColor or not self.current or not self.action or not UnitExists("target") then
-		bCheckRange = false
-	else
-		inRange = IsSpellInRange(self.current, "target")
-		if inRange == nil then
-			bCheckRange = false
-		end
-	end
-
-	if bCheckRange and inRange == 0 then
-		color = "CastNotInRange"
-	end
-
-	CastBar.super.prototype.UpdateBar(self, scale, color, alpha)
-end
-
--------------------------------------------------------------------------------
-
--- Load us up
-IceHUD.PlayerCast = CastBar:new()
+local L = LibStub("AceLocale-3.0"):GetLocale("IceHUD", false)
+local CastBar = IceCore_CreateClass(IceCastBar)
+
+local IceHUD = _G.IceHUD
+
+CastBar.prototype.spellCastSent = nil
+CastBar.prototype.sentSpell = nil
+
+-- Constructor --
+function CastBar.prototype:init()
+	CastBar.super.prototype.init(self, "CastBar")
+
+	self:SetDefaultColor("CastLag", 255, 0, 0)
+	self:SetDefaultColor("CastNotInRange", 200, 200, 200)
+
+	self.unit = "player"
+end
+
+
+-- 'Public' methods -----------------------------------------------------------
+
+-- OVERRIDE
+function CastBar.prototype:GetDefaultSettings()
+	local settings = CastBar.super.prototype.GetDefaultSettings(self)
+
+	settings["side"] = IceCore.Side.Left
+	settings["offset"] = 0
+	settings["flashInstants"] = "Caster"
+	settings["flashFailures"] = "Caster"
+	settings["lagAlpha"] = 0.7
+	settings["showBlizzCast"] = false
+	settings["shouldAnimate"] = false
+	settings["hideAnimationSettings"] = true
+	settings["usesDogTagStrings"] = false
+	settings["rangeColor"] = true
+	settings["bAllowExpand"] = false
+	settings["respectLagTolerance"] = true
+
+	return settings
+end
+
+
+-- OVERRIDE
+function CastBar.prototype:GetOptions()
+	local opts = CastBar.super.prototype.GetOptions(self)
+
+	opts["flashInstants"] =
+	{
+		type = 'select',
+		name = L["Flash Instant Spells"],
+		desc = L["Defines when cast bar should flash on instant spells"],
+		get = function(info)
+			return IceHUD:GetSelectValue(info, self.moduleSettings.flashInstants)
+		end,
+		set = function(info, value)
+			self.moduleSettings.flashInstants = info.option.values[value]
+		end,
+		values = { "Always", "Caster", "Never" },
+		disabled = function()
+			return not self.moduleSettings.enabled
+		end,
+		order = 40
+	}
+
+	opts["flashFailures"] =
+	{
+		type = 'select',
+		name = L["Flash on Spell Failures"],
+		desc = L["Defines when cast bar should flash on failed spells"],
+		get = function(info)
+			return IceHUD:GetSelectValue(info, self.moduleSettings.flashFailures)
+		end,
+		set = function(info, value)
+			self.moduleSettings.flashFailures = info.option.values[value]
+		end,
+		disabled = function()
+			return not self.moduleSettings.enabled
+		end,
+		values = { "Always", "Caster", "Never" },
+		order = 41
+	}
+
+	opts["lagAlpha"] =
+	{
+		type = 'range',
+		name = L["Lag Indicator alpha"],
+		desc = L["Lag indicator alpha (0 is disabled)"],
+		min = 0,
+		max = 1,
+		step = 0.1,
+		get = function()
+			return self.moduleSettings.lagAlpha
+		end,
+		set = function(info, value)
+			self.moduleSettings.lagAlpha = value
+			self:Redraw()
+		end,
+		disabled = function()
+			return not self.moduleSettings.enabled
+		end,
+		order = 42
+	}
+
+	opts["showBlizzCast"] =
+	{
+		type = 'toggle',
+		name = L["Show default cast bar"],
+		desc = L["Whether or not to show the default cast bar."],
+		get = function()
+			return self.moduleSettings.showBlizzCast
+		end,
+		set = function(info, value)
+			self.moduleSettings.showBlizzCast = value
+			self:ToggleBlizzCast(self.moduleSettings.showBlizzCast)
+		end,
+		disabled = function()
+			return not self.moduleSettings.enabled
+		end,
+		order = 43
+	}
+
+	opts["respectLagTolerance"] =
+	{
+		type = 'toggle',
+		name = L["Respect lag tolerance"],
+		desc = L["When checked, if a 'Custom Lag Tolerance' is set in the game's Combat options, the lag indicator will always use that tolerance value. Otherwise, it uses the computed latency."],
+		get = function()
+			return self.moduleSettings.respectLagTolerance
+		end,
+		set = function(info, value)
+			self.moduleSettings.respectLagTolerance = value
+			self:CVarUpdate()
+		end,
+		disabled = function()
+			return not self.moduleSettings.enabled or GetCVar("reducedLagTolerance") == "0"
+		end,
+		order = 42.1,
+	}
+
+	opts["barVisible"] = {
+		type = 'toggle',
+		name = L["Bar visible"],
+		desc = L["Toggle bar visibility"],
+		get = function()
+			return self.moduleSettings.barVisible['bar']
+		end,
+		set = function(info, v)
+			self.moduleSettings.barVisible['bar'] = v
+			if v then
+				self.barFrame:Show()
+			else
+				self.barFrame:Hide()
+			end
+		end,
+		disabled = function()
+			return not self.moduleSettings.enabled
+		end,
+		order = 28
+	}
+
+	opts["bgVisible"] = {
+		type = 'toggle',
+		name = L["Bar background visible"],
+		desc = L["Toggle bar background visibility"],
+		get = function()
+			return self.moduleSettings.barVisible['bg']
+		end,
+		set = function(info, v)
+			self.moduleSettings.barVisible['bg'] = v
+			if v then
+				self.frame.bg:Show()
+			else
+				self.frame.bg:Hide()
+			end
+		end,
+		disabled = function()
+			return not self.moduleSettings.enabled
+		end,
+		order = 29
+	}
+
+	opts["rangeColor"] = {
+		type = 'toggle',
+		name = L["Change color when not in range"],
+		desc = L["Changes the bar color to the CastNotInRange color when the target goes out of range for the current spell."],
+		width = 'double',
+		get = function()
+			return self.moduleSettings.rangeColor
+		end,
+		set = function(info, v)
+			self.moduleSettings.rangeColor = v
+		end,
+		disabled = function()
+			return not self.moduleSettings.enabled
+		end,
+		order = 30
+	}
+
+	opts["textSettings"] =
+	{
+		type = 'group',
+		name = "|c"..self.configColor..L["Text Settings"].."|r",
+		desc = L["Settings related to texts"],
+		order = 32,
+		disabled = function()
+			return not self.moduleSettings.enabled
+		end,
+		args = {
+			fontsize = {
+				type = 'range',
+				name = L["Bar Font Size"],
+				desc = L["Bar Font Size"],
+				get = function()
+					return self.moduleSettings.barFontSize
+				end,
+				set = function(info, v)
+					self.moduleSettings.barFontSize = v
+					self:Redraw()
+				end,
+				min = 8,
+				max = 20,
+				step = 1,
+				order = 11
+			},
+
+			lockFontAlpha = {
+				type = "toggle",
+				name = L["Lock Bar Text Alpha"],
+				desc = L["Locks text alpha to 100%"],
+				get = function()
+					return self.moduleSettings.lockUpperTextAlpha
+				end,
+				set = function(info, v)
+					self.moduleSettings.lockUpperTextAlpha = v
+					self:Redraw()
+				end,
+				order = 13
+			},
+
+			upperTextVisible = {
+				type = 'toggle',
+				name = L["Spell cast text visible"],
+				desc = L["Toggle spell cast text visibility"],
+				get = function()
+					return self.moduleSettings.textVisible['upper']
+				end,
+				set = function(info, v)
+					self.moduleSettings.textVisible['upper'] = v
+					self:Redraw()
+				end,
+				order = 14
+			},
+
+			textVerticalOffset = {
+				type = 'range',
+				name = L["Text Vertical Offset"],
+				desc = L["Offset of the text from the bar vertically (negative is farther below)"],
+				min = -250,
+				max = 350,
+				step = 1,
+				get = function()
+					return self.moduleSettings.textVerticalOffset
+				end,
+				set = function(info, v)
+					self.moduleSettings.textVerticalOffset = v
+					self:Redraw()
+				end,
+				disabled = function()
+					return not self.moduleSettings.enabled
+				end
+			},
+
+			textHorizontalOffset = {
+				type = 'range',
+				name = L["Text Horizontal Offset"],
+				desc = L["Offset of the text from the bar horizontally"],
+				min = -350,
+				max = 350,
+				step = 1,
+				get = function()
+					return self.moduleSettings.textHorizontalOffset
+				end,
+				set = function(info, v)
+					self.moduleSettings.textHorizontalOffset = v
+					self:Redraw()
+				end,
+				disabled = function()
+					return not self.moduleSettings.enabled
+				end
+			},
+
+			forceJustifyText = {
+				type = 'select',
+				name = L["Force Text Justification"],
+				desc = L["This sets the alignment for the text on this bar"],
+				get = function()
+					return self.moduleSettings.forceJustifyText
+				end,
+				set = function(info, value)
+					self.moduleSettings.forceJustifyText = value
+					self:Redraw()
+				end,
+				values = { NONE = "None", LEFT = "Left", RIGHT = "Right" },
+				disabled = function()
+					return not self.moduleSettings.enabled
+				end,
+			}
+		}
+	}
+
+	return opts
+end
+
+function CastBar.prototype:Enable(core)
+	CastBar.super.prototype.Enable(self, core)
+
+	self:RegisterEvent("UNIT_ENTERED_VEHICLE", "EnteringVehicle")
+	self:RegisterEvent("UNIT_EXITED_VEHICLE", "ExitingVehicle")
+	self:RegisterEvent("PLAYER_ENTERING_WORLD", "CheckVehicle")
+
+	self:RegisterEvent("CVAR_UPDATE", "CVarUpdate")
+
+	self:CVarUpdate()
+
+	if self.moduleSettings.enabled and not self.moduleSettings.showBlizzCast then
+		self:ToggleBlizzCast(false)
+	end
+
+	if self.moduleSettings.shouldAnimate then
+		self.moduleSettings.shouldAnimate = false
+	end
+end
+
+
+function CastBar.prototype:EnteringVehicle(event, unit, arg2)
+	if (self.unit == "player" and IceHUD:ShouldSwapToVehicle(unit, arg2)) then
+		self.unit = "vehicle"
+		self:Update(self.unit)
+	end
+end
+
+
+function CastBar.prototype:ExitingVehicle(event, unit)
+	if (unit == "player" and self.unit == "vehicle") then
+		self.unit = "player"
+		self:Update(self.unit)
+	end
+end
+
+
+function CastBar.prototype:CheckVehicle()
+	if UnitHasVehicleUI("player") then
+		self:EnteringVehicle(nil, "player", true)
+	else
+		self:ExitingVehicle(nil, "player")
+	end
+end
+
+function CastBar.prototype:CVarUpdate(...)
+	self.useFixedLatency = self.moduleSettings.respectLagTolerance and GetCVar("reducedLagTolerance") == "1"
+	self.fixedLatency = tonumber(GetCVar("maxSpellStartRecoveryoffset")) / 1000
+end
+
+function CastBar.prototype:Disable(core)
+	CastBar.super.prototype.Disable(self, core)
+
+	if self.moduleSettings.showBlizzCast then
+		self:ToggleBlizzCast(true)
+	end
+end
+
+function CastBar.prototype:ToggleBlizzCast(on)
+	if on then
+		-- restore blizz cast bar
+		CastingBarFrame:GetScript("OnLoad")(CastingBarFrame)
+		PetCastingBarFrame:GetScript("OnLoad")(PetCastingBarFrame)
+	else
+		-- remove blizz cast bar
+		CastingBarFrame:UnregisterAllEvents()
+		PetCastingBarFrame:UnregisterAllEvents()
+	end
+end
+
+
+-- OVERRIDE
+function CastBar.prototype:CreateFrame()
+	CastBar.super.prototype.CreateFrame(self)
+
+	self:CreateLagBar()
+end
+
+
+function CastBar.prototype:CreateLagBar()
+	self.lagBar = self:BarFactory(self.lagBar, "LOW", "OVERLAY")
+
+	local r, g, b = self:GetColor("CastLag")
+	if (self.settings.backgroundToggle) then
+		r, g, b = self:GetColor("CastCasting")
+	end
+
+	self.lagBar.bar:SetVertexColor(r, g, b, self.moduleSettings.lagAlpha)
+	self.lagBar.bar:Hide()
+end
+
+
+-- OVERRIDE
+function CastBar.prototype:SpellCastSent(event, unit, spell, rank, target, lineId)
+	CastBar.super.prototype.SpellCastSent(self, event, unit, spell, rank, target, lineId)
+	if (unit ~= self.unit) then return end
+
+	if IceHUD.WowVer < 70000 then
+		self.spellCastSent = GetTime()
+	end
+	self.sentSpell = lineId
+end
+
+-- OVERRIDE
+function CastBar.prototype:SpellCastChanged(event, arg1)
+	CastBar.super.prototype.SpellCastChanged(self, event, arg1)
+	if IceHUD.WowVer >= 70000 then
+		self.spellCastSent = GetTime()
+	end
+end
+
+-- OVERRIDE
+function CastBar.prototype:SpellCastStart(event, unit, spell, rank, lineId, spellId)
+	CastBar.super.prototype.SpellCastStart(self, event, unit, spell, rank, lineId, spellId)
+	if (unit ~= self.unit) then return end
+
+	if not self:IsVisible() or not self.actionDuration then
+		return
+	end
+
+	if self.sentSpell ~= lineId then
+		self.spellCastSent = nil
+	end
+
+	local scale
+	if self.unit == "vehicle" then
+		scale = 0
+	elseif self.useFixedLatency then
+		scale = IceHUD:Clamp(self.fixedLatency / self.actionDuration, 0, 1)
+	else
+		local now = GetTime()
+		local lag = now - (self.spellCastSent or now)
+		scale = IceHUD:Clamp(lag / self.actionDuration, 0, 1)
+	end
+
+	self:SetBarCoord(self.lagBar, scale, true, true)
+
+	self.spellCastSent = nil
+end
+
+
+-- OVERRIDE
+function CastBar.prototype:SpellCastChannelStart(event, unit)
+	CastBar.super.prototype.SpellCastChannelStart(self, event, unit)
+	if (unit ~= self.unit) then return end
+
+	if not self:IsVisible() or not self.actionDuration then
+		return
+	end
+
+	local scale
+	if self.unit == "vehicle" then
+		scale = 0
+	elseif self.useFixedLatency then
+		scale = IceHUD:Clamp(self.fixedLatency / self.actionDuration, 0, 1)
+	else
+		local now = GetTime()
+		local lag = now - (self.spellCastSent or now)
+		scale = IceHUD:Clamp(lag / self.actionDuration, 0, 1)
+	end
+
+	local top = not self.moduleSettings.reverseChannel
+
+	self:SetBarCoord(self.lagBar, scale, top, true)
+
+	self.spellCastSent = nil
+end
+
+
+function CastBar.prototype:UpdateBar(scale, color, alpha)
+	local bCheckRange = true
+	local inRange
+
+	if not self.moduleSettings.rangeColor or not self.current or not self.action or not UnitExists("target") then
+		bCheckRange = false
+	else
+		inRange = IsSpellInRange(self.current, "target")
+		if inRange == nil then
+			bCheckRange = false
+		end
+	end
+
+	if bCheckRange and inRange == 0 then
+		color = "CastNotInRange"
+	end
+
+	CastBar.super.prototype.UpdateBar(self, scale, color, alpha)
+end
+
+-------------------------------------------------------------------------------
+
+-- Load us up
+IceHUD.PlayerCast = CastBar:new()

modules/ClassPowerCounter.lua

@@ -17,6 +17,7 @@ IceClassPowerCounter.prototype.DesiredAnimPause = 0.5
 IceClassPowerCounter.prototype.requiredSpec = nil
 IceClassPowerCounter.prototype.shouldShowUnmodified = false
 IceClassPowerCounter.prototype.unmodifiedMaxPerRune = 10
+IceClassPowerCounter.prototype.unit = "player"
 
 IceClassPowerCounter.prototype.growModes = { width = 1, height = 2 }
 IceClassPowerCounter.prototype.currentGrowMode = nil
@@ -418,6 +419,11 @@ end
 function IceClassPowerCounter.prototype:Enable(core)
 	IceClassPowerCounter.super.prototype.Enable(self, core)
 
+	if IceHUD.WowVer >= 70000 then
+		self.numRunes = UnitPowerMax(self.unit, self.unitPower)
+	end
+	self:CreateFrame()
+
 	self:CheckValidLevel(nil, UnitLevel("player"))
 end
 
@@ -483,6 +489,14 @@ function IceClassPowerCounter.prototype:UpdateRunePower(event, arg1, arg2)
 		return
 	end
 
+	if IceHUD.WowVer >= 70000 then
+		local numMax = UnitPowerMax(self.unit, self.unitPower)
+		if numMax ~= self.numRunes then
+			self.numRunes = numMax
+			self:CreateFrame()
+		end
+	end
+
 	local numReady = UnitPower("player", self.unitPower)
 	local percentReady = self.shouldShowUnmodified and (UnitPower("player", self.unitPower, true) / self.unmodifiedMaxPerRune) or numReady
 
@@ -624,9 +638,20 @@ function IceClassPowerCounter.prototype:ShineFinished(rune)
 end
 
 function IceClassPowerCounter.prototype:GetRuneTexture(rune)
-	assert(false, "Must override GetRuneTexture in child classes")
+	return nil
 end
 
+function IceClassPowerCounter.prototype:GetRuneAtlas(rune)
+	return nil
+end
+
+function IceClassPowerCounter.prototype:UseAtlasSize(rune)
+	return false
+end
+
+function IceClassPowerCounter.prototype:GetShineAtlas(rune)
+	return nil
+end
 
 function IceClassPowerCounter.prototype:CreateFrame()
 	IceClassPowerCounter.super.prototype.CreateFrame(self)
@@ -659,11 +684,6 @@ function IceClassPowerCounter.prototype:SetDisplayMode()
 		for i=1, self.numRunes do
 			self:SetupRuneTexture(i)
 			self.frame.graphical[i]:Show()
-			if self.moduleSettings.inactiveDisplayMode == "Darkened" then
-				self.frame.graphical[i].runebg:Show()
-			else
-				self.frame.graphical[i].runebg:Hide()
-			end
 		end
 	end
 end
@@ -698,14 +718,16 @@ function IceClassPowerCounter.prototype:CreateRune(i)
 
 		self.frame.graphical[i].rune = self.frame.graphical[i]:CreateTexture(nil, "ARTWORK")
 		self.frame.graphical[i].rune:SetVertexColor(0, 0, 0)
-		self.frame.graphical[i].runebg = self.frame.graphical[i]:CreateTexture(nil, "BACKGROUND")
-		self.frame.graphical[i].runebg:SetVertexColor(0, 0, 0)
 		self:SetupRuneTexture(i)
 
 		self.frame.graphical[i].shine = self.frame.graphical[i]:CreateTexture(nil, "OVERLAY")
-		self.frame.graphical[i].shine:SetTexture("Interface\\ComboFrame\\ComboPoint")
-		self.frame.graphical[i].shine:SetBlendMode("ADD")
+		if self:GetShineAtlas(i) then
+			self.frame.graphical[i].shine:SetAtlas(self:GetShineAtlas(i))
+		else
+			self.frame.graphical[i].shine:SetTexture("Interface\\ComboFrame\\ComboPoint")
 		self.frame.graphical[i].shine:SetTexCoord(0.5625, 1, 0, 1)
+		end
+		self.frame.graphical[i].shine:SetBlendMode("ADD")
 		self.frame.graphical[i].shine:ClearAllPoints()
 		self.frame.graphical[i].shine:SetPoint("CENTER", self.frame.graphical[i], "CENTER")
 
@@ -720,14 +742,10 @@ function IceClassPowerCounter.prototype:CreateRune(i)
 	self.frame.graphical[i]:SetHeight(self.runeHeight)
 	self.frame.graphical[i].rune:SetWidth(self.runeWidth)
 	self.frame.graphical[i].rune:SetHeight(self.runeHeight)
-	self.frame.graphical[i].runebg:SetWidth(self.runeWidth)
-	self.frame.graphical[i].runebg:SetHeight(self.runeHeight)
 	if self.currentGrowMode == self.growModes["width"] then
 		self.frame.graphical[i].rune:SetPoint("LEFT", self.frame.graphical[i], "LEFT")
-		self.frame.graphical[i].runebg:SetPoint("LEFT", self.frame.graphical[i], "LEFT")
 	else
 		self.frame.graphical[i].rune:SetPoint("BOTTOM", self.frame.graphical[i], "BOTTOM")
-		self.frame.graphical[i].runebg:SetPoint("BOTTOM", self.frame.graphical[i], "BOTTOM")
 	end
 end
 
@@ -745,7 +763,6 @@ function IceClassPowerCounter.prototype:SetupRuneTexture(rune)
 
 	-- make sure any texture aside from the special one is square and has the proper coordinates
 	self.frame.graphical[rune].rune:SetTexCoord(a, b, c, d)
-	self.frame.graphical[rune].runebg:SetTexCoord(a, b, c, d)
 	self.frame.graphical[rune]:SetWidth(width)
 	self.frame:SetWidth(width*self.numRunes)
 	local runeAdjust = rune - (self.numRunes / 2) - 0.5
@@ -756,7 +773,12 @@ function IceClassPowerCounter.prototype:SetupRuneTexture(rune)
 	end
 
 	if self:GetRuneMode() == "Graphical" then
-		self.frame.graphical[rune].rune:SetTexture(self:GetRuneTexture(rune))
+		local tex = self:GetRuneTexture(rune)
+		if tex then
+			self.frame.graphical[rune].rune:SetTexture(tex)
+		else
+			self.frame.graphical[rune].rune:SetAtlas(self:GetRuneAtlas(rune), self:UseAtlasSize(rune))
+		end
 	elseif self:GetRuneMode() == "Graphical Bar" then
 		self.frame.graphical[rune].rune:SetTexture(IceElement.TexturePath .. "Combo")
 	elseif self:GetRuneMode() == "Graphical Circle" then
@@ -766,7 +788,6 @@ function IceClassPowerCounter.prototype:SetupRuneTexture(rune)
 	elseif self:GetRuneMode() == "Graphical Clean Circle" then
 		self.frame.graphical[rune].rune:SetTexture(IceElement.TexturePath .. "ComboCleanCurves")
 	end
-	self.frame.graphical[rune].runebg:SetTexture(self.frame.graphical[rune].rune:GetTexture())
 end
 
 function IceClassPowerCounter.prototype:GetAlphaAdd()

modules/ComboPoints.lua

@@ -3,7 +3,6 @@ local ComboPoints = IceCore_CreateClass(IceElement)
 
 local IceHUD = _G.IceHUD
 
-local AnticipationAuraName = "Anticipation"
 local AnticipationSpellId = 114015
 
 ComboPoints.prototype.comboSize = 20
@@ -18,6 +17,15 @@ function ComboPoints.prototype:init()
 end
 
 
+function ComboPoints.prototype:GetMaxComboPoints()
+	local retval = UnitPowerMax("player", SPELL_POWER_COMBO_POINTS)
+	if retval == 0 then -- accommodate non-rogues who still need combo point displays for some specific encounters/quests
+		retval = 5
+	end
+
+	return retval
+end
+
 
 -- 'Public' methods -----------------------------------------------------------
 
@@ -150,28 +158,30 @@ function ComboPoints.prototype:GetOptions()
 		order = 33.2
 	}
 
-	opts["anticipation"] = {
-		type = "toggle",
-		name = L["Show Anticipation"],
-		desc = L["Show points stored by the Anticipation talent"],
-		get = function()
-			return self.moduleSettings.showAnticipation
-		end,
-		set = function(info, v)
-			self.moduleSettings.showAnticipation = v
-			self:AddAnticipation() -- This will activate or deactivate as needed
-			self:Redraw()
-		end,
-		disabled = function()
-			return not self.moduleSettings.enabled
-		end,
-		order = 33.3
-	}
+	if IceHUD.WowVer < 70000 then
+		opts["anticipation"] = {
+			type = "toggle",
+			name = L["Show Anticipation"],
+			desc = L["Show points stored by the Anticipation talent"],
+			get = function()
+				return self.moduleSettings.showAnticipation
+			end,
+			set = function(info, v)
+				self.moduleSettings.showAnticipation = v
+				self:AddAnticipation() -- This will activate or deactivate as needed
+				self:Redraw()
+			end,
+			disabled = function()
+				return not self.moduleSettings.enabled
+			end,
+			order = 33.3
+		}
+	end
 
 	opts["gradient"] = {
 		type = "toggle",
 		name = L["Change color"],
-		desc = L["1 combo point: yellow, 5 combo points: red"],
+		desc = L["1 combo point: yellow, max combo points: red"],
 		get = function()
 			return self.moduleSettings.gradient
 		end,
@@ -239,11 +249,18 @@ function ComboPoints.prototype:Enable(core)
 
 	self:RegisterEvent("PLAYER_TARGET_CHANGED", "UpdateComboPoints")
 	if IceHUD.WowVer >= 30000 then
-		self:RegisterEvent("UNIT_COMBO_POINTS", "UpdateComboPoints")
+		if IceHUD.WowVer < 70000 then
+			self:RegisterEvent("UNIT_COMBO_POINTS", "UpdateComboPoints")
+		else
+			self:RegisterEvent("UNIT_POWER", "UpdateComboPoints")
+			self:RegisterEvent("UNIT_MAXPOWER", "UpdateMaxComboPoints")
+		end
 		self:RegisterEvent("UNIT_ENTERED_VEHICLE", "UpdateComboPoints")
 		self:RegisterEvent("UNIT_EXITED_VEHICLE", "UpdateComboPoints")
-		self:RegisterEvent("PLAYER_TALENT_UPDATE", "AddAnticipation")
-		self:AddAnticipation()
+		if IceHUD.WowVer < 70000 then
+			self:RegisterEvent("PLAYER_TALENT_UPDATE", "AddAnticipation")
+			self:AddAnticipation()
+		end
 	else
 		self:RegisterEvent("PLAYER_COMBO_POINTS", "UpdateComboPoints")
 	end
@@ -255,7 +272,15 @@ function ComboPoints.prototype:Enable(core)
 	self:CreateComboFrame(true)
 end
 
-
+function ComboPoints.prototype:UpdateMaxComboPoints(event, unit, powerType)
+	if unit == "player" and powerType == "COMBO_POINTS" then
+		for i = 1, #self.frame.graphical do
+			self.frame.graphicalBG[i]:Hide()
+			self.frame.graphical[i]:Hide()
+		end
+		self:Redraw()
+	end
+end
 
 -- 'Protected' methods --------------------------------------------------------
 
@@ -265,11 +290,11 @@ function ComboPoints.prototype:CreateFrame()
 
 	self.frame:SetFrameStrata("BACKGROUND")
 	if self.moduleSettings.graphicalLayout == "Horizontal" then
-		self.frame:SetWidth(self.comboSize*5)
+		self.frame:SetWidth((self.comboSize - 5)*self:GetMaxComboPoints())
 		self.frame:SetHeight(1)
 	else
 		self.frame:SetWidth(1)
-		self.frame:SetHeight(self.comboSize*5)
+		self.frame:SetHeight(self.comboSize*self:GetMaxComboPoints())
 	end
 	self.frame:ClearAllPoints()
 	self.frame:SetPoint("TOP", self.parent, "BOTTOM", self.moduleSettings.hpos, self.moduleSettings.vpos)
@@ -298,9 +323,10 @@ function ComboPoints.prototype:CreateComboFrame(forceTextureUpdate)
 	end
 
 	local i
+	local maxComboPoints = self:GetMaxComboPoints()
 
 	-- create backgrounds
-	for i = 1, 5 do
+	for i = 1, maxComboPoints do
 		if (not self.frame.graphicalBG[i]) then
 			local frame = CreateFrame("Frame", nil, self.frame)
 			self.frame.graphicalBG[i] = frame
@@ -324,9 +350,9 @@ function ComboPoints.prototype:CreateComboFrame(forceTextureUpdate)
 		self.frame.graphicalBG[i]:SetWidth(self.comboSize)
 		self.frame.graphicalBG[i]:SetHeight(self.comboSize)
 		if self.moduleSettings.graphicalLayout == "Horizontal" then
-			self.frame.graphicalBG[i]:SetPoint("TOPLEFT", ((i-1) * (self.comboSize-5)) + (i-1) + ((i-1) * self.moduleSettings.comboGap), 0)
+			self.frame.graphicalBG[i]:SetPoint("TOPLEFT", ((i-1) * (self.comboSize-5)) - 2.5 + ((i-1) * self.moduleSettings.comboGap), 0)
 		else
-			self.frame.graphicalBG[i]:SetPoint("TOPLEFT", 0, -1 * (((i-1) * (self.comboSize-5)) + (i-1) + ((i-1) * self.moduleSettings.comboGap)))
+			self.frame.graphicalBG[i]:SetPoint("TOPLEFT", 0, -1 * (((i-1) * (self.comboSize-5)) - 2.5 + ((i-1) * self.moduleSettings.comboGap)))
 		end
 		self.frame.graphicalBG[i]:SetAlpha(0.15)
 		self.frame.graphicalBG[i].texture:SetVertexColor(self:GetColor("ComboPoints"))
@@ -335,7 +361,7 @@ function ComboPoints.prototype:CreateComboFrame(forceTextureUpdate)
 	end
 
 	-- create combo points
-	for i = 1, 5 do
+	for i = 1, maxComboPoints do
 		if (not self.frame.graphical[i]) then
 			local frame = CreateFrame("Frame", nil, self.frame)
 			self.frame.graphical[i] = frame
@@ -360,7 +386,7 @@ function ComboPoints.prototype:CreateComboFrame(forceTextureUpdate)
 
 		local r, g, b = self:GetColor("ComboPoints")
 		if (self.moduleSettings.gradient) then
-			g = g - (0.15*i)
+			g = g - ((1 / maxComboPoints)*i)
 		end
 		self.frame.graphical[i].texture:SetVertexColor(r, g, b)
 
@@ -368,58 +394,68 @@ function ComboPoints.prototype:CreateComboFrame(forceTextureUpdate)
 	end
 
 	-- create Anticipation points
-	for i = 1, 5 do
-		if (not self.frame.graphicalAnt[i]) then
-			local frame = CreateFrame("Frame", nil, self.frame)
-			self.frame.graphicalAnt[i] = frame
-			frame.texture = frame:CreateTexture()
-			frame.texture:SetAllPoints(frame)
-		end
-
-		if forceTextureUpdate then
-			if self.moduleSettings.comboMode == "Graphical Bar" then
-				self.frame.graphicalAnt[i].texture:SetTexture(IceElement.TexturePath .. "Combo")
-			elseif self.moduleSettings.comboMode == "Graphical Circle" then
-				self.frame.graphicalAnt[i].texture:SetTexture(IceElement.TexturePath .. "ComboRound")
-			elseif self.moduleSettings.comboMode == "Graphical Glow" then
-				self.frame.graphicalAnt[i].texture:SetTexture(IceElement.TexturePath .. "ComboGlow")
-			elseif self.moduleSettings.comboMode == "Graphical Clean Circle" then
-				self.frame.graphicalAnt[i].texture:SetTexture(IceElement.TexturePath .. "ComboCleanCurves")
+	if IceHUD.WowVer < 70000 then
+		for i = 1, 5 do
+			if (not self.frame.graphicalAnt[i]) then
+				local frame = CreateFrame("Frame", nil, self.frame)
+				self.frame.graphicalAnt[i] = frame
+				frame.texture = frame:CreateTexture()
+				frame.texture:SetAllPoints(frame)
 			end
+
+			if forceTextureUpdate then
+				if self.moduleSettings.comboMode == "Graphical Bar" then
+					self.frame.graphicalAnt[i].texture:SetTexture(IceElement.TexturePath .. "Combo")
+				elseif self.moduleSettings.comboMode == "Graphical Circle" then
+					self.frame.graphicalAnt[i].texture:SetTexture(IceElement.TexturePath .. "ComboRound")
+				elseif self.moduleSettings.comboMode == "Graphical Glow" then
+					self.frame.graphicalAnt[i].texture:SetTexture(IceElement.TexturePath .. "ComboGlow")
+				elseif self.moduleSettings.comboMode == "Graphical Clean Circle" then
+					self.frame.graphicalAnt[i].texture:SetTexture(IceElement.TexturePath .. "ComboCleanCurves")
+				end
+			end
+
+			self.frame.graphicalAnt[i]:SetFrameStrata("LOW")
+			self.frame.graphicalAnt[i]:SetFrameLevel(self.frame.graphical[i]:GetFrameLevel() + 1)
+			self.frame.graphicalAnt[i]:SetWidth(math.floor(self.comboSize / 2))
+			self.frame.graphicalAnt[i]:SetHeight(math.floor(self.comboSize / 2))
+
+			self.frame.graphicalAnt[i]:SetPoint("CENTER", self.frame.graphical[i], "CENTER")
+
+			local r, g, b = self:GetColor("AnticipationPoints")
+			if (self.moduleSettings.gradient) then
+				r = r - 0.25 * (i - 1) -- Go to straight blue, which is most visible against the redorange
+			end
+			self.frame.graphicalAnt[i].texture:SetVertexColor(r, g, b)
+
+			self.frame.graphicalAnt[i]:Hide()
 		end
-
-		self.frame.graphicalAnt[i]:SetFrameStrata("LOW")
-		self.frame.graphicalAnt[i]:SetFrameLevel(self.frame.graphical[i]:GetFrameLevel() + 1)
-		self.frame.graphicalAnt[i]:SetWidth(math.floor(self.comboSize / 2))
-		self.frame.graphicalAnt[i]:SetHeight(math.floor(self.comboSize / 2))
-
-		self.frame.graphicalAnt[i]:SetPoint("CENTER", self.frame.graphical[i], "CENTER")
-
-		local r, g, b = self:GetColor("AnticipationPoints")
-		if (self.moduleSettings.gradient) then
-			r = r - 0.25 * (i - 1) -- Go to straight blue, which is most visible against the redorange
-		end
-		self.frame.graphicalAnt[i].texture:SetVertexColor(r, g, b)
-
-		self.frame.graphicalAnt[i]:Hide()
 	end
-
 end
 
-function ComboPoints.prototype:UpdateComboPoints()
+function ComboPoints.prototype:UpdateComboPoints(...)
+	if select('#', ...) >= 3 and select(1, ...) == "UNIT_POWER" and select(3, ...) ~= "COMBO_POINTS" then
+		return
+	end
+
 	local points, anticipate, _
 	if IceHUD.IceCore:IsInConfigMode() then
-		points = 5
+		points = self:GetMaxComboPoints()
 	elseif IceHUD.WowVer >= 30000 then
 		-- Parnic: apparently some fights have combo points while the player is in a vehicle?
 		local isInVehicle = UnitHasVehicleUI("player")
 		local checkUnit = isInVehicle and "vehicle" or "player"
 		if IceHUD.WowVer >= 60000 then
-			points = UnitPower(checkUnit, 4)
+			points = UnitPower(checkUnit, SPELL_POWER_COMBO_POINTS)
 		else
 			points = GetComboPoints(checkUnit, "target")
 		end
-		_, _, _, anticipate = UnitAura("player", AnticipationAuraName)
+
+		if IceHUD.WowVer < 70000 then
+			_, _, _, anticipate = UnitAura("player", GetSpellInfo(AnticipationSpellId))
+		else
+			anticipate = 0
+		end
 	else
 		points = GetComboPoints("target")
 	end
@@ -427,10 +463,14 @@ function ComboPoints.prototype:UpdateComboPoints()
 	points = points or 0
 	anticipate = self.moduleSettings.showAnticipation and anticipate or 0
 
+	if self:GetMaxComboPoints() > #self.frame.graphical then
+		self:CreateFrame()
+	end
+
 	if (self.moduleSettings.comboMode == "Numeric") then
 		local r, g, b = self:GetColor("ComboPoints")
 		if (self.moduleSettings.gradient and points) then
-			g = g - (0.15*points)
+			g = g - ((1 / self:GetMaxComboPoints())*points)
 		end
 		self.frame.numeric:SetTextColor(r, g, b, 0.7)
 
@@ -447,7 +487,7 @@ function ComboPoints.prototype:UpdateComboPoints()
 	else
 		self.frame.numeric:SetText()
 
-		for i = 1, table.getn(self.frame.graphical) do
+		for i = 1, self:GetMaxComboPoints() do
 			local hideIfNoTarget = not UnitExists("target") and not self.moduleSettings.bShowWithNoTarget
 
 			if ((points > 0) or (anticipate > 0)) and not hideIfNoTarget then
@@ -462,10 +502,12 @@ function ComboPoints.prototype:UpdateComboPoints()
 				self.frame.graphical[i]:Hide()
 			end
 
-			if (i <= anticipate) and not hideIfNoTarget then
-				self.frame.graphicalAnt[i]:Show()
-			else
-				self.frame.graphicalAnt[i]:Hide()
+			if i <= #self.frame.graphicalAnt then
+				if (i <= anticipate) and not hideIfNoTarget then
+					self.frame.graphicalAnt[i]:Show()
+				else
+					self.frame.graphicalAnt[i]:Hide()
+				end
 			end
 		end
 	end
@@ -476,7 +518,7 @@ do
 
 	function ComboPoints.prototype:CheckAnticipation(e, unit) -- UNIT_AURA handler
 		if UnitIsUnit(unit, "player") then
-			local _, _, _, newAntStacks = UnitAura("player", AnticipationAuraName)
+			local _, _, _, newAntStacks = UnitAura("player", GetSpellInfo(AnticipationSpellId))
 			if newAntStacks ~= antStacks then
 				antStacks = newAntStacks
 				self:UpdateComboPoints()

modules/ComboPointsBar.lua

@@ -66,7 +66,11 @@ function ComboPointsBar.prototype:Enable(core)
 
 	self:RegisterEvent("PLAYER_TARGET_CHANGED", "UpdateComboPoints")
 	if IceHUD.WowVer >= 30000 then
-		self:RegisterEvent("UNIT_COMBO_POINTS", "UpdateComboPoints")
+		if IceHUD.WowVer < 70000 then
+			self:RegisterEvent("UNIT_COMBO_POINTS", "UpdateComboPoints")
+		else
+			self:RegisterEvent("UNIT_POWER", "UpdateComboPoints")
+		end
 		self:RegisterEvent("UNIT_ENTERED_VEHICLE", "UpdateComboPoints")
 		self:RegisterEvent("UNIT_EXITED_VEHICLE", "UpdateComboPoints")
 	else
@@ -80,16 +84,22 @@ function ComboPointsBar.prototype:CreateFrame()
 	self:UpdateComboPoints()
 end
 
-function ComboPointsBar.prototype:UpdateComboPoints()
+local color = {}
+
+function ComboPointsBar.prototype:UpdateComboPoints(...)
+	if select('#', ...) >= 3 and select(1, ...) == "UNIT_POWER" and select(3, ...) ~= "COMBO_POINTS" then
+		return
+	end
+
 	local points
 	if IceHUD.IceCore:IsInConfigMode() then
-		points = 5
+		points = UnitPowerMax("player", SPELL_POWER_COMBO_POINTS)
 	elseif IceHUD.WowVer >= 30000 then
 		-- Parnic: apparently some fights have combo points while the player is in a vehicle?
 		local isInVehicle = UnitHasVehicleUI("player")
 		local checkUnit = isInVehicle and "vehicle" or "player"
 		if IceHUD.WowVer >= 60000 then
-			points = UnitPower(checkUnit, 4)
+			points = UnitPower(checkUnit, SPELL_POWER_COMBO_POINTS)
 		else
 			points = GetComboPoints(checkUnit, "target")
 		end
@@ -106,9 +116,8 @@ function ComboPointsBar.prototype:UpdateComboPoints()
 		self:UpdateBar(0, "undef")
 	else
 		self:Show(true)
-		local color = {}
 		self:SetScaledColor(color, (points - 1) / 4.0, self.settings.colors["ComboPointsBarMax"], self.settings.colors["ComboPointsBarMin"])
-		self:UpdateBar(points / 5.0, "undef")
+		self:UpdateBar(points / UnitPowerMax("player", SPELL_POWER_COMBO_POINTS), "undef")
 		self.barFrame.bar:SetVertexColor(color.r, color.g, color.b, self.alpha)
 	end
 

modules/CustomBar.lua

@@ -157,6 +157,7 @@ function IceCustomBar.prototype:GetDefaultSettings()
 	settings["lowerTextColor"] = {r=1, g=1, b=1}
 	settings["upperTextColor"] = {r=1, g=1, b=1}
 	settings["customUnit"] = "player"
+	settings["minCount"] = 0
 
 	return settings
 end
@@ -386,6 +387,24 @@ function IceCustomBar.prototype:GetOptions()
 		order = 30.7,
 	}
 
+	opts["minCount"] = {
+		type = 'input',
+		name = L["Minimum stacks to show"],
+		desc = L["Only show the bar when the number of applications of this buff or debuff exceeds this number"],
+		get = function()
+			return self.moduleSettings.minCount and tostring(self.moduleSettings.minCount) or "0"
+		end,
+		set = function(info, v)
+			self.moduleSettings.minCount = tonumber(v)
+			self:Redraw()
+			self:UpdateCustomBar(self.unit)
+		end,
+		disabled = function()
+			return not self.moduleSettings.enabled
+		end,
+		order = 30.71,
+	}
+
 	opts["barColor"] = {
 		type = 'color',
 		name = L["Bar color"],
@@ -716,16 +735,15 @@ function IceCustomBar.prototype:UpdateCustomBar(unit, fromUpdate)
 
 	local now = GetTime()
 	local remaining = nil
-	local count = 0
 	local auraIcon = nil
 	local endTime = 0
 
 	if not fromUpdate then
 		if tonumber(self.moduleSettings.buffToTrack) == nil then
-			self.auraDuration, remaining, count, auraIcon, endTime =
+			self.auraDuration, remaining, self.auraBuffCount, auraIcon, endTime =
 				self:GetAuraDuration(self.unit, self.moduleSettings.buffToTrack)
 		else
-			self.auraDuration, remaining, count, auraIcon, endTime =
+			self.auraDuration, remaining, self.auraBuffCount, auraIcon, endTime =
 				self:GetAuraDuration(self.unit, GetSpellInfo(self.moduleSettings.buffToTrack))
 		end
 
@@ -753,7 +771,9 @@ function IceCustomBar.prototype:UpdateCustomBar(unit, fromUpdate)
 		end
 	end
 
-	if self.auraEndTime ~= nil and (self.auraEndTime == 0 or self.auraEndTime >= now) then
+	self.auraBuffCount = self.auraBuffCount or 0
+
+	if self.auraEndTime ~= nil and (self.auraEndTime == 0 or self.auraEndTime >= now) and (not self.moduleSettings.minCount or self.auraBuffCount >= self.moduleSettings.minCount) then
 		if not self:ShouldAlwaysSubscribe() and not fromUpdate and not IceHUD.IceCore:IsUpdateSubscribed(self) then
 			if not self.UpdateCustomBarFunc then
 				self.UpdateCustomBarFunc = function() self:UpdateCustomBar(self.unit, true) end
@@ -803,8 +823,6 @@ function IceCustomBar.prototype:UpdateCustomBar(unit, fromUpdate)
 			end
 		end
 		fullString = self.moduleSettings.upperText .. (not self.bIsAura and (" " .. buffString) or "")
-	else
-		self.auraBuffCount = 0
 	end
 
 	if DogTag ~= nil then

modules/CustomCount.lua

@@ -6,9 +6,6 @@ local IceHUD = _G.IceHUD
 IceCustomCount.prototype.countSize = 20
 IceCustomCount.prototype.lastPoints = 0
 
-local validUnits = {"player", "target", "focus", "pet", "vehicle", "targettarget", "main hand weapon", "off hand weapon"}
-local buffOrDebuff = {"buff", "debuff"}
-
 -- Constructor --
 function IceCustomCount.prototype:init()
 	IceCustomCount.super.prototype.init(self, "CustomCount")
@@ -20,12 +17,7 @@ end
 -- OVERRIDE
 function IceCustomCount.prototype:GetOptions()
 	local opts = IceCustomCount.super.prototype.GetOptions(self)
-
-	opts["customHeader"] = {
-		type = 'header',
-		name = L["Aura settings"],
-		order = 30.1,
-	}
+	IceStackCounter_GetOptions(self, opts)
 
 	opts["deleteme"] = {
 		type = 'execute',
@@ -75,79 +67,6 @@ function IceCustomCount.prototype:GetOptions()
 		order = 30.3,
 	}
 
-	opts["auraTarget"] = {
-		type = 'select',
-		values = validUnits,
-		name = L["Unit to track"],
-		desc = L["Select which unit that this bar should be looking for buffs/debuffs on"],
-		get = function(info)
-			return IceHUD:GetSelectValue(info, self.moduleSettings.auraTarget)
-		end,
-		set = function(info, v)
-			self.moduleSettings.auraTarget = info.option.values[v]
-			self.unit = info.option.values[v]
-			self:Redraw()
-			IceHUD:NotifyOptionsChange()
-		end,
-		disabled = function()
-			return not self.moduleSettings.enabled
-		end,
-		order = 30.4,
-	}
-
-	opts["auraType"] = {
-		type = 'select',
-		values = buffOrDebuff,
-		name = L["Buff or debuff?"],
-		desc = L["Whether we are tracking a buff or debuff"],
-		get = function(info)
-			return IceHUD:GetSelectValue(info, self.moduleSettings.auraType)
-		end,
-		set = function(info, v)
-			self.moduleSettings.auraType = info.option.values[v]
-			self:Redraw()
-		end,
-		disabled = function()
-			return not self.moduleSettings.enabled or self.unit == "main hand weapon" or self.unit == "off hand weapon"
-		end,
-		order = 30.5,
-	}
-
-	opts["auraName"] = {
-		type = 'input',
-		name = L["Aura to track"],
-		desc = L["Which buff/debuff this counter will be tracking. \n\nRemember to press ENTER after filling out this box with the name you want or it will not save."],
-		get = function()
-			return self.moduleSettings.auraName
-		end,
-		set = function(info, v)
-			self.moduleSettings.auraName = v
-			self:Redraw()
-		end,
-		disabled = function()
-			return not self.moduleSettings.enabled or self.unit == "main hand weapon" or self.unit == "off hand weapon"
-		end,
-		usage = "<which aura to track>",
-		order = 30.6,
-	}
-
-	opts["trackOnlyMine"] = {
-		type = 'toggle',
-		name = L["Only track auras by me"],
-		desc = L["Checking this means that only buffs or debuffs that the player applied will trigger this bar"],
-		get = function()
-			return self.moduleSettings.onlyMine
-		end,
-		set = function(info, v)
-			self.moduleSettings.onlyMine = v
-			self:Redraw()
-		end,
-		disabled = function()
-			return not self.moduleSettings.enabled or self.unit == "main hand weapon" or self.unit == "off hand weapon"
-		end,
-		order = 30.7,
-	}
-
 	opts["countColor"] = {
 		type = 'color',
 		name = L["Count color"],
@@ -186,28 +105,6 @@ function IceCustomCount.prototype:GetOptions()
 		order = 30.81,
 	}
 
-	opts["maxCount"] = {
-		type = 'input',
-		name = L["Maximum applications"],
-		desc = L["How many total applications of this buff/debuff can be applied. For example, only 5 sunders can ever be on a target, so this would be set to 5 for tracking Sunder.\n\nRemember to press ENTER after filling out this box with the name you want or it will not save."],
-		get = function()
-			return tostring(self.moduleSettings.maxCount)
-		end,
-		set = function(info, v)
-			if not v or not tonumber(v) or tonumber(v) <= 0 then
-				v = 5
-			end
-			self.moduleSettings.maxCount = tonumber(v)
-			self:CreateCustomFrame(true)
-			self:Redraw()
-		end,
-		disabled = function()
-			return not self.moduleSettings.enabled
-		end,
-		usage = "<the maximum number of valid applications>",
-		order = 30.9,
-	}
-
 	opts["normalHeader"] = {
 		type = 'header',
 		name = L["Counter look and feel"],
@@ -283,7 +180,6 @@ function IceCustomCount.prototype:GetOptions()
 		end,
 		set = function(info, v)
 			self.moduleSettings.countMode = info.option.values[v]
-			self:CreateCustomFrame(true)
 			self:Redraw()
 			IceHUD:NotifyOptionsChange()
 		end,
@@ -360,10 +256,10 @@ function IceCustomCount.prototype:GetCustomMinColor()
 	return self.moduleSettings.countMinColor.r, self.moduleSettings.countMinColor.g, self.moduleSettings.countMinColor.b, self.alpha
 end
 
-
--- OVERRIDE
 function IceCustomCount.prototype:GetDefaultSettings()
 	local defaults =  IceCustomCount.super.prototype.GetDefaultSettings(self)
+	IceStackCounter_GetDefaultSettings(defaults)
+
 	defaults["vpos"] = 0
 	defaults["hpos"] = 0
 	defaults["countFontSize"] = 20
@@ -373,14 +269,10 @@ function IceCustomCount.prototype:GetDefaultSettings()
 	defaults["alwaysFullAlpha"] = true
 	defaults["graphicalLayout"] = "Horizontal"
 	defaults["countGap"] = 0
-	defaults["maxCount"] = 5
-	defaults["auraTarget"] = "player"
-	defaults["auraName"] = ""
-	defaults["onlyMine"] = true
 	defaults["customBarType"] = "Counter"
 	defaults["countMinColor"] = {r=1, g=1, b=0, a=1}
 	defaults["countColor"] = {r=1, g=0, b=0, a=1}
-	defaults["auraType"] = "buff"
+
 	return defaults
 end
 
@@ -390,6 +282,7 @@ function IceCustomCount.prototype:Redraw()
 	IceCustomCount.super.prototype.Redraw(self)
 
 	self:CreateFrame()
+	self:CreateCustomFrame(true)
 	self:UpdateCustomCount()
 end
 
@@ -398,22 +291,8 @@ end
 function IceCustomCount.prototype:Enable(core)
 	IceCustomCount.super.prototype.Enable(self, core)
 
-	self:RegisterEvent("UNIT_AURA", "UpdateCustomCount")
-	self:RegisterEvent("UNIT_PET", "UpdateCustomCount")
-	self:RegisterEvent("PLAYER_PET_CHANGED", "UpdateCustomCount")
-	self:RegisterEvent("PLAYER_FOCUS_CHANGED", "UpdateCustomCount")
-	self:RegisterEvent("PLAYER_TARGET_CHANGED", "UpdateCustomCount")
-	self:RegisterEvent("PLAYER_DEAD", "UpdateCustomCount")
-
-	self.unit = self.moduleSettings.auraTarget or "player"
-
-	if not tonumber(self.moduleSettings.maxCount) or tonumber(self.moduleSettings.maxCount) <= 0 then
-		self.moduleSettings.maxCount = 5
-		self:CreateCustomFrame(true)
-		self:Redraw()
-	else
-		self:CreateCustomFrame(true)
-	end
+	self:CreateCustomFrame(true)
+	IceStackCounter_Enable(self)
 	self:UpdateCustomCount()
 end
 
@@ -427,11 +306,11 @@ function IceCustomCount.prototype:CreateFrame()
 
 	self.frame:SetFrameStrata("BACKGROUND")
 	if self.moduleSettings.graphicalLayout == "Horizontal" then
-		self.frame:SetWidth((self.countSize + self.moduleSettings.countGap)*self.moduleSettings.maxCount)
+		self.frame:SetWidth((self.countSize + self.moduleSettings.countGap)*IceStackCounter_GetMaxCount(self))
 		self.frame:SetHeight(1)
 	else
 		self.frame:SetWidth(1)
-		self.frame:SetHeight((self.countSize + self.moduleSettings.countGap)*self.moduleSettings.maxCount)
+		self.frame:SetHeight((self.countSize + self.moduleSettings.countGap)*IceStackCounter_GetMaxCount(self))
 	end
 	self.frame:ClearAllPoints()
 	self.frame:SetPoint("TOP", self.parent, "BOTTOM", self.moduleSettings.hpos, self.moduleSettings.vpos)
@@ -458,8 +337,10 @@ function IceCustomCount.prototype:CreateCustomFrame(doTextureUpdate)
 		self.frame.graphical = {}
 	end
 
+	local max = IceStackCounter_GetMaxCount(self)
+
 	-- create backgrounds
-	for i = 1, self.moduleSettings.maxCount do
+	for i = 1, max do
 		if (not self.frame.graphicalBG[i]) then
 			local frame = CreateFrame("Frame", nil, self.frame)
 			self.frame.graphicalBG[i] = frame
@@ -493,7 +374,7 @@ function IceCustomCount.prototype:CreateCustomFrame(doTextureUpdate)
 	end
 
 	-- create counts
-	for i = 1, self.moduleSettings.maxCount do
+	for i = 1, max do
 		if (not self.frame.graphical[i]) then
 			local frame = CreateFrame("Frame", nil, self.frame)
 			self.frame.graphical[i] = frame
@@ -524,7 +405,7 @@ end
 
 
 function IceCustomCount.prototype:SetCustomColor()
-	for i=1, self.moduleSettings.maxCount do
+	for i=1, IceStackCounter_GetMaxCount(self) do
 		self.frame.graphicalBG[i].texture:SetVertexColor(self:GetCustomColor())
 
 		local r, g, b = self:GetCustomColor()
@@ -536,9 +417,10 @@ function IceCustomCount.prototype:SetCustomColor()
 end
 
 function IceCustomCount.prototype:GetGradientColor(curr)
+	local max = IceStackCounter_GetMaxCount(self)
 	local r, g, b = self:GetCustomColor()
 	local mr, mg, mb = self:GetCustomMinColor()
-	local scale = (curr-1)/(self.moduleSettings.maxCount-1)
+	local scale = max > 1 and ((curr-1)/(max-1)) or 1
 
 	r = r * scale + mr * (1-scale)
 	g = g * scale + mg * (1-scale)
@@ -553,19 +435,7 @@ function IceCustomCount.prototype:UpdateCustomCount()
 		return
 	end
 
-	local points
-	if IceHUD.IceCore:IsInConfigMode() then
-		points = tonumber(self.moduleSettings.maxCount)
-	else
-		points = IceHUD:GetAuraCount(self.moduleSettings.auraType == "buff" and "HELPFUL" or "HARMFUL",
-			self.unit, self.moduleSettings.auraName, self.moduleSettings.onlyMine, true)
-	end
-
-	self.lastPoints = points
-
-	if (points == 0) then
-		points = nil
-	end
+	local points = IceStackCounter_GetCount(self)
 
 	if (self.moduleSettings.countMode == "Numeric") then
 		local r, g, b = self:GetCustomColor()
@@ -597,5 +467,5 @@ function IceCustomCount.prototype:UpdateCustomCount()
 end
 
 function IceCustomCount.prototype:UseTargetAlpha(scale)
-	return self.lastPoints ~= nil and self.lastPoints > 0
+	return IceStackCounter_UseTargetAlpha(self)
 end

modules/CustomCounterBar.lua

@@ -0,0 +1,345 @@
+local L = LibStub("AceLocale-3.0"):GetLocale("IceHUD", false)
+IceCustomCounterBar = IceCore_CreateClass(IceBarElement)
+
+IceCustomCounterBar.prototype.currColor = {}
+
+local AuraIconWidth = 20
+local AuraIconHeight = 20
+local DefaultAuraIcon = "Interface\\Icons\\Spell_Frost_Frost"
+
+function IceCustomCounterBar.prototype:init()
+	IceCustomCounterBar.super.prototype.init(self, "CustomCounterBar")
+
+	self.bTreatEmptyAsFull = true
+end
+
+function IceCustomCounterBar.prototype:GetOptions()
+	local opts = IceCustomCounterBar.super.prototype.GetOptions(self)
+	IceStackCounter_GetOptions(self, opts)
+
+	opts["deleteme"] = {
+		type = 'execute',
+		name = L["Delete me"],
+		desc = L["Deletes this custom module and all associated settings. Cannot be undone!"],
+		func = function()
+			local dialog = StaticPopup_Show("ICEHUD_DELETE_CUSTOM_MODULE")
+			if dialog then
+				dialog.data = self
+			end
+		end,
+		order = 20.1,
+	}
+
+	opts["duplicateme"] = {
+		type = 'execute',
+		name = L["Duplicate me"],
+		desc = L["Creates a new module of this same type and with all the same settings."],
+		func = function()
+			IceHUD:CreateCustomModuleAndNotify(self.moduleSettings.customBarType, self.moduleSettings)
+		end,
+		order = 20.2,
+	}
+
+	opts["type"] = {
+		type = "description",
+		name = string.format("%s %s", L["Module type:"], tostring(self:GetBarTypeDescription(self.moduleSettings.customBarType))),
+		order = 21,
+	}
+
+	opts["name"] = {
+		type = 'input',
+		name = L["Counter name"],
+		desc = L["The name of this counter (must be unique!). \n\nRemember to press ENTER after filling out this box with the name you want or it will not save."],
+		get = function()
+			return self.elementName
+		end,
+		set = function(info, v)
+			if v ~= "" then
+				IceHUD.IceCore:RenameDynamicModule(self, v)
+			end
+		end,
+		disabled = function()
+			return not self.moduleSettings.enabled
+		end,
+		usage = "<a name for this bar>",
+		order = 29.91,
+	}
+
+	opts["countColor"] = {
+		type = 'color',
+		name = L["Count color"],
+		desc = L["The color for this counter"],
+		get = function()
+			return self.moduleSettings.countColor.r, self.moduleSettings.countColor.g, self.moduleSettings.countColor.b, 1
+		end,
+		set = function(info, r,g,b)
+			self.moduleSettings.countColor.r = r
+			self.moduleSettings.countColor.g = g
+			self.moduleSettings.countColor.b = b
+			self:Redraw()
+		end,
+		disabled = function()
+			return not self.moduleSettings.enabled
+		end,
+		order = 29.95,
+	}
+
+	opts["countMinColor"] = {
+		type = 'color',
+		name = L["Count minimum color"],
+		desc = L["The minimum color for this counter (only used if Change Color is enabled)"],
+		get = function()
+			return self.moduleSettings.countMinColor.r, self.moduleSettings.countMinColor.g,self.moduleSettings.countMinColor.b, 1
+		end,
+		set = function(info, r,g,b)
+			self.moduleSettings.countMinColor.r = r
+			self.moduleSettings.countMinColor.g = g
+			self.moduleSettings.countMinColor.b = b
+			self:Redraw()
+		end,
+		disabled = function()
+			return not self.moduleSettings.enabled or not self.moduleSettings.gradient
+		end,
+		order = 29.96,
+	}
+
+	opts["gradient"] = {
+		type = "toggle",
+		name = L["Change color"],
+		desc = L["This will fade the graphical representation from the min color specified to the regular color\n\n(e.g. if the min color is yellow, the color is red, and there are 3 total applications, then the first would be yellow, second orange, and third red)"],
+		get = function()
+			return self.moduleSettings.gradient
+		end,
+		set = function(info, v)
+			self.moduleSettings.gradient = v
+			self:Redraw()
+		end,
+		disabled = function()
+			return not self.moduleSettings.enabled
+		end,
+		order = 29.97
+	}
+
+	opts["iconSettings"] = {
+		type = 'group',
+		name = "|c"..self.configColor..L["Icon Settings"].."|r",
+		args = {
+			displayAuraIcon = {
+				type = 'toggle',
+				name = L["Display aura icon"],
+				desc = L["Whether or not to display an icon for the aura that this bar is tracking"],
+				get = function()
+					return self.moduleSettings.displayAuraIcon
+				end,
+				set = function(info, v)
+					self.moduleSettings.displayAuraIcon = v
+					if self.barFrame.icon then
+						if v then
+							self.barFrame.icon:Show()
+						else
+							self.barFrame.icon:Hide()
+						end
+					end
+				end,
+				disabled = function()
+					return not self.moduleSettings.enabled
+				end,
+				order = 40.1,
+			},
+
+			auraIconXOffset = {
+				type = 'range',
+				min = -250,
+				max = 250,
+				step = 1,
+				name = L["Aura icon horizontal offset"],
+				desc = L["Adjust the horizontal position of the aura icon"],
+				get = function()
+					return self.moduleSettings.auraIconXOffset
+				end,
+				set = function(info, v)
+					self.moduleSettings.auraIconXOffset = v
+					self:PositionIcons()
+				end,
+				disabled = function()
+					return not self.moduleSettings.enabled or not self.moduleSettings.displayAuraIcon
+				end,
+				order = 40.2,
+			},
+
+			auraIconYOffset = {
+				type = 'range',
+				min = -250,
+				max = 250,
+				step = 1,
+				name = L["Aura icon vertical offset"],
+				desc = L["Adjust the vertical position of the aura icon"],
+				get = function()
+					return self.moduleSettings.auraIconYOffset
+				end,
+				set = function(info, v)
+					self.moduleSettings.auraIconYOffset = v
+					self:PositionIcons()
+				end,
+				disabled = function()
+					return not self.moduleSettings.enabled or not self.moduleSettings.displayAuraIcon
+				end,
+				order = 40.3,
+			},
+
+			auraIconScale = {
+				type = 'range',
+				min = 0.1,
+				max = 3.0,
+				step = 0.05,
+				name = L["Aura icon scale"],
+				desc = L["Adjusts the size of the aura icon for this bar"],
+				get = function()
+					return self.moduleSettings.auraIconScale
+				end,
+				set = function(info, v)
+					self.moduleSettings.auraIconScale = v
+					self:PositionIcons()
+				end,
+				disabled = function()
+					return not self.moduleSettings.enabled or not self.moduleSettings.displayAuraIcon
+				end,
+				order = 40.4,
+			},
+		},
+	}
+
+	return opts
+end
+
+function IceCustomCounterBar.prototype:GetDefaultSettings()
+	local defaults = IceCustomCounterBar.super.prototype.GetDefaultSettings(self)
+	IceStackCounter_GetDefaultSettings(defaults)
+
+	defaults.textVisible['lower'] = false
+	defaults.offset = 9
+	defaults.desiredLerpTime = 0.1
+	defaults.customBarType = "CounterBar"
+	defaults.countMinColor = {r=1, g=1, b=0, a=1}
+	defaults.countColor = {r=1, g=0, b=0, a=1}
+	defaults.gradient = false
+	defaults.usesDogTagStrings = false
+	defaults.displayAuraIcon = false
+	defaults.auraIconXOffset = 40
+	defaults.auraIconYOffset = 0
+	defaults.auraIconScale = 1
+
+	return defaults
+end
+
+function IceCustomCounterBar.prototype:Enable(core)
+	IceCustomCounterBar.super.prototype.Enable(self, core)
+
+	if self.moduleSettings.auraIconScale == nil then
+		self.moduleSettings.auraIconScale = 1
+	end
+	if self.moduleSettings.auraIconXOffset == nil then
+		self.moduleSettings.auraIconXOffset = 40
+	end
+	if self.moduleSettings.auraIconYOffset == nil then
+		self.moduleSettings.auraIconYOffset = 0
+	end
+
+	self:UpdateAuraIcon()
+
+	IceStackCounter_Enable(self)
+end
+
+function IceCustomCounterBar.prototype:Redraw()
+	IceCustomCounterBar.super.prototype.Redraw(self)
+
+	self:UpdateAuraIcon()
+	self:UpdateCustomCount()
+end
+
+function IceCustomCounterBar.prototype:PositionIcons()
+	if not self.barFrame or not self.barFrame.icon then
+		return
+	end
+
+	self.barFrame.icon:ClearAllPoints()
+	self.barFrame.icon:SetPoint("TOPLEFT", self.frame, "TOPLEFT", self.moduleSettings.auraIconXOffset, self.moduleSettings.auraIconYOffset)
+	self.barFrame.icon:SetWidth(AuraIconWidth * (self.moduleSettings.auraIconScale or 1))
+	self.barFrame.icon:SetHeight(AuraIconHeight * (self.moduleSettings.auraIconScale or 1))
+end
+
+function IceCustomCounterBar.prototype:CreateFrame()
+	IceCustomCounterBar.super.prototype.CreateFrame(self)
+
+	if not self.barFrame.icon then
+		self.barFrame.icon = self.masterFrame:CreateTexture(nil, "LOW")
+		self.barFrame.icon:SetTexture(DefaultAuraIcon)
+		self.barFrame.icon:SetTexCoord(0.1, 0.9, 0.1, 0.9)
+		self.barFrame.icon:SetDrawLayer("OVERLAY")
+		self.barFrame.icon:Hide()
+	end
+	self:PositionIcons()
+
+	self:UpdateCustomCount()
+end
+
+function IceCustomCounterBar.prototype:Show(bShouldShow)
+	IceCustomCounterBar.super.prototype.Show(self, bShouldShow)
+
+	if self.moduleSettings.displayAuraIcon then
+		self.barFrame.icon:Show()
+	else
+		self.barFrame.icon:Hide()
+	end
+end
+
+function IceCustomCounterBar.prototype:UpdateAuraIcon()
+	if not self.barFrame or not self.barFrame.icon then
+		return
+	end
+
+	local auraIcon, _
+	_, _, auraIcon = GetSpellInfo(self.moduleSettings.auraName)
+
+	if auraIcon == nil then
+		auraIcon = "Interface\\Icons\\Spell_Frost_Frost"
+	end
+
+	self.barFrame.icon:SetTexture(auraIcon)
+end
+
+function IceCustomCounterBar.prototype:UpdateCustomCount()
+	local points = IceStackCounter_GetCount(self) or 0
+	local max = IceStackCounter_GetMaxCount(self) or 1
+	local percent = IceHUD:Clamp(1.0 * points / (max > 0 and max or 1), 0, 1)
+
+	if IceHUD.IceCore:IsInConfigMode() then
+		points = IceStackCounter_GetMaxCount(self)
+		percent = 1
+		self.barFrame.icon:Show()
+	end
+
+	if points == nil or points == 0 then
+		self:Show(false)
+		self:UpdateBar(0, "undef")
+	else
+		self:Show(true)
+
+		self.currColor.r = self.moduleSettings.countColor.r
+		self.currColor.g = self.moduleSettings.countColor.g
+		self.currColor.b = self.moduleSettings.countColor.b
+
+		if self.moduleSettings.gradient then
+			self:SetScaledColor(self.currColor, percent, self.moduleSettings.countColor, self.moduleSettings.countMinColor)
+		end
+
+		self:UpdateBar(percent, "undef")
+		self.barFrame.bar:SetVertexColor(self.currColor.r, self.currColor.g, self.currColor.b, self.alpha)
+	end
+
+	self:SetBottomText1(points or "0")
+end
+
+function IceCustomCounterBar.prototype:Update()
+	self:UpdateCustomCount()
+end

modules/DruidMana.lua

@@ -1,76 +0,0 @@
-local L = LibStub("AceLocale-3.0"):GetLocale("IceHUD", false)
-local DruidMana = IceCore_CreateClass(IceUnitBar)
-
-DruidMana.prototype.druidMana = nil
-DruidMana.prototype.druidManaMax = nil
-
-local MANA_POWER_INDEX = SPELL_POWER_MANA
-
--- Constructor --
-function DruidMana.prototype:init()
-	DruidMana.super.prototype.init(self, "DruidMana", "player")
-
-	self.side = IceCore.Side.Right
-	self.offset = 0
-
-	self:SetDefaultColor("DruidMana", 87, 82, 141)
-end
-
-
-function DruidMana.prototype:GetDefaultSettings()
-	local settings = DruidMana.super.prototype.GetDefaultSettings(self)
-
-	settings["side"] = IceCore.Side.Right
-	settings["offset"] = 0
-	settings["textVisible"] = {upper = true, lower = false}
-	settings["upperText"] = "[PercentDruidMP:Round]"
-	settings["lowerText"] = "[FractionalDruidMP:Color('3071bf'):Bracket]"
-
-	return settings
-end
-
-
-function DruidMana.prototype:Enable(core)
-	DruidMana.super.prototype.Enable(self, core)
-
-	self:RegisterEvent("UPDATE_SHAPESHIFT_FORM", "Update")
-	if IceHUD.WowVer >= 40000 then
-		self:RegisterEvent("UNIT_POWER", "Update")
-		self:RegisterEvent("UNIT_MAXPOWER", "Update")
-	else
-		self:RegisterEvent("UNIT_MAXMANA", "Update")
-		self:RegisterEvent("UNIT_MANA", "Update")
-	end
-end
-
-
-function DruidMana.prototype:Disable(core)
-	DruidMana.super.prototype.Disable(self, core)
-end
-
-
-function DruidMana.prototype:Update()
-	DruidMana.super.prototype.Update(self)
-
-	local forms = (UnitPowerType(self.unit) ~= 0)
-
-	self.druidMana = UnitPower(self.unit, MANA_POWER_INDEX)
-	self.druidManaMax = UnitPowerMax(self.unit, MANA_POWER_INDEX)
-
-	if (not self.alive or not forms or not self.druidMana or not self.druidManaMax or self.druidManaMax == 0) then
-		self:Show(false)
-		return
-	else
-		self:Show(true)
-	end
-
-	self:UpdateBar(self.druidManaMax ~= 0 and self.druidMana / self.druidManaMax or 0, "DruidMana")
-end
-
-
-
--- Load us up (if we are a druid)
-local _, unitClass = UnitClass("player")
-if (unitClass == "DRUID") then
-	IceHUD.DruidMana = DruidMana:new()
-end

modules/EclipseBar.lua

@@ -190,6 +190,6 @@ function EclipseBar.prototype:MyOnUpdate()
 end
 
 local _, unitClass = UnitClass("player")
-if (unitClass == "DRUID" and IceHUD.WowVer >= 40000) then
+if (unitClass == "DRUID" and IceHUD.WowVer >= 40000 and IceHUD.WowVer < 70000) then
 	IceHUD.EclipseBar = EclipseBar:new()
 end

modules/GlobalCoolDown.lua

@@ -1,8 +1,6 @@
 local L = LibStub("AceLocale-3.0"):GetLocale("IceHUD", false)
 local GlobalCoolDown = IceCore_CreateClass(IceBarElement)
 
-local maxSpellCastSkipTimeMs = 1500
-
 -- Constructor --
 function GlobalCoolDown.prototype:init()
 	GlobalCoolDown.super.prototype.init(self, "GlobalCoolDown")
@@ -18,27 +16,36 @@ end
 function GlobalCoolDown.prototype:Enable(core)
 	GlobalCoolDown.super.prototype.Enable(self, core)
 
+	if self.moduleSettings.inverse == "EXPAND" then
+		self.moduleSettings.inverse = "NORMAL"
+	end
+
+	self:RegisterEvent("UNIT_SPELLCAST_SENT","SpellCastSent")
+
 	--self:RegisterEvent("ACTIONBAR_UPDATE_COOLDOWN", "CooldownStateChanged")
 	self:RegisterEvent("UNIT_SPELLCAST_START","CooldownStateChanged")
+	self:RegisterEvent("UNIT_SPELLCAST_CHANNEL_START","CooldownStateChanged")
 	self:RegisterEvent("UNIT_SPELLCAST_SUCCEEDED","CooldownStateChanged")
 
-	self:RegisterEvent("UNIT_SPELLCAST_INTERRUPTED","CooldownAborted")
-	self:RegisterEvent("UNIT_SPELLCAST_FAILED","CooldownAborted")
+	self:RegisterEvent("UNIT_SPELLCAST_CHANNEL_STOP","SpellCastStop")
+	self:RegisterEvent("UNIT_SPELLCAST_INTERRUPTED","SpellCastStop")
+	self:RegisterEvent("UNIT_SPELLCAST_FAILED","SpellCastStop")
+	self:RegisterEvent("UNIT_SPELLCAST_STOP","SpellCastStop")
+
+	self:RegisterEvent("CVAR_UPDATE", "CVarUpdate")
+
+	self:CVarUpdate()
 
 	self:Show(false)
 
-	self.frame:SetFrameStrata("TOOLTIP")
+	self.frame:SetFrameStrata("LOW")
 
 	self.CDSpellId = self:GetSpellId()
 end
 
-function GlobalCoolDown.prototype:CooldownAborted(event, unit, spell)
-	if unit ~= "player" or not spell or not self.CurrSpell or self.CurrSpell ~= spell then
-		return
-	end
-
-	self.CurrLerpTime = self.moduleSettings.desiredLerpTime
-	self.CurrSpell = nil
+function GlobalCoolDown.prototype:CVarUpdate()
+	self.useFixedLatency = self.moduleSettings.respectLagTolerance and GetCVar("reducedLagTolerance") == "1"
+	self.fixedLatency = tonumber(GetCVar("maxSpellStartRecoveryoffset")) / 1000.0
 end
 
 -- OVERRIDE
@@ -57,6 +64,9 @@ function GlobalCoolDown.prototype:GetDefaultSettings()
 	settings["bHideMarkerSettings"] = true
 	settings["showDuringCast"] = true
 	settings["barVisible"]["bg"] = false
+	settings["bAllowExpand"] = false
+	settings["lagAlpha"] = 0.7
+	settings["respectLagTolerance"] = true
 
 	return settings
 end
@@ -84,6 +94,45 @@ function GlobalCoolDown.prototype:GetOptions()
 		order = 21,
 	}
 
+	opts["lagAlpha"] =
+	{
+		type = 'range',
+		name = L["Lag Indicator alpha"],
+		desc = L["Lag indicator alpha (0 is disabled)"],
+		min = 0,
+		max = 1,
+		step = 0.1,
+		get = function()
+			return self.moduleSettings.lagAlpha
+		end,
+		set = function(info, value)
+			self.moduleSettings.lagAlpha = value
+			self:Redraw()
+		end,
+		disabled = function()
+			return not self.moduleSettings.enabled
+		end,
+		order = 42
+	}
+
+	opts["respectLagTolerance"] =
+	{
+		type = 'toggle',
+		name = L["Respect lag tolerance"],
+		desc = L["When checked, if a 'Custom Lag Tolerance' is set in the game's Combat options, the lag indicator will always use that tolerance value. Otherwise, it uses the computed latency."],
+		get = function()
+			return self.moduleSettings.respectLagTolerance
+		end,
+		set = function(info, value)
+			self.moduleSettings.respectLagTolerance = value
+			self:CVarUpdate()
+		end,
+		disabled = function()
+			return not self.moduleSettings.enabled or GetCVar("reducedLagTolerance") == "0"
+		end,
+		order = 42.1,
+	}
+
 	return opts
 end
 
@@ -91,6 +140,26 @@ function GlobalCoolDown.prototype:IsFull(scale)
 	return false
 end
 
+function GlobalCoolDown.prototype:SpellCastSent(event, unit, spell)
+	if unit ~= "player" or not spell then
+		return
+	end
+
+	self.spellCastSent = GetTime()
+end
+
+function GlobalCoolDown.prototype:SpellCastStop(event, unit, spell, _, _, spellId)
+	if unit ~= "player" or not spellId or not self.CurrSpellId or self.CurrSpellId ~= spellId then
+		return
+	end
+
+	self.CurrSpellId = nil
+
+	if event == "UNIT_SPELLCAST_INTERRUPTED" or event == "UNIT_SPELLCAST_FAILED" then
+		self.CurrLerpTime = self.moduleSettings.desiredLerpTime
+	end
+end
+
 function GlobalCoolDown.prototype:GetSpellCastTime(spell)
 	if not spell then
 		return nil, nil
@@ -110,20 +179,31 @@ function GlobalCoolDown.prototype:GetSpellCastTime(spell)
 	end
 end
 
-function GlobalCoolDown.prototype:CooldownStateChanged(event, unit, spell)
-	if unit ~= "player" or not spell then
+function GlobalCoolDown.prototype:CooldownStateChanged(event, unit, spell, _, _, spellId)
+	if unit ~= "player" or not spellId then
 		return
 	end
 
-	if not self.moduleSettings.showDuringCast then
-		local castTime = self:GetSpellCastTime(spell)
-		if castTime and castTime > maxSpellCastSkipTimeMs then
-			return
-		end
+	-- Ignore all events unrelated to the spell currently being cast
+	if self.CurrSpellId and self.CurrSpellId ~= spellId then
+		return
+	end
+
+	-- Update the current spell ID for all events indicating a spellcast is starting
+	if event ~= "UNIT_SPELLCAST_SUCCEEDED" then
+		self.CurrSpellId = spellId
 	end
 
 	local start, dur = GetSpellCooldown(self.CDSpellId)
 
+	if not self.moduleSettings.showDuringCast then
+		local castTime = self:GetSpellCastTime(spellId)
+		local channeledSpellName = UnitChannelInfo(unit)
+		if (castTime and castTime >= dur*1000) or channeledSpellName then
+			return
+		end
+	end
+
 	if start and dur ~= nil and dur > 0 and dur <= 1.5 then
 		local bRestart = not self.startTime or start > self.startTime + 0.5
 		if bRestart then
@@ -136,15 +216,23 @@ function GlobalCoolDown.prototype:CooldownStateChanged(event, unit, spell)
 			self.CurrLerpTime = 0
 			self.lastLerpTime = GetTime()
 			self.moduleSettings.desiredLerpTime = dur or 1
-			self.CurrSpell = spell
 
 			self:UpdateBar(0, "GlobalCoolDown")
 			self:Show(true)
-		end
-	end
 
-	if event == "UNIT_SPELLCAST_SUCCEEDED" then
-		self.CurrSpell = nil
+			-- Update latency indicator
+			local scale = 0
+			if self.useFixedLatency then
+				scale = IceHUD:Clamp(self.fixedLatency / self.duration, 0, 1)
+			else
+				local now = GetTime()
+				local lag = now - (self.spellCastSent or now)
+				scale = IceHUD:Clamp(lag / self.duration, 0, 1)
+			end
+
+			self:SetBarCoord(self.lagBar, scale, false, true)
+			self.spellCastSent = nil
+		end
 	end
 end
 
@@ -163,9 +251,25 @@ function GlobalCoolDown.prototype:CreateFrame()
 	self.barFrame.bar:SetVertexColor(self:GetColor("GlobalCoolDown", 0.8))
 	local r, g, b = self.settings.backgroundColor.r, self.settings.backgroundColor.g, self.settings.backgroundColor.b
 	self.frame.bg:SetVertexColor(r, g, b, 0.6)
+
+	self:CreateLagBar()
+end
+
+function GlobalCoolDown.prototype:CreateLagBar()
+	self.lagBar = self:BarFactory(self.lagBar, "LOW", "OVERLAY")
+
+	local r, g, b = self:GetColor("CastLag")
+	if (self.settings.backgroundToggle) then
+		r, g, b = self:GetColor("CastCasting")
+	end
+
+	self.lagBar.bar:SetVertexColor(r, g, b, self.moduleSettings.lagAlpha)
+	self.lagBar.bar:Hide()
 end
 
 function GlobalCoolDown.prototype:GetSpellId()
+	return 61304
+--[[
 	local defaultSpells
 
 	defaultSpells = {
@@ -184,6 +288,7 @@ function GlobalCoolDown.prototype:GetSpellId()
 
 	local _, unitClass = UnitClass("player")
 	return defaultSpells[unitClass]
+]]
 end
 
 -- Load us up

modules/HarmonyPower.lua

@@ -23,6 +23,9 @@ function HarmonyPower.prototype:init()
 	else
 		self.unitPower = SPELL_POWER_LIGHT_FORCE
 	end
+	if IceHUD.WowVer >= 70000 then
+		self.requiredSpec = SPEC_MONK_WINDWALKER
+	end
 	self.minLevel = 0
 	self.bTreatEmptyAsFull = true
 	self.unit = "player"
@@ -33,8 +36,6 @@ function HarmonyPower.prototype:Enable(core)
 	HarmonyPower.super.prototype.Enable(self, core)
 
 	self:RegisterEvent("UNIT_POWER_FREQUENT", "UpdateRunePower")
-
-	self:Redraw()
 end
 
 function HarmonyPower.prototype:UpdateRunePower(event, arg1, arg2)
@@ -48,10 +49,6 @@ function HarmonyPower.prototype:UpdateRunePower(event, arg1, arg2)
 		return
 	end
 
-	if self.fakeNumRunes ~= nil and self.fakeNumRunes > 0 then
-		numRunes = self.fakeNumRunes
-	end
-
 	if numRunes ~= self.numRunes then
 		if numRunes < self.numRunes and #self.frame.graphical >= numRunes then
 			for i=numRunes + 1, #self.frame.graphical do
@@ -94,15 +91,23 @@ function HarmonyPower.prototype:GetRuneTexture(rune)
 end
 
 function HarmonyPower.prototype:ShowBlizz()
-	MonkHarmonyBar:Show()
+	local frame = MonkHarmonyBarFrame
+	if frame == nil then
+		frame = MonkHarmonyBar
+	end
 
-	MonkHarmonyBar:GetScript("OnLoad")(MonkHarmonyBar)
+	frame:Show()
+	frame:GetScript("OnLoad")(frame)
 end
 
 function HarmonyPower.prototype:HideBlizz()
-	MonkHarmonyBar:Hide()
+	local frame = MonkHarmonyBarFrame
+	if frame == nil then
+		frame = MonkHarmonyBar
+	end
 
-	MonkHarmonyBar:UnregisterAllEvents()
+	frame:Hide()
+	frame:UnregisterAllEvents()
 end
 
 -- Load us up

modules/HolyPower.lua

@@ -27,6 +27,9 @@ function HolyPower.prototype:init()
 	self.numericColor = "HolyPowerNumeric"
 	self.unitPower = SPELL_POWER_HOLY_POWER
 	self.minLevel = PALADINPOWERBAR_SHOW_LEVEL
+	if IceHUD.WowVer >= 70000 then
+		self.requiredSpec = SPEC_PALADIN_RETRIBUTION
+	end
 	self.bTreatEmptyAsFull = true
 	self.unit = "player"
 	self.numRunes = 5
@@ -75,15 +78,23 @@ function HolyPower.prototype:GetRuneTexture(rune)
 end
 
 function HolyPower.prototype:ShowBlizz()
-	PaladinPowerBar:Show()
+	local frame = PaladinPowerBarFrame
+	if frame == nil then
+		frame = PaladinPowerBar
+	end
 
-	PaladinPowerBar:GetScript("OnLoad")(PaladinPowerBar)
+	frame:Show()
+	frame:GetScript("OnLoad")(frame)
 end
 
 function HolyPower.prototype:HideBlizz()
-	PaladinPowerBar:Hide()
+	local frame = PaladinPowerBarFrame
+	if frame == nil then
+		frame = PaladinPowerBar
+	end
 
-	PaladinPowerBar:UnregisterAllEvents()
+	frame:Hide()
+	frame:UnregisterAllEvents()
 end
 
 function HolyPower.prototype:UpdateRunePower(event)

modules/MonkManaBar.lua

@@ -1,53 +0,0 @@
-local MonkManaBar = IceCore_CreateClass(IceHUDPlayerAlternatePower)
-
-function MonkManaBar.prototype:init(moduleName, unit)
-	MonkManaBar.super.prototype.init(self, "MonkMana", unit)
-
-	self.bTreatEmptyAsFull = false
-end
-
-function MonkManaBar.prototype:GetDefaultSettings()
-	local settings = MonkManaBar.super.prototype.GetDefaultSettings(self)
-
-	settings["upperText"] = "[PercentMonkMP:Round]"
-	settings["lowerText"] = "[Concatenate(MonkMP:Short, \"/\", MaxMonkMP:Short):Bracket]"
-
-	return settings
-end
-
-function MonkManaBar.prototype:GetOptions()
-	local opts = MonkManaBar.super.prototype.GetOptions(self)
-
-	opts.showBlizz = nil
-	opts.hideBlizz = nil
-
-	return opts
-end
-
-function MonkManaBar.prototype:Enable(core)
-	self.specRestriction = SPEC_MONK_MISTWEAVER
-	self.powerIndex = SPELL_POWER_MANA
-	self:RegisterEvent("PLAYER_SPECIALIZATION_CHANGED", "CheckShouldShowOnSpecChange")
-	self:RegisterEvent("UNIT_DISPLAYPOWER", "CheckShouldShowOnSpecChange")
-
-	MonkManaBar.super.prototype.Enable(self, core)
-
-	self:CheckShouldShowOnSpecChange(nil, self.unit)
-end
-
-function MonkManaBar.prototype:CheckShouldShowOnSpecChange(event, unit)
-	if unit ~= self.unit and event ~= "PLAYER_SPECIALIZATION_CHANGED" then
-		return
-	end
-
-	if GetSpecialization() == self.specRestriction then
-		self:PowerBarShow(event, self.unit)
-	else
-		self:PowerBarHide(event, self.unit)
-	end
-end
-
--- Load us up
-if select(2, UnitClass("player")) == "MONK" then
-	IceHUD.MonkManaBar = MonkManaBar:new()
-end

modules/PlayerAbsorb.lua

@@ -17,11 +17,5 @@ function PlayerAbsorb.prototype:GetDefaultSettings()
 	return settings
 end
 
-function PlayerAbsorb.prototype:MyRegisterCustomEvents()
-end
-
-function PlayerAbsorb.prototype:MyUnregisterCustomEvents()
-end
-
 -- Load us up
 IceHUD.PlayerAbsorb = PlayerAbsorb:new()

modules/PlayerAltMana.lua

@@ -0,0 +1,95 @@
+local L = LibStub("AceLocale-3.0"):GetLocale("IceHUD", false)
+local PlayerAltMana = IceCore_CreateClass(IceUnitBar)
+
+PlayerAltMana.prototype.PlayerAltMana = nil
+PlayerAltMana.prototype.PlayerAltManaMax = nil
+
+local _, unitClass = UnitClass("player")
+
+-- Constructor --
+function PlayerAltMana.prototype:init()
+	PlayerAltMana.super.prototype.init(self, "PlayerAltMana", "player")
+
+	self.side = IceCore.Side.Right
+	self.offset = 0
+
+	self:SetDefaultColor("PlayerAltMana", 87, 82, 141)
+end
+
+function PlayerAltMana.prototype:GetDefaultSettings()
+	local settings = PlayerAltMana.super.prototype.GetDefaultSettings(self)
+
+	settings["side"] = IceCore.Side.Right
+	settings["offset"] = 0
+	settings["textVisible"] = {upper = true, lower = false}
+	settings["upperText"] = "[PercentMana:Round]"
+	settings["lowerText"] = "[FractionalMana:Color('3071bf'):Bracket]"
+
+	return settings
+end
+
+function GetEventsToRegister()
+	return {"UNIT_DISPLAYPOWER"}
+--[[	if unitClass == "PRIEST" then
+		return {"PLAYER_SPECIALIZATION_CHANGED"}
+	elseif unitClass == "SHAMAN" then
+		return {"PLAYER_SPECIALIZATION_CHANGED"}
+	elseif unitClass == "DRUID" then
+		return {"UPDATE_SHAPESHIFT_FORM"}
+	end
+]]-- probably not necessary, but could use as a fallback
+end
+
+function PlayerAltMana.prototype:Enable(core)
+	PlayerAltMana.super.prototype.Enable(self, core)
+
+	local eventsToRegister = GetEventsToRegister()
+	for i = 1, #eventsToRegister do
+		self:RegisterEvent(eventsToRegister[i], "Update")
+	end
+	self:RegisterEvent("UNIT_POWER_FREQUENT", "Update")
+	self:RegisterEvent("UNIT_MAXPOWER", "Update")
+end
+
+
+function PlayerAltMana.prototype:Disable(core)
+	PlayerAltMana.super.prototype.Disable(self, core)
+end
+
+function ShouldShow(unit)
+	if unitClass == "MONK" then
+		return GetSpecialization() == SPEC_MONK_MISTWEAVER
+	end
+	return UnitPowerType(unit) ~= SPELL_POWER_MANA
+--[[	if unitClass == "PRIEST" then
+		return UnitPowerType(unit) == SPELL_POWER_INSANITY
+	elseif unitClass == "SHAMAN" then
+		return GetSpecialization() ~= SPEC_SHAMAN_RESTORATION
+	elseif unitClass == "DRUID" then
+		return UnitPowerType(unit) ~= SPELL_POWER_MANA
+	end
+]]-- probably not necessary, but could use as a fallback
+end
+
+function PlayerAltMana.prototype:Update()
+	PlayerAltMana.super.prototype.Update(self)
+
+	self.PlayerAltMana = UnitPower(self.unit, SPELL_POWER_MANA)
+	self.PlayerAltManaMax = UnitPowerMax(self.unit, SPELL_POWER_MANA)
+
+	if (not self.alive or not ShouldShow(self.unit) or not self.PlayerAltMana or not self.PlayerAltManaMax or self.PlayerAltManaMax == 0) then
+		self:Show(false)
+		return
+	else
+		self:Show(true)
+	end
+
+	self:UpdateBar(self.PlayerAltManaMax ~= 0 and self.PlayerAltMana / self.PlayerAltManaMax or 0, "PlayerAltMana")
+end
+
+if (unitClass == "PRIEST" and IceHUD.WowVer >= 70000)
+	or (unitClass == "DRUID")
+	or (unitClass == "SHAMAN" and IceHUD.WowVer >= 70000)
+	or (unitClass == "MONK" and IceHUD.WowVer < 70000) then
+	IceHUD.PlayerAltMana = PlayerAltMana:new()
+end

modules/PlayerMana.lua

@@ -16,6 +16,12 @@ function PlayerMana.prototype:init()
 	self:SetDefaultColor("PlayerEnergy", 218, 231, 31)
 	self:SetDefaultColor("PlayerFocus", 242, 149, 98)
 	self:SetDefaultColor("PlayerRunicPower", 62, 54, 152)
+	if IceHUD.WowVer >= 70000 then
+		self:SetDefaultColor("PlayerInsanity", 150, 50, 255)
+		self:SetDefaultColor("PlayerFury", 255, 50, 255)
+		self:SetDefaultColor("PlayerMaelstrom", 62, 54, 152)
+		self:SetDefaultColor("PlayerPain", 255, 50, 255)
+	end
 end
 
 
@@ -94,6 +100,27 @@ end
 		order = 53
 	}
 
+	opts["scaleManaColorForAll"] = {
+		type = "toggle",
+		name = L["Scale for non-mana users"],
+		desc = L["Uses the 'color bar by mana %' setting/colors even for classes that don't use Mana"],
+		width = 'double',
+		get = function()
+			return self.moduleSettings.scaleManaColorForAll
+		end,
+		set = function(info, value)
+			self.moduleSettings.scaleManaColorForAll = value
+			self:Redraw()
+		end,
+		disabled = function()
+			return not self.moduleSettings.enabled
+		end,
+		hidden = function()
+			return not self.moduleSettings.scaleManaColor
+		end,
+		order = 53.1
+	}
+
 	return opts
 end
 
@@ -233,15 +260,16 @@ function PlayerMana.prototype:ManaType(event, unit)
 		end
 	end
 
-	if self.manaType == SPELL_POWER_RAGE or self.manaType == SPELL_POWER_RUNIC_POWER then
-		self.bTreatEmptyAsFull = true
-	else
-		self.bTreatEmptyAsFull = false
-	end
+	self.bTreatEmptyAsFull = self:TreatEmptyAsFull()
 
 	self:Update(self.unit)
 end
 
+function PlayerMana.prototype:TreatEmptyAsFull()
+	return self.manaType == SPELL_POWER_RAGE or self.manaType == SPELL_POWER_RUNIC_POWER
+		or (IceHUD.WowVer >= 70000 and (self.manaType == SPELL_POWER_LUNAR_POWER or self.manaType == SPELL_POWER_INSANITY
+		or self.manaType == SPELL_POWER_FURY or self.manaType == SPELL_POWER_PAIN or self.manaType == SPELL_POWER_MAELSTROM))
+end
 
 function PlayerMana.prototype:UpdateEvent(event, unit, powertype)
 	self:Update(unit, powertype)
@@ -275,11 +303,10 @@ function PlayerMana.prototype:Update(unit, powertype)
 	end
 
 	local color = "PlayerMana"
-	if (self.moduleSettings.scaleManaColor) then
-		color = "ScaledManaColor"
-	end
 	if not (self.alive) then
 		color = "Dead"
+	elseif (self.moduleSettings.scaleManaColor and (UnitPowerType(self.unit) == SPELL_POWER_MANA or self.moduleSettings.scaleManaColorForAll)) then
+		color = "ScaledManaColor"
 	else
 		if (self.manaType == SPELL_POWER_RAGE) then
 			color = "PlayerRage"
@@ -289,6 +316,14 @@ function PlayerMana.prototype:Update(unit, powertype)
 			color = "PlayerRunicPower"
 		elseif (self.manaType == SPELL_POWER_FOCUS) then
 			color = "PlayerFocus"
+		elseif (IceHUD.WowVer >= 70000 and self.manaType == SPELL_POWER_INSANITY) then
+			color = "PlayerInsanity"
+		elseif (IceHUD.WowVer >= 70000 and self.manaType == SPELL_POWER_FURY) then
+			color = "PlayerFury"
+		elseif (IceHUD.WowVer >= 70000 and self.manaType == SPELL_POWER_MAELSTROM) then
+			color = "PlayerMaelstrom"
+		elseif (IceHUD.WowVer >= 70000 and self.manaType == SPELL_POWER_PAIN) then
+			color = "PlayerPain"
 		end
 	end
 
@@ -296,8 +331,8 @@ function PlayerMana.prototype:Update(unit, powertype)
 
 	self:ConditionalUpdateFlash()
 
-	if (self.manaPercentage == 1 and self.manaType ~= SPELL_POWER_RAGE and self.manaType ~= SPELL_POWER_RUNIC_POWER)
-		or (self.manaPercentage == 0 and (self.manaType == SPELL_POWER_RAGE or self.manaType == SPELL_POWER_RUNIC_POWER)) then
+	if (self.manaPercentage == 1 and not self:TreatEmptyAsFull())
+		or (self.manaPercentage == 0 and self:TreatEmptyAsFull()) then
 		self:SetupOnUpdate(false)
 	else
 		self:SetupOnUpdate(true)
@@ -347,13 +382,13 @@ function PlayerMana.prototype:UpdateEnergy(event, unit)
 		return
 	end
 
-	self.previousEnergy = UnitPower(self.unit)
+	self.previousEnergy = UnitPower(self.unit, UnitPowerType(self.unit))
 	if IceHUD.WowVer < 40000 then
 		self:Update(unit)
 	end
 
 	if self:ShouldUseTicker() and
-		((not (self.previousEnergy) or (self.previousEnergy <= UnitPower(self.unit))) and
+		((not (self.previousEnergy) or (self.previousEnergy <= UnitPower(self.unit, UnitPowerType(self.unit)))) and
 		(self.moduleSettings.tickerEnabled) and self.manaType == SPELL_POWER_ENERGY) then
 			self.tickStart = GetTime()
 			self.tickerFrame:Show()

modules/Resolve.lua

@@ -0,0 +1,85 @@
+local L = LibStub("AceLocale-3.0"):GetLocale("IceHUD", false)
+local Resolve = IceCore_CreateClass(IceUnitBar)
+
+local RESOLVE_SPELL_ID = 158300
+local RESOLVE_MAX = 240
+
+Resolve.prototype.current = nil
+Resolve.prototype.max = RESOLVE_MAX
+
+-- constructor
+function Resolve.prototype:init()
+	Resolve.super.prototype.init(self, "Resolve", "player")
+
+	self.current = 0
+	self:SetDefaultColor("Resolve", 200, 45, 45)
+
+	self.bTreatEmptyAsFull = true
+end
+
+-- default settings
+function Resolve.prototype:GetDefaultSettings()
+	local defaults = Resolve.super.prototype.GetDefaultSettings(self)
+	defaults.enabled = false
+	defaults.usesDogTagStrings = false
+	defaults.lockUpperTextAlpha = false
+	defaults.shouldAnimate = false
+	defaults.hideAnimationSettings = true
+	defaults.offset = 5
+	defaults.side = IceCore.Side.Left
+	return defaults
+end
+
+-- enable plugin
+function Resolve.prototype:Enable(core)
+	Resolve.super.prototype.Enable(self, core)
+
+	-- Avoiding iteration where I can
+	self:RegisterEvent("UNIT_AURA", "UpdateCurrent")
+
+	self:Update()
+end
+
+-- disable plugin
+function Resolve.prototype:Disable(core)
+	Resolve.super.prototype.Disable(self, core)
+
+	self:UnregisterAllEvents()
+end
+
+-- scan the tooltip and extract the Resolve value
+do
+	local spellName = GetSpellInfo(RESOLVE_SPELL_ID)
+
+	function Resolve.prototype:UpdateCurrent(event, unit)
+		if (unit and (unit ~= self.unit)) then
+			return
+		end
+
+		self.current = select(15, UnitAura(self.unit, spellName)) or 0
+
+		self:Update()
+	end
+end
+
+function Resolve.prototype:Update()
+	Resolve.super.prototype.Update(self)
+
+	if self.current == 0 then
+		self:Show(false)
+		return
+	else
+		self:Show(true)
+	end
+
+	self:UpdateBar(self.current / self.max, "Resolve")
+	self:SetBottomText1(floor((self.current / self.max) * 100) .. "%")
+	self:SetBottomText2(tostring(self.current) .."/"..tostring(self.max))
+end
+
+-- Load for tanks only
+local _, unitClass = UnitClass("player")
+if ((unitClass == "DEATHKNIGHT" or unitClass == "DRUID" or unitClass == "PALADIN" or unitClass == "WARRIOR" or unitClass == "MONK")
+	and IceHUD.WowVer >= 60000 and IceHUD.WowVer < 70000) then
+  IceHUD.Resolve = Resolve:new()
+end

modules/RollTheBones.lua

@@ -0,0 +1,397 @@
+local L = LibStub("AceLocale-3.0"):GetLocale("IceHUD", false)
+local RollTheBones = IceCore_CreateClass(IceUnitBar)
+
+local IceHUD = _G.IceHUD
+
+local baseTime = 12
+local gapPerComboPoint = 6
+local maxComboPoints = 5
+local rtbEndTime = 0
+local rtbDuration = 0
+
+local CurrMaxRtBDuration = 0
+local PotentialRtBDuration = 0
+
+local RtBBuffs = {199603, 193358, 193357, 193359, 199600, 193356}
+local RtBSet = {}
+for _, v in ipairs(RtBBuffs) do
+  RtBSet[v] = true
+end
+
+-- Constructor --
+function RollTheBones.prototype:init()
+  RollTheBones.super.prototype.init(self, "RollTheBones", "player")
+
+  self.moduleSettings = {}
+  self.moduleSettings.desiredLerpTime = 0
+  self.moduleSettings.shouldAnimate = false
+
+  self:SetDefaultColor("RollTheBones", 0.75, 1, 0.2)
+  self:SetDefaultColor("RollTheBonesPotential", 1, 1, 1)
+
+  self.bTreatEmptyAsFull = true
+end
+
+-- 'Public' methods -----------------------------------------------------------
+
+-- OVERRIDE
+function RollTheBones.prototype:Enable(core)
+  RollTheBones.super.prototype.Enable(self, core)
+
+  self:RegisterEvent("UNIT_AURA", "UpdateRollTheBones")
+  self:RegisterEvent("UNIT_POWER", "ComboPointsChanged")
+
+  if not self.moduleSettings.alwaysFullAlpha then
+    self:Show(false)
+  else
+    self:UpdateRollTheBones()
+  end
+
+  self:SetBottomText1("")
+end
+
+function RollTheBones.prototype:Disable(core)
+  RollTheBones.super.prototype.Disable(self, core)
+end
+
+function RollTheBones.prototype:ComboPointsChanged(...)
+  if select('#', ...) >= 3 and select(1, ...) == "UNIT_POWER" and select(3, ...) ~= "COMBO_POINTS" then
+    return
+  end
+
+  self:TargetChanged()
+  self:UpdateDurationBar()
+end
+
+-- OVERRIDE
+function RollTheBones.prototype:GetDefaultSettings()
+  local settings = RollTheBones.super.prototype.GetDefaultSettings(self)
+
+  settings["enabled"] = false
+  settings["shouldAnimate"] = false
+  settings["desiredLerpTime"] = nil
+  settings["lowThreshold"] = 0
+  settings["side"] = IceCore.Side.Right
+  settings["offset"] = 6
+  settings["upperText"]="RtB:"
+  settings["showAsPercentOfMax"] = true
+  settings["durationAlpha"] = 0.6
+  settings["usesDogTagStrings"] = false
+  settings["lockLowerFontAlpha"] = false
+  settings["lowerTextString"] = ""
+  settings["lowerTextVisible"] = false
+  settings["hideAnimationSettings"] = true
+  settings["bAllowExpand"] = true
+  settings["bShowWithNoTarget"] = true
+
+  return settings
+end
+
+-- OVERRIDE
+function RollTheBones.prototype:GetOptions()
+  local opts = RollTheBones.super.prototype.GetOptions(self)
+
+  opts["textSettings"].args["upperTextString"]["desc"] = "The text to display under this bar. # will be replaced with the number of Roll the Bones seconds remaining."
+  opts["textSettings"].args["upperTextString"].hidden = false
+
+  opts["showAsPercentOfMax"] =
+  {
+    type = 'toggle',
+    name = L["Show bar as % of maximum"],
+    desc = L["If this is checked, then the RtB buff time shows as a percent of the maximum attainable (taking set bonuses and talents into account). Otherwise, the bar always goes from full to empty when applying RtB no matter the duration."],
+    get = function()
+      return self.moduleSettings.showAsPercentOfMax
+    end,
+    set = function(info, v)
+      self.moduleSettings.showAsPercentOfMax = v
+    end,
+    disabled = function()
+      return not self.moduleSettings.enabled
+    end
+  }
+
+  opts["durationAlpha"] =
+  {
+    type = "range",
+    name = L["Potential RtB time bar alpha"],
+    desc = L["What alpha value to use for the bar that displays how long your RtB will last if you activate it. (This gets multiplied by the bar's current alpha to stay in line with the bar on top of it)"],
+    min = 0,
+    max = 100,
+    step = 5,
+    get = function()
+      return self.moduleSettings.durationAlpha * 100
+    end,
+    set = function(info, v)
+      self.moduleSettings.durationAlpha = v / 100.0
+      self:Redraw()
+    end,
+    disabled = function()
+      return not self.moduleSettings.enabled
+    end
+  }
+
+  opts["bShowWithNoTarget"] =
+  {
+    type = 'toggle',
+    name = L["Show with no target"],
+    desc = L["Whether or not to display when you have no target selected but have combo points available"],
+    get = function()
+      return self.moduleSettings.bShowWithNoTarget
+    end,
+    set = function(info, v)
+      self.moduleSettings.bShowWithNoTarget = v
+      self:ComboPointsChanged()
+    end,
+    disabled = function()
+      return not self.moduleSettings.enabled
+    end,
+  }
+
+  return opts
+end
+
+function RollTheBones.prototype:CreateFrame()
+  RollTheBones.super.prototype.CreateFrame(self)
+
+  self:CreateDurationBar()
+end
+
+function RollTheBones.prototype:CreateDurationBar()
+  self.durationFrame = self:BarFactory(self.durationFrame, "BACKGROUND","ARTWORK")
+
+  -- Rokiyo: Do we need to call this here?
+  self.CurrScale = 0
+
+  self.durationFrame.bar:SetVertexColor(self:GetColor("RollTheBonesPotential", self.moduleSettings.durationAlpha))
+  self.durationFrame.bar:SetHeight(0)
+
+  self:UpdateBar(1, "undef")
+
+  -- force update the bar...if we're in here, then either the UI was just loaded or the player is jacking with the options.
+  -- either way, make sure the duration bar matches accordingly
+  self:UpdateDurationBar()
+end
+
+function RollTheBones.prototype:RotateHorizontal()
+  RollTheBones.super.prototype.RotateHorizontal(self)
+
+  self:RotateFrame(self.durationFrame)
+end
+
+function RollTheBones.prototype:ResetRotation()
+  RollTheBones.super.prototype.ResetRotation(self)
+
+  if self.durationFrame and self.durationFrame.anim then
+    self.durationFrame.anim:Stop()
+  end
+end
+
+-- 'Protected' methods --------------------------------------------------------
+
+function RollTheBones.prototype:GetBuffDuration(unitName, ids)
+  local i = 1
+  local buff, rank, texture, count, type, duration, endTime, remaining, spellId
+  buff, _, _, count, type, duration, endTime, _, _, _, spellId = UnitBuff(unitName, i)
+
+  while buff do
+    if (spellId and ids[spellId]) then
+      if endTime and not remaining then
+        remaining = endTime - GetTime()
+      end
+      return duration, remaining
+    end
+
+    i = i + 1;
+
+    buff, _, _, count, type, duration, endTime, _, _, _, spellId = UnitBuff(unitName, i)
+
+  end
+
+  return nil, nil
+end
+
+function RollTheBones.prototype:MyOnUpdate()
+  RollTheBones.super.prototype.MyOnUpdate(self)
+  if self.bUpdateRtb then
+    self:UpdateRollTheBones(nil, self.unit, true)
+  end
+  if self.target or self.moduleSettings.bShowWithNoTarget then
+    self:UpdateDurationBar()
+  end
+end
+
+local function RTBGetComboPoints(unit)
+  return UnitPower(unit, SPELL_POWER_COMBO_POINTS)
+end
+
+-- use this to figure out if Roll the Bones is available or not. neither IsSpellKnown nor IsPlayerSpell are correct for it
+-- when SnD is known, but this is.
+local function HasSpell(id)
+    local spell = GetSpellInfo(id)
+    return spell == GetSpellInfo(spell)
+end
+
+local function ShouldHide()
+  return not HasSpell(193316)
+end
+
+function RollTheBones.prototype:UpdateRollTheBones(event, unit, fromUpdate)
+  if unit and unit ~= self.unit then
+    return
+  end
+
+  local now = GetTime()
+  local remaining = nil
+
+  if not fromUpdate then
+    rtbDuration, remaining = self:GetBuffDuration(self.unit, RtBSet)
+
+    if not remaining then
+      rtbEndTime = 0
+    else
+      rtbEndTime = remaining + now
+    end
+  end
+
+  if rtbEndTime and rtbEndTime >= now then
+    if not fromUpdate then
+      self.bUpdateRtb = true
+    end
+
+    self:Show(true)
+    if not remaining then
+      remaining = rtbEndTime - now
+    end
+    local denominator = (self.moduleSettings.showAsPercentOfMax and CurrMaxRtBDuration or rtbDuration)
+    self:UpdateBar(denominator ~= 0 and remaining / denominator or 0, "RollTheBones")
+  else
+    self:UpdateBar(0, "RollTheBones")
+
+    if RTBGetComboPoints(self.unit) == 0 or (not UnitExists("target") and not self.moduleSettings.bShowWithNoTarget) or ShouldHide() then
+      if self.bIsVisible then
+        self.bUpdateRtb = nil
+      end
+
+      if not self.moduleSettings.alwaysFullAlpha or ShouldHide() then
+        self:Show(false)
+      end
+    end
+  end
+
+  -- somewhat redundant, but we also need to check potential remaining time
+  if (remaining ~= nil) or PotentialRtBDuration > 0 then
+    local potText = " (" .. PotentialRtBDuration .. ")"
+    self:SetBottomText1(self.moduleSettings.upperText .. tostring(floor(remaining or 0)) .. (self.moduleSettings.durationAlpha ~= 0 and potText or ""))
+  end
+end
+
+function RollTheBones.prototype:TargetChanged()
+  if self.moduleSettings.bShowWithNoTarget and RTBGetComboPoints(self.unit) > 0 then
+    self.target = true
+  else
+    self.target = UnitExists("target")
+  end
+  self:Update(self.unit)
+
+  self:UpdateDurationBar()
+  self:UpdateRollTheBones()
+end
+
+function RollTheBones.prototype:UpdateDurationBar(event, unit)
+  if unit and unit ~= self.unit then
+    return
+  end
+
+  local points = RTBGetComboPoints(self.unit)
+  -- check for Deeper Stratagem
+  local _, _, _, DeeperStratagem = GetTalentInfo(3, 1, 1)
+
+  if DeeperStratagem then
+    -- first, set the cached upper limit of RtB duration
+    CurrMaxRtBDuration = self:GetMaxBuffTime(maxComboPoints + 1)
+  else
+    CurrMaxRtBDuration = self:GetMaxBuffTime(maxComboPoints)
+  end
+
+  if event then
+    self:UpdateRollTheBones()
+  end
+
+  -- player doesn't want to show the percent of max or the alpha is zeroed out, so don't bother with the duration bar
+  if not self.moduleSettings.showAsPercentOfMax or self.moduleSettings.durationAlpha == 0 or (points == 0 and not self:IsVisible())
+    or ShouldHide() then
+    self.durationFrame:Hide()
+    return
+  end
+  self.durationFrame:Show()
+
+  -- if we have combo points and a target selected, go ahead and show the bar so the duration bar can be seen
+  if points > 0 and (UnitExists("target") or self.moduleSettings.bShowWithNoTarget) then
+    self:Show(true)
+  end
+
+  if self.moduleSettings.durationAlpha > 0 then
+    PotentialRtBDuration = self:GetMaxBuffTime(points)
+
+    -- compute the scale from the current number of combo points
+    local scale = IceHUD:Clamp(PotentialRtBDuration / CurrMaxRtBDuration, 0, 1)
+
+    -- sadly, animation uses bar-local variables so we can't use the animation for 2 bar textures on the same bar element
+    if (self.moduleSettings.reverse) then
+      scale = 1 - scale
+    end
+
+    self.durationFrame.bar:SetVertexColor(self:GetColor("RollTheBonesPotential", self.moduleSettings.durationAlpha))
+    self:SetBarCoord(self.durationFrame, scale)
+  end
+
+  if rtbEndTime < GetTime() then
+    local potText = " (" .. PotentialRtBDuration .. ")"
+    self:SetBottomText1(self.moduleSettings.upperText .. "0" .. (self.moduleSettings.durationAlpha > 0 and potText or ""))
+  end
+end
+
+function RollTheBones.prototype:GetMaxBuffTime(numComboPoints)
+  local maxduration
+
+  if numComboPoints == 0 then
+    return 0
+  end
+
+  maxduration = baseTime + ((numComboPoints - 1) * gapPerComboPoint)
+
+  return maxduration
+end
+
+function RollTheBones.prototype:GetItemIdFromItemLink(linkStr)
+  local itemId
+  local _
+
+  if linkStr then
+    _, itemId, _, _, _, _, _, _, _ = strsplit(":", linkStr)
+  end
+
+  return itemId or 0
+end
+
+function RollTheBones.prototype:IsItemIdInList(itemId, list)
+  for i=1,#list do
+    if string.match(itemId, list[i]) then
+      return true
+    end
+  end
+
+  return false
+end
+
+function RollTheBones.prototype:OutCombat()
+  RollTheBones.super.prototype.OutCombat(self)
+
+  self:UpdateRollTheBones()
+end
+
+local _, unitClass = UnitClass("player")
+-- Load us up
+if unitClass == "ROGUE" and IceHUD.WowVer >= 70000 then
+  IceHUD.RollTheBones = RollTheBones:new()
+end

modules/Runes.lua

@@ -3,12 +3,23 @@ local Runes = IceCore_CreateClass(IceElement)
 
 local IceHUD = _G.IceHUD
 
+local CooldownFrame_SetTimer = CooldownFrame_SetTimer
+if IceHUD.WowVer >= 70000 then
+	CooldownFrame_SetTimer = CooldownFrame_Set
+end
+
 -- blizzard cracks me up. the below block is copied verbatim from RuneFrame.lua ;)
 --Readability == win
 local RUNETYPE_BLOOD = 1;
 local RUNETYPE_DEATH = 2;
 local RUNETYPE_FROST = 3;
 local RUNETYPE_CHROMATIC = 4;
+local RUNETYPE_LEGION = 5; -- not real, but makes for an easy update
+
+local GetRuneType = GetRuneType
+if IceHUD.WowVer >= 70000 then
+	GetRuneType = function() return RUNETYPE_LEGION end
+end
 
 -- setup the names to be more easily readable
 Runes.prototype.runeNames = {
@@ -16,6 +27,7 @@ Runes.prototype.runeNames = {
 	[RUNETYPE_DEATH] = "Unholy",
 	[RUNETYPE_FROST] = "Frost",
 	[RUNETYPE_CHROMATIC] = "Death",
+	[RUNETYPE_LEGION] = "SingleRune",
 }
 
 Runes.prototype.runeSize = 25
@@ -26,10 +38,14 @@ Runes.prototype.numRunes = 6
 function Runes.prototype:init()
 	Runes.super.prototype.init(self, "Runes")
 
-	self:SetDefaultColor("Runes"..self.runeNames[RUNETYPE_BLOOD], 255, 0, 0)
-	self:SetDefaultColor("Runes"..self.runeNames[RUNETYPE_DEATH], 0, 207, 0)
-	self:SetDefaultColor("Runes"..self.runeNames[RUNETYPE_FROST], 0, 255, 255)
-	self:SetDefaultColor("Runes"..self.runeNames[RUNETYPE_CHROMATIC], 204, 26, 255)
+	if IceHUD.WowVer < 70000 then
+		self:SetDefaultColor("Runes"..self.runeNames[RUNETYPE_BLOOD], 255, 0, 0)
+		self:SetDefaultColor("Runes"..self.runeNames[RUNETYPE_DEATH], 0, 207, 0)
+		self:SetDefaultColor("Runes"..self.runeNames[RUNETYPE_FROST], 0, 255, 255)
+		self:SetDefaultColor("Runes"..self.runeNames[RUNETYPE_CHROMATIC], 204, 26, 255)
+	else
+		self:SetDefaultColor("Runes"..self.runeNames[RUNETYPE_LEGION], 204, 204, 255)
+	end
 	self.scalingEnabled = true
 end
 
@@ -192,11 +208,16 @@ end
 
 -- OVERRIDE
 function Runes.prototype:Enable(core)
+	if IceHUD.WowVer >= 70000 then
+		self.numRunes = UnitPowerMax("player", SPELL_POWER_RUNES)
+	end
+
 	Runes.super.prototype.Enable(self, core)
 
 	self:RegisterEvent("RUNE_POWER_UPDATE", "UpdateRunePower")
 	self:RegisterEvent("RUNE_TYPE_UPDATE", "UpdateRuneType")
 	self:RegisterEvent("PLAYER_ENTERING_WORLD", "ResetRuneAvailability")
+	self:RegisterEvent("UNIT_MAXPOWER", "CheckMaxNumRunes")
 
 	if (self.moduleSettings.hideBlizz) then
 		self:HideBlizz()
@@ -211,6 +232,20 @@ function Runes.prototype:Disable(core)
 	end
 end
 
+function Runes.prototype:CheckMaxNumRunes(event, unit, powerType)
+	if unit ~= "player" then
+		return
+	end
+
+	if UnitPowerMax("player", SPELL_POWER_RUNES) ~= self.numRunes then
+		self.numRunes = UnitPowerMax("player", SPELL_POWER_RUNES)
+		for i = 1, #self.frame.graphical do
+			self.frame.graphical[i]:Hide()
+		end
+		self:Redraw()
+	end
+end
+
 function Runes.prototype:ResetRuneAvailability()
 	for i=1, self.numRunes do
 		self:UpdateRunePower(nil, i, true)
@@ -224,10 +259,10 @@ function Runes.prototype:UpdateRunePower(event, rune, dontFlash)
 		return
 	end
 
---	DEFAULT_CHAT_FRAME:AddMessage("Runes.prototype:UpdateRunePower: rune="..rune.." usable="..(usable and "yes" or "no").." GetRuneType(rune)="..GetRuneType(rune));
-
 	local start, duration, usable = GetRuneCooldown(rune)
 
+--	print("Runes.prototype:UpdateRunePower: rune="..rune.." usable="..(usable and "yes" or "no").." GetRuneType(rune)="..GetRuneType(rune));
+
 	if usable then
 		if self.moduleSettings.cooldownMode == "Cooldown" then
 			self.frame.graphical[rune].cd:Hide()
@@ -247,14 +282,14 @@ function Runes.prototype:UpdateRunePower(event, rune, dontFlash)
 			}
 			UIFrameFade(self.frame.graphical[rune].shine, fadeInfo);
 		end
-	else
+	elseif start ~= nil and duration ~= nil then
 		if self.moduleSettings.cooldownMode == "Cooldown" then
-			self.frame.graphical[rune].cd:SetCooldown(GetRuneCooldown(rune))
+			CooldownFrame_SetTimer(self.frame.graphical[rune].cd, start, duration, true)
 			self.frame.graphical[rune].cd:Show()
 		elseif self.moduleSettings.cooldownMode == "Alpha" then
 			self.frame.graphical[rune]:SetAlpha(0.2)
 	 	elseif self.moduleSettings.cooldownMode == "Both" then
-			self.frame.graphical[rune].cd:SetCooldown(GetRuneCooldown(rune))
+	 		CooldownFrame_SetTimer(self.frame.graphical[rune].cd, start, duration, true)
 			self.frame.graphical[rune].cd:Show()
 			self.frame.graphical[rune]:SetAlpha(0.2)
 		end
@@ -266,7 +301,7 @@ function Runes.prototype:ShineFinished(rune)
 end
 
 function Runes.prototype:UpdateRuneType(event, rune)
---	DEFAULT_CHAT_FRAME:AddMessage("Runes.prototype:UpdateRuneType: rune="..rune.." GetRuneType(rune)="..GetRuneType(rune));
+	IceHUD:Debug("Runes.prototype:UpdateRuneType: rune="..rune.." GetRuneType(rune)="..GetRuneType(rune));
 
 	if not rune or tonumber(rune) ~= rune or rune < 1 or rune > self.numRunes then
 		return
@@ -355,13 +390,15 @@ function Runes.prototype:CreateRune(i, type, name)
 	self.frame.graphical[i]:SetHeight(self.runeSize)
 
 	-- hax for blizzard's swapping the unholy and frost rune placement on the default ui...
-	local runeSwapI
-	if i == 3 or i == 4 then
-		runeSwapI = i + 2
-	elseif i == 5 or i == 6 then
-		runeSwapI = i - 2
-	else
-		runeSwapI = i
+	local runeSwapI = i
+	if IceHUD.WowVer < 70000 then
+		if i == 3 or i == 4 then
+			runeSwapI = i + 2
+		elseif i == 5 or i == 6 then
+			runeSwapI = i - 2
+		else
+			runeSwapI = i
+		end
 	end
 	if self.moduleSettings.displayMode == "Horizontal" then
 		self.frame.graphical[i]:SetPoint("TOPLEFT", (runeSwapI-1) * (self.runeSize-5) + (runeSwapI-1) + ((runeSwapI-1) * self.moduleSettings.runeGap), 0)
@@ -369,7 +406,8 @@ function Runes.prototype:CreateRune(i, type, name)
 		self.frame.graphical[i]:SetPoint("TOPLEFT", 0, -1 * ((runeSwapI-1) * (self.runeSize-5) + (runeSwapI-1) + ((runeSwapI-1) * self.moduleSettings.runeGap)))
 	end
 
-	self.frame.graphical[i].rune:SetTexture(self:GetRuneTexture(name))
+	local runeTex = self:GetRuneTexture(name)
+	self.frame.graphical[i].rune:SetTexture(runeTex)
 	self.frame.graphical[i].rune:SetVertexColor(self:GetColor("Runes"..name))
 	self.frame.graphical[i]:Show()
 
@@ -377,6 +415,8 @@ function Runes.prototype:CreateRune(i, type, name)
 	self.frame.graphical[i].cd:SetFrameLevel(self.frame.graphical[i]:GetFrameLevel()+1)
 	self.frame.graphical[i].cd:ClearAllPoints()
 	self.frame.graphical[i].cd:SetAllPoints(self.frame.graphical[i])
+	self.frame.graphical[i].cd:SetSwipeTexture(runeTex)
+	self.frame.graphical[i].cd:SetDrawEdge(false)
 
 	self.frame.graphical[i].shine:SetTexture("Interface\\ComboFrame\\ComboPoint")
 	self.frame.graphical[i].shine:SetBlendMode("ADD")

modules/ShadowOrbs.lua

@@ -103,7 +103,7 @@ end
 
 -- Load us up
 local _, unitClass = UnitClass("player")
-if (unitClass == "PRIEST" and IceHUD.WowVer >= 50000) then
+if (unitClass == "PRIEST" and IceHUD.WowVer >= 50000 and IceHUD.WowVer < 70000) then
 	IceHUD.ShadowOrbs = ShadowOrbs:new()
 end
 

modules/Shards.lua

@@ -9,6 +9,7 @@ local AfflictionCoords =
 	{0.01562500, 0.28125000, 0.00781250, 0.13281250},
 	{0.01562500, 0.28125000, 0.00781250, 0.13281250},
 	{0.01562500, 0.28125000, 0.00781250, 0.13281250},
+	{0.01562500, 0.28125000, 0.00781250, 0.13281250},
 }
 
 local DestructionCoords =
@@ -31,12 +32,24 @@ function ShardCounter.prototype:init()
 
 	self.numericColor = "ShardCounterNumeric"
 	self.minLevel = SHARDBAR_SHOW_LEVEL
+
+	if IceHUD.WowVer >= 70000 then
+		self.runeHeight = 23
+		self.runeWidth = 26
+		self.runeCoords = AfflictionCoords
+		self.unitPower = SPELL_POWER_SOUL_SHARDS
+		self.unit = "player"
+	end
 end
 
 function ShardCounter.prototype:Enable(core)
+	if IceHUD.WowVer >= 70000 then
+		self.numRunes = UnitPowerMax(self.unit, self.unitPower)
+	end
+
 	ShardCounter.super.prototype.Enable(self, core)
 
-	if IceHUD.WowVer >= 50000 then
+	if IceHUD.WowVer >= 50000 and IceHUD.WowVer < 70000 then
 		self:RegisterEvent("PLAYER_TALENT_UPDATE", "UpdatePowerType")
 		self:RegisterEvent("UNIT_DISPLAYPOWER", "UpdatePowerType")
 		self:RegisterEvent("ACTIVE_TALENT_GROUP_CHANGED", "UpdatePowerType")
@@ -44,12 +57,14 @@ function ShardCounter.prototype:Enable(core)
 		self:RegisterEvent("PLAYER_SPECIALIZATION_CHANGED", "UpdatePowerType")
 		self:RegisterEvent("UNIT_MAXPOWER", "UpdatePowerType")
 	end
-	self:UpdatePowerType()
+	if IceHUD.WowVer < 70000 then
+		self:UpdatePowerType()
+	end
 end
 
 function ShardCounter.prototype:UpdateRunePower(event, arg1, arg2)
-	if IceHUD.WowVer >= 50000 then
-		if event == "UNIT_POWER_FREQUENT" and arg1 == "player" then
+	if IceHUD.WowVer >= 50000 and IceHUD.WowVer < 70000 then
+		if event == "UNIT_POWER_FREQUENT" and arg1 == self.unit then
 			if CurrentSpec == SPEC_WARLOCK_DESTRUCTION and arg2 ~= "BURNING_EMBERS" then
 				return
 			elseif CurrentSpec == SPEC_WARLOCK_DEMONOLOGY and arg2 ~= "DEMONIC_FURY" then
@@ -60,13 +75,20 @@ function ShardCounter.prototype:UpdateRunePower(event, arg1, arg2)
 		end
 	end
 
-	if event == "PLAYER_ENTERING_WORLD" then
+	if event == "PLAYER_ENTERING_WORLD" and IceHUD.WowVer < 70000 then
 		self:UpdatePowerType(event)
 	end
 
 	ShardCounter.super.prototype.UpdateRunePower(self, event, arg1, arg2)
 end
 
+function ShardCounter.prototype:CheckGreenFire()
+	if IsSpellKnown(WARLOCK_GREEN_FIRE) then
+		self:Redraw();
+		self:UnregisterEvent("SPELLS_CHANGED")
+	end
+end
+
 function ShardCounter.prototype:UpdatePowerType(event)
 	if IceHUD.WowVer >= 50000 then
 		CurrentSpec = GetSpecialization()
@@ -83,7 +105,7 @@ function ShardCounter.prototype:UpdatePowerType(event)
 		self.runeCoords = AfflictionCoords
 		self.unitPower = SPELL_POWER_SOUL_SHARDS
 
-		local powerMax = UnitPowerMax("player", self.unitPower)
+		local powerMax = UnitPowerMax(self.unit, self.unitPower)
 		if powerMax == 0 then -- abort abort! this is bad.
 			return
 		end
@@ -95,7 +117,7 @@ function ShardCounter.prototype:UpdatePowerType(event)
 
 		if IceHUD.WowVer >= 50000 then
 			if not IsPlayerSpell(WARLOCK_SOULBURN) then
-				self.requiredSpec = -1
+				self.requiredSpec = nil
 				self:RegisterEvent("SPELLS_CHANGED", "UpdatePowerType")
 			else
 				self:UnregisterEvent("SPELLS_CHANGED", "UpdatePowerType")
@@ -105,7 +127,7 @@ function ShardCounter.prototype:UpdatePowerType(event)
 		self.runeCoords = DestructionCoords
 		self.unitPower = SPELL_POWER_BURNING_EMBERS
 
-		local powerMax = UnitPowerMax("player", self.unitPower)
+		local powerMax = UnitPowerMax(self.unit, self.unitPower)
 		if powerMax == 0 then -- abort abort! this is bad.
 			return
 		end
@@ -119,8 +141,10 @@ function ShardCounter.prototype:UpdatePowerType(event)
 		self.currentGrowMode = self.growModes["height"]
 
 		if not IsPlayerSpell(WARLOCK_BURNING_EMBERS) then
-			self.requiredSpec = -1
+			self.requiredSpec = nil
 			self:RegisterEvent("SPELLS_CHANGED", "UpdatePowerType")
+		elseif not IsSpellKnown(WARLOCK_GREEN_FIRE) then
+			self:RegisterEvent("SPELLS_CHANGED", "CheckGreenFire")
 		else
 			self:UnregisterEvent("SPELLS_CHANGED", "UpdatePowerType")
 		end
@@ -133,7 +157,7 @@ function ShardCounter.prototype:UpdatePowerType(event)
 		self.numConsideredFull = 99
 		self.currentGrowMode = self.growModes["width"]
 	else
-		self.requiredSpec = -1
+		self.requiredSpec = nil
 		self:RegisterEvent("SPELLS_CHANGED", "UpdatePowerType")
 	end
 
@@ -186,7 +210,11 @@ function ShardCounter.prototype:GetRuneTexture(rune)
 	end
 
 	if CurrentSpec == SPEC_WARLOCK_DESTRUCTION then
-		return "Interface\\PlayerFrame\\Warlock-DestructionUI"
+		if IsSpellKnown(WARLOCK_GREEN_FIRE) then
+			return "Interface\\PlayerFrame\\Warlock-DestructionUI-Green"
+		else
+			return "Interface\\PlayerFrame\\Warlock-DestructionUI"
+		end
 	elseif CurrentSpec == SPEC_WARLOCK_DEMONOLOGY then
 		return "Interface\\PlayerFrame\\Warlock-DemonologyUI"
 	end

modules/SliceAndDice.lua

@@ -50,7 +50,11 @@ function SliceAndDice.prototype:Enable(core)
 	SliceAndDice.super.prototype.Enable(self, core)
 
 	self:RegisterEvent("UNIT_AURA", "UpdateSliceAndDice")
-	self:RegisterEvent("UNIT_COMBO_POINTS", "ComboPointsChanged")
+	if IceHUD.WowVer < 70000 then
+		self:RegisterEvent("UNIT_COMBO_POINTS", "ComboPointsChanged")
+	else
+		self:RegisterEvent("UNIT_POWER", "ComboPointsChanged")
+	end
 
 	if not self.moduleSettings.alwaysFullAlpha then
 		self:Show(false)
@@ -65,7 +69,11 @@ function SliceAndDice.prototype:Disable(core)
 	SliceAndDice.super.prototype.Disable(self, core)
 end
 
-function SliceAndDice.prototype:ComboPointsChanged()
+function SliceAndDice.prototype:ComboPointsChanged(...)
+	if select('#', ...) >= 3 and select(1, ...) == "UNIT_POWER" and select(3, ...) ~= "COMBO_POINTS" then
+		return
+	end
+
 	self:TargetChanged()
 	self:UpdateDurationBar()
 end
@@ -188,7 +196,7 @@ end
 function SliceAndDice.prototype:ResetRotation()
 	SliceAndDice.super.prototype.ResetRotation(self)
 
-	if self.durationFrame.anim then
+	if self.durationFrame and self.durationFrame.anim then
 		self.durationFrame.anim:Stop()
 	end
 end
@@ -236,7 +244,7 @@ end
 
 local function SNDGetComboPoints(unit)
 	if IceHUD.WowVer >= 60000 then
-		return UnitPower(unit, 4)
+		return UnitPower(unit, SPELL_POWER_COMBO_POINTS)
 	elseif IceHUD.WowVer >= 30000 then
 		return GetComboPoints(unit, "target")
 	else
@@ -244,6 +252,20 @@ local function SNDGetComboPoints(unit)
 	end
 end
 
+-- use this to figure out if Roll the Bones is available or not. neither IsSpellKnown nor IsPlayerSpell are correct for it
+-- when SnD is known, but this is.
+local function HasSpell(id)
+    local spell = GetSpellInfo(id)
+    return spell == GetSpellInfo(spell)
+end
+
+local function ShouldHide()
+	return --[[(IceHUD.WowVer < 70000 or not IsSpellKnown(193316)) and]] not IsPlayerSpell(5171) -- IsSpellKnown returns incorrect info for SnD in 7.0
+	-- commented code is here in case we decide we'd like to use this module for Roll the Bones.
+	-- if we do, though, the "active" check gets way more complicated since it can activate any number of 6 different abilities
+	-- with different durations
+end
+
 function SliceAndDice.prototype:UpdateSliceAndDice(event, unit, fromUpdate)
 	if unit and unit ~= self.unit then
 		return
@@ -276,12 +298,12 @@ function SliceAndDice.prototype:UpdateSliceAndDice(event, unit, fromUpdate)
 	else
 		self:UpdateBar(0, "SliceAndDice")
 
-		if SNDGetComboPoints(self.unit) == 0 or (not UnitExists("target") and not self.moduleSettings.bShowWithNoTarget) then
+		if SNDGetComboPoints(self.unit) == 0 or (not UnitExists("target") and not self.moduleSettings.bShowWithNoTarget) or ShouldHide() then
 			if self.bIsVisible then
 				self.bUpdateSnd = nil
 			end
 
-			if not self.moduleSettings.alwaysFullAlpha then
+			if not self.moduleSettings.alwaysFullAlpha or ShouldHide() then
 				self:Show(false)
 			end
 		end
@@ -321,7 +343,8 @@ function SliceAndDice.prototype:UpdateDurationBar(event, unit)
 	end
 
 	-- player doesn't want to show the percent of max or the alpha is zeroed out, so don't bother with the duration bar
-	if not self.moduleSettings.showAsPercentOfMax or self.moduleSettings.durationAlpha == 0 or (points == 0 and not self:IsVisible()) then
+	if not self.moduleSettings.showAsPercentOfMax or self.moduleSettings.durationAlpha == 0 or (points == 0 and not self:IsVisible())
+		or ShouldHide() then
 		self.durationFrame:Hide()
 		return
 	end

modules/Stagger.lua

@@ -0,0 +1,298 @@
+local L = LibStub("AceLocale-3.0"):GetLocale("IceHUD", false)
+local StaggerBar = IceCore_CreateClass(IceUnitBar)
+local IceHUD = _G.IceHUD
+
+local tostring = tostring
+local floor = math.floor
+local min = math.min
+local strform = string.format
+
+local playerName = ""
+local LightID = 124275
+local ModerateID = 124274
+local HeavyID = 124273
+local StaggerID = 124255
+local staggerNames = {"", "", ""}
+
+local MinLevel = 10
+
+StaggerBar.prototype.StaggerDuration = 0
+StaggerBar.prototype.StaggerEndTime = 0
+
+function StaggerBar.prototype:init()
+	StaggerBar.super.prototype.init(self, "Stagger", "player")
+
+	self:SetDefaultColor("Stagger1", 200, 180, 20)
+	self:SetDefaultColor("Stagger2", 200, 90, 10)
+	self:SetDefaultColor("Stagger3", 200, 0, 0)
+	self:SetDefaultColor("StaggerTime", 255, 255, 255)
+
+	self.bTreatEmptyAsFull = false
+end
+
+function StaggerBar.prototype:Redraw()
+	StaggerBar.super.prototype.Redraw(self)
+
+	self:MyOnUpdate()
+end
+
+function StaggerBar.prototype:GetDefaultSettings()
+	local settings =  StaggerBar.super.prototype.GetDefaultSettings(self)
+
+	settings["enabled"] = true
+	settings["shouldAnimate"] = true
+	settings["lowThreshold"] = 0
+	settings["side"] = IceCore.Side.Left
+	settings["offset"] = 3
+	settings["upperText"]=""
+	settings["showAsPercentOfMax"] = true
+	settings["maxPercent"] = 20
+	settings["timerAlpha"] = 0.3
+	settings["lockLowerFontAlpha"] = false
+	settings["lowerTextString"] = ""
+	settings["lowerTextVisible"] = false
+	settings["hideAnimationSettings"] = true
+	settings["bAllowExpand"] = true
+	settings["bShowWithNoTarget"] = true
+	settings["upperText"] = "[PercentStagger]"
+	settings["lowerText"] = "[FractionalStagger:Short]"
+
+	return settings
+end
+
+function StaggerBar.prototype:GetOptions()
+	local opts = StaggerBar.super.prototype.GetOptions(self)
+
+	opts.reverse.hidden = true
+
+	opts["maxPercent"] =
+	{
+		type = "range",
+		name = "Max Percent",
+		desc = "Maximum percentage of your maximum health for the Stagger bar to represent. I.e, if set to 20%, the bar will be full when the Stagger damage over time effect is dealing 20% of your maximum health per second.",
+		min = 0,
+		max = 50,
+		step = 1,
+		get = function()
+			return self.moduleSettings.maxPercent
+		end,
+		set = function(info, v)
+			self.moduleSettings.maxPercent = v
+			self:Redraw()
+		end,
+		disabled = function()
+			return not self.moduleSettings.enabled
+		end
+	}
+
+	opts["timerAlpha"] =
+	{
+		type = "range",
+		name = "Timer bar alpha",
+		desc = "What alpha value to use for the bar that displays how long until Stagger wears off.",
+		min = 0,
+		max = 100,
+		step = 5,
+		get = function()
+			return self.moduleSettings.timerAlpha * 100
+		end,
+		set = function(info, v)
+			self.moduleSettings.timerAlpha = v / 100
+			self:Redraw()
+		end,
+		disabled = function()
+			return not self.moduleSettings.enabled
+		end
+	}
+
+	return opts
+end
+
+function StaggerBar.prototype:Enable(core)
+	StaggerBar.super.prototype.Enable(self, core)
+
+	playerName = UnitName(self.unit)
+	staggerNames[1] = GetSpellInfo(LightID)
+	staggerNames[2] = GetSpellInfo(ModerateID)
+	staggerNames[3] = GetSpellInfo(HeavyID)
+
+	self:RegisterEvent("COMBAT_LOG_EVENT_UNFILTERED")
+	self:RegisterEvent("PLAYER_ENTERING_WORLD")
+	self:RegisterEvent("ACTIVE_TALENT_GROUP_CHANGED")
+
+	self:UpdateShown()
+end
+
+function StaggerBar.prototype:Disable(core)
+	StaggerBar.super.prototype.Disable(self, core)
+end
+
+function StaggerBar.prototype:CreateFrame()
+	StaggerBar.super.prototype.CreateFrame(self)
+	self:CreateTimerBar()
+
+	self:UpdateShown()
+	self:UpdateAlpha()
+end
+
+function StaggerBar.prototype:CreateTimerBar()
+	self.timerFrame = self:BarFactory(self.timerFrame, "MEDIUM","ARTWORK")
+
+	self.CurrScale = 0
+
+	self.timerFrame.bar:SetVertexColor(self:GetColor("StaggerTime", self.moduleSettings.timerAlpha))
+	self.timerFrame.bar:SetHeight(0)
+
+	self:UpdateBar(1, "undef")
+	self:UpdateTimerFrame()
+end
+
+function StaggerBar.prototype:UpdateShown()
+	if GetSpecialization() == SPEC_MONK_BREWMASTER and not UnitInVehicle(self.unit) and UnitLevel(self.unit) >= MinLevel then
+		self:Show(true)
+	else
+		self:Show(false)
+	end
+end
+
+function StaggerBar.prototype:PLAYER_ENTERING_WORLD()
+	self:UpdateStaggerBar()
+end
+
+function StaggerBar.prototype:ACTIVE_TALENT_GROUP_CHANGED()
+	self:UpdateStaggerBar()
+end
+
+function StaggerBar.prototype:GetDebuffInfo()
+	if IceHUD.WowVer >= 70000 then
+		self.amount = UnitStagger(self.unit)
+		self.staggerLevel = 1
+
+		local healthMax = UnitHealthMax(self.unit)
+		local percent = self.amount / healthMax
+		if percent >= STAGGER_YELLOW_TRANSITION then
+			self.staggerLevel = 2
+		elseif percent >= STAGGER_RED_TRANSITION then
+			self.staggerLevel = 3
+		end
+		return
+	end
+
+	local amount = 0
+	local duration = 0
+	local staggerLevel = 1
+
+	for i = 1, IceCore.BuffLimit do
+		local debuffID = select(11, UnitDebuff(self.unit, i))
+
+		if debuffID == LightID or debuffID == ModerateID or debuffID == HeavyID then
+			local spellName = select(1, UnitDebuff(self.unit, i))
+
+			duration = select(6, UnitAura(self.unit, spellName, "", "HARMFUL"))
+			amount = select(15, UnitAura(self.unit, spellName, "", "HARMFUL"))
+			staggerLevel = (debuffID == LightID) and 1 or (debuffID == ModerateID) and 2 or 3
+
+			break
+		end
+	end
+
+	self.amount = amount or 0
+	self.duration = duration or 0
+	self.staggerLevel = staggerLevel or 1
+end
+
+function StaggerBar.prototype:COMBAT_LOG_EVENT_UNFILTERED(_, timestamp, event, hideCaster, sourceGUID, sourceName, sourceFlags, sourceFlags2, destGUID, destName, destFlags, destFlags2, spellID)
+	if destName == playerName then
+		if spellID == StaggerID or event == "SWING_DAMAGE" or event == "SPELL_AURA_APPLIED" or event == "SPELL_AURA_REMOVED" then
+			self:UpdateStaggerBar()
+		end
+	end
+end
+
+function StaggerBar.prototype:UpdateStaggerBar()
+	self:GetDebuffInfo()
+
+	-- local health = UnitHealth(self.unit)
+	local maxHealth = UnitHealthMax(self.unit)
+	local scale = IceHUD:Clamp((self.amount / maxHealth) * (100 / self.moduleSettings.maxPercent), 0, 1)
+
+	if self.amount > 0 and (IceHUD.WowVer >= 7000 or self.duration <= 10) then
+		-- self.timerFrame.bar:SetVertexColor(self:GetColor("StaggerTime", self.moduleSettings.timerAlpha))
+		self:UpdateBar(scale or 0, "Stagger"..self.staggerLevel)
+		self:UpdateShown()
+		self:UpdateTimerFrame()
+	else
+		self:UpdateBar(0, "Stagger1")
+		self:Show(false)
+	end
+end
+
+function StaggerBar.prototype:GetDebuffDuration(unitName, buffName)
+	local name, _, _, _, _, duration, endTime = UnitDebuff(unitName, buffName)
+
+	if name then
+		return duration, endTime - GetTime()
+	end
+
+	return nil, nil
+end
+
+function StaggerBar.prototype:MyOnUpdate()
+	StaggerBar.super.prototype.MyOnUpdate(self)
+
+	if self.bUpdateTimer then
+		self:UpdateTimerFrame(nil, self.unit, true)
+	end
+end
+
+function StaggerBar.prototype:UpdateTimerFrame(event, unit, fromUpdate)
+	if unit and unit ~= self.unit then
+		return
+	end
+
+	local now = GetTime()
+	local remaining = nil
+
+	if not fromUpdate then
+		for i = 1, 3 do
+			self.StaggerDuration, remaining = self:GetDebuffDuration(self.unit, staggerNames[i])
+
+			if remaining then
+				break
+			end
+		end
+
+		if not remaining then
+			self.StaggerEndTime = 0
+		else
+			self.StaggerEndTime = remaining + now
+		end
+	end
+
+	if self.StaggerEndTime and self.StaggerEndTime >= now then
+		if not fromUpdate then
+			self.bUpdateTimer = true
+		end
+
+		if not remaining and (self.StaggerEndTime and self.StaggerEndTime >= now) then
+			remaining = self.StaggerEndTime - now
+		end
+
+		if remaining then
+			self:SetBarCoord(self.timerFrame, IceHUD:Clamp(remaining / 10, 0, 1))
+			self.timerFrame:Show()
+		else
+			self:SetBarCoord(self.timerFrame, 0)
+			self.timerFrame:Hide()
+		end
+	else
+		self:SetBarCoord(self.timerFrame, 0)
+		self.timerFrame:Hide()
+		self.bUpdateTimer = false
+	end
+end
+
+local _, unitClass = UnitClass("player")
+if unitClass == "MONK" then
+	IceHUD.StaggerBar = StaggerBar:new()
+end

modules/TargetAbsorb.lua

@@ -4,13 +4,8 @@ IceTargetAbsorb.prototype.highestAbsorbSinceLastZero = 0
 IceTargetAbsorb.prototype.ColorName = "TargetAbsorb"
 
 local UnitGetTotalAbsorbs = UnitGetTotalAbsorbs
-if IceHUD.WowVer < 50200 then
-	UnitGetTotalAbsorbs = nil
-end
 
--- Constructor --
 function IceTargetAbsorb.prototype:init(moduleName, unit, colorName)
-	-- not sure if this is necessary...i think it is...this way, we can instantiate this bar on its own or as a parent class
 	if moduleName == nil or unit == nil then
 		IceTargetAbsorb.super.prototype.init(self, "TargetAbsorb", "target")
 	else
@@ -29,45 +24,46 @@ function IceTargetAbsorb.prototype:GetDefaultSettings()
 
 	settings["side"] = IceCore.Side.Right
 	settings["offset"] = 3
-	settings["upperText"] = "[TotalAbsorb]"
+	settings["upperText"] = "[TotalAbsorb:VeryShort]"
 
 	return settings
 end
 
--- OVERRIDE
 function IceTargetAbsorb.prototype:Enable(core)
 	IceTargetAbsorb.super.prototype.Enable(self, core)
 
 	self:RegisterEvent("UNIT_ABSORB_AMOUNT_CHANGED", "UpdateAbsorbAmount")
 	self:MyRegisterCustomEvents()
 
-	self:UpdateAbsorbAmount("UNIT_ABSORB_AMOUNT_CHANGED", self.unit)
+	self:UpdateAbsorbAmount()
 
 	self:Show(false)
 end
 
 function IceTargetAbsorb.prototype:MyRegisterCustomEvents()
-	self:RegisterEvent("PLAYER_TARGET_CHANGED", "UpdateAbsorbAmount")
 end
 
 function IceTargetAbsorb.prototype:MyUnregisterCustomEvents()
-	self:UnregisterEvent("PLAYER_TARGET_CHANGED")
+end
+
+function IceTargetAbsorb.prototype:Update()
+	self:UpdateAbsorbAmount()
 end
 
 function IceTargetAbsorb.prototype:UpdateAbsorbAmount(event, unit)
-	if UnitGetTotalAbsorbs == nil or (event == "UNIT_ABSORB_AMOUNT_CHANGED" and unit ~= self.unit) then
+	if event == "UNIT_ABSORB_AMOUNT_CHANGED" and unit ~= self.unit then
 		return
 	end
 
-	local absorbAmount = UnitGetTotalAbsorbs(self.unit)
+	local absorbAmount = UnitGetTotalAbsorbs(self.unit) or 0
 
-	if absorbAmount == nil or absorbAmount <= 0 then
+	if absorbAmount <= 0 then
 		self.highestAbsorbSinceLastZero = 0
 	elseif absorbAmount > self.highestAbsorbSinceLastZero then
 		self.highestAbsorbSinceLastZero = absorbAmount
 	end
 
-	if absorbAmount == nil or absorbAmount <= 0 or self.highestAbsorbSinceLastZero <= 0 then
+	if absorbAmount <= 0 or self.highestAbsorbSinceLastZero <= 0 then
 		self:Show(false)
 	else
 		self:Show(true)
@@ -82,4 +78,6 @@ function IceTargetAbsorb.prototype:Disable(core)
 	self:MyUnregisterCustomEvents()
 end
 
-IceHUD.TargetAbsorb = IceTargetAbsorb:new()
+if UnitGetTotalAbsorbs ~= nil then
+	IceHUD.TargetAbsorb = IceTargetAbsorb:new()
+end

modules/TargetCC.lua

@@ -45,9 +45,14 @@ local StunCCList = {
 	-- shockwave
 	46968,
 	-- Gnaw
-	47481,
+	91800,
+	91797,
     -- Fists of Fury
     113656,
+    -- Fist of Justice
+    105593,
+    -- Remorseless Winter
+    115001,
 }
 
 local IncapacitateCCList = {
@@ -177,7 +182,7 @@ local RootCCList = {
 	-- Venom Web Spray
 	54706,
 	-- Chains of Ice
-	45524,
+	96294,
     -- Disable
     116095,
 }
@@ -226,6 +231,7 @@ function TargetCC.prototype:PopulateSpellList(debuffListVar, ccList, ccName)
 
 		if spellName and spellName ~= "" then
 			debuffListVar[spellName] = ccName
+			debuffListVar[ccList[i]] = ccName
 		end
 	end
 end
@@ -309,7 +315,7 @@ end
 
 function TargetCC.prototype:GetMaxDebuffDuration(unitName, debuffNames)
 	local i = 1
-	local debuff, rank, texture, count, debuffType, duration, endTime, unitCaster = UnitAura(unitName, i, "HARMFUL")
+	local debuff, rank, texture, count, debuffType, duration, endTime, unitCaster, _, _, spellId = UnitAura(unitName, i, "HARMFUL")
 	local isMine = unitCaster == "player"
 	local result = {nil, nil, nil}
 	local remaining
@@ -317,7 +323,7 @@ function TargetCC.prototype:GetMaxDebuffDuration(unitName, debuffNames)
 	while debuff do
 		remaining = endTime - GetTime()
 
-		if debuffNames[debuff] and (not self.moduleSettings.onlyShowForMyDebuffs or isMine) then
+		if debuffNames[spellId] and (not self.moduleSettings.onlyShowForMyDebuffs or isMine) then
 			if result[0] then
 				if result[2] < remaining then
 					result = {debuff, duration, remaining}
@@ -329,7 +335,7 @@ function TargetCC.prototype:GetMaxDebuffDuration(unitName, debuffNames)
 
 		i = i + 1;
 
-		debuff, rank, texture, count, debuffType, duration, endTime, unitCaster = UnitAura(unitName, i, "HARMFUL")
+		debuff, rank, texture, count, debuffType, duration, endTime, unitCaster, _, _, spellId = UnitAura(unitName, i, "HARMFUL")
 		isMine = unitCaster == "player"
 	end
 

modules/TargetInfo.lua

@@ -1,6 +1,11 @@
 local L = LibStub("AceLocale-3.0"):GetLocale("IceHUD", false)
 IceTargetInfo = IceCore_CreateClass(IceElement)
 
+local CooldownFrame_SetTimer = CooldownFrame_SetTimer
+if IceHUD.WowVer >= 70000 then
+	CooldownFrame_SetTimer = CooldownFrame_Set
+end
+
 local DogTag = nil
 
 local internal = "internal"
@@ -1320,6 +1325,7 @@ do
 					icon:SetHeight(size-2)
 				end
 			else
+				frame.texture:SetTexture(0, 0, 0, 0.5)
 				icon:SetWidth(size-2)
 				icon:SetHeight(size-2)
 			end
@@ -1445,7 +1451,7 @@ function IceTargetInfo.prototype:SetupAura(aura, i, icon, duration, expirationTi
 	if (duration and duration > 0 and expirationTime and expirationTime > 0) then
 		local start = expirationTime - duration
 
-		frame.cd:SetCooldown(start, duration)
+		CooldownFrame_SetTimer(frame.cd, start, duration, true)
 		frame.cd:Show()
 	else
 		frame.cd:Hide()
@@ -1624,7 +1630,11 @@ end
 
 function IceTargetInfo.prototype:TargetFlags(event, unit)
 	if (unit == self.unit or unit == internal) then
-		self.tapped = UnitIsTapped(self.unit) and (not UnitIsTappedByPlayer(self.unit))
+		if IceHUD.WowVer < 70000 then
+			self.tapped = UnitIsTapped(self.unit) and (not UnitIsTappedByPlayer(self.unit))
+		else
+			self.tapped = UnitIsTapDenied(self.unit)
+		end
 		self.targetCombat = UnitAffectingCombat(self.unit) and " |cffee4030Combat|r" or ""
 		self:UpdateBuffs()
 		self:Update(unit)

modules/TargetMana.lua

@@ -18,6 +18,12 @@ function IceTargetMana.prototype:init(moduleName, unit)
 	self:SetDefaultColor("TargetEnergy", 228, 242, 31)
 	self:SetDefaultColor("TargetFocus", 242, 149, 98)
 	self:SetDefaultColor("TargetRunicPower", 52, 64, 221)
+	if IceHUD.WowVer >= 70000 then
+		self:SetDefaultColor("TargetInsanity", 150, 50, 255)
+		self:SetDefaultColor("TargetFury", 255, 50, 255)
+		self:SetDefaultColor("TargetMaelstrom", 52, 64, 221)
+		self:SetDefaultColor("TargetPain", 255, 50, 255)
+	end
 end
 
 
@@ -105,6 +111,14 @@ function IceTargetMana.prototype:Update(unit)
 			self.color = "TargetEnergy"
 		elseif (manaType == SPELL_POWER_RUNIC_POWER) then
 			self.color = "TargetRunicPower"
+		elseif (IceHUD.WowVer >= 70000 and manaType == SPELL_POWER_INSANITY) then
+			self.color = "TargetInsanity"
+		elseif (IceHUD.WowVer >= 70000 and manaType == SPELL_POWER_FURY) then
+			self.color = "TargetFury"
+		elseif (IceHUD.WowVer >= 70000 and manaType == SPELL_POWER_MAELSTROM) then
+			self.color = "TargetMaelstrom"
+		elseif (IceHUD.WowVer >= 70000 and manaType == SPELL_POWER_PAIN) then
+			self.color = "TargetPain"
 		end
 
 		if (self.tapped) then
@@ -112,11 +126,7 @@ function IceTargetMana.prototype:Update(unit)
 		end
 	end
 
-	if manaType == SPELL_POWER_RAGE or manaType == SPELL_POWER_RUNIC_POWER then
-		self.bTreatEmptyAsFull = true
-	else
-		self.bTreatEmptyAsFull = false
-	end
+	self.bTreatEmptyAsFull = self:TreatEmptyAsFull(manaType)
 
 	self:UpdateBar(self.manaPercentage, self.color)
 
@@ -126,6 +136,11 @@ function IceTargetMana.prototype:Update(unit)
 	end
 end
 
+function IceTargetMana.prototype:TreatEmptyAsFull(manaType)
+	return manaType == SPELL_POWER_RAGE or manaType == SPELL_POWER_RUNIC_POWER
+		or (IceHUD.WowVer >= 70000 and (manaType == SPELL_POWER_LUNAR_POWER or manaType == SPELL_POWER_INSANITY
+		or manaType == SPELL_POWER_FURY or manaType == SPELL_POWER_PAIN or manaType == SPELL_POWER_MAELSTROM))
+end
 
 -- OVERRIDE
 function IceTargetMana.prototype:GetOptions()

modules/Threat.lua

@@ -332,7 +332,7 @@ threatValue = 100
 		scaledPercentZeroToOne = 0
 		scaledPercent = 0
 
-		IceHUD:Debug( "Threat: nil threat on valid target" )
+		--IceHUD:Debug( "Threat: nil threat on valid target" )
 	else
 		if self.moduleSettings.showScaledThreat then
 			scaledPercentZeroToOne = scaledPercent / 100

modules/Totems.lua

@@ -1,6 +1,11 @@
 local L = LibStub("AceLocale-3.0"):GetLocale("IceHUD", false)
 local Totems = IceCore_CreateClass(IceElement)
 
+local CooldownFrame_SetTimer = CooldownFrame_SetTimer
+if IceHUD.WowVer >= 70000 then
+	CooldownFrame_SetTimer = CooldownFrame_Set
+end
+
 -- the below block is copied from TotemFrame.lua
 local FIRE_TOTEM_SLOT = 1;
 local EARTH_TOTEM_SLOT = 2;
@@ -239,7 +244,7 @@ function Totems.prototype:UpdateTotem(event, totem, ...)
 	local haveTotem, name, startTime, duration, icon = GetTotemInfo(totem);
 	if duration > 0 then
 		self.frame.graphical[totem].totem:SetTexture(icon)
-		self.frame.graphical[totem].cd:SetCooldown(startTime, duration)
+		CooldownFrame_SetTimer(self.frame.graphical[totem].cd, startTime, duration, true)
 		self.frame.graphical[totem].cd:Show()
 		self.frame.graphical[totem]:Show()
 	else
@@ -367,7 +372,7 @@ function Totems.prototype:CreateTotem(i, name)
 	self.frame.graphical[i].cd:ClearAllPoints()
 	self.frame.graphical[i].cd:SetAllPoints(self.frame.graphical[i])
 	if duration > 0 then
-		self.frame.graphical[i].cd:SetCooldown(startTime, duration)
+		CooldownFrame_SetTimer(self.frame.graphical[i].cd, startTime, duration, true)
 		self.frame.graphical[i].cd:Show()
 		self.frame.graphical[i]:Show()
 	end