You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1326 lines
45 KiB
1326 lines
45 KiB
local Details = Details
|
|
local addonName, Details222 = ...
|
|
|
|
local AceLocale = LibStub("AceLocale-3.0")
|
|
local Loc = AceLocale:GetLocale( "Details" )
|
|
|
|
---@type detailsframework
|
|
local detailsFramework = DetailsFramework
|
|
|
|
local gump = Details.gump
|
|
local _
|
|
|
|
--lua locals
|
|
local unpack = unpack
|
|
local floor = math.floor
|
|
local gameCooltip = GameCooltip
|
|
local CreateFrame = CreateFrame
|
|
|
|
function Details222.CreateAllDisplaysFrame()
|
|
local icon_size = 16
|
|
local text_color = {.9, .9, .9, 1}
|
|
|
|
local allDisplaysFrame = CreateFrame("frame", "DetailsAllAttributesFrame", UIParent,"BackdropTemplate")
|
|
allDisplaysFrame:SetFrameStrata("tooltip")
|
|
allDisplaysFrame:Hide()
|
|
allDisplaysFrame:SetSize(600, 150)
|
|
allDisplaysFrame:SetClampedToScreen(true)
|
|
allDisplaysFrame.buttons = {}
|
|
|
|
function allDisplaysFrame:UpdateFontStrings()
|
|
for _, attribute in ipairs(allDisplaysFrame.buttons) do
|
|
for _, button in ipairs(attribute) do
|
|
Details222.BreakdownWindow.ApplyFontSettings(button.text)
|
|
end
|
|
end
|
|
end
|
|
|
|
DetailsSwitchPanel.all_switch = allDisplaysFrame
|
|
|
|
detailsFramework:AddRoundedCornersToFrame(allDisplaysFrame, Details.PlayerBreakdown.RoundedCornerPreset)
|
|
Details:RegisterFrameToColor(allDisplaysFrame)
|
|
|
|
allDisplaysFrame:SetScript("OnMouseDown", function(self, button)
|
|
if (button == "RightButton") then
|
|
self:Hide()
|
|
end
|
|
end)
|
|
|
|
allDisplaysFrame:SetScript("OnEnter", function(self, button)
|
|
allDisplaysFrame.interacting = true
|
|
allDisplaysFrame.last_up = GetTime()
|
|
end)
|
|
|
|
allDisplaysFrame:SetScript("OnLeave", function(self, button)
|
|
allDisplaysFrame.interacting = false
|
|
allDisplaysFrame.last_up = GetTime()
|
|
end)
|
|
|
|
local on_update_all_switch = function(self, elapsed)
|
|
if (not self.interacting) then
|
|
if (GetTime() > allDisplaysFrame.last_up + 2) then
|
|
local cursorX, cursorY = GetCursorPosition()
|
|
cursorX, cursorY = floor(cursorX), floor(cursorY)
|
|
if (allDisplaysFrame.cursor_x ~= cursorX or allDisplaysFrame.cursor_y ~= cursorY) then
|
|
self:Hide()
|
|
else
|
|
allDisplaysFrame.last_up = GetTime() - 1
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
allDisplaysFrame:SetScript("OnHide", function(self)
|
|
allDisplaysFrame:SetScript("OnUpdate", nil)
|
|
end)
|
|
|
|
function Details:ShowAllSwitch()
|
|
if (allDisplaysFrame:IsShown()) then
|
|
return allDisplaysFrame:Hide()
|
|
end
|
|
|
|
allDisplaysFrame.instance = self
|
|
GameTooltip:Hide()
|
|
gameCooltip:Hide()
|
|
allDisplaysFrame:ClearAllPoints()
|
|
allDisplaysFrame:SetPoint("bottom", self.baseframe.UPFrame, "top", 4)
|
|
|
|
allDisplaysFrame:Show()
|
|
|
|
if (Details.switch.frame:IsShown()) then
|
|
Details.switch:CloseMe()
|
|
end
|
|
end
|
|
|
|
local on_click_all_switch_button = function(self, button)
|
|
if (button == "LeftButton") then
|
|
local attribute = self.attribute
|
|
local subAttribute = self.sub_attribute
|
|
local instance = allDisplaysFrame.instance
|
|
|
|
--check if is a plugin button
|
|
if (self.isPlugin) then
|
|
if (Details.RaidTables.NameTable[self.pluginName]) then
|
|
Details.RaidTables:EnableRaidMode(instance, self.pluginName)
|
|
elseif (Details.SoloTables.NameTable [self.pluginName]) then
|
|
Details.SoloTables:EnableSoloMode(instance, self.pluginName)
|
|
else
|
|
Details:Msg("Plugin not found.")
|
|
end
|
|
|
|
allDisplaysFrame:Hide()
|
|
return
|
|
end
|
|
|
|
if (instance.modo == Details._detalhes_props["MODO_ALONE"] or instance.modo == Details._detalhes_props["MODO_RAID"]) then
|
|
instance:SetMode(2)
|
|
end
|
|
|
|
instance:TrocaTabela(instance, true, attribute, subAttribute)
|
|
allDisplaysFrame:Hide()
|
|
|
|
elseif (button == "RightButton") then
|
|
allDisplaysFrame:Hide()
|
|
end
|
|
end
|
|
|
|
local hoverOverTexture = allDisplaysFrame:CreateTexture(nil, "border")
|
|
hoverOverTexture:SetTexture(unpack(DetailsSwitchPanel.HoverOverBackground))
|
|
hoverOverTexture:SetSize(130, 18)
|
|
hoverOverTexture:Hide()
|
|
|
|
local on_enter_all_switch_button = function(self)
|
|
Details:SetFontColor(self.text, "orange")
|
|
allDisplaysFrame.interacting = true
|
|
allDisplaysFrame.last_up = GetTime()
|
|
|
|
hoverOverTexture:SetSize(130, 18)
|
|
hoverOverTexture:ClearAllPoints()
|
|
hoverOverTexture:SetPoint("topleft", self, "topleft", -2, 1)
|
|
hoverOverTexture:Show()
|
|
end
|
|
|
|
local on_leave_all_switch_button = function(self)
|
|
Details:SetFontColor(self.text, text_color)
|
|
allDisplaysFrame.interacting = false
|
|
allDisplaysFrame.last_up = GetTime()
|
|
hoverOverTexture:Hide()
|
|
end
|
|
|
|
local on_enter_all_switch_button_icon = function(self)
|
|
self.MainFrame.texture:SetBlendMode("ADD")
|
|
on_enter_all_switch_button(self.MainFrame)
|
|
end
|
|
local on_leave_all_switch_button_icon = function(self)
|
|
self.MainFrame.texture:SetBlendMode("BLEND")
|
|
on_leave_all_switch_button(self.MainFrame)
|
|
end
|
|
|
|
allDisplaysFrame.check_text_size = function(font_string)
|
|
local text_width = font_string:GetStringWidth()
|
|
while (text_width > 104) do
|
|
local text = font_string:GetText()
|
|
text = strsub (text, 1, #text-1)
|
|
font_string:SetText(text)
|
|
text_width = font_string:GetStringWidth()
|
|
end
|
|
end
|
|
|
|
local create_all_switch_button = function(attribute, sub_attribute, x, y)
|
|
local button = CreateFrame("button", "DetailsAllAttributesFrame" .. attribute .. sub_attribute, allDisplaysFrame)
|
|
button:SetSize(130, 16)
|
|
button.texture = button:CreateTexture(nil, "overlay")
|
|
button.texture:SetPoint("left", 0, 0)
|
|
button.texture:SetSize(icon_size, icon_size)
|
|
|
|
local texture_highlight_frame = CreateFrame("button", "DetailsAllAttributesFrame" .. attribute .. sub_attribute .. "IconFrame", button)
|
|
texture_highlight_frame:SetSize(icon_size, icon_size)
|
|
texture_highlight_frame:SetPoint("left", 0, 0)
|
|
texture_highlight_frame.texture = button.texture
|
|
texture_highlight_frame.MainFrame = button
|
|
|
|
button.text = button:CreateFontString(nil, "overlay", "GameFontNormal")
|
|
button.text:SetPoint("left", button.texture, "right", 2, 0)
|
|
button.attribute = attribute
|
|
button.sub_attribute = sub_attribute
|
|
button:SetPoint("topleft", x, y)
|
|
Details:SetFontSize(button.text, Details.all_switch_config.font_size)
|
|
Details:SetFontColor(button.text, text_color)
|
|
|
|
button:SetScript("OnClick", on_click_all_switch_button)
|
|
button:SetScript("OnEnter", on_enter_all_switch_button)
|
|
button:SetScript("OnLeave", on_leave_all_switch_button)
|
|
|
|
texture_highlight_frame:SetScript("OnClick", on_click_all_switch_button)
|
|
texture_highlight_frame:SetScript("OnEnter", on_enter_all_switch_button_icon)
|
|
texture_highlight_frame:SetScript("OnLeave", on_leave_all_switch_button_icon)
|
|
|
|
button:RegisterForClicks ("LeftButtonDown", "RightButtonDown")
|
|
|
|
return button
|
|
end
|
|
|
|
allDisplaysFrame:SetScript("OnShow", function()
|
|
|
|
if (not allDisplaysFrame.already_built) then
|
|
local x, y = 8, -8
|
|
allDisplaysFrame.higher_counter = 0
|
|
|
|
for attribute = 1, Details.atributos[0] do
|
|
--localized attribute name
|
|
local loc_attribute_name = Details.atributos.lista [attribute]
|
|
|
|
local title_icon = allDisplaysFrame:CreateTexture(nil, "overlay")
|
|
title_icon:SetPoint("topleft", x, y)
|
|
local texture, l, r, t, b = Details:GetAttributeIcon (attribute)
|
|
title_icon:SetTexture(texture)
|
|
title_icon:SetTexCoord(l, r, t, b)
|
|
title_icon:SetSize(18, 18)
|
|
local title_str = allDisplaysFrame:CreateFontString(nil, "overlay", "GameFontNormal")
|
|
title_str:SetPoint("left", title_icon, "right", 2, 0)
|
|
title_str:SetText(loc_attribute_name)
|
|
|
|
y = y - 20
|
|
|
|
allDisplaysFrame.buttons [attribute] = {}
|
|
for i = 1, #Details.sub_atributos [attribute].lista do
|
|
--localized sub attribute name
|
|
local loc_sub_attribute_name = Details.sub_atributos [attribute].lista [i]
|
|
local button = create_all_switch_button (attribute, i, x, y)
|
|
|
|
button.text:SetText(loc_sub_attribute_name)
|
|
Details:SetFontSize(button.text, Details.all_switch_config.font_size)
|
|
|
|
allDisplaysFrame.check_text_size (button.text)
|
|
button.texture:SetTexture(Details.sub_atributos [attribute].icones [i] [1])
|
|
button.texture:SetTexCoord(unpack(Details.sub_atributos [attribute].icones [i] [2]))
|
|
table.insert(allDisplaysFrame.buttons [attribute], button)
|
|
y = y - 17
|
|
end
|
|
|
|
if (#Details.sub_atributos [attribute].lista > allDisplaysFrame.higher_counter) then
|
|
allDisplaysFrame.higher_counter = #Details.sub_atributos [attribute].lista
|
|
end
|
|
|
|
x = x + 130
|
|
y = -8
|
|
end
|
|
|
|
--prepare for scripts
|
|
allDisplaysFrame.x = x
|
|
allDisplaysFrame.y = -8
|
|
allDisplaysFrame.buttons [Details.atributos[0]+1] = {}
|
|
|
|
local title_icon = allDisplaysFrame:CreateTexture(nil, "overlay")
|
|
local texture, l, r, t, b = Details:GetAttributeIcon (Details.atributos[0]+1)
|
|
title_icon:SetTexture([[Interface\AddOns\Details\images\icons]])
|
|
title_icon:SetTexCoord(412/512, 441/512, 43/512, 79/512)
|
|
title_icon:SetVertexColor(.7, .6, .5, 1)
|
|
title_icon:SetSize(16, 16)
|
|
local title_str = allDisplaysFrame:CreateFontString(nil, "overlay", "GameFontNormal")
|
|
title_str:SetPoint("left", title_icon, "right", 2, 0)
|
|
title_str:SetText("Scripts")
|
|
|
|
title_icon:SetPoint("topleft", allDisplaysFrame.x, allDisplaysFrame.y)
|
|
allDisplaysFrame.y = allDisplaysFrame.y - 20
|
|
allDisplaysFrame.title_custom = title_icon
|
|
|
|
allDisplaysFrame.already_built = true
|
|
|
|
--prepare for plugins
|
|
allDisplaysFrame.buttons[6] = {}
|
|
local title_icon = allDisplaysFrame:CreateTexture(nil, "overlay")
|
|
title_icon:SetTexture([[Interface\AddOns\Details\images\modo_icones]])
|
|
title_icon:SetTexCoord(32/256*3, 32/256*4, 0, 1)
|
|
title_icon:SetSize(16, 16)
|
|
|
|
local title_str = allDisplaysFrame:CreateFontString(nil, "overlay", "GameFontNormal")
|
|
title_str:SetPoint("left", title_icon, "right", 2, 0)
|
|
title_str:SetText(Loc["STRING_OPTIONS_PLUGINS"])
|
|
title_icon:SetPoint("topleft", allDisplaysFrame.x + 130, -8)
|
|
allDisplaysFrame.title_scripts = title_icon
|
|
end
|
|
|
|
--update scripts
|
|
local custom_index = Details.atributos[0]+1
|
|
for _, button in ipairs(allDisplaysFrame.buttons [custom_index]) do
|
|
button:Hide()
|
|
end
|
|
|
|
local button_index = 1
|
|
for i = #Details.custom, 1, -1 do
|
|
local button = allDisplaysFrame.buttons [custom_index] [button_index]
|
|
if (not button) then
|
|
button = create_all_switch_button (custom_index, i, allDisplaysFrame.x, allDisplaysFrame.y)
|
|
table.insert(allDisplaysFrame.buttons [custom_index], button)
|
|
allDisplaysFrame.y = allDisplaysFrame.y - 17
|
|
end
|
|
|
|
local custom = Details.custom [i]
|
|
button.text:SetText(custom.name)
|
|
Details:SetFontSize(button.text, Details.all_switch_config.font_size)
|
|
|
|
allDisplaysFrame.check_text_size (button.text)
|
|
button.texture:SetTexture(custom.icon)
|
|
button.texture:SetTexCoord(0.078125, 0.921875, 0.078125, 0.921875)
|
|
button:Show()
|
|
|
|
button_index = button_index + 1
|
|
end
|
|
|
|
if (#Details.custom > allDisplaysFrame.higher_counter) then
|
|
allDisplaysFrame.higher_counter = #Details.custom
|
|
end
|
|
|
|
--update plugins
|
|
local script_index = Details.atributos[0]+2
|
|
local button_index = 1
|
|
allDisplaysFrame.x = allDisplaysFrame.x + 130
|
|
allDisplaysFrame.y = -28
|
|
|
|
for _, button in ipairs(allDisplaysFrame.buttons[script_index]) do
|
|
button:Hide()
|
|
end
|
|
|
|
--build raid plugins list
|
|
local raidPlugins = Details.RaidTables:GetAvailablePlugins()
|
|
if (#raidPlugins >= 0) then
|
|
for i, ptable in ipairs(raidPlugins) do
|
|
--if a plugin has the member 'NoMenu', it won't be shown on menus to select plugins
|
|
if (ptable[3].__enabled and not ptable[3].NoMenu) then
|
|
--PluginName, PluginIcon, PluginObject, PluginAbsoluteName
|
|
local button = allDisplaysFrame.buttons [script_index] [button_index]
|
|
if (not button) then
|
|
button = create_all_switch_button(script_index, button_index, allDisplaysFrame.x, allDisplaysFrame.y)
|
|
table.insert(allDisplaysFrame.buttons [script_index], button)
|
|
allDisplaysFrame.y = allDisplaysFrame.y - 17
|
|
end
|
|
|
|
--set the button to select the plugin
|
|
button.isPlugin = true
|
|
button.pluginName = ptable[4]
|
|
|
|
button.text:SetText(ptable[1])
|
|
Details:SetFontSize(button.text, Details.all_switch_config.font_size)
|
|
|
|
allDisplaysFrame.check_text_size(button.text)
|
|
button.texture:SetTexture(ptable[2])
|
|
button.texture:SetTexCoord(0.078125, 0.921875, 0.078125, 0.921875)
|
|
button:Show()
|
|
|
|
button_index = button_index + 1
|
|
end
|
|
end
|
|
end
|
|
|
|
--check if the plugins list is the biggest list
|
|
button_index = button_index - 1
|
|
if (button_index > allDisplaysFrame.higher_counter) then
|
|
allDisplaysFrame.higher_counter = button_index
|
|
end
|
|
|
|
allDisplaysFrame:SetHeight((allDisplaysFrame.higher_counter * 17) + 20 + 16)
|
|
allDisplaysFrame:SetWidth((120 * 6) + (6 * 2) + (12 * 4))
|
|
|
|
allDisplaysFrame.last_up = GetTime()
|
|
local cursorX, cursorY = GetCursorPosition()
|
|
allDisplaysFrame.cursor_x, allDisplaysFrame.cursor_y = floor(cursorX), floor(cursorY)
|
|
allDisplaysFrame:SetScript("OnUpdate", on_update_all_switch)
|
|
allDisplaysFrame:SetScale(Details.all_switch_config.scale)
|
|
end)
|
|
|
|
end
|
|
|
|
--api locals
|
|
do
|
|
local bookmarkFrame = CreateFrame("frame", "DetailsSwitchPanel", UIParent, "BackdropTemplate")
|
|
bookmarkFrame:SetPoint("center", UIParent, "center", 500, -300)
|
|
bookmarkFrame:SetWidth(250)
|
|
bookmarkFrame:SetHeight(100)
|
|
bookmarkFrame:SetFrameStrata("FULLSCREEN")
|
|
bookmarkFrame:SetFrameLevel(16)
|
|
bookmarkFrame.editing_window = nil
|
|
|
|
DetailsFramework:ApplyStandardBackdrop(bookmarkFrame, true)
|
|
bookmarkFrame:SetBackdropBorderColor(0, 0, 0, 0)
|
|
|
|
local backgroundGradientTexture = DetailsFramework:CreateTexture(bookmarkFrame, {gradient = "vertical", fromColor = {0, 0, 0, 0.2}, toColor = {0, 0, 0, 0.4}}, 1, 1, "artwork", {0, 1, 0, 1})
|
|
backgroundGradientTexture:SetAllPoints()
|
|
|
|
bookmarkFrame.HoverOverBackground = {.6, .6, .6, .2}
|
|
bookmarkFrame.hoverOverTexture = bookmarkFrame:CreateTexture(nil, "border")
|
|
bookmarkFrame.hoverOverTexture:SetTexture(unpack(bookmarkFrame.HoverOverBackground))
|
|
bookmarkFrame.hoverOverTexture:SetSize(130, 18)
|
|
bookmarkFrame.hoverOverTexture:Hide()
|
|
|
|
local icon_size = 16
|
|
local text_color = {.9, .9, .9, 1}
|
|
|
|
---------------------------------------------------------------------------------------------------------------------------
|
|
|
|
--animation has been disabled (July 2019)
|
|
--they aren't called anymore on showing and hiding the bookmark frame
|
|
--show animation
|
|
local animHub = Details.gump:CreateAnimationHub (bookmarkFrame, function() bookmarkFrame:Show() end)
|
|
Details.gump:CreateAnimation(animHub, "scale", 1, 0.04, 0, 1, 1, 1, "LEFT", 0, 0)
|
|
Details.gump:CreateAnimation(animHub, "alpha", 1, 0.04, 0, 1)
|
|
bookmarkFrame.ShowAnimation = animHub
|
|
|
|
--hide animation
|
|
local animHub = Details.gump:CreateAnimationHub (bookmarkFrame, function() bookmarkFrame:Show() end, function() bookmarkFrame:Hide() end)
|
|
Details.gump:CreateAnimation(animHub, "scale", 1, 0.04, 1, 1, 0, 1, "RIGHT", 0, 0)
|
|
Details.gump:CreateAnimation(animHub, "alpha", 1, 0.04, 1, 0)
|
|
bookmarkFrame.HideAnimation = animHub
|
|
|
|
---------------------------------------------------------------------------------------------------------------------------
|
|
function Details.switch:CloseMe()
|
|
Details.switch.frame:Hide()
|
|
Details.switch.frame:ClearAllPoints()
|
|
|
|
gameCooltip:Hide()
|
|
Details.switch.current_instancia:StatusBarAlert(nil)
|
|
Details.switch.current_instancia = nil
|
|
end
|
|
|
|
bookmarkFrame.close = gump:NewDetailsButton(bookmarkFrame, bookmarkFrame, _, function() end, nil, nil, 1, 1, "", "", "", "", {rightFunc = {func = Details.switch.CloseMe, param1 = nil, param2 = nil}}, "DetailsSwitchPanelClose")
|
|
bookmarkFrame.close:SetPoint("topleft", bookmarkFrame, "topleft")
|
|
bookmarkFrame.close:SetPoint("bottomright", bookmarkFrame, "bottomright")
|
|
bookmarkFrame.close:SetFrameLevel(9)
|
|
bookmarkFrame:Hide()
|
|
|
|
Details.switch.frame = bookmarkFrame
|
|
Details.switch.button_height = 24
|
|
end
|
|
|
|
Details.switch.buttons = {}
|
|
Details.switch.slots = Details.switch.slots or 6
|
|
Details.switch.showing = 0
|
|
Details.switch.table = Details.switch.table or {}
|
|
Details.switch.current_instancia = nil
|
|
Details.switch.current_button = nil
|
|
Details.switch.height_necessary = (Details.switch.button_height * Details.switch.slots) / 2
|
|
|
|
function Details.switch:HideAllBookmarks()
|
|
for _, bookmark in ipairs(Details.switch.buttons) do
|
|
bookmark:Hide()
|
|
end
|
|
end
|
|
|
|
function Details.switch:ShowMe(instancia)
|
|
Details.switch.current_instancia = instancia
|
|
|
|
if (IsControlKeyDown()) then
|
|
if (not Details.tutorial.ctrl_click_close_tutorial) then
|
|
if (not DetailsCtrlCloseWindowPanelTutorial) then
|
|
local tutorialFrame = CreateFrame("frame", "DetailsCtrlCloseWindowPanelTutorial", Details.switch.frame, "BackdropTemplate")
|
|
tutorialFrame:SetFrameStrata("FULLSCREEN_DIALOG")
|
|
tutorialFrame:SetAllPoints()
|
|
tutorialFrame:EnableMouse(true)
|
|
tutorialFrame:SetBackdrop({bgFile = "Interface\\AddOns\\Details\\images\\background", tile = true, tileSize = 16 })
|
|
tutorialFrame:SetBackdropColor(0.05, 0.05, 0.05, 0.95)
|
|
|
|
tutorialFrame.info_label = tutorialFrame:CreateFontString(nil, "overlay", "GameFontNormal")
|
|
tutorialFrame.info_label:SetPoint("topleft", tutorialFrame, "topleft", 10, -10)
|
|
tutorialFrame.info_label:SetText(Loc["STRING_MINITUTORIAL_CLOSECTRL1"])
|
|
tutorialFrame.info_label:SetJustifyH("left")
|
|
|
|
tutorialFrame.mouse = tutorialFrame:CreateTexture(nil, "overlay")
|
|
tutorialFrame.mouse:SetTexture([[Interface\TUTORIALFRAME\UI-TUTORIAL-FRAME]])
|
|
tutorialFrame.mouse:SetTexCoord(0.0019531, 0.1484375, 0.6269531, 0.8222656)
|
|
tutorialFrame.mouse:SetSize(20, 22)
|
|
tutorialFrame.mouse:SetPoint("topleft", tutorialFrame.info_label, "bottomleft", -3, -10)
|
|
|
|
tutorialFrame.close_label = tutorialFrame:CreateFontString(nil, "overlay", "GameFontHighlightSmall")
|
|
tutorialFrame.close_label:SetPoint("left", tutorialFrame.mouse, "right", 4, 0)
|
|
tutorialFrame.close_label:SetText(Loc["STRING_MINITUTORIAL_CLOSECTRL2"])
|
|
tutorialFrame.close_label:SetJustifyH("left")
|
|
|
|
local checkbox = CreateFrame("CheckButton", "DetailsCtrlCloseWindowPanelTutorialCheckBox", tutorialFrame, "ChatConfigCheckButtonTemplate")
|
|
checkbox:SetPoint("topleft", tutorialFrame.mouse, "bottomleft", -1, -5)
|
|
_G[checkbox:GetName().."Text"]:SetText(Loc["STRING_MINITUTORIAL_BOOKMARK4"])
|
|
|
|
tutorialFrame:SetScript("OnMouseDown", function()
|
|
if (checkbox:GetChecked()) then
|
|
Details.tutorial.ctrl_click_close_tutorial = true
|
|
end
|
|
|
|
tutorialFrame:Hide()
|
|
if (instancia:IsEnabled()) then
|
|
return instancia:ShutDown()
|
|
end
|
|
end)
|
|
end
|
|
|
|
DetailsCtrlCloseWindowPanelTutorial:Show()
|
|
DetailsCtrlCloseWindowPanelTutorial.info_label:SetWidth(Details.switch.frame:GetWidth()-30)
|
|
DetailsCtrlCloseWindowPanelTutorial.close_label:SetWidth(Details.switch.frame:GetWidth()-30)
|
|
|
|
Details.switch.frame:SetPoint("topleft", instancia.baseframe, "topleft", 0, 1)
|
|
Details.switch.frame:SetPoint("bottomright", instancia.baseframe, "bottomright", 0, 1)
|
|
Details.switch.frame:Show()
|
|
return
|
|
end
|
|
|
|
return instancia:ShutDown()
|
|
|
|
elseif (IsShiftKeyDown()) then
|
|
if (not Details.switch.segments_blocks) then
|
|
local segment_switch = function(self, button, segment)
|
|
if (button == "LeftButton") then
|
|
Details.switch.current_instancia:TrocaTabela(segment)
|
|
Details.switch.CloseMe()
|
|
elseif (button == "RightButton") then
|
|
Details.switch.CloseMe()
|
|
end
|
|
end
|
|
|
|
local hide_label = function(self)
|
|
self.texture:Hide()
|
|
self.button:Hide()
|
|
self.background:Hide()
|
|
self:Hide()
|
|
end
|
|
|
|
local show_label = function(self)
|
|
self.texture:Show()
|
|
self.button:Show()
|
|
self.background:Show()
|
|
self:Show()
|
|
end
|
|
|
|
local on_enter = function(self)
|
|
--self.MyObject.this_background:SetBlendMode("ADD")
|
|
--self.MyObject.boss_texture:SetBlendMode("ADD")
|
|
end
|
|
|
|
local on_leave = function(self)
|
|
self.MyObject.this_background:SetBlendMode("BLEND")
|
|
self.MyObject.boss_texture:SetBlendMode("BLEND")
|
|
end
|
|
|
|
function Details.switch:CreateSegmentBlock()
|
|
local s = gump:CreateLabel(Details.switch.frame)
|
|
Details:SetFontSize(s, 9)
|
|
|
|
local index = #Details.switch.segments_blocks
|
|
if (index == 1) then --overall button
|
|
index = -1
|
|
elseif (index >= 2) then
|
|
index = index - 1
|
|
end
|
|
|
|
local button = gump:CreateButton(Details.switch.frame, segment_switch, 100, 20, "", index)
|
|
button:SetPoint("topleft", s, "topleft", -17, 0)
|
|
button:SetPoint("bottomright", s, "bottomright", 0, 0)
|
|
button:SetClickFunction(segment_switch, nil, nil, "right")
|
|
|
|
local boss_texture = gump:CreateImage(button, nil, 16, 16)
|
|
boss_texture:SetPoint("right", s, "left", -2, 0)
|
|
|
|
local background = button:CreateTexture(nil, "background")
|
|
background:SetTexture("Interface\\SPELLBOOK\\Spellbook-Parts")
|
|
background:SetTexCoord(0.31250000, 0.96484375, 0.37109375, 0.52343750)
|
|
background:SetWidth(85)
|
|
background:SetPoint("topleft", s.widget, "topleft", -16, 3)
|
|
background:SetPoint("bottomright", s.widget, "bottomright", -3, -5)
|
|
|
|
button.this_background = background
|
|
button.boss_texture = boss_texture.widget
|
|
|
|
s.texture = boss_texture
|
|
s.button = button
|
|
s.background = background
|
|
|
|
button:SetScript("OnEnter", on_enter)
|
|
button:SetScript("OnLeave", on_leave)
|
|
|
|
s.HideMe = hide_label
|
|
s.ShowMe = show_label
|
|
|
|
table.insert(Details.switch.segments_blocks, s)
|
|
return s
|
|
end
|
|
|
|
function Details.switch:GetSegmentBlock (index)
|
|
local block = Details.switch.segments_blocks [index]
|
|
if (not block) then
|
|
return Details.switch:CreateSegmentBlock()
|
|
else
|
|
return block
|
|
end
|
|
end
|
|
|
|
function Details.switch:ClearSegmentBlocks()
|
|
for _, block in ipairs(Details.switch.segments_blocks) do
|
|
block:HideMe()
|
|
end
|
|
end
|
|
|
|
function Details.switch:ResizeSegmentBlocks()
|
|
|
|
local x = 7
|
|
local y = 5
|
|
|
|
local window_width, window_height = Details.switch.current_instancia:GetSize()
|
|
|
|
local horizontal_amt = floor(math.max(window_width / 100, 2))
|
|
local vertical_amt = floor((window_height - y) / 20)
|
|
local size = window_width / horizontal_amt
|
|
|
|
local frame = Details.switch.frame
|
|
|
|
Details.switch:ClearSegmentBlocks()
|
|
|
|
local i = 1
|
|
for vertical = 1, vertical_amt do
|
|
x = 7
|
|
for horizontal = 1, horizontal_amt do
|
|
local button = Details.switch:GetSegmentBlock (i)
|
|
|
|
button:SetPoint("topleft", frame, "topleft", x + 16, -y)
|
|
button:SetSize(size - 22, 12)
|
|
button:ShowMe()
|
|
|
|
i = i + 1
|
|
x = x + size
|
|
if (i > 40) then
|
|
break
|
|
end
|
|
end
|
|
y = y + 20
|
|
end
|
|
end
|
|
|
|
Details.switch.segments_blocks = {}
|
|
|
|
--current and overall
|
|
Details.switch:CreateSegmentBlock()
|
|
Details.switch:CreateSegmentBlock()
|
|
|
|
local block1 = Details.switch:GetSegmentBlock (1)
|
|
block1:SetText(Loc["STRING_CURRENTFIGHT"])
|
|
block1.texture:SetTexture([[Interface\Scenarios\ScenariosParts]])
|
|
block1.texture:SetTexCoord(55/512, 81/512, 368/512, 401/512)
|
|
|
|
local block2 = Details.switch:GetSegmentBlock (2)
|
|
block2:SetText(Loc["STRING_SEGMENT_OVERALL"])
|
|
block2.texture:SetTexture([[Interface\Scenarios\ScenariosParts]])
|
|
block2.texture:SetTexCoord(55/512, 81/512, 368/512, 401/512)
|
|
end
|
|
|
|
Details.switch:ClearSegmentBlocks()
|
|
Details.switch:HideAllBookmarks()
|
|
|
|
local segmentsTable = Details:GetCombatSegments()
|
|
|
|
local segmentIndex = 1
|
|
for i = 3, #segmentsTable + 2 do
|
|
---@type combat
|
|
local combat = segmentsTable[segmentIndex]
|
|
|
|
local block = Details.switch:GetSegmentBlock(i)
|
|
local enemy, color, raid_type, killed, is_trash, portrait, background, background_coords = Details:GetSegmentInfo(segmentIndex)
|
|
|
|
block:SetText("#" .. segmentIndex .. " " .. enemy)
|
|
|
|
if (combat.is_boss and combat.instance_type == "raid") then
|
|
local L, R, T, B, Texture = Details:GetBossIcon (combat.is_boss.mapid, combat.is_boss.index)
|
|
if (L) then
|
|
block.texture:SetTexture(Texture)
|
|
block.texture:SetTexCoord(L, R, T, B)
|
|
else
|
|
block.texture:SetTexture([[Interface\Scenarios\ScenarioIcon-Boss]])
|
|
end
|
|
else
|
|
block.texture:SetTexture([[Interface\Scenarios\ScenarioIcon-Boss]])
|
|
end
|
|
|
|
block:ShowMe()
|
|
segmentIndex = segmentIndex + 1
|
|
end
|
|
|
|
Details.switch.frame:SetScale(instancia.window_scale)
|
|
Details.switch:ResizeSegmentBlocks()
|
|
|
|
for i = segmentIndex+2, #Details.switch.segments_blocks do
|
|
Details.switch.segments_blocks [i]:HideMe()
|
|
end
|
|
|
|
Details.switch.frame:SetPoint("topleft", instancia.baseframe, "topleft", 0, 1)
|
|
Details.switch.frame:SetPoint("bottomright", instancia.baseframe, "bottomright", 0, 1)
|
|
Details.switch.frame:Show()
|
|
|
|
return
|
|
|
|
else
|
|
if (Details.no_bookmark) then
|
|
return
|
|
end
|
|
|
|
if (Details.no_bookmark_on_combat and InCombatLockdown()) then
|
|
return
|
|
end
|
|
|
|
if (Details.switch.segments_blocks) then
|
|
Details.switch:ClearSegmentBlocks()
|
|
end
|
|
end
|
|
|
|
--check if there is some custom contidional
|
|
if (instancia.atributo == 5) then
|
|
local custom_object = instancia:GetCustomObject()
|
|
if (custom_object and custom_object.OnSwitchShow) then
|
|
local interrupt = custom_object.OnSwitchShow (instancia)
|
|
if (interrupt) then
|
|
return
|
|
end
|
|
end
|
|
end
|
|
|
|
Details.switch.frame:SetPoint("topleft", instancia.baseframe, "topleft", 0, 1)
|
|
Details.switch.frame:SetPoint("bottomright", instancia.baseframe, "bottomright", 0, 1)
|
|
|
|
local altura = instancia.baseframe:GetHeight()
|
|
local mostrar_quantas = floor(altura / Details.switch.button_height) * 2
|
|
|
|
local precisa_mostrar = 0
|
|
for i = 1, #Details.switch.table do
|
|
local slot = Details.switch.table [i]
|
|
if (not slot) then
|
|
Details.switch.table [i] = {}
|
|
slot = Details.switch.table [i]
|
|
end
|
|
if (slot.atributo) then
|
|
precisa_mostrar = precisa_mostrar + 1
|
|
else
|
|
break
|
|
end
|
|
end
|
|
|
|
if (Details.switch.mostrar_quantas ~= mostrar_quantas) then
|
|
for i = 1, #Details.switch.buttons do
|
|
if (i <= mostrar_quantas) then
|
|
Details.switch.buttons [i]:Show()
|
|
else
|
|
Details.switch.buttons [i]:Hide()
|
|
end
|
|
end
|
|
|
|
if (#Details.switch.buttons < mostrar_quantas) then
|
|
Details.switch.slots = mostrar_quantas
|
|
end
|
|
|
|
Details.switch.mostrar_quantas = mostrar_quantas
|
|
end
|
|
|
|
Details.switch:Resize (precisa_mostrar)
|
|
Details.switch:Update()
|
|
|
|
Details.switch.frame:SetScale(instancia.window_scale)
|
|
Details.switch.frame:Show()
|
|
|
|
Details.switch:Resize (precisa_mostrar)
|
|
|
|
if (DetailsSwitchPanel.all_switch:IsShown()) then
|
|
return DetailsSwitchPanel.all_switch:Hide()
|
|
end
|
|
end
|
|
|
|
-- ~setting
|
|
function Details.switch:Config(_, _, atributo, sub_atributo)
|
|
if (not sub_atributo) then
|
|
return
|
|
end
|
|
|
|
if (type(atributo) == "string") then
|
|
--is a plugin?
|
|
local plugin = Details:GetPlugin(atributo)
|
|
if(plugin) then
|
|
Details.switch.table[Details.switch.editing_bookmark].atributo = "plugin"
|
|
Details.switch.table[Details.switch.editing_bookmark].sub_atributo = atributo
|
|
end
|
|
else
|
|
--is a attribute or custom script
|
|
Details.switch.table[Details.switch.editing_bookmark].atributo = atributo
|
|
Details.switch.table[Details.switch.editing_bookmark].sub_atributo = sub_atributo
|
|
end
|
|
|
|
Details.switch.editing_bookmark = nil
|
|
gameCooltip:Hide()
|
|
Details.switch:Update()
|
|
end
|
|
|
|
--[[global]] function DetailsChangeDisplayFromBookmark(number, instance)
|
|
if (not instance) then
|
|
local lowerInstanceId = Details:GetLowerInstanceNumber()
|
|
if (lowerInstanceId) then
|
|
instance = Details:GetInstance(lowerInstanceId)
|
|
end
|
|
if (not instance) then
|
|
return Details:Msg(Loc["STRING_WINDOW_NOTFOUND"])
|
|
end
|
|
end
|
|
|
|
local bookmark = Details.switch.table[number]
|
|
|
|
if (bookmark) then
|
|
Details.switch.current_instancia = instance
|
|
if (not bookmark.atributo) then
|
|
return Details:Msg(string.format(Loc["STRING_SWITCH_SELECTMSG"], number))
|
|
end
|
|
|
|
Details:FastSwitch(nil, bookmark, number)
|
|
end
|
|
end
|
|
|
|
function Details:FastSwitch(button, bookmark, bookmarkNumber, selectNew)
|
|
local unknownPlugin = bookmark and bookmark.atributo == "plugin" and not Details:GetPlugin(bookmark.sub_atributo)
|
|
|
|
if (selectNew or not bookmark.atributo or unknownPlugin) then
|
|
gameCooltip:Reset()
|
|
gameCooltip:SetOwner(button)
|
|
gameCooltip:SetType(3)
|
|
gameCooltip:SetFixedParameter(Details.switch.current_instancia)
|
|
|
|
Details.switch.editing_bookmark = bookmarkNumber
|
|
|
|
Details:MontaAtributosOption(Details.switch.current_instancia, Details.switch.Config)
|
|
|
|
--build raid plugins list
|
|
gameCooltip:AddLine(Loc["STRING_MODE_PLUGINS"])
|
|
gameCooltip:AddMenu(1, function() end, 4, true)
|
|
gameCooltip:AddIcon([[Interface\AddOns\Details\images\modo_icones]], 1, 1, 20, 20, 32/256*3, 32/256*4, 0, 1)
|
|
|
|
local availablePlugins = Details.RaidTables:GetAvailablePlugins()
|
|
local amt = 0
|
|
|
|
if (#availablePlugins >= 0) then
|
|
for index, ptable in ipairs(availablePlugins) do
|
|
if (ptable [3].__enabled and not ptable[3].NoMenu) then
|
|
gameCooltip:AddMenu(2, Details.switch.Config, Details.switch.current_instancia, ptable [4], true, ptable [1], ptable [2], true) --PluginName, PluginIcon, PluginObject, PluginAbsoluteName
|
|
amt = amt + 1
|
|
end
|
|
end
|
|
gameCooltip:SetWallpaper(2, Details.tooltip.menus_bg_texture, Details.tooltip.menus_bg_coords, Details.tooltip.menus_bg_color, true)
|
|
end
|
|
|
|
if (#Details.SoloTables.Menu > 0) then
|
|
for index, ptable in ipairs(Details.SoloTables.Menu) do
|
|
if (ptable [3].__enabled and not ptable[3].NoMenu) then
|
|
gameCooltip:AddMenu(2, Details.switch.Config, Details.switch.current_instancia, ptable [4], true, ptable [1], ptable [2], true)
|
|
end
|
|
end
|
|
gameCooltip:SetWallpaper(2, Details.tooltip.menus_bg_texture, Details.tooltip.menus_bg_coords, Details.tooltip.menus_bg_color, true)
|
|
end
|
|
|
|
if (amt <= 3) then
|
|
gameCooltip:SetOption("SubFollowButton", true)
|
|
end
|
|
|
|
gameCooltip:SetOption("HeightAnchorMod", -7)
|
|
gameCooltip:SetOption("TextSize", Details.font_sizes.menus)
|
|
return gameCooltip:ShowCooltip()
|
|
end
|
|
|
|
if (IsShiftKeyDown()) then
|
|
--get a closed window or created a new one
|
|
local instance = Details:CreateInstance()
|
|
if (not instance) then
|
|
Details.switch.CloseMe()
|
|
return Details:Msg(Loc["STRING_WINDOW_NOTFOUND"])
|
|
end
|
|
Details.switch.current_instancia = instance
|
|
end
|
|
|
|
if (Details.switch.current_instancia.modo == Details._detalhes_props["MODO_ALONE"]) then
|
|
Details.switch.current_instancia:SetMode(2)
|
|
|
|
elseif (Details.switch.current_instancia.modo == Details._detalhes_props["MODO_RAID"]) then
|
|
Details.switch.current_instancia:SetMode(2)
|
|
end
|
|
|
|
if (bookmark.atributo == "plugin") then
|
|
--is a plugin, check if is a raid or solo plugin
|
|
if (Details.RaidTables.NameTable [bookmark.sub_atributo]) then
|
|
local raidPlugins = Details.RaidTables:GetAvailablePlugins()
|
|
local isAvailable = false
|
|
if (#raidPlugins >= 0) then
|
|
for i, ptable in ipairs(raidPlugins) do
|
|
--check if the plugin is available
|
|
if (ptable[4] == bookmark.sub_atributo) then
|
|
isAvailable = true
|
|
end
|
|
end
|
|
end
|
|
|
|
if (isAvailable) then
|
|
Details.RaidTables:EnableRaidMode(Details.switch.current_instancia, bookmark.sub_atributo)
|
|
else
|
|
Details:Msg("plugin already in use in another window. If you are wondering where, check the Orange Gear > Window Control.") --localize-me
|
|
end
|
|
|
|
elseif (Details.SoloTables.NameTable [bookmark.sub_atributo]) then
|
|
Details.SoloTables:EnableSoloMode(Details.switch.current_instancia, bookmark.sub_atributo)
|
|
else
|
|
Details:Msg("Plugin not found.")
|
|
end
|
|
else
|
|
Details.switch.current_instancia:TrocaTabela(Details.switch.current_instancia, true, bookmark.atributo, bookmark.sub_atributo)
|
|
end
|
|
|
|
Details.switch.CloseMe()
|
|
end
|
|
|
|
function Details.switch:InitSwitch()
|
|
local instancia = Details.tabela_instancias[1]
|
|
Details.switch:ShowMe(instancia)
|
|
Details.switch:CloseMe()
|
|
end
|
|
|
|
function Details.switch:OnRemoveCustom(customIndex)
|
|
for i = 1, Details.switch.slots do
|
|
local options = Details.switch.table[i]
|
|
if (options and options.atributo == 5 and options.sub_atributo == customIndex) then
|
|
options.atributo = nil
|
|
options.sub_atributo = nil
|
|
--update if already shown once at least
|
|
if (Details.switch.vertical_amt) then
|
|
Details.switch:Update()
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
local default_coords = {5/64, 59/64, 5/64, 59/64}
|
|
local vertex_color_default = {1, 1, 1}
|
|
local vertex_color_unknown = {1, 1, 1}
|
|
local add_coords = {464/512, 473/512, 1/512, 11/512}
|
|
|
|
function Details.switch:Update()
|
|
if (not Details.switch.vertical_amt) then
|
|
--wasn't opened yet, so doesn't matter if we update or not
|
|
return
|
|
end
|
|
|
|
local slots = Details.switch.slots
|
|
local x = 10
|
|
local y = 5
|
|
local jump = false
|
|
local hide_the_rest
|
|
|
|
local offset = FauxScrollFrame_GetOffset(DetailsSwitchPanelScroll)
|
|
local slots_shown = Details.switch.slots
|
|
|
|
for i = 1, slots_shown do
|
|
--bookmark index
|
|
local index = (offset * Details.switch.vertical_amt) + i
|
|
|
|
--button
|
|
local button = Details.switch.buttons [i]
|
|
if (not button) then
|
|
button = Details.switch:NewSwitchButton (Details.switch.frame, i, x, y, jump)
|
|
button:SetFrameLevel(Details.switch.frame:GetFrameLevel()+2)
|
|
Details.switch.showing = Details.switch.showing + 1
|
|
end
|
|
|
|
local options = Details.switch.table [index]
|
|
if (not options and index <= 40) then
|
|
options = {}
|
|
Details.switch.table [index] = options
|
|
end
|
|
|
|
button.bookmark_number = index --button on icon
|
|
button.button2.bookmark_number = index --button on text
|
|
|
|
local icone
|
|
local coords
|
|
local name
|
|
local vcolor
|
|
local add
|
|
local textColor = "white"
|
|
|
|
if (options and options.sub_atributo) then
|
|
if (options.atributo == 5) then --custom
|
|
local CustomObject = Details.custom [options.sub_atributo]
|
|
if (not CustomObject) then --ele j� foi deletado
|
|
icone = [[Interface\AddOns\Details\images\icons]]
|
|
coords = add_coords
|
|
name = Loc["STRING_SWITCH_CLICKME"]
|
|
vcolor = vertex_color_unknown
|
|
add = true
|
|
else
|
|
icone = CustomObject.icon
|
|
coords = default_coords
|
|
name = CustomObject.name
|
|
vcolor = vertex_color_default
|
|
end
|
|
|
|
elseif (options.atributo == "plugin") then --plugin
|
|
|
|
local plugin = Details:GetPlugin (options.sub_atributo)
|
|
if (plugin) then
|
|
|
|
local raidPlugins = Details.RaidTables:GetAvailablePlugins()
|
|
local isAvailable = false
|
|
if (#raidPlugins >= 0) then
|
|
for i, ptable in ipairs(raidPlugins) do
|
|
--check if the plugin is available
|
|
if (ptable[4] == plugin.real_name) then
|
|
isAvailable = true
|
|
end
|
|
end
|
|
end
|
|
|
|
if (isAvailable) then
|
|
vcolor = vertex_color_default
|
|
else
|
|
vcolor = {.35, .35, .35, .35}
|
|
textColor = "gray"
|
|
end
|
|
icone = plugin.__icon
|
|
coords = default_coords
|
|
name = plugin.__name
|
|
|
|
else
|
|
icone = [[Interface\AddOns\Details\images\icons]]
|
|
coords = add_coords
|
|
name = Loc["STRING_SWITCH_CLICKME"]
|
|
vcolor = vertex_color_unknown
|
|
add = true
|
|
end
|
|
else
|
|
icone = Details.sub_atributos [options.atributo].icones [options.sub_atributo] [1]
|
|
coords = Details.sub_atributos [options.atributo].icones [options.sub_atributo] [2]
|
|
name = Details.sub_atributos [options.atributo].lista [options.sub_atributo]
|
|
vcolor = vertex_color_default
|
|
end
|
|
else
|
|
|
|
icone = [[Interface\AddOns\Details\images\icons]]
|
|
coords = add_coords
|
|
name = Loc["STRING_SWITCH_CLICKME"]
|
|
vcolor = vertex_color_unknown
|
|
add = true
|
|
end
|
|
|
|
button:Show()
|
|
button.button2:Show()
|
|
|
|
local width, height = button.button2.texto:GetSize()
|
|
button.button2.texto:SetWidth(300)
|
|
button.button2.texto:SetText(name)
|
|
local text_width = button.button2.texto:GetStringWidth()
|
|
|
|
while (text_width > Details.switch.text_size) do
|
|
Details:SetFontSize(button.button2.texto, Details.bookmark_text_size)
|
|
local text = button.button2.texto:GetText()
|
|
text = strsub(text, 1, #text-1)
|
|
button.button2.texto:SetText(text)
|
|
text_width = button.button2.texto:GetStringWidth()
|
|
end
|
|
|
|
button.button2.texto:SetSize(width, height)
|
|
DetailsFramework:SetFontColor(button.button2.texto, textColor)
|
|
|
|
button.textureNormal:SetTexture(icone, true)
|
|
button.textureNormal:SetTexCoord(unpack(coords))
|
|
button.textureNormal:SetVertexColor(unpack(vcolor))
|
|
button.texturePushed:SetTexture(icone, true)
|
|
button.texturePushed:SetTexCoord(unpack(coords))
|
|
button.texturePushed:SetVertexColor(unpack(vcolor))
|
|
button.textureH:SetTexture(icone, true)
|
|
button.textureH:SetVertexColor(unpack(vcolor))
|
|
button.textureH:SetTexCoord(unpack(coords))
|
|
button:ChangeIcon(button.textureNormal, button.texturePushed, nil, button.textureH)
|
|
|
|
if (add) then
|
|
button:SetSize(12, 12)
|
|
else
|
|
button:SetSize(15, 15)
|
|
end
|
|
|
|
if (name == Loc["STRING_SWITCH_CLICKME"]) then
|
|
button:SetAlpha(0.3)
|
|
button.textureNormal:SetDesaturated(true)
|
|
button.button2.texto:SetPoint("left", button, "right", 5, -1)
|
|
else
|
|
button:SetAlpha(1)
|
|
button.textureNormal:SetDesaturated(false)
|
|
button.button2.texto:SetPoint("left", button, "right", 3, -1)
|
|
end
|
|
|
|
if (jump) then
|
|
x = x - 125
|
|
y = y + Details.switch.button_height
|
|
jump = false
|
|
else
|
|
x = x + 1254
|
|
jump = true
|
|
end
|
|
|
|
end
|
|
|
|
FauxScrollFrame_Update(DetailsSwitchPanelScroll, ceil (40 / Details.switch.vertical_amt) , Details.switch.horizontal_amt, 20)
|
|
end
|
|
|
|
local scroll = CreateFrame("scrollframe", "DetailsSwitchPanelScroll", DetailsSwitchPanel, "FauxScrollFrameTemplate")
|
|
scroll:SetAllPoints()
|
|
scroll:SetScript("OnVerticalScroll", function(self, offset) FauxScrollFrame_OnVerticalScroll (self, offset, 20, Details.switch.Update) end) --altura
|
|
scroll.ScrollBar:Hide()
|
|
scroll.ScrollBar.ScrollUpButton:Hide()
|
|
scroll.ScrollBar.ScrollDownButton:Hide()
|
|
|
|
function Details.switch:Resize()
|
|
local x, xOriginal = 5, 5
|
|
local y = 5
|
|
local incrementY = 18
|
|
local windowWidth, windowHeight = Details.switch.current_instancia:GetSize()
|
|
|
|
local horizontalAmt = floor(math.max(windowWidth / 100, 2))
|
|
local verticalAmt = floor((windowHeight - y) / incrementY)
|
|
|
|
Details.switch.y_increment = incrementY
|
|
local size = windowWidth / horizontalAmt
|
|
local bookmarkFrame = Details.switch.frame
|
|
|
|
for index, button in ipairs(Details.switch.buttons) do
|
|
button:Hide()
|
|
end
|
|
|
|
Details.switch.vertical_amt = verticalAmt
|
|
Details.switch.horizontal_amt = horizontalAmt
|
|
Details.switch.text_size = size - 30
|
|
|
|
local i = 1
|
|
for vertical = 1, verticalAmt do
|
|
x = xOriginal
|
|
for horizontal = 1, horizontalAmt do
|
|
local button = Details.switch.buttons[i]
|
|
local options = Details.switch.table[i]
|
|
|
|
if (not options) then
|
|
options = {atributo = nil, sub_atributo = nil}
|
|
Details.switch.table[i] = options
|
|
end
|
|
|
|
if (not button) then
|
|
button = Details.switch:NewSwitchButton(bookmarkFrame, i, x, y)
|
|
button:SetFrameLevel(bookmarkFrame:GetFrameLevel()+2)
|
|
Details.switch.showing = Details.switch.showing + 1
|
|
end
|
|
|
|
button:SetPoint("topleft", bookmarkFrame, "topleft", x, -y)
|
|
button.textureNormal:SetPoint("topleft", bookmarkFrame, "topleft", x, -y)
|
|
button.texturePushed:SetPoint("topleft", bookmarkFrame, "topleft", x, -y)
|
|
button.textureH:SetPoint("topleft", bookmarkFrame, "topleft", x, -y)
|
|
button.button2.texto:SetSize(size - 30, 12)
|
|
button.button2:SetPoint("bottomright", button, "bottomright", size - 30, 0)
|
|
button:Show()
|
|
|
|
i = i + 1
|
|
x = x + size
|
|
if (i > 40) then
|
|
break
|
|
end
|
|
end
|
|
y = y + incrementY + 2
|
|
end
|
|
|
|
Details.switch.slots = i - 1
|
|
end
|
|
|
|
local bookmarkButtonBodyOnEnter = function(self)
|
|
if (not Details.switch.table[self.id].atributo) then
|
|
gameCooltip:Reset()
|
|
gameCooltip:SetOwner(self)
|
|
|
|
gameCooltip:SetOption("TextSize", 10)
|
|
gameCooltip:SetOption("ButtonsYMod", 0)
|
|
gameCooltip:SetOption("YSpacingMod", 0)
|
|
gameCooltip:SetOption("IgnoreButtonAutoHeight", false)
|
|
|
|
gameCooltip:AddLine(Loc["STRING_SWITCH_CLICKME"]) --add bookmark
|
|
gameCooltip:AddIcon([[Interface\Glues\CharacterSelect\Glues-AddOn-Icons]], 1, 1, 16, 16, 0.75, 1, 0, 1, {0, 1, 0})
|
|
gameCooltip:Show()
|
|
else
|
|
gameCooltip:Hide()
|
|
end
|
|
|
|
Details:SetFontColor(self.texto, "orange")
|
|
|
|
DetailsSwitchPanel.hoverOverTexture:SetSize(self:GetWidth(), self:GetHeight()) --size of button
|
|
DetailsSwitchPanel.hoverOverTexture:ClearAllPoints()
|
|
DetailsSwitchPanel.hoverOverTexture:SetPoint("topleft", self, "topleft", -18, 1)
|
|
DetailsSwitchPanel.hoverOverTexture:SetPoint("bottomright", self, "bottomright", 8, -1)
|
|
DetailsSwitchPanel.hoverOverTexture:Show()
|
|
end
|
|
|
|
local bookmarkButtonBodyOnLeave = function(self)
|
|
if (gameCooltip:IsTooltip()) then
|
|
gameCooltip:Hide()
|
|
end
|
|
self.texto:SetTextColor(.9, .9, .9, .9)
|
|
self.button1_icon:SetBlendMode("BLEND")
|
|
end
|
|
|
|
local bookmarkButtonIconOnEnter = function(self)
|
|
if (gameCooltip:IsMenu()) then
|
|
return
|
|
end
|
|
|
|
gameCooltip:Reset()
|
|
gameCooltip:SetOwner(self)
|
|
|
|
gameCooltip:AddLine("select bookmark")
|
|
gameCooltip:AddIcon([[Interface\TUTORIALFRAME\UI-TUTORIAL-FRAME]], 1, 1, 12, 14, 0.0019531, 0.1484375, 0.6269531, 0.8222656)
|
|
|
|
gameCooltip:SetOption("TextSize", 10)
|
|
gameCooltip:SetOption("ButtonsYMod", 0)
|
|
gameCooltip:SetOption("YSpacingMod", 0)
|
|
gameCooltip:SetOption("IgnoreButtonAutoHeight", false)
|
|
|
|
Details:SetFontColor(self.texto, "orange")
|
|
gameCooltip:Show()
|
|
end
|
|
|
|
local bookmarkButtonIconOnLeave = function(self)
|
|
if (gameCooltip:IsTooltip()) then
|
|
gameCooltip:Hide()
|
|
end
|
|
self.texto:SetTextColor(.9, .9, .9, .9)
|
|
end
|
|
|
|
local bookmarkButtonIconOnClick = function(self, button)
|
|
if (button == "RightButton") then
|
|
--select another bookmark
|
|
Details:FastSwitch(self, nil, self.bookmark_number, true)
|
|
else
|
|
--change the display
|
|
local bookmark = Details.switch.table[self.bookmark_number]
|
|
if (bookmark.atributo) then
|
|
Details:FastSwitch(self, bookmark, self.bookmark_number)
|
|
else
|
|
--invalid bookmark, select another bookmark
|
|
Details:FastSwitch(self, bookmark, self.bookmark_number, true)
|
|
end
|
|
end
|
|
end
|
|
|
|
local bookmarkButtonBodyOnClick = function(self, button)
|
|
if (button == "RightButton") then
|
|
--close the bookmark menu
|
|
Details.switch:CloseMe()
|
|
else
|
|
--change the display
|
|
local bookmark = Details.switch.table[self.bookmark_number]
|
|
if (bookmark.atributo) then
|
|
Details:FastSwitch(self, bookmark, self.bookmark_number)
|
|
else
|
|
--invalid bookmark, select another bookmark
|
|
Details:FastSwitch(self, bookmark, self.bookmark_number, true)
|
|
end
|
|
end
|
|
end
|
|
|
|
local changeIconFunc = function(self, icon1, icon2, icon3, icon4)
|
|
self:SetNormalTexture(icon1 or "")
|
|
self:SetPushedTexture(icon2 or "")
|
|
self:SetDisabledTexture(icon3 or "")
|
|
self:SetHighlightTexture(icon4 or "", "ADD")
|
|
end
|
|
|
|
function Details.switch:NewSwitchButton(frame, index, x, y, rightButton)
|
|
local newSwitchButton = CreateFrame("button", "DetailsSwitchPanelButton_1_" .. index, frame, "BackdropTemplate")
|
|
newSwitchButton:SetSize(15, 24)
|
|
newSwitchButton:SetPoint("topleft", frame, "topleft", x, -y)
|
|
newSwitchButton:SetScript("OnMouseDown", bookmarkButtonIconOnClick)
|
|
newSwitchButton:SetScript("OnEnter", bookmarkButtonIconOnEnter)
|
|
newSwitchButton:SetScript("OnLeave", bookmarkButtonIconOnLeave)
|
|
newSwitchButton.ChangeIcon = changeIconFunc
|
|
newSwitchButton.id = index
|
|
|
|
local backgroundTexture = DetailsFramework:CreateTexture(newSwitchButton, {gradient = "vertical", fromColor = {0, 0, 0, 0.3}, toColor = "transparent"}, 1, 1, "artwork", {0, 1, 0, 1})
|
|
backgroundTexture:SetAllPoints()
|
|
|
|
local button2 = CreateFrame("button", "DetailsSwitchPanelButton_2_" .. index, newSwitchButton, "BackdropTemplate")
|
|
button2:SetSize(1, 1)
|
|
button2:SetPoint("topleft", newSwitchButton, "topright", 1, 0)
|
|
button2:SetPoint("bottomright", newSwitchButton, "bottomright", 90, 0)
|
|
button2:SetScript("OnMouseDown", bookmarkButtonBodyOnClick)
|
|
button2:SetScript("OnEnter", bookmarkButtonBodyOnEnter)
|
|
button2:SetScript("OnLeave", bookmarkButtonBodyOnLeave)
|
|
button2.id = index
|
|
newSwitchButton.button2 = button2
|
|
|
|
--icon
|
|
newSwitchButton.textureNormal = newSwitchButton:CreateTexture(nil, "background")
|
|
newSwitchButton.textureNormal:SetAllPoints()
|
|
|
|
--icon pushed
|
|
newSwitchButton.texturePushed = newSwitchButton:CreateTexture(nil, "background")
|
|
newSwitchButton.texturePushed:SetAllPoints()
|
|
|
|
--highlight
|
|
newSwitchButton.textureH = newSwitchButton:CreateTexture(nil, "background")
|
|
newSwitchButton.textureH:SetAllPoints()
|
|
|
|
--text
|
|
gump:NewLabel(button2, button2, nil, "texto", "", "GameFontNormal")
|
|
button2.texto:SetPoint("left", newSwitchButton, "right", 5, -1)
|
|
button2.texto:SetTextColor(.9, .9, .9, 1)
|
|
|
|
Details:SetFontSize(button2.texto, Details.bookmark_text_size)
|
|
|
|
newSwitchButton.texto = button2.texto
|
|
|
|
button2.button1_icon = newSwitchButton.textureNormal
|
|
button2.button1_icon2 = newSwitchButton.texturePushed
|
|
button2.button1_icon3 = newSwitchButton.textureH
|
|
|
|
button2.MouseOnEnterHook = bookmarkButtonBodyOnEnter
|
|
button2.MouseOnLeaveHook = bookmarkButtonBodyOnLeave
|
|
|
|
Details.switch.buttons[index] = newSwitchButton
|
|
return newSwitchButton
|
|
end
|
|
|
|
|