vanilla-wow-addons – Rev 1
?pathlinks?
local L = AceLibrary("AceLocale-2.0"):new("FuBar_GarbageFu")
local Tablet = AceLibrary("Tablet-2.0");
local dewdrop = AceLibrary("Dewdrop-2.0");
local compost = AceLibrary("Compost-2.0");
local abacus = AceLibrary("Abacus-2.0");
local PeriodicTable = PeriodicTableEmbed:GetInstance("1");
GarbageFu = AceLibrary("AceAddon-2.0"):new("FuBarPlugin-2.0", "AceEvent-2.0", "AceConsole-2.0", "AceDB-2.0", "AceDebug-2.0");
GarbageFu.version = "1.0." .. string.sub("$Revision: 10349 $", 12, -3);
GarbageFu.date = string.sub("$Date: 2006-09-06 11:24:19 -0700 (Wed, 06 Sep 2006) $", 8, 17);
GarbageFu.hasIcon = true;
GarbageFu.clickableTooltip = true;
GarbageFu.overrideMenu = true;
GarbageFu.printFrame = DEFAULT_CHAT_FRAME;
GarbageFu.debugFrame = DEFAULT_CHAT_FRAME;
GarbageFu:RegisterDB("GarbageFuDB");
GarbageFu:RegisterDefaults("profile", {
moneyformat = 1,
namelength = 32,
ignoreammobag = true,
ignoreherbbag = false,
ignoresoulbag = false,
ignoreenchbag = false,
sellallbutton = true,
sellonlygrey = true,
pricetype = false,
garbageprices = false,
itemicon = false,
version = "",
textcolor = { r=0.2, g=0.8, b=1 };
threshold = 0,
dropsets = {},
dropitem = {},
keepsets = {},
keepitem = {},
});
GarbageFu:RegisterDefaults("account", {
overrideprices = {};
});
------------------------------------------------------------------------------------------------------
-- Simple Property functions
------------------------------------------------------------------------------------------------------
function GarbageFu:IsAutodrop()
return self.db.profile.autodrop;
end
function GarbageFu:ToggleAutodrop()
self.db.profile.autodrop = not self.db.profile.autodrop;
end
function GarbageFu:GetDropThreshold()
return self.db.profile.threshold;
end
function GarbageFu:IsDropThreshold(value)
return self.db.profile.threshold == tonumber(value);
end
function GarbageFu:SetDropThreshold(value)
self.db.profile.threshold = tonumber(value);
self:UpdateDisplay();
end
function GarbageFu:GetMoneyFormat(value)
return self.db.profile.moneyformat;
end
function GarbageFu:SetMoneyFormat(value)
self.db.profile.moneyformat = tonumber(value);
self:UpdateDisplay();
end
function GarbageFu:GetNameLength(value)
return self.db.profile.namelength;
end
function GarbageFu.SetNameLength(self,value)
self.db.profile.namelength = value;
self:UpdateText();
end
function GarbageFu:IsIgnoringAmmoBag()
return self.db.profile.ignoreammobag;
end
function GarbageFu:ToggleIgnoreAmmoBag()
self.db.profile.ignoreammobag = not self.db.profile.ignoreammobag;
self:InitBagScan();
end
function GarbageFu:IsIgnoringHerbBag()
return self.db.profile.ignoreherbbag;
end
function GarbageFu:ToggleIgnoreHerbBag()
self.db.profile.ignoreherbbag = not self.db.profile.ignoreherbbag;
self:InitBagScan();
end
function GarbageFu:IsIgnoringSoulBag()
return self.db.profile.ignoresoulbag;
end
function GarbageFu:ToggleIgnoreSoulBag()
self.db.profile.ignoresoulbag = not self.db.profile.ignoresoulbag;
self:InitBagScan();
end
function GarbageFu:IsIgnoringEnchBag()
return self.db.profile.ignoreenchbag;
end
function GarbageFu:ToggleIgnoreEnchBag()
self.db.profile.ignoreenchbag = not self.db.profile.ignoreenchbag;
self:InitBagScan();
end
function GarbageFu:IsSafeToDelete()
return self.vars.safedelete;
end
function GarbageFu:SetSafeToDelete(value)
self.vars.safedelete = value;
end
function GarbageFu:IsSellAllButton()
return self.db.profile.sellallbutton;
end
function GarbageFu:ToggleSellAllButton()
self.db.profile.sellallbutton = not self.db.profile.sellallbutton;
if self.db.profile.sellallbutton then
MerchantFrame.sellAllButton:Show();
else
MerchantFrame.sellAllButton:Hide();
end
end
function GarbageFu:IsItemIcon()
return self.db.profile.itemicon;
end
function GarbageFu:ToggleItemIcon()
self.db.profile.itemicon = not self.db.profile.itemicon;
self:UpdateText();
end
function GarbageFu:IsPriceType()
return self.db.profile.pricetype;
end
function GarbageFu:TogglePriceType()
self.db.profile.pricetype = not self.db.profile.pricetype;
self:UpdateTooltip();
end
function GarbageFu:IsSellOnlyGrey()
return self.db.profile.sellonlygrey;
end
function GarbageFu:ToggleSellOnlyGrey()
self.db.profile.sellonlygrey = not self.db.profile.sellonlygrey;
end
function GarbageFu:IsUsingGarbagePrices()
return self.db.profile.garbageprices;
end
function GarbageFu:ToggleUseGarbagePrices()
self.db.profile.garbageprices = not self.db.profile.garbageprices;
if ( self.db.profile.garbageprices ) then
self.db.profile.garbageprices = self:LoadGarbagePrices();
else
self.vars.vendorprices = nil;
self.vars.pricecache = self:Table(self.vars.pricecache);
end
self:InitBagScan();
end
------------------------------------------------------------------------------------------------------
-- A little more complicate property functions
------------------------------------------------------------------------------------------------------
function GarbageFu:IsDropItem(itemid)
if (self.db.profile.dropitem[itemid]) then return true end
end
function GarbageFu:ToggleDropItem(itemid)
if (self.db.profile.dropitem[itemid]) then
self.db.profile.dropitem[itemid] = nil;
else
self.db.profile.dropitem[itemid] = true;
self.db.profile.keepitem[itemid] = nil;
end
self:UpdateDisplay();
end
function GarbageFu:IsKeepItem(itemid)
if (self.db.profile.keepitem[itemid]) then return true end
end
function GarbageFu:ToggleKeepItem(itemid)
if (self.db.profile.keepitem[itemid]) then
self.db.profile.keepitem[itemid] = nil;
else
self.db.profile.keepitem[itemid] = true;
self.db.profile.dropitem[itemid] = nil;
end
self:UpdateDisplay();
end
------------------------------------------------------------------------------------------------------
-- Constant data
------------------------------------------------------------------------------------------------------
GarbageFu.vars = {};
GarbageFu.vars.moneyformats = {
{ name=L["Condensed"], ex=abacus:FormatMoneyCondensed(123456,true,true) },
{ name=L["Short"], ex=abacus:FormatMoneyShort(123456,true,true) },
{ name=L["Full"], ex=abacus:FormatMoneyFull(123456,true,true) },
{ name=L["Extended"], ex=abacus:FormatMoneyExtended(123456,true,true) },
}
GarbageFu.vars.sets = {
{id="foodall", name=L["Food"], order=1, sub = {
{id="food", name=L["Normal Food"], order=1 },
{id="foodbonus", name=L["Bonus Food"], order=2 },
{id="foodstat", name=L["Stat Food"], order=3 },
{id="foodbreadconjured", name=L["Conjured Bread"], order=4 },
{id="foodraw", name=L["Raw Food"], order=5 },
{id="foodclassbread", name=L["Bread"], order=6 },
{id="foodclassfish", name=L["Fish"], order=7 },
{id="foodclassmeat", name=L["Meat"], order=8 },
{id="foodclasscheese", name=L["Cheese"], order=9 },
{id="foodclassfruit", name=L["Fruit"], order=10 },
{id="foodclassfungus", name=L["Fungus"], order=11 },
}, },
{id="waterall", name=L["Water"], order=2, sub = {
{id="water", name=L["Normal Water"], order=1 },
{id="waterperc", name=L["Percent Water"], order=2 },
{id="waterconjured", name=L["Conjured Water"], order=3 },
}, },
{id="booze", name=L["Booze"], order=3 },
{id="tradeskills", name=L["Tradeskill"], order=4, sub = {
{id="tradeskillalchemy", name=L["Alchemy"], order=1 },
{id="tradeskillblacksmithing", name=L["Blacksmithing"], order=2 },
{id="tradeskillcooking", name=L["Cooking"], order=3 },
{id="tradeskillenchanting", name=L["Enchanting"], order=4 },
{id="tradeskillengineering", name=L["Engineering"], order=5 },
{id="tradeskillfirstaid", name=L["First Aid"], order=6 },
{id="tradeskillleatherworking", name=L["Leatherworking"], order=7 },
{id="tradeskilltailoring", name=L["Tailoring"], order=8 },
{id="tradeskillpoison", name=L["Poison"], order=9 },
{id="tradeskillsmelting", name=L["Smelting"], order=10 },
}, },
{id="tradeskilltools", name=L["Tradeskill Tools"], order=5 },
{id="gatherskill", name=L["Gathered"], order=6, sub = {
{id="gatherskillfishing", name=L["Fishing"], order=1 },
{id="gatherskilldisenchant", name=L["Disenchant"], order=2 },
{id="gatherskillherbalism", name=L["Herbalism"], order=3 },
{id="gatherskillmining", name=L["Mining"], order=4 },
{id="gatherskillskinning", name=L["Skinning"], order=5 },
}, },
{id="ammo", name=L["Ammunition"], order=7 },
{id="bandages", name=L["Bandages"], order=8 },
{id="explosives", name=L["Explosives"], order=9 },
{id="faire", name=L["Darkmoon Fair"], order=10 },
{id="fireworks", name=L["Fireworks"], order=11 },
{id="poisons", name=L["Poisons"], order=12 },
{id="potionall", name=L["Potions"], order=13, sub = {
{id="potionhealall", name=L["Heal Potions"], order=1 },
{id="potionmanaall", name=L["Mana Potions"], order=2 },
{id="potionrage", name=L["Rage Potions"], order=3 },
{id="potioncure", name=L["Cure Potions"], order=4 },
{id="potionbuff", name=L["Buff Potions"], order=5 },
}, },
{id="scrolls", name=L["Scrolls"], order=14 },
{id="reagent", name=L["Reagents"], order=15, sub = {
{id="reagentpaladin", name=L["Paladin"], order=1 },
{id="reagentdruid", name=L["Druid"], order=2 },
{id="reagentmage", name=L["Mage"], order=3 },
{id="reagentpriest", name=L["Priest"], order=4 },
{id="reagentrogue", name=L["Rogue"], order=5 },
{id="reagentshaman", name=L["Shaman"], order=6 },
{id="reagentwarlock", name=L["Warlock"], order=7 },
}, },
{id="weapontempenchants", name=L["Weapon Enchants"], order=16 },
{id="mounts", name=L["Mounts"], order=17 },
{id="minipetall", name=L["Mini Pets"], order=18 },
}
------------------------------------------------------------------------------------------------------
-- FuBar required functions
------------------------------------------------------------------------------------------------------
function GarbageFu:OnInitialize()
-- Put stuff that only neeeds to be done once here
self.vars.bags = self:Table();
self.vars.items = self:Table();
self.vars.colors = self:Table();
self.vars.pricecache = self:Table();
-- Get Item quality colors
for i=0,6 do
self.vars.colors[i] = self:Table();
self.vars.colors[i].r, self.vars.colors[i].g, self.vars.colors[i].b, self.vars.colors[i].hex = GetItemQualityColor(i);
self.vars.colors[i].desc = getglobal("ITEM_QUALITY".. i.. "_DESC");
end
-- Create Static dialog for Reset Settings
StaticPopupDialogs["GARBAGEFU_RESET"] = {
text = L["Are you sure you want to reset all your settings for GarbageFU?"],
button1 = TEXT(ACCEPT),
button2 = TEXT(CANCEL),
OnAccept = function() GarbageFu.SettingsReset(self) end,
timeout = 0,
whileDead = 1,
hideOnEscape = 1
};
-- Sort Sets tables
for i,s in self.vars.sets do
if s.sub then table.sort(s.sub,function(a,b) return a.order<b.order end) end
end
table.sort(self.vars.sets,function(a,b) return a.order<b.order end)
-- Create the SellAllButton
self:MakeSellAllButton()
if self:IsUsingGarbagePrices() then
self:LoadGarbagePrices();
end
-- Store AddOn version. In case we need to check it in the future for upgrades.
self.db.profile.version = self.version;
end
function GarbageFu:OnEnable()
-- Stuff that needs to be done every time the mod is enabled
self:SetSafeToDelete(false);
if self:IsSellAllButton() then
MerchantFrame.sellAllButton:Show();
end
self:InitBagScan();
self:MakeSetsTables();
self:OnEnteringWorld();
self:SetSafeToDelete(true);
end
function GarbageFu:OnDisable()
self:SetSafeToDelete(false);
MerchantFrame.sellAllButton:Hide();
end
function GarbageFu:OnDataUpdate()
end
function GarbageFu:OnTextUpdate()
self:DebugPrint("OnTextUpdate");
local item = self:GetFirstDroppableItem();
if item then
local text = "";
if ( string.len(item.name) > self:GetNameLength() ) then
text = self.vars.colors[item.qual].hex..string.sub(item.name, 1, self:GetNameLength()-2).."..".."|r";
else
text = self.vars.colors[item.qual].hex..item.name.."|r";
end
if ( item.maxstack > 1 ) then
text = text.." |cffffff00x"..tostring(item.stack).."|r";
end
text = text.." "..self:GetMoneyString(item.totvalue);
self:SetText(text);
if self:IsItemIcon() then self:SetIcon(item.tex) else self:SetIcon(true) end
else
self:SetText("GarbageFu");
self:SetIcon(true);
end
if self:IsThereItemsToSell() then
MerchantFrame.sellAllButton:Enable();
else
MerchantFrame.sellAllButton:Disable();
end
end
function GarbageFu:OnTooltipUpdate()
self:DebugPrint("OnTooltipUpdate");
local cat;
if self:IsPriceType() then
cat = Tablet:AddCategory('columns', 3)
else
cat = Tablet:AddCategory('columns', 2)
end
for i,item in self.vars.items do
if self:IsItemDroppable(item) then
local stacktext = "|r";
if ( item.maxstack > 1 ) then
stacktext = stacktext .. "|r |cffffff00("..tostring(item.stack).."/"..tostring(item.maxstack)..")|r";
end
local moneytext = self:GetMoneyString(item.totvalue)
cat:AddLine(
'text', self.vars.colors[item.qual].hex..item.name..stacktext,
'text2', moneytext,
'text3', item.pricetype,
'hasCheck', true, 'checked', true, 'checkIcon', item.tex,
'func', 'OnClickItem', 'arg1', self, 'arg2', item
)
end
end
if MerchantFrame:IsVisible() then
Tablet:SetHint(L["Shift-Click to sell item\nControl-Click to add item to keep list"]);
else
Tablet:SetHint(L["Shift-Click to drop item\nControl-Click to add item to keep list"]);
end
end
function GarbageFu:OnMenuRequest(level, value, inTooltip, value2)
if value then
if value2 then
self:DebugPrint("OnMenuRequest level="..level.." value="..value.." value2="..value2);
else
self:DebugPrint("OnMenuRequest level="..level.." value="..value);
end
else
self:DebugPrint("OnMenuRequest level="..level);
end
if ( level == 1 ) then
local item = self:GetFirstDroppableItem();
if item then
local text = self.vars.colors[item.qual].hex..item.name.."|r";
if ( item.maxstack > 1 ) then
text = text.." |cffffff00x"..tostring(item.stack).."|r";
end
dewdrop:AddLine('text', text..' '..self:GetMoneyString(item.totvalue),
'notClickable', true, 'checked', true, 'checkIcon', item.tex );
local text = MerchantFrame:IsVisible() and L["Sell this item"] or L["Drop this item"];
dewdrop:AddLine('text', text, 'arg1', self, 'func', 'DropFirstItem', 'tooltipTitle', text,
'tooltipText', L["Drops this item, or sells it if the vendor window is open"] );
if ( item.qual > 0 ) then
dewdrop:AddLine('text', L["Keep this item"], 'arg1', self, 'func', 'KeepFirstItem',
'tooltipTitle', L["Keep this item"], 'tooltipText', L["Adds this item to the keep items list"]);
end
if MerchantFrame:IsVisible() and self:IsThereItemsToSell() then
local sellValue = self:GetSellValue();
GameTooltip:AddLine(L["Value:"].." "..self:GetMoneyString(sellValue));
if self:IsSellOnlyGrey() then
dewdrop:AddLine('text', L["Sell all grey items"].." "..self:GetMoneyString(sellValue),
'arg1', self, 'func', 'SellAllItems',
'tooltipTitle', L["Sell all grey items"], 'tooltipText', L["SellsAll TooltipText2"],
'closeWhenClicked', true );
else
dewdrop:AddLine('text', L["Sell all garbage items"].." "..self:GetMoneyString(sellValue),
'arg1', self, 'func', 'SellAllItems',
'tooltipTitle', L["Sell all garbage items"], 'tooltipText', L["SellsAll TooltipText1"],
'closeWhenClicked', true );
end
end
if ( item.qual > 0 or item.totvalue == 0 or self.db.account.overrideprices[item.id]) then
dewdrop:AddLine('text', L["Edit value for this item"], 'hasArrow', true,
'hasEditBox', true, 'editBoxText', tostring(item.value),
'editBoxArg1', self, 'editBoxFunc', GarbageFu.SetFirstItemValue,
'editBoxChangeArg1', self, 'editBoxChangeFunc', GarbageFu.ValidateValue,
'tooltipTitle', L["Edit value for this item"], 'tooltipText', L["Value TooltipText"] );
end
dewdrop:AddLine();
end
dewdrop:AddLine('text', L["Drop"], 'hasArrow', true, 'value', 'drop' );
dewdrop:AddLine('text', L["Keep"], 'hasArrow', true, 'value', 'keep' );
dewdrop:AddLine('text', L["Edit item values"], 'hasArrow', true, 'value', 'itemvalue' );
dewdrop:AddLine();
dewdrop:AddLine('text', L["Options"], 'hasArrow', true, 'value', 'options' );
elseif ( level == 2 ) then
if ( value == 'drop' ) then
dewdrop:AddLine('text', L["Drop"], "isTitle", true );
dewdrop:AddLine('text', L["Drop Sets"], 'hasArrow', true, 'value', 'dropsets' );
dewdrop:AddLine('text', L["Drop Items"], 'hasArrow', true, 'value', 'dropitem' );
elseif ( value == 'keep' ) then
dewdrop:AddLine('text', L["Keep"], "isTitle", true );
dewdrop:AddLine('text', L["Keep Sets"], 'hasArrow', true, 'value', 'keepsets' );
dewdrop:AddLine('text', L["Keep Items"], 'hasArrow', true, 'value', 'keepitem' );
elseif ( value == 'itemvalue' ) then
-- Edit item values
dewdrop:AddLine('text', L["Edit item values"], "isTitle", true );
local tbl = self:GetCustomItemValueTable();
for _,i in tbl do
dewdrop:AddLine('text', self.vars.colors[i.qual].hex .. i.name,
'checked', self.db.account.overrideprices[i.id] ~= nil, 'hasArrow', true, 'hasEditBox', true,
'editBoxText', tostring(i.value),
'editBoxArg1', self, 'editBoxArg2', i.id, 'editBoxFunc', GarbageFu.SetItemValue,
'editBoxChangeArg1', self, 'editBoxChangeFunc', GarbageFu.ValidateValue,
'tooltipTitle', L["Edit value for this item"], 'tooltipText', L["Value TooltipText"]);
end
--compost:Reclaim(tbl,2);
--tbl = nil;
elseif ( value == 'options' ) then
dewdrop:AddLine('text', L["Drop Threshold"], 'hasArrow', true, 'value', 'threshold' );
dewdrop:AddLine('text', L["Money Format"], 'hasArrow', true, 'value', 'moneyformat' );
dewdrop:AddLine('text', L["Max Item Name Length"], 'hasArrow', true,
'hasSlider', true, 'sliderMin', 5, 'sliderMax', 32, 'sliderStep', 1,
'sliderValue', self:GetNameLength(),
'sliderFunc', GarbageFu.SetNameLength, 'sliderArg1', self );
dewdrop:AddLine('text', L["Sell All Button on Merchant Window"], 'checked', self:IsSellAllButton(),
'arg1', self, 'func', 'ToggleSellAllButton',
'tooltipTitle', L["Sell All Button on Merchant Window"], 'tooltipText', L["SellAllButton TooltipText"]);
dewdrop:AddLine('text', L["Only Autosell Grey Items"], 'checked', self:IsSellOnlyGrey(),
'arg1', self, 'func', 'ToggleSellOnlyGrey',
'tooltipTitle', L["Only Autosell Grey Items"], 'tooltipText', L["OnlyGrey TooltipText"]);
dewdrop:AddLine('text', L["Use Items Icon on Toolbar"], 'checked', self:IsItemIcon(),
'arg1', self, 'func', 'ToggleItemIcon');
dewdrop:AddLine('text', L["Show Price Type in Tooltip"], 'checked', self:IsPriceType(),
'arg1', self, 'func', 'TogglePriceType');
dewdrop:AddLine('text', L["Use GarbageFu Prices"], 'checked', self:IsUsingGarbagePrices(),
'arg1', self, 'func', 'ToggleUseGarbagePrices',
'disabled', not self:IsGarbagePricesAvailable(),
'tooltipTitle', L["Use GarbageFu Prices"], 'tooltipText', L["GarbageFu_Prices ToltipText"]);
dewdrop:AddLine('text', L["Ignore Ammo Bags"], 'checked', self:IsIgnoringAmmoBag(),
'arg1', self, 'func', 'ToggleIgnoreAmmoBag');
dewdrop:AddLine('text', L["Ignore Herb Bags"], 'checked', self:IsIgnoringHerbBag(),
'arg1', self, 'func', 'ToggleIgnoreHerbBag');
dewdrop:AddLine('text', L["Ignore Soulshard Bags"], 'checked', self:IsIgnoringSoulBag(),
'arg1', self, 'func', 'ToggleIgnoreSoulBag');
dewdrop:AddLine('text', L["Ignore Enchanting Bags"], 'checked', self:IsIgnoringEnchBag(),
'arg1', self, 'func', 'ToggleIgnoreEnchBag');
--dewdrop:AddLine('text', L["Rescan"], 'arg1', self, 'func', 'InitBagScan' );
dewdrop:AddLine('text', L["Reset"], 'arg1', "GARBAGEFU_RESET", 'func', StaticPopup_Show, 'closeWhenClicked', true );
dewdrop:AddLine();
self:AddImpliedMenuOptions(2);
end
elseif ( level == 3 ) then
if (value2 == 'drop') then
if ( value == 'dropsets' ) then
-- Drop - Sets
dewdrop:AddLine('text', L["Drop Sets"], "isTitle", true );
for n,i in self.vars.sets do
local checked = self:IsDropSet(n);
local checkIcon = "Interface\\Buttons\\UI-CheckBox-Check"
if self:IsChildDropSet(n) then
checked = true;
checkIcon = "Interface\\Buttons\\UI-CheckBox-Check-Disabled"
end
dewdrop:AddLine('text', i.name,
'checked', checked, 'checkIcon', checkIcon,
'disabled', self:IsKeepSet(n),
'hasArrow', i.sub ~= nil, 'value', n,
'arg1', self, 'arg2', n, 'func', 'ToggleDropSets' );
end
elseif ( value == 'dropitem' ) then
-- Drop - Items
dewdrop:AddLine('text', L["Drop Items"], "isTitle", true );
local tbl = self:GetDropItemTable();
for _,i in tbl do
dewdrop:AddLine('text', self.vars.colors[i.qual].hex .. i.name,
'checked', self:IsDropItem(i.id),
'arg1', self, 'arg2', i.id, 'func', 'ToggleDropItem');
end
--compost:Reclaim(tbl,2);
--tbl = nil;
end
elseif (value2 == 'keep') then
if ( value == 'keepsets' ) then
-- Keep - Sets
dewdrop:AddLine('text', L["Keep Sets"], "isTitle", true );
for n,i in self.vars.sets do
local checked = self:IsKeepSet(n);
local checkIcon = "Interface\\Buttons\\UI-CheckBox-Check"
if self:IsChildKeepSet(n) then
checked = true;
checkIcon = "Interface\\Buttons\\UI-CheckBox-Check-Disabled"
end
dewdrop:AddLine('text', i.name,
'checked', checked, 'checkIcon', checkIcon,
'disabled', self:IsDropSet(n),
'hasArrow', i.sub ~= nil, 'value', n,
'arg1', self, 'arg2', n, 'func', 'ToggleKeepSets' );
end
elseif ( value == 'keepitem' ) then
-- Keep - Items
dewdrop:AddLine('text', L["Keep Items"], "isTitle", true );
local tbl = self:GetKeepItemTable();
for _,i in tbl do
dewdrop:AddLine('text', self.vars.colors[i.qual].hex .. i.name,
'checked', self:IsKeepItem(i.id),
'arg1', self, 'arg2', i.id, 'func', 'ToggleKeepItem');
end
--compost:Reclaim(tbl,2);
--tbl = nil;
end
elseif ( value2 == 'options' ) then
if ( value == 'threshold' ) then
dewdrop:AddLine('text', L["Drop Threshold"], "isTitle", true );
for a=0,6 do
dewdrop:AddLine('text', self.vars.colors[a].hex..self.vars.colors[a].desc.."|r",
'checked', a == self:GetDropThreshold(),
'arg1', self, 'arg2', a, 'isRadio', true,
'func', 'SetDropThreshold' );
end
elseif ( value == 'moneyformat' ) then
dewdrop:AddLine('text', L["Money Format"], "isTitle", true );
for a,f in self.vars.moneyformats do
dewdrop:AddLine('text', f.name.."\t"..f.ex,
'checked', a == self:GetMoneyFormat(),
'arg1', self, 'arg2', a, 'isRadio', true,
'func', 'SetMoneyFormat' );
end
else
self:AddImpliedMenuOptions(2);
end
end
elseif ( level == 4 ) then
if ( value2 == 'dropsets' ) then
dewdrop:AddLine('text', L["Drop Set"].." "..self.vars.sets[value].name, "isTitle", true );
for n,i in self.vars.sets[value].sub do
dewdrop:AddLine('text', i.name,
'checked', self:IsDropSet(value,n),
'disabled',self:IsKeepSet(value,n),
'arg1', self, 'arg2', value, 'arg3', n, 'func', 'ToggleDropSets' );
end
elseif ( value2 == 'keepsets' ) then
dewdrop:AddLine('text', L["Keep Set"].." "..self.vars.sets[value].name, "isTitle", true );
for n,i in self.vars.sets[value].sub do
dewdrop:AddLine('text', i.name,
'checked', self:IsKeepSet(value,n),
'disabled', self:IsDropSet(value,n),
'arg1', self, 'arg2', value, 'arg3', n, 'func', 'ToggleKeepSets' );
end
end
end
end
function GarbageFu:OnClick(button)
if IsShiftKeyDown() then
self:DropFirstItem();
end
if IsControlKeyDown() then
self:KeepFirstItem();
end
end
------------------------------------------------------------------------------------------------------
-- Event functions
------------------------------------------------------------------------------------------------------
function GarbageFu:OnClickItem(item)
if IsShiftKeyDown() then
self:DropItem(item);
end
if IsControlKeyDown() then
self:KeepItem(item);
end
end
function GarbageFu:OnEnteringWorld()
self:RegisterEvent("BAG_UPDATE","OnBagUpdate");
self:RegisterEvent("MERCHANT_SHOW","OnMerchantOpen");
self:RegisterEvent("MERCHANT_CLOSED","OnMerchantClose");
self:RegisterEvent("PLAYER_LEAVING_WORLD","OnLeavingWorld");
if self:IsEventRegistered("PLAYER_ENTERING_WORLD") then self:UnregisterEvent("PLAYER_ENTERING_WORLD") end
end
function GarbageFu:OnLeavingWorld()
self:RegisterEvent("PLAYER_ENTERING_WORLD","OnEnteringWorld");
if self:IsEventRegistered("BAG_UPDATE") then self:UnregisterEvent("BAG_UPDATE") end
if self:IsEventRegistered("MERCHANT_SHOW") then self:UnregisterEvent("MERCHANT_SHOW") end
if self:IsEventRegistered("MERCHANT_CLOSED") then self:UnregisterEvent("MERCHANT_CLOSED") end
if self:IsEventRegistered("PLAYER_LEAVING_WORLD") then self:UnregisterEvent("PLAYER_LEAVING_WORLD") end
end
function GarbageFu:OnBagUpdate(bag)
-- local bag = arg1;
self:DebugPrint("OnBagUpdate bag="..tostring(bag));
if ( not bag or bag < 0 or bag > 4 ) then return end
if ( self.vars.bags[bag].bagName ~= GetBagName(bag) ) then -- Houston, we got a problem
self:DebugPrint("New or changed bag detected. Doing a full scan");
self:InitBagScan(); -- New or changed bag detected. Do a full scan
return
end
if self.vars.bags[bag].ignore then return end
self:SetSafeToDelete(false);
for slot=1,self.vars.bags[bag].numSlots do
if not self.vars.bags[bag][slot] then self.vars.bags[bag][slot] = self:Table() end
local link = GetContainerItemLink(bag, slot);
local _, stack = GetContainerItemInfo(bag, slot);
if ( link ~= self.vars.bags[bag][slot].link or stack ~= self.vars.bags[bag][slot].stack ) then
self.vars.bags[bag][slot].link = link;
self.vars.bags[bag][slot].stack = stack;
self:UpdateItem(bag,slot);
self:SortItems();
self:UpdateDisplay();
end
end
self:SetSafeToDelete(true);
end
------------------------------------------------------------------------------------------------------
-- Core functions
------------------------------------------------------------------------------------------------------
function GarbageFu:InitBagScan()
self:SetSafeToDelete(false);
self.vars.items = self:Table(self.vars.items,3);
for bag=0,4 do
self.vars.bags[bag] = self:Table(self.vars.bags[bag],3);
self.vars.bags[bag].numSlots = GetContainerNumSlots(bag);
self.vars.bags[bag].bagName = GetBagName(bag);
self.vars.bags[bag].ignore = self:IgnoreBag(bag);
if not self.vars.bags[bag].ignore then
for slot=1,self.vars.bags[bag].numSlots do
self.vars.bags[bag][slot] = self:Table(self.vars.bags[bag][slot],2);
self.vars.bags[bag][slot].link = GetContainerItemLink(bag, slot)
_, self.vars.bags[bag][slot].stack = GetContainerItemInfo(bag, slot)
self:UpdateItem(bag,slot);
end
end
end
self:SortItems();
self:UpdateDisplay();
self:SetSafeToDelete(true);
end
function GarbageFu:UpdateItem(bag, slot)
local itemidx = nil;
local item = nil;
for a,i in self.vars.items do
if( i.bag == bag and i.slot == slot ) then
itemidx = a;
item = i;
break;
end
end
if ( self.vars.bags[bag][slot].link ) then
if ( not item ) then item = self:Table() end
item.bag = bag;
item.slot = slot;
item.stack = self.vars.bags[bag][slot].stack;
if ( item.link ~= self.vars.bags[bag][slot].link ) then
item.link = self.vars.bags[bag][slot].link;
item.id, item.code, item.name, item.color = self:GetItemId(item.link);
if ( item.id ) then
_, _, item.qual, _, _, _, item.maxstack, _, item.tex = GetItemInfo(item.id);
if not item.qual then --- Item not in local cache
item.qual = self:GetItemQualFromColor(item.color);
item.tex = "Interface\\Icons\\INV_Misc_QuestionMark.blp";
item.maxstack = 0;
item.notseen = true;
else
item.notseen = nil;
end
self:GetItemValue(item);
else
item.notseen = true;
end
else -- Just new stack size, recalc totvalue
if ( item.value ) then
item.totvalue = item.value * item.stack;
end
end
if ( not itemidx ) then
table.insert(self.vars.items, item);
end
elseif ( itemidx ) then
compost:Reclaim(table.remove(self.vars.items, itemidx),2);
end
end
local function ItemSortFunc(item1, item2)
if item1.notseen then return false end
if item2.notseen then return true end
if ( item1.totvalue < item2.totvalue ) then return true end
if ( item1.totvalue == item2.totvalue ) then
if ( item1.id < item2.id ) then return true end
end
return false
end
function GarbageFu:SortItems()
table.sort(self.vars.items, ItemSortFunc);
end
function GarbageFu:GetItemId(link)
if link then
local _, _, color, code, id, name = string.find(link, "|cff(%x%x%x%x%x%x)|Hitem:((%d+):%d+:%d+:%d+)|h%[(.+)%]|h|r")
return tonumber(id), code, name, color
end
end
function GarbageFu:GetItemQualFromColor(color)
for i,c in self.vars.colors do
if ( color == string.sub(c.hex,5) ) then return i end
end
end
-- Check if an item is elegiable for drop
function GarbageFu:IsItemDroppable(item)
if (item.notseen) then self:UpdateItem(item.bag,item.slot) end -- Not seen item. Try again.
if (item.notseen) then return false end -- Still not seen.
if (item.totvalue == 0 and item.qual > 0) then return false end -- All items above poor quality without price is not dropped for saftey reasons
if (self.db.profile.keepitem[item.id]) then return false end
if (self.db.profile.dropitem[item.id]) then return true end
if self:IsItemInKeepSets(item.id) then return false end
if self:IsItemInDropSets(item.id) then return true end
if (item.qual <= self:GetDropThreshold()) then return true end
return false
end
function GarbageFu:GetFirstDroppableItem()
for i,item in self.vars.items do
if self:IsItemDroppable(item) then
return item
end
end
end
------------------------------------------------------------------------------------------------------
-- Drop down menu functions
------------------------------------------------------------------------------------------------------
function GarbageFu:GetDropItemTable()
self.vars.temptbl = self:Table(self.vars.temptbl);
-- local tbl = {};
local tbl2 = self:Table();
-- Start with itemid's listed as drop
for i,_ in self.db.profile.dropitem do
local item = self:Table();
item.id = i;
item.name,_,item.qual = GetItemInfo(i);
if item.name then
table.insert(self.vars.temptbl,item);
tbl2[i] = true;
else
compost:Reclaim(item,1);
item = nil;
end
end
-- Add items in inventory with a qual over drop threshold or in keep sets
for _,i in self.vars.items do
if ( not i.notseen and not tbl2[i.id] and i.totvalue > 0 and
(i.qual>self:GetDropThreshold() or self:IsItemInKeepSets(i.id)) and
not self:IsItemInDropSets(i.id)) then
local item = self:Table();
item.id = i.id;
item.name = i.name;
item.qual = i.qual;
table.insert(self.vars.temptbl,item);
tbl2[i.id] = true;
end
end
compost:Reclaim(tbl2,2);
tbl2 = nil;
table.sort(self.vars.temptbl,function(a,b) return a.name<b.name end);
return self.vars.temptbl
end
function GarbageFu:GetKeepItemTable()
self.vars.temptbl = self:Table(self.vars.temptbl);
local tbl2 = self:Table();
-- Start with itemid's listed as keep
for i,_ in self.db.profile.keepitem do
local item = self:Table();
item.id = i;
item.name,_,item.qual = GetItemInfo(i);
if item.name then
table.insert(self.vars.temptbl,item);
tbl2[i] = true;
else
compost:Reclaim(item,1);
item = nil;
end
end
-- Add items in inventory with a qual eq or below drop threshold or in drop sets. Not poor quality items
for _,i in self.vars.items do
if ( not i.notseen and i.totvalue > 0 and i.qual > 0 and not tbl2[i.id] and
(i.qual<=self:GetDropThreshold() or self:IsItemInDropSets(i.id)) and
not self:IsItemInKeepSets(i.id)) then
local item = self:Table();
item.id = i.id;
item.name = i.name;
item.qual = i.qual;
table.insert(self.vars.temptbl,item);
tbl2[i.id] = true;
end
end
compost:Reclaim(tbl2,2);
tbl2 = nil;
table.sort(self.vars.temptbl,function(a,b) return a.name<b.name end);
return self.vars.temptbl
end
function GarbageFu:GetCustomItemValueTable()
self.vars.temptbl = self:Table(self.vars.temptbl);
local tbl2 = self:Table();
-- Start with itemid's with a custom price
for i,v in self.db.account.overrideprices do
local item = self:Table();
item.id = i;
item.value = v;
item.name,_,item.qual = GetItemInfo(i);
if item.name then
table.insert(self.vars.temptbl,item);
tbl2[i] = true;
else
compost:Reclaim(item,1);
item = nil;
end
end
-- Add items in inventory. Not poor quality items that already have a price
for _,i in self.vars.items do
if ( not i.notseen and not tbl2[i.id] and (i.qual > 0 or i.totvalue == 0)) then
local item = self:Table();
item.id = i.id;
item.name = i.name;
item.qual = i.qual;
item.value = i.value;
if not item.value then item.value = 0 end
table.insert(self.vars.temptbl,item);
tbl2[i.id] = true;
end
end
compost:Reclaim(tbl2,2);
tbl2 = nil;
table.sort(self.vars.temptbl,function(a,b) return a.name<b.name end);
return self.vars.temptbl
end
function GarbageFu:KeepFirstItem()
local item = self:GetFirstDroppableItem();
if item then
self:KeepItem(item);
end
end
function GarbageFu:KeepItem(item)
if item then
self:ToggleKeepItem(item.id);
self:MyPrint(L["Adding %s to keep item list"], item.link );
end
end
function GarbageFu:DropFirstItem()
local item = self:GetFirstDroppableItem();
if item then
self:DropItem(item);
end
end
function GarbageFu:DropItem(item)
if not item or not item.bag or not item.slot then return end
if not self:IsSafeToDelete() then return end
if self:IsItemDroppable(item) then
if (MerchantFrame:IsVisible()) then
self:MyPrint(L["Selling x%s %s worth %s"], item.stack, item.name, self:GetMoneyString(item.totvalue) );
UseContainerItem(item.bag, item.slot)
self:SetSafeToDelete(false);
else
self:MyPrint(L["Dropping x%s %s worth %s"], item.stack, item.name, self:GetMoneyString(item.totvalue) );
PickupContainerItem(item.bag, item.slot)
DeleteCursorItem();
self:SetSafeToDelete(false);
end
end
end
function GarbageFu:SettingsReset()
self:ResetDB('profile');
self:ResetDB('account');
self.vars.dropsets = self:Table(self.vars.dropsets,1);
self.vars.keepsets = self:Table(self.vars.keepsets,1);
self:UpdateDisplay();
end
function GarbageFu:GetMoneyString(value)
if ( value == 0 ) then
return "|cffffcc00??|r"; -- No price
elseif ( self.db.profile.moneyformat == 1 ) then
return abacus:FormatMoneyCondensed(value,true,true)
elseif ( self.db.profile.moneyformat == 2 ) then
return abacus:FormatMoneyShort(value,true,true)
elseif ( self.db.profile.moneyformat == 3 ) then
return abacus:FormatMoneyFull(value,true,true)
else
return abacus:FormatMoneyExtended(value,true,true)
end
end
------------------------------------------------------------------------------------------------------
-- Sets functions
------------------------------------------------------------------------------------------------------
function GarbageFu:IsItemInSet(itemId,set)
local val,set = PeriodicTable:ItemInSet(itemId,set);
if set then return true end
end
-- Check if item is in one of the sets selected for drop.
function GarbageFu:IsItemInDropSets(itemid)
local val,set = PeriodicTable:ItemInSet(itemid,self.vars.dropsets);
if set then return true end
end
-- Check if item is in one of the sets selected for keep.
function GarbageFu:IsItemInKeepSets(itemid)
local val,set = PeriodicTable:ItemInSet(itemid,self.vars.keepsets);
if set then return true end
end
function GarbageFu:IsDropSet(set,subset)
local setid = self.vars.sets[set].id;
if subset then
local subsetid = self.vars.sets[set].sub[subset].id;
return self.db.profile.dropsets[setid] or self.db.profile.dropsets[subsetid];
end
return self.db.profile.dropsets[setid];
end
function GarbageFu:IsChildDropSet(set)
if self.vars.sets[set].sub then
for _,s in self.vars.sets[set].sub do
if self.db.profile.dropsets[s.id] then
return true;
end
end
end
end
-- Converts self.db.profile.dropsets into self.vars.dropsets
-- Needed because self.db.profile.dropsets is index by name and self.vars.dropsets needs to be indexed by number with names as string.
function GarbageFu:MakeSetsTables()
self.vars.dropsets = self:Table(self.vars.dropsets,1);
for n,_ in self.db.profile.dropsets do
table.insert(self.vars.dropsets,n);
end
self.vars.keepsets = self:Table(self.vars.keepsets,1);
for n,_ in self.db.profile.keepsets do
table.insert(self.vars.keepsets,n);
end
end
function GarbageFu:ToggleDropSets(set,subset)
self:DebugPrint("ToggleDropSets(set) set="..tostring(set).." subset="..tostring(subset));
local setid = self.vars.sets[set].id;
if subset then -- Clicked a child
local subsetid = self.vars.sets[set].sub[subset].id;
if self.db.profile.dropsets[setid] then -- Check if parent is set
self.db.profile.dropsets[setid] = nil; -- Clear parent
for _,s in self.vars.sets[set].sub do
self.db.profile.dropsets[s.id] = true; -- Set all children
end
end
if self.db.profile.dropsets[subsetid] then -- Reverse child
self.db.profile.dropsets[subsetid] = nil;
else
self.db.profile.dropsets[subsetid] = true;
end
local allset = true;
for _,s in self.vars.sets[set].sub do
if not self.db.profile.dropsets[s.id] then -- Check if all children are set
allset = false;
break;
end
end
if allset then -- All children are set
self.db.profile.dropsets[setid] = true; -- set parent
for i,s in self.vars.sets[set].sub do
self.db.profile.dropsets[s.id] = nil; -- And clear all children
end
end
else -- Clicked a parent or a single
if self.db.profile.dropsets[setid] then -- Reverse it
self.db.profile.dropsets[setid] = nil;
else
self.db.profile.dropsets[setid] = true;
if self.vars.sets[set].sub then -- If it is a parent
for _,s in self.vars.sets[set].sub do -- Clear all children for both drop and keep
self.db.profile.dropsets[s.id] = nil;
self.db.profile.keepsets[s.id] = nil;
end
end
end
end
self:MakeSetsTables();
self:UpdateDisplay();
end
function GarbageFu:IsKeepSet(set,subset)
local setid = self.vars.sets[set].id;
if subset then
local subsetid = self.vars.sets[set].sub[subset].id;
return self.db.profile.keepsets[setid] or self.db.profile.keepsets[subsetid];
end
return self.db.profile.keepsets[setid];
end
function GarbageFu:IsChildKeepSet(set)
if self.vars.sets[set].sub then
for _,s in self.vars.sets[set].sub do
if self.db.profile.keepsets[s.id] then
return true;
end
end
end
end
function GarbageFu:ToggleKeepSets(set,subset)
self:DebugPrint("ToggleKeepSets(set) set="..tostring(set).." subset="..tostring(subset));
local setid = self.vars.sets[set].id;
if subset then -- Clicked a child
local subsetid = self.vars.sets[set].sub[subset].id;
if self.db.profile.keepsets[setid] then -- Check if parent is set
self.db.profile.keepsets[setid] = nil; -- Clear parent
for _,s in self.vars.sets[set].sub do
self.db.profile.keepsets[s.id] = true; -- Set all children
end
end
if self.db.profile.keepsets[subsetid] then -- Reverse child
self.db.profile.keepsets[subsetid] = nil;
else
self.db.profile.keepsets[subsetid] = true;
end
local allset = true;
for _,s in self.vars.sets[set].sub do
if not self.db.profile.keepsets[s.id] then -- Check if all children are set
allset = false;
break;
end
end
if allset then -- All children are set
self.db.profile.keepsets[setid] = true; -- set parent
for i,s in self.vars.sets[set].sub do
self.db.profile.keepsets[s.id] = nil; -- And clear all children
end
end
else -- Clicked a parent or a single
if self.db.profile.keepsets[setid] then -- Reverse it
self.db.profile.keepsets[setid] = nil;
else
self.db.profile.keepsets[setid] = true;
if self.vars.sets[set].sub then -- If it is a parent
for _,s in self.vars.sets[set].sub do -- Clear all children for both drop and keep
self.db.profile.keepsets[s.id] = nil;
self.db.profile.dropsets[s.id] = nil;
end
end
end
end
self:MakeSetsTables();
self:UpdateDisplay();
end
------------------------------------------------------------------------------------------------------
-- Special bag functions
------------------------------------------------------------------------------------------------------
function GarbageFu:GetBagId(bag)
local slotId = ContainerIDToInventoryID(bag);
local bagLink = GetInventoryItemLink("player",slotId);
local bagId = self:GetItemId(bagLink);
return bagId;
end
function GarbageFu:IsBagAmmoBag(bagId)
return self:IsItemInSet(bagId, {"bagsammo","bagsquiver"});
end
function GarbageFu:IsBagHerbBag(bagId)
return self:IsItemInSet(bagId, "bagsherb");
end
function GarbageFu:IsBagSoulBag(bagId)
return self:IsItemInSet(bagId, "bagssoul");
end
function GarbageFu:IsBagEnchBag(bagId)
return self:IsItemInSet(bagId, "bagsench");
end
function GarbageFu:IgnoreBag(bag)
local bagId = self:GetBagId(bag);
if ( self:IsIgnoringAmmoBag() and self:IsBagAmmoBag(bagId) ) then return true end
if ( self:IsIgnoringHerbBag() and self:IsBagHerbBag(bagId) ) then return true end
if ( self:IsIgnoringSoulBag() and self:IsBagSoulBag(bagId) ) then return true end
if ( self:IsIgnoringEnchBag() and self:IsBagEnchBag(bagId) ) then return true end
end
------------------------------------------------------------------------------------------------------
-- Sell Items functions
------------------------------------------------------------------------------------------------------
function GarbageFu:IsItemSellable(item)
if ( item.qual == 0 or ( not self:IsSellOnlyGrey() and self:IsItemDroppable(item))) then
return true;
end
return false;
end
function GarbageFu:IsThereItemsToSell()
for _,item in pairs(self.vars.items) do
if self:IsItemSellable(item) then
return true;
end
end
return false;
end
function GarbageFu:GetSellItems()
local sellItems = self:Table();
local sellValue = 0;
for _,item in pairs(self.vars.items) do
if self:IsItemSellable(item) then
table.insert(sellItems,item);
sellValue = sellValue + item.totvalue;
end
end
return sellItems, sellValue;
end
function GarbageFu:GetSellValue()
local sellValue = 0;
for _,item in pairs(self.vars.items) do
if self:IsItemSellable(item) then
sellValue = sellValue + item.totvalue;
end
end
return sellValue;
end
function GarbageFu:SellAllItems()
if ( not self:IsEventScheduled("SellItem") ) then
if self.vars.sellitems then compost:Reclaim(self.vars.sellitems) end
self.vars.sellitems, self.vars.sellvalue = self:GetSellItems();
if self.vars.sellitems[1] then
self:ScheduleRepeatingEvent("SellItem", self.SellItemEvent, 0.5, self);
end
end
end
function GarbageFu:SellItemEvent()
local item = self.vars.sellitems[1];
if ( item and MerchantFrame:IsVisible() ) then
if self:IsSafeToDelete() then
self:SetSafeToDelete(false);
self:MyPrint(L["Selling x%s %s worth %s"], item.stack, item.name, self:GetMoneyString(item.totvalue) );
UseContainerItem(item.bag, item.slot)
table.remove(self.vars.sellitems,1);
end
else -- No more items or Merchant frame closed
if ( not item ) then
self:MyPrint(L["All items sold."]);
MerchantFrame.sellAllButton:Disable();
end
self:CancelScheduledEvent("SellItem");
return
end
end
function GarbageFu:OnMerchantOpen()
if self:IsThereItemsToSell() then
MerchantFrame.sellAllButton:Enable();
else
MerchantFrame.sellAllButton:Disable();
end
end
function GarbageFu:OnMerchantClose()
if ( self:IsEventScheduled("SellItem") ) then
self:CancelScheduledEvent("SellItem");
end
end
local buttonSize = 32
function GarbageFu:MakeSellAllButton()
if not MerchantFrame.sellAllButton then
local sellAllButton = CreateFrame("Button", "GarbageFu_SellItemButton", MerchantFrame)
MerchantFrame.sellAllButton = sellAllButton
sellAllButton:SetWidth(buttonSize)
sellAllButton:SetHeight(buttonSize)
local texture = sellAllButton:CreateTexture()
texture:SetWidth(buttonSize * 1.6458333)
texture:SetHeight(buttonSize * 1.6458333)
texture:SetPoint("CENTER", sellAllButton, "CENTER")
texture:SetTexture("Interface\\Buttons\\UI-Quickslot2")
sellAllButton:SetNormalTexture(texture)
local texture = sellAllButton:CreateTexture(nil, "BACKGROUND")
texture:SetTexture("Interface\\AddOns\\FuBar_GarbageFu\\icon.tga")
texture:SetAllPoints(sellAllButton)
sellAllButton:SetPushedTexture("Interface\\Buttons\\UI-Quickslot-Depress")
local texture = sellAllButton:CreateTexture()
texture:SetTexture("Interface\\Buttons\\ButtonHilight-Square")
texture:SetAllPoints(sellAllButton)
sellAllButton:SetHighlightTexture(texture)
local texture = sellAllButton:CreateTexture()
texture:SetTexture("Interface\\AddOns\\FuBar_GarbageFu\\icon.tga")
texture:SetDesaturated(true)
texture:SetAllPoints(sellAllButton)
sellAllButton:SetDisabledTexture(texture)
sellAllButton:SetPoint("TOPRIGHT", MerchantFrame, "TOPRIGHT", -44, -38)
sellAllButton:SetScript("OnClick", function()
self:SellAllItems()
end)
sellAllButton:SetScript("OnEnter", function()
self:SellAllButtonOnEnter(this)
end)
sellAllButton:SetScript("OnLeave", function()
GameTooltip:Hide()
end)
local texture = sellAllButton:CreateTexture(nil, "ARTWORK")
texture:SetTexture(0, 0, 0, 0.5)
texture:SetAllPoints(sellAllButton)
local button_Enable = sellAllButton.Enable
function sellAllButton:Enable()
button_Enable(self)
texture:Hide()
end
local button_Disable = sellAllButton.Disable
function sellAllButton:Disable()
button_Disable(self)
texture:Show()
end
MerchantFrame.sellAllButton:Disable()
end
end
function GarbageFu:SellAllButtonOnEnter(button)
GameTooltip:SetOwner(button, "ANCHOR_RIGHT")
if self:IsSellOnlyGrey() then
GameTooltip:SetText(L["Sell all grey items"]);
GameTooltip:AddLine(L["SellsAll TooltipText2"]);
else
GameTooltip:SetText(L["Sell all garbage items"]);
GameTooltip:AddLine(L["SellsAll TooltipText1"]);
end
local sellValue = self:GetSellValue();
GameTooltip:AddLine(L["Value:"].." "..self:GetMoneyString(sellValue));
GameTooltip:Show()
end
------------------------------------------------------------------------------------------------------
-- Item Price functions
------------------------------------------------------------------------------------------------------
-- Get item value. Doh!
function GarbageFu:GetItemValue(item)
if item.id and item.qual and item.code then
item.value, item.pricetype = self:GetUserOverridePrice(item.id)
if not item.value then item.value, item.pricetype = self:GetKCIVendorPrice(item.id) end
if not item.value then item.value, item.pricetype = self:GetInformantVendorPrice(item) end
if not item.value then item.value, item.pricetype = self:GetWoWEconVendorPrice(item) end
if not item.value then item.value, item.pricetype = self:GetItemSyncVendorPrice(item.link) end
if not item.value then item.value, item.pricetype = self:GetPriceMasterVendorPrice(item.id) end
if not item.value then item.value, item.pricetype = self:GetLudwigSellValueVendorPrice(item.id) end
if not item.value then item.value, item.pricetype = self:GetLocalVendorPrice(item.id) end
end
if item.value then
item.totvalue = item.value * item.stack;
else
item.value = 0; -- No item value know
item.totvalue = 0; -- No item value know
end
end
-- Price Types. First char: U = User, V = Vendor, A = Auction
-- Second char: Addon the price was gotten from.
-- K = KC_Items, W = WoWEcon, I = Informant, P = PriceMaster, L = Ludwig, T = Local table
-- Get item price from the User Override table
function GarbageFu:GetUserOverridePrice(itemid)
if self.db.account.overrideprices[itemid] then
return self.db.account.overrideprices[itemid], "|cffff7700UO|r"
end
end
-- KC_Items
function GarbageFu:GetKCIVendorPrice(itemid)
local kv, vs
if not KC_ItemsDB then return end
kv = KC_ItemsDB[itemid]
if kv then _, _, vs = string.find(kv, ",(%d+),%d+") end
if (vs and vs ~= "0") then return tonumber(vs), "|cff0077ffVK|r" end
end
-- Auctioneer/Informant
function GarbageFu:GetInformantVendorPrice(item)
if not Informant then return end
local itemData = Informant.GetItem(item.id)
if (itemData and itemData['buy'] and itemData['buy'] ~= 0) then return itemData['sell'], "|cff0077ffVI" end
end
-- WoWEcon
function GarbageFu:GetWoWEconVendorPrice(item)
if not WOWEcon_Enabled then return end
local price = WOWEcon_GetVendorPrice_ByLink(item.link);
if price and price > 0 then return price, "|cff0077ffVW|r" end
end
-- PriceMaster doesn't have a price asking function, so we have to tap directly in to it's data. Ugly!
function GarbageFu:GetPriceMasterVendorPrice(itemid)
if ( CompletePrices and CompletePrices[itemid] and CompletePrices[itemid].p ) then
return CompletePrices[itemid].p, "|cff0077ffVP|r"
end
end
-- Ludwig_SellValue
function GarbageFu:GetLudwigSellValueVendorPrice(itemid)
local items = tostring(itemid)
if ( Ludwig_SellValues and Ludwig_SellValues[items] ) then
return Ludwig_SellValues[items], "|cff0077ffVL|r"
end
end
function GarbageFu:GetItemSyncVendorPrice(itemlink)
if (not ISync) then return end;
local price = tonumber(ISync:FetchDB(ISync:GetCoreID(itemlink), "price"));
if price and price > 0 then return price, "|cff0077ffVS|r" end
end
-- Look it up in our own price table
function GarbageFu:GetLocalVendorPrice(itemid)
if not self.vars.vendorprices then return end
if self.vars.pricecache[itemid] then return self.vars.pricecache[itemid], "|cff0077ffVT|r" end
local _, _, price = string.find(self.vars.vendorprices, " "..itemid..":(%d+)")
if price then
self.vars.pricecache[itemid] = tonumber(price)
return self.vars.pricecache[itemid], "|cff0077ffVT|r"
end
end
-- Check that we got a numeric value from the editbox.
function GarbageFu.ValidateValue(self, value)
self:DebugPrint( "ValidateValue value="..tostring(value));
local res = ""
for s in string.gfind(value, "(%d*).-(%d*)") do
res=res..s
end
return res
end
-- Stores a new User Override price for the top item.
function GarbageFu.SetFirstItemValue(self, value)
local item = self:GetFirstDroppableItem();
if item then
GarbageFu.SetItemValue(self, item.id, value);
end
end
-- Stores a new User Override price for an item, or removing it.
function GarbageFu.SetItemValue(self, itemid, value)
value = tonumber(value);
if itemid then
self:DebugPrint( "SetItemValue value="..tostring(value).."itemid="..tostring(itemid));
if ( not value or value == 0 ) then
if self.db.account.overrideprices[itemid] then
self.db.account.overrideprices[itemid] = nil;
local name = GetItemInfo(itemid);
self:MyPrint(L["Removing custom price for %s."], name);
end
else
self.db.account.overrideprices[itemid] = value;
local name = GetItemInfo(itemid);
self:MyPrint(L["Setting price for %s to %s."], name, self:GetMoneyString(value));
end
self:UpdateItemValue(itemid)
self:SortItems();
self:UpdateDisplay();
end
end
-- Updates all occurances of itemid in the inventory with a new price.
function GarbageFu:UpdateItemValue(itemid)
for _, item in self.vars.items do
if ( item.id == itemid ) then
self:GetItemValue(item);
end
end
end
-- Load our own price table.
function GarbageFu:LoadGarbagePrices(db)
if not IsAddOnLoaded("FuBar_GarbageFu_Prices") then
local res,reason = LoadAddOn("FuBar_GarbageFu_Prices");
end
if GarbageFu_PriceDb then
self.vars.vendorprices = GarbageFu_PriceDb;
return true;
elseif GarbageFu_PriceTbl then
self.vars.vendorprices = "";
self.vars.pricecache = GarbageFu_PriceTbl;
else
self:MyPrint(L["Can't load FuBar_GarbageFu_Price. Check that it exists and are enabled"]);
return;
end
end
function GarbageFu:IsGarbagePricesAvailable()
local name, title, notes, enabled, loadable, reason = GetAddOnInfo("FuBar_GarbageFu_Prices");
return not reason;
end
------------------------------------------------------------------------------------------------------
-- Compost interface
------------------------------------------------------------------------------------------------------
-- Method that will get a table from compost. If a table is passed in it will be erased and return.
-- If a depth is specified then any subtables will be reclaimed by compost before erasing the table and returning it.
function GarbageFu:Table(t,depth)
if t then
if type(t) ~= "table" then
error("GarbageFu:Table called with a none table as input");
return
end
if depth and depth > 0 then
for i in pairs(t) do
if type(t[i]) == "table" then
compost:Reclaim(t[i], depth - 1 );
end
end
end
return compost:Erase(t);
else
return compost:GetTable();
end
end
------------------------------------------------------------------------------------------------------
-- Chat output functions
------------------------------------------------------------------------------------------------------
function GarbageFu:DebugPrint(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10)
if self.CustomDebug then
self:CustomDebug(1, 0.5, 0, nil, nil, nil, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
end
end
function GarbageFu:MyPrint(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10)
self:CustomPrint(self.db.profile.textcolor.r, self.db.profile.textcolor.g, self.db.profile.textcolor.b, nil, nil, nil, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
end