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.
552 lines
26 KiB
552 lines
26 KiB
local _, S = ...
|
|
|
|
S.MAX_GROUPS = 25
|
|
|
|
function SortedItemList_UpdateScrollBar(self)
|
|
local n = self.scrollChild:GetHeight() - self:GetHeight()
|
|
if n < 1 then n = 1 end
|
|
n = math.ceil(n)
|
|
self.scrollBar:SetMinMaxValues(1, n)
|
|
self:StopScrolling()
|
|
end
|
|
|
|
local function SortedItemList_OnUpdate(self, elapsed)
|
|
if ((MouseIsOver(self) or MouseIsOver(self.itemDropButton)) and GetCursorInfo() == "item")
|
|
and not ((self.itemDropButton.type == "BANK" or self.itemDropButton.type == "REAGENT") and not Sorted_bankIsOpened) then
|
|
self.itemDropButton:Show()
|
|
else
|
|
self.itemDropButton:Hide()
|
|
end
|
|
if self.animating then
|
|
self.animElapsed = self.animElapsed + elapsed * 6
|
|
if self.animElapsed > 1 or Sorted_GetSetting("animations") == 1 then
|
|
self.animElapsed = 1
|
|
self.animating = false
|
|
end
|
|
local mult = math.sin(self.animElapsed * math.pi * 0.5)
|
|
for _, groupHeader in pairs(self.groupHeaders) do
|
|
if groupHeader:IsShown() then
|
|
if groupHeader.animate and groupHeader.previousY then
|
|
groupHeader.currentY = groupHeader.previousY + (groupHeader.targetY - groupHeader.previousY) * mult
|
|
else
|
|
groupHeader.currentY = groupHeader.targetY
|
|
end
|
|
groupHeader:SetPoint("TOP", 0, groupHeader.currentY)
|
|
end
|
|
end
|
|
for _, itemButton in pairs(self.itemButtons) do
|
|
if SortedItemList_ItemButtonShown(self, itemButton) then
|
|
if itemButton.animate and itemButton.previousY then
|
|
itemButton.currentY = itemButton.previousY + (itemButton.targetY - itemButton.previousY) * mult
|
|
else
|
|
itemButton.currentY = itemButton.targetY
|
|
end
|
|
itemButton:SetPoint("TOP", 0, itemButton.currentY)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
function SortedItemList_UpdateItemButtons(self, itemID)
|
|
for _, itemButton in ipairs(self.itemButtons) do
|
|
if (not itemID or itemID == itemButton.itemID) then
|
|
SortedItemButton_Update(itemButton)
|
|
end
|
|
end
|
|
|
|
-- Combine stacks
|
|
if Sorted_GetSetting("combineStacks") == 2 then
|
|
local items = {}
|
|
for _, itemButton in ipairs(self.itemButtons) do
|
|
local itemData = itemButton:GetData()
|
|
if SortedItemList_ItemButtonShown(self, itemButton) and (not itemID or itemID == itemData.itemID) then
|
|
if items[itemData.link] then
|
|
if items[itemData.link].count < itemData.count then
|
|
items[itemData.link].count = itemData.count
|
|
items[itemData.link].bag = itemData.bag
|
|
items[itemData.link].slot = itemData.slot
|
|
end
|
|
items[itemData.link].totalCount = items[itemData.link].totalCount + itemData.count
|
|
else
|
|
items[itemData.link] = {
|
|
["count"] = itemData.count,
|
|
["bag"] = itemData.bag,
|
|
["slot"] = itemData.slot,
|
|
["totalCount"] = itemData.count
|
|
}
|
|
end
|
|
end
|
|
end
|
|
for _, itemButton in ipairs(self.itemButtons) do
|
|
local itemData = itemButton:GetData()
|
|
if SortedItemList_ItemButtonShown(self, itemButton) and (not itemID or itemID == itemData.itemID) then
|
|
SortedItemButton_Update(itemButton)
|
|
if not (itemButton.bag == items[itemData.link].bag and itemButton.slot == items[itemData.link].slot) then
|
|
itemButton.empty = true
|
|
else
|
|
itemButton.count = items[itemData.link].totalCount
|
|
if itemButton.count > 1 then
|
|
itemButton.quantityString:SetText(itemButton.count)
|
|
if itemData.value > 0 and not itemData.hasNoValue then
|
|
itemButton.valueString:SetText(Sorted_FormatValueString(itemData.value * itemButton.count))
|
|
local color = Sorted_GetValueColor(itemData.value * itemButton.count)
|
|
itemButton.valueString:SetTextColor(color.r, color.g, color.b)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
end
|
|
|
|
function SortedItemList_SetBackdropAlpha(self, alpha)
|
|
for _, itemButton in pairs(self.itemButtons) do
|
|
itemButton.bgTex:SetGradientAlpha(
|
|
"VERTICAL",
|
|
0, 0, 0, 0,
|
|
0, 0, 0, 0.1 * alpha
|
|
)
|
|
end
|
|
end
|
|
|
|
function SortedItemList_ItemButtonShown(self, itemButton)
|
|
return not itemButton.empty
|
|
and not ((itemButton.bag > 0 and itemButton.bag <= NUM_BAG_SLOTS) and self.type == "BAGS" and Sorted_GetBagFrameShown(itemButton.bag))
|
|
and not ((itemButton.bag > NUM_BAG_SLOTS and itemButton.bag <= NUM_BAG_SLOTS + NUM_BANKBAGSLOTS) and self.type == "BANK" and Sorted_GetBagFrameShown(itemButton.bag))
|
|
end
|
|
|
|
function SortedItemList_PositionItemButtons(self, animate, onlyAnimateFiltered)
|
|
self.animating = true
|
|
if animate then
|
|
self.animElapsed = 0
|
|
else
|
|
self.animElapsed = 1
|
|
end
|
|
|
|
for _, v in pairs(self.groupHeaders) do
|
|
v:Hide()
|
|
end
|
|
|
|
local count, currentGrouping, y = 0, -1, -2
|
|
for _, itemButton in ipairs(self.itemButtons) do
|
|
if (SortedItemList_ItemButtonShown(self, itemButton)) then
|
|
if Sorted_GetSetting("grouping") > 0 and (not itemButton.filtered) then
|
|
local group, text
|
|
if Sorted_GetSetting("newOnTop") == 2 and itemButton:IsNew() then
|
|
group, text = nil, nil--0, "New"
|
|
else
|
|
group, text = S.groupingMethods[Sorted_GetSetting("grouping")].func(itemButton:GetData())
|
|
end
|
|
if group and text and group ~= currentGrouping then
|
|
currentGrouping = group
|
|
self.groupHeaders[currentGrouping]:Show()
|
|
self.groupHeaders[currentGrouping]:SetPoint("LEFT")
|
|
self.groupHeaders[currentGrouping].previousY = self.groupHeaders[currentGrouping].currentY
|
|
--self.groupHeaders[currentGrouping]:SetPoint("TOP", 0, y - 6)
|
|
self.groupHeaders[currentGrouping].targetY = y - 6
|
|
self.groupHeaders[currentGrouping].animate = not onlyAnimateFiltered
|
|
self.groupHeaders[currentGrouping].text:SetText(text)
|
|
if S.collapsedGroups[currentGrouping] then
|
|
self.groupHeaders[currentGrouping].collapseButton:Hide()
|
|
self.groupHeaders[currentGrouping].expandButton:Show()
|
|
else
|
|
self.groupHeaders[currentGrouping].collapseButton:Show()
|
|
self.groupHeaders[currentGrouping].expandButton:Hide()
|
|
end
|
|
count = count + 1
|
|
y = y - 28
|
|
end
|
|
end
|
|
if Sorted_GetSetting("grouping") == 0 or not S.collapsedGroups[currentGrouping] or itemButton.filtered then
|
|
if itemButton.filtered and currentGrouping >= 0 then
|
|
-- Add a space between the last group and the greyed-out, filtered items
|
|
currentGrouping = -1
|
|
y = y - 12
|
|
end
|
|
itemButton:Show()
|
|
itemButton:SetPoint("LEFT")
|
|
itemButton:SetPoint("RIGHT", self.scrollBar, "LEFT", -2, 0)
|
|
itemButton.previousY = itemButton.currentY
|
|
--itemButton:SetPoint("TOP", 0, y)
|
|
itemButton.targetY = y
|
|
itemButton:SetHeight(Sorted_GetSetting("iconSize") + Sorted_GetSetting("padding"))
|
|
itemButton.iconFrame:SetSize(Sorted_GetSetting("iconSize"), Sorted_GetSetting("iconSize"))
|
|
itemButton.iconGlow:SetSize(Sorted_GetSetting("iconSize") * (1 + Sorted_GetSetting("iconBorderThickness") / 10), Sorted_GetSetting("iconSize") * (1 + Sorted_GetSetting("iconBorderThickness") / 10))
|
|
count = count + 1
|
|
y = y - (Sorted_GetSetting("iconSize") + Sorted_GetSetting("padding"))
|
|
if itemButton.filtered then
|
|
itemButton:SetAlpha(0.2)
|
|
itemButton.iconGlow:SetAlpha(0)
|
|
itemButton.animate = true
|
|
else
|
|
if S.IsCurrentPlayerSelected() then
|
|
itemButton:SetAlpha(1)
|
|
else
|
|
itemButton:SetAlpha(0.9)
|
|
end
|
|
itemButton.iconGlow:SetAlpha(1)
|
|
itemButton.animate = not onlyAnimateFiltered
|
|
end
|
|
else
|
|
itemButton:ClearAllPoints()
|
|
itemButton:Hide()
|
|
itemButton.animate = false
|
|
end
|
|
else
|
|
itemButton:ClearAllPoints()
|
|
itemButton:Hide()
|
|
end
|
|
end
|
|
self.scrollChild:SetHeight(-y)
|
|
--[[if not (type=="BANK" or type=="REAGENT") or Sorted_bankIsOpened then
|
|
self.itemDropButton:SetPoint("TOPLEFT", self.scrollChild, "BOTTOMLEFT", 0, 64)
|
|
self.scrollChild:SetHeight(self.scrollChild:GetHeight() + 64)
|
|
else
|
|
self.itemDropButton:SetPoint("TOPLEFT", self.scrollChild, "BOTTOMLEFT", 0, 0)
|
|
end]]
|
|
if self.scrollChild:GetHeight() < self:GetHeight() then
|
|
self.scrollChild:SetHeight(self:GetHeight())
|
|
end
|
|
Sorted_UpdateScrollBars()
|
|
-- Set warning string
|
|
local type = self.type
|
|
if type == "BAGS" or type == "BANK" or type == "REAGENT" then
|
|
--[[if count == 0 then
|
|
if Sorted_SelectedFilter == 13 then
|
|
self.warningString:SetText("No miscellaneous items found")
|
|
elseif Sorted_SelectedFilter > 0 then
|
|
self.warningString:SetText("No "..Sorted_FilterButtons[Sorted_SelectedFilter].text:GetText():lower().." found")
|
|
else
|
|
self.warningString:SetText("No items found")
|
|
end
|
|
if #SortedFrameSearchBox:GetText() > 0 then
|
|
self.warningString:SetText(self.warningString:GetText().." containing\n\"".._G["SortedFrameSearchBox"]:GetText().."\"")
|
|
end
|
|
else
|
|
self.warningString:SetText("")
|
|
end]]
|
|
if type=="BANK" and not Sorted_GetBankCached() then
|
|
if S.IsCurrentPlayerSelected() then
|
|
self.warningString:SetText(Sorted.Localize("WARNING_BANK_NOT_CACHED"))
|
|
else
|
|
self.warningString:SetText(Sorted.Localize("WARNING_BANK_NOT_CACHED_OTHER", Sorted_Data[Sorted_SelectedPlayerGUID].name))
|
|
end
|
|
elseif type=="REAGENT" and not Sorted_GetReagentUnlocked() then
|
|
if not S.IsCurrentPlayerSelected() then
|
|
self.warningString:SetText(Sorted.Localize("WARNING_REAGENTBANK_NOT_PURCHASED_OTHER", Sorted_Data[Sorted_SelectedPlayerGUID].name))
|
|
self.PurchaseButton:Hide()
|
|
self.CostMoneyFrame:Hide()
|
|
else
|
|
if not Sorted_bankIsOpened then
|
|
self.warningString:SetText(Sorted.Localize("WARNING_REAGENTBANK_NOT_PURCHASED"))
|
|
self.PurchaseButton:Hide()
|
|
self.CostMoneyFrame:Hide()
|
|
else
|
|
self.warningString:SetText(Sorted.Localize("WARNING_REAGENTBANK_PURCHASE"))
|
|
self.PurchaseButton:Show()
|
|
self.CostMoneyFrame:Show()
|
|
end
|
|
end
|
|
elseif count == 0 then
|
|
self.warningString:SetText(Sorted.Localize("WARNING_NO_ITEMS_FOUND"))
|
|
else
|
|
self.warningString:SetText("")
|
|
end
|
|
end
|
|
end
|
|
|
|
function SortedItemList_OnLoad(self)
|
|
self:OnLoad()
|
|
local type = self:GetParent().type
|
|
if type == "REAGENT" and Sorted_IsClassic() then
|
|
return
|
|
end
|
|
self.type = type
|
|
self.scrollBar = CreateFrame("Slider", self:GetName().."ScrollBar", self, "UIPanelScrollBarTrimTemplate")
|
|
if type == "BANK" or type == "REAGENT" then
|
|
self.scrollBar:SetPoint("TOPRIGHT", -3, -17)
|
|
self.scrollBar:SetPoint("BOTTOM", 0, 13)
|
|
elseif string.sub(type, 1, 9) == "CONTAINER" or type == "KEYRING" then
|
|
self.scrollBar:SetPoint("TOPRIGHT", -1, -17)
|
|
self.scrollBar:SetPoint("BOTTOM", 0, 15)
|
|
else
|
|
self.scrollBar:SetPoint("TOPRIGHT", 0, 8)
|
|
self.scrollBar:SetPoint("BOTTOM", 0, 13)
|
|
end
|
|
self.scrollBar:SetMinMaxValues(1, 1000)
|
|
self.scrollBar:SetValueStep(1)
|
|
self.scrollBar.scrollStep = 32
|
|
self.scrollBar:SetValue(0)
|
|
local bg = self.scrollBar:CreateTexture(self:GetName().."ScrollBarBG", "BACKGROUND")
|
|
bg:SetVertTile(true) bg:SetHorizTile(true)
|
|
bg:SetAllPoints()
|
|
bg:SetTexture("Interface\\Addons\\Sorted\\Textures\\UI-Background")
|
|
|
|
self.scrollChild = CreateFrame("Frame", self:GetName().."ScrollChild", self)
|
|
self.scrollChild:SetPoint("RIGHT", self.scrollBar, "LEFT", 0, 0)
|
|
self.scrollChild:SetWidth(800)
|
|
self:SetScrollChild(self.scrollChild)
|
|
|
|
self.groupHeaders = {}
|
|
for i = 0, S.MAX_GROUPS do
|
|
local groupHeader = CreateFrame("Button", self.scrollChild:GetName().."GroupHeader"..i, self.scrollChild)
|
|
groupHeader:SetHighlightTexture("Interface\\Addons\\Sorted\\Textures\\UI-Highlight")
|
|
groupHeader:GetHighlightTexture():SetTexCoord(0.5, 1, 0.3, 0.7)
|
|
groupHeader:GetHighlightTexture():SetVertexColor(1, 0.93, 0.9)
|
|
groupHeader:SetPushedTexture("Interface\\Addons\\Sorted\\Textures\\UI-Highlight")
|
|
groupHeader:GetPushedTexture():SetTexCoord(0.5, 1, 0.3, 0.7)
|
|
groupHeader:GetPushedTexture():SetVertexColor(1, 0.93, 0.9)
|
|
groupHeader:GetPushedTexture():SetBlendMode("ADD")
|
|
groupHeader:SetID(i)
|
|
groupHeader.collapseButton = CreateFrame("Button", groupHeader:GetName().."CollapseButton", groupHeader)
|
|
groupHeader.collapseButton:SetNormalTexture("Interface\\Buttons\\UI-MinusButton-Up")
|
|
groupHeader.collapseButton:SetPushedTexture("Interface\\Buttons\\UI-MinusButton-Down")
|
|
groupHeader.collapseButton:SetHighlightTexture("Interface\\Buttons\\UI-PlusButton-Hilight")
|
|
groupHeader.collapseButton:SetPoint("LEFT", 4, 0)
|
|
groupHeader.collapseButton:SetSize(20,20)
|
|
groupHeader.collapseButton:SetFrameLevel(groupHeader:GetFrameLevel() + 1)
|
|
groupHeader.expandButton = CreateFrame("Button", groupHeader:GetName().."ExpandButton", groupHeader)
|
|
groupHeader.expandButton:SetNormalTexture("Interface\\Buttons\\UI-PlusButton-Up")
|
|
groupHeader.expandButton:SetPushedTexture("Interface\\Buttons\\UI-PlusButton-Down")
|
|
groupHeader.expandButton:SetHighlightTexture("Interface\\Buttons\\UI-PlusButton-Hilight")
|
|
groupHeader.expandButton:SetPoint("LEFT", 4, 0)
|
|
groupHeader.expandButton:SetSize(20,20)
|
|
groupHeader.expandButton:Hide()
|
|
groupHeader.expandButton:SetFrameLevel(groupHeader:GetFrameLevel() + 1)
|
|
|
|
groupHeader.collapseButton:SetScript("OnEnter", function(self) groupHeader:LockHighlight() end)
|
|
groupHeader.collapseButton:SetScript("OnLeave", function(self) groupHeader:UnlockHighlight() end)
|
|
groupHeader.collapseButton:SetScript("OnMouseDown", function(self) if button == "LeftButton" then groupHeader:SetButtonState("PUSHED") end end)
|
|
groupHeader.collapseButton:SetScript("OnMouseUp", function(self) groupHeader:SetButtonState("NORMAL") end)
|
|
groupHeader.collapseButton:SetScript("OnClick", function(self) groupHeader:Click() end)
|
|
groupHeader.expandButton:SetScript("OnEnter", function(self) groupHeader:LockHighlight() end)
|
|
groupHeader.expandButton:SetScript("OnLeave", function(self) groupHeader:UnlockHighlight() end)
|
|
groupHeader.expandButton:SetScript("OnMouseDown", function(self) if button == "LeftButton" then groupHeader:SetButtonState("PUSHED") end end)
|
|
groupHeader.expandButton:SetScript("OnMouseUp", function(self) groupHeader:SetButtonState("NORMAL") end)
|
|
groupHeader.expandButton:SetScript("OnClick", function(self) groupHeader:Click() end)
|
|
|
|
groupHeader:SetScript("OnEnter", function(self)
|
|
groupHeader.collapseButton:LockHighlight()
|
|
groupHeader.expandButton:LockHighlight()
|
|
end)
|
|
groupHeader:SetScript("OnLeave", function(self)
|
|
groupHeader.collapseButton:UnlockHighlight()
|
|
groupHeader.expandButton:UnlockHighlight()
|
|
end)
|
|
groupHeader:SetScript("OnMouseDown", function(self, button)
|
|
if button == "LeftButton" then
|
|
groupHeader.collapseButton:SetButtonState("PUSHED")
|
|
groupHeader.expandButton:SetButtonState("PUSHED")
|
|
end
|
|
end)
|
|
groupHeader:SetScript("OnMouseUp", function(self)
|
|
groupHeader.collapseButton:SetButtonState("NORMAL")
|
|
groupHeader.expandButton:SetButtonState("NORMAL")
|
|
end)
|
|
groupHeader:SetScript("OnClick", function(self, button)
|
|
if S.collapsedGroups[self:GetID()] then
|
|
S.collapsedGroups[self:GetID()] = nil
|
|
else
|
|
S.collapsedGroups[self:GetID()] = true
|
|
end
|
|
Sorted_SortItems(true)
|
|
end)
|
|
|
|
groupHeader:SetHeight(20)
|
|
groupHeader:SetPoint("RIGHT")
|
|
groupHeader.text = groupHeader:CreateFontString()
|
|
groupHeader.text:SetFontObject(Sorted11Font)
|
|
groupHeader.text:SetPoint("LEFT", 26, 0)
|
|
groupHeader.text:SetDrawLayer("OVERLAY", 2)
|
|
groupHeader.bg = groupHeader:CreateTexture()
|
|
groupHeader.bg:SetTexture("Interface\\Addons\\Sorted\\Textures\\Shadow")
|
|
groupHeader.bg:SetPoint("TOPLEFT", 0, 12)
|
|
groupHeader.bg:SetPoint("BOTTOMRIGHT", groupHeader.text, "BOTTOMRIGHT", 16, -16)
|
|
groupHeader.bg:SetDrawLayer("OVERLAY", 1)
|
|
|
|
self.groupHeaders[i] = groupHeader
|
|
end
|
|
|
|
self.itemButtons = {}
|
|
local index = 1
|
|
local containers
|
|
local maxSlots = 36
|
|
if type == "REAGENT" then
|
|
maxSlots = 98
|
|
end
|
|
if type == "BAGS" or type == "BANK" or type == "REAGENT" or type == "KEYRING" then
|
|
containers = Sorted_ContainersOfType(type)
|
|
if type == "KEYRING" then
|
|
self.container = KEYRING_CONTAINER
|
|
end
|
|
elseif string.sub(type, 1, 9) == "CONTAINER" then
|
|
self.container = tonumber(string.sub(type, 10))
|
|
containers = { self.container }
|
|
end
|
|
for _, bag in pairs(containers) do
|
|
for slot = 1, maxSlots do
|
|
self.itemButtons[index] = Sorted_CreateItemButton(self.scrollChild, bag, slot)
|
|
self.itemButtons[index].bag = bag
|
|
self.itemButtons[index].slot = slot
|
|
if type=="BANK" or type=="REAGENT" then
|
|
self.itemButtons[index].isBankSlot = true
|
|
end
|
|
|
|
self.itemButtons[index].button:HookScript("OnEnter", function(self)
|
|
if not Sorted_GetFavorited(self:GetParent():GetData()) then
|
|
self:GetParent().favoriteButton:GetNormalTexture():SetTexCoord(0, 0.21875, 0.21875 * 2, 0.21875 * 3)
|
|
end
|
|
end)
|
|
|
|
self.itemButtons[index].button:HookScript("OnLeave", function(self)
|
|
if not Sorted_GetFavorited(self:GetParent():GetData()) then
|
|
self:GetParent().favoriteButton:GetNormalTexture():SetTexCoord(1, 1, 1, 1)
|
|
end
|
|
end)
|
|
|
|
--[[self.itemButtons[index].button:SetScript("OnClick", function(self, button)
|
|
if IsModifiedClick() then
|
|
SortedItemButton_OnModifiedClick(self, button)
|
|
else
|
|
ContainerFrameItemButton_OnClick(self, button)
|
|
end
|
|
end)]]
|
|
--Sorted_Slots[index].button:SetScript("OnReceiveDrag", function(self) SortedItemButton_OnClick(self, "LeftButton") end)
|
|
|
|
self.itemButtons[index].favoriteButton:HookScript("OnEnter", function(self)
|
|
self:GetParent().mouseOver = true
|
|
end)
|
|
self.itemButtons[index].favoriteButton:HookScript("OnLeave", function(self)
|
|
self:GetParent().button.highlight:Hide()
|
|
self:GetParent().mouseOver = false
|
|
end)
|
|
|
|
self.itemButtons[index].favoriteButton:HookScript("OnClick", function(self, mouseButton)
|
|
if SortedIconSelectionMenu:IsShown() then
|
|
SortedIconSelectionMenu:Hide()
|
|
return
|
|
end
|
|
if mouseButton == "LeftButton" then
|
|
Sorted_ToggleFavorite(self:GetParent():GetData())
|
|
Sorted_UpdateItemButtons()
|
|
Sorted_FilterItems()
|
|
elseif mouseButton == "RightButton" then
|
|
SortedIconSelectionMenu.itemButton = self:GetParent()
|
|
local x,y = GetCursorPosition()
|
|
x,y = x/UIParent:GetEffectiveScale(), y/UIParent:GetEffectiveScale()
|
|
SortedIconSelectionMenu:SetPoint("LEFT", UIParent, "BOTTOMLEFT", x * (1 / SortedIconSelectionMenu:GetScale()) + 8, y * (1 / SortedIconSelectionMenu:GetScale()))
|
|
SortedIconSelectionMenu:Show()
|
|
end
|
|
end)
|
|
|
|
index = index + 1
|
|
end
|
|
end
|
|
|
|
self.scrollChild:EnableMouse("LeftButton")
|
|
self.scrollChild:SetScript("OnReceiveDrag", SortedItemList_OnClick)
|
|
|
|
self.itemDropButton = CreateFrame("Button", self:GetName().."ItemDropButton", self)
|
|
self.itemDropButton:SetFrameLevel(self:GetFrameLevel() + 2)
|
|
self.itemDropButton:SetNormalTexture("Interface\\Addons\\Sorted\\Textures\\UI-ItemDrop-Slot")
|
|
self.itemDropButton:SetHighlightTexture("Interface\\Addons\\Sorted\\Textures\\UI-ItemDrop-Slot-Highlight")
|
|
self.itemDropButton.type = type
|
|
if string.sub(type, 1, 9) == "CONTAINER" then
|
|
self.itemDropButton:SetPoint("BOTTOMRIGHT", -21, 0)
|
|
self.itemDropButton:SetSize(112, 54)
|
|
self.itemDropButton:GetNormalTexture():SetTexCoord(0, 1, 0, 0.96875)
|
|
self.itemDropButton:GetHighlightTexture():SetTexCoord(0, 1, 0, 0.96875)
|
|
else
|
|
self.itemDropButton:SetPoint("BOTTOMRIGHT", -21, -3)
|
|
self.itemDropButton:SetSize(112, 56)
|
|
end
|
|
self.itemDropButton:GetHighlightTexture():SetAlpha(0.7)
|
|
self.itemDropButton:SetScript("OnMouseDown", function(self) Sorted_PutItemInBags(self.type) end)
|
|
self.itemDropButton:SetScript("OnReceiveDrag", function(self) Sorted_PutItemInBags(self.type) end)
|
|
self.itemDropButton:SetScript("OnEnter", function(self)
|
|
if GetCursorInfo() == "item" then
|
|
SortedTooltip.Schedule(function()
|
|
GameTooltip:SetOwner(self, "ANCHOR_TOPRIGHT")
|
|
GameTooltip:ClearLines()
|
|
if self.type == "REAGENT" then
|
|
GameTooltip:AddLine("Place item in your reagent bank")
|
|
elseif string.sub(self.type, 1, 9) == "CONTAINER" then
|
|
GameTooltip:AddLine("Place item in this bag")
|
|
else
|
|
GameTooltip:AddLine("Place item in your "..self.type:lower())
|
|
end
|
|
GameTooltip:Show()
|
|
end)
|
|
end
|
|
end)
|
|
self.itemDropButton:SetScript("OnLeave", SortedTooltip.Cancel)
|
|
|
|
--[[local texL = self.itemDropButton:CreateTexture(self.itemDropButton:GetName().."TexL", "BACKGROUND")
|
|
texL:SetPoint("TOPLEFT")
|
|
texL:SetPoint("BOTTOMRIGHT", self.itemDropButton, "BOTTOMLEFT", 64, 0)
|
|
texL:SetTexture("Interface\\Addons\\Sorted\\Textures\\UI-ItemDrop-Button-Mult")
|
|
texL:SetTexCoord(0, 0.25, 0, 1)
|
|
texL:SetBlendMode("MOD")
|
|
local texR = self.itemDropButton:CreateTexture(self.itemDropButton:GetName().."TexR", "BACKGROUND")
|
|
texR:SetPoint("TOPRIGHT")
|
|
texR:SetPoint("BOTTOMLEFT", self.itemDropButton, "BOTTOMRIGHT", -160, 0)
|
|
texR:SetTexture("Interface\\Addons\\Sorted\\Textures\\UI-ItemDrop-Button-Mult")
|
|
texR:SetTexCoord(0.375, 1, 0, 1)
|
|
texR:SetBlendMode("MOD")
|
|
local texC = self.itemDropButton:CreateTexture(self.itemDropButton:GetName().."TexC", "BACKGROUND")
|
|
texC:SetPoint("TOPRIGHT", texR, "TOPLEFT")
|
|
texC:SetPoint("BOTTOMLEFT", texL, "BOTTOMRIGHT")
|
|
texC:SetTexture("Interface\\Addons\\Sorted\\Textures\\UI-ItemDrop-Button-Mult", "BACKGROUND")
|
|
texC:SetTexCoord(0.25, 0.375, 0, 1)
|
|
texC:SetBlendMode("MOD")]]
|
|
|
|
|
|
self.foregroundFrame = CreateFrame("Frame", self:GetName().."ForegroundFrame", self.scrollChild)
|
|
self.foregroundFrame:SetAllPoints()
|
|
if type=="REAGENT" then
|
|
self.PurchaseButton:SetParent(self.foregroundFrame)
|
|
self.CostMoneyFrame:SetParent(self.foregroundFrame)
|
|
end
|
|
self.warningString:SetParent(self.foregroundFrame)
|
|
|
|
|
|
-- Create column separator lines, starting from the left
|
|
local posX = 0
|
|
local indexReached = 0
|
|
for i, v in ipairs(Sorted_sortButtons) do
|
|
if not v.dontDrawColumnSeparators then
|
|
local columnSeparator = self.foregroundFrame:CreateTexture(self:GetName().."TexColSep"..i, "OVERLAY")
|
|
columnSeparator:SetPoint("TOP")
|
|
columnSeparator:SetPoint("BOTTOM")
|
|
columnSeparator:SetTexture("Interface\\Addons\\Sorted\\Textures\\UI-Column-Seperator")
|
|
columnSeparator:SetTexCoord(0, 0.9375, 0.1, 0.1)
|
|
columnSeparator:SetWidth(3.5)
|
|
columnSeparator.relScrollBar = self.scrollBar
|
|
if not v.columnSeparators then v.columnSeparators = {} end
|
|
table.insert(v.columnSeparators, columnSeparator)
|
|
end
|
|
end
|
|
|
|
if type == "BAGS" then
|
|
self.ShouldUpdate = function(self)
|
|
return true
|
|
end
|
|
elseif type == "BANK" then
|
|
self.ShouldUpdate = function(self)
|
|
return SortedBankSidePanel:IsShown()
|
|
end
|
|
elseif type == "REAGENT" then
|
|
self.ShouldUpdate = function(self)
|
|
return SortedReagentSidePanel:IsShown()
|
|
end
|
|
else
|
|
self.ShouldUpdate = function(self)
|
|
return _G["SortedBag"..self.container.."Frame"]:IsShown()
|
|
end
|
|
end
|
|
|
|
self:HookScript("OnUpdate", SortedItemList_OnUpdate)
|
|
|
|
table.insert(Sorted_itemLists, self)
|
|
end
|
|
|