WoWInterface SVN mRunes
Compare Revisions
- This comparison shows the changes necessary to convert path
/trunk
- from Rev 7 to Rev 8
- ↔ Reverse comparison
Rev 7 → Rev 8
mRunes/Modules/Runes.lua
New file
0,0 → 1,525
\ No newline at end of file
| local _, class = UnitClass("player") |
| if class ~= "DEATHKNIGHT" then |
| return |
| end |
| local plugin = mRunes:NewModule("Runes", "AceEvent-3.0") |
| plugin.mRunesPlugin = true |
| local AceGUI = LibStub("AceGUI-3.0") |
| local LSM = LibStub("LibSharedMedia-3.0") |
| local BD = LibStub("LibBackdrop-1.0") |
| local FA = LibStub("LibFrameAnchorRegistry-1.0") |
| local UIF |
| local db |
| -- Rune Types |
| local RUNETYPE_BLOOD = 1; |
| local RUNETYPE_UNHOLY = 2; |
| local RUNETYPE_FROST = 3; |
| local RUNETYPE_DEATH = 4; |
| local RuneNames = { |
| "Blood 1", |
| "Blood 2", |
| "Unholy 1", |
| "Unholy 2", |
| "Frost 1", |
| "Frost 2", |
| } |
| local NrRunes = 6 |
| local InCombat = false |
| local RuneOnCD = true |
| local ConfigMode = false |
| local Update |
| local backdrop = { |
| tile = true, |
| tileSize = 16, |
| insets = {}, |
| } |
| plugin.DisplayName = "Runes" |
| plugin.DisplayIcon = [[Interface\Icons\INV_Glyph_MajorDeathKnight]] |
| plugin.DisplayOrder = 1 |
| function plugin:OnInitialize() |
| local defaults = { |
| profile = { |
| Enabled = true, |
| HideBlizz = true, |
| Attached = { |
| f = "mRunesCenter", |
| x = 0, |
| y = 0, |
| Point = "CENTER", |
| RelPoint = "CENTER", |
| }, |
| Rune = { |
| ["**"] = { |
| Order = 1, |
| } |
| }, |
| InternalSpacing = 2, |
| FrameColor = {0, 0, 0, 0.5}, |
| RuneSpacing = 1.12, |
| Width = 330, |
| Height = 22, |
| RuneTexture = "HalD", |
| RuneAlphaInCombat = 1, |
| RuneAlphaOutCombat = 0.2, |
| RuneAlphaActive = 0.5, |
| RuneCooldownInset = 2, |
| RuneCooldownAlwaysShow = false, |
| RuneCooldownShow = true, |
| RuneCooldownHorAlign = "LEFT", |
| Font = "accid", |
| FontSize = 16, |
| FontFlags = "OUTLINE", |
| FontColor = {1, 1, 1, 1}, |
| BorderTexture = "None", |
| BorderWidth = 5, |
| BorderInsets = 0, |
| BorderPadding = 2, |
| BorderColor = {0, 0, 0, 1}, |
| RuneColors = { |
| [RUNETYPE_BLOOD] = {1.0, 0.0, 0.0, 1}, |
| [RUNETYPE_UNHOLY] ={0.0, 0.8, 0.0, 1}, |
| [RUNETYPE_FROST] = {0.0, 1.0, 1.0, 1}, |
| [RUNETYPE_DEATH] = {0.8, 0.1, 1.0, 1}, |
| } |
| } |
| } |
| self.db = mRunes.db:RegisterNamespace(self:GetName(), defaults) |
| self.db.RegisterCallback(self, "OnProfileChanged", "ProfileChanged") |
| self.db.RegisterCallback(self, "OnProfileCopied", "ProfileChanged") |
| self.db.RegisterCallback(self, "OnProfileReset", "ProfileChanged") |
| db = self.db.profile |
| self:SetEnabledState(db.Enabled) |
| UIF = LibStub("LibGUIFactory-1.0"):GetFactory("mRunes") |
| if not mRuneFrame then |
| self:CreateFuneFrame() |
| end |
| end |
| function plugin:OnEnable() |
| self:ApplySettings() |
| self.Frame:Show() |
| self:RegisterEvent("RUNE_TYPE_UPDATE", "RuneTypeUpdate") |
| self:RegisterEvent("RUNE_POWER_UPDATE", "RuneStateChange") |
| self:RegisterEvent("PLAYER_ENTERING_WORLD", "EnterWorld") |
| mRunes.RegisterCallback(self, "EnteringCombat") |
| mRunes.RegisterCallback(self, "LeavingCombat") |
| mRunes.RegisterCallback(self, "ToggleConfigMode") |
| FA.RegisterCallback(self, "FrameRegistered", "ApplySettings") |
| if UnitAffectingCombat("player") then |
| self:EnteringCombat("EnteringCombat") |
| else |
| self:LeavingCombat("LeavingCombat") |
| end |
| end |
| function plugin:OnDisable() |
| self.Frame:Hide() |
| end |
| function plugin:ProfileChanged() |
| db = self.db.profile |
| self:ApplySettings() |
| end |
| -- ~~~~~~~~~~~~~~~~~~~~ |
| -- Callbacks ~~~~~~~~~~ |
| -- ~~~~~~~~~~~~~~~~~~~~ |
| function plugin:EnteringCombat(event) |
| mRunes.FadeIn(self.Frame, false, db.RuneAlphaInCombat) |
| InCombat = true |
| RuneOnCD = false |
| end |
| function plugin:LeavingCombat(event) |
| mRunes.FadeOut(self.Frame, db.RuneAlphaOutCombat) |
| InCombat = false |
| end |
| function plugin:EnterWorld(...) |
| if self.Runes then |
| for i, rune in pairs(self.Runes) do |
| rune.Update = true |
| self:RuneTypeUpdate("RUNE_TYPE_UPDATE", i) |
| end |
| end |
| end |
| function plugin:ToggleConfigMode(event, enable) |
| ConfigMode = enable |
| if enable then |
| self.Frame.ConfigText:Show() |
| mRunes.FadeIn(self.Frame, false, 1) |
| else |
| self.Frame.ConfigText:Hide() |
| if InCombat then |
| mRunes.FadeIn(self.Frame, true, db.RuneAlphaInCombat) |
| elseif RuneOnCD then |
| mRunes.FadeIn(self.Frame, true, db.RuneAlphaActive) |
| else |
| mRunes.FadeIn(self.Frame, true, db.RuneAlphaOutCombat) |
| end |
| Update(self.Frame, 0) |
| end |
| end |
| -- ~~~~~~~~~~~~~~~~~~~~ |
| -- Events ~~~~~~~~~~~~~ |
| -- ~~~~~~~~~~~~~~~~~~~~ |
| -- Rune type changed (unholy runes) |
| function plugin:RuneTypeUpdate(event, runeID) |
| self.Runes[runeID]:SetStatusBarColor(unpack(db.RuneColors[GetRuneType(runeID)])) |
| end |
| -- Rune Ready/Not Ready event |
| function plugin:RuneStateChange(event, runeID, ready) |
| if runeID == 8 or runeID == 7 then return end |
| if ready then |
| self.Runes[runeID]:SetValue(1) |
| self.Runes[runeID].Update = nil |
| self.Runes[runeID].CDText:SetText(("%.1f"):format(0)) |
| if not db.RuneCooldownAlwaysShow then |
| self.Runes[runeID].CDText:Hide() |
| end |
| else |
| self.Runes[runeID].Update = not ready |
| mRunes:RegisterOnUpdate(self, Update) |
| end |
| end |
| Update = function(self, elapsed) |
| self = plugin |
| local haveCD = false |
| local oldHaveCD = RuneOnCD |
| for i, rune in pairs(self.Runes) do |
| if rune.Update then |
| local StartTime, CooldownTime, Ready = GetRuneCooldown(i) |
| local diff = GetTime() - StartTime |
| local remaining = CooldownTime - diff |
| local t = diff / CooldownTime |
| rune:SetValue(t) |
| if remaining < 0 and not db.RuneCooldownAlwaysShow then |
| rune.CDText:Hide() |
| elseif db.RuneCooldownShow then |
| rune.CDText:Show() |
| rune.CDText:SetText(("%.1f"):format(Ready and 0 or (remaining < 0 and 0 or remaining))) |
| end |
| if Ready then rune.Update = nil else haveCD = true end |
| end |
| end |
| if not InCombat then |
| RuneOnCD = haveCD |
| if RuneOnCD and (RuneOnCD ~= oldHaveCD) then |
| local currAlpha = self.Frame:GetAlpha() |
| if currAlpha < db.RuneAlphaActive then |
| mRunes.FadeIn(self.Frame, false, db.RuneAlphaActive) |
| else |
| mRunes.FadeOut(self.Frame, db.RuneAlphaActive) |
| end |
| elseif not RuneOnCD and (RuneOnCD ~= oldHaveCD) then |
| mRunes:UnregisterOnUpdate(self, Update) |
| mRunes.FadeOut(self.Frame, db.RuneAlphaOutCombat) |
| end |
| end |
| end |
| -- ~~~~~~~~~~~~~~~~~~~~ |
| -- Settings ~~~~~~~~~~~ |
| -- ~~~~~~~~~~~~~~~~~~~~ |
| local OrderedRunes = {} |
| local function SortRunes(a, b) |
| local adb = db.Rune[a.id] |
| local bdb = db.Rune[b.id] |
| if adb.Order == bdb.Order then |
| return a.id < b.id |
| else |
| return adb.Order < bdb.Order |
| end |
| end |
| function plugin:ApplySettings() |
| if self.Frame then |
| local anchor = FA:GetAnchor(db.Attached.f) |
| self.Frame:ClearAllPoints() |
| self.Frame:SetPoint(db.Attached.Point, anchor, db.Attached.RelPoint, db.Attached.x, db.Attached.y) |
| self.Frame:SetWidth(db.Width) |
| self.Frame:SetHeight(db.Height) |
| backdrop.insets.left = db.BorderInsets |
| backdrop.insets.right = db.BorderInsets |
| backdrop.insets.top = db.BorderInsets |
| backdrop.insets.bottom = db.BorderInsets |
| backdrop.edgeFile = LSM:Fetch("border", db.BorderTexture) |
| backdrop.edgeSize = db.BorderWidth |
| backdrop.bgFile = LSM:Fetch("background", "Solid") |
| self.Frame:SetBackdrop(backdrop) |
| self.Frame:SetBackdropColor(unpack(db.FrameColor)) |
| self.Frame:SetBackdropBorderColor(unpack(db.BorderColor)) |
| wipe(OrderedRunes) |
| for i, rune in pairs(self.Runes) do |
| rune:ClearAllPoints() |
| tinsert(OrderedRunes, rune) |
| end |
| table.sort(OrderedRunes, SortRunes) |
| local RuneWidth = db.Width / 6 |
| for i, rune in pairs(OrderedRunes) do |
| rune:ClearAllPoints() |
| if i == 1 then |
| rune:SetPoint("LEFT", db.BorderPadding + db.RuneSpacing / 2, 0) |
| rune:SetWidth(RuneWidth - db.RuneSpacing - db.BorderPadding / 3) |
| else |
| rune:SetPoint("LEFT", OrderedRunes[i-1], "RIGHT", db.RuneSpacing, 0) |
| rune:SetWidth(RuneWidth - db.RuneSpacing - db.BorderPadding / 3) |
| end |
| rune:SetHeight(db.Height - db.BorderPadding * 2) |
| rune:SetStatusBarTexture(LSM:Fetch("statusbar", db.RuneTexture)) |
| rune:GetStatusBarTexture():SetHorizTile(false) |
| rune:SetStatusBarColor(unpack(db.RuneColors[GetRuneType(rune.id)])) |
| local leftinset, rightinset = 0, 0 |
| if db.RuneCooldownHorAlign == "LEFT" then |
| leftinset = db.RuneCooldownInset |
| elseif db.RuneCooldownHorAlign == "RIGHT" then |
| rightinset = -db.RuneCooldownInset |
| end |
| rune.CDText:ClearAllPoints() |
| rune.CDText:SetPoint("TOPLEFT", leftinset, 0) |
| rune.CDText:SetPoint("BOTTOMRIGHT", rightinset, 0) |
| rune.CDText:SetFont(LSM:Fetch("font", db.Font), db.FontSize, db.FontFlags) |
| rune.CDText:SetTextColor(unpack(db.FontColor)) |
| rune.CDText:SetJustifyH(db.RuneCooldownHorAlign) |
| rune.CDText:SetJustifyV("MIDDLE") |
| if db.RuneCooldownAlwaysShow and db.RuneCooldownShow then |
| rune.CDText:Show() |
| elseif not db.RuneCooldownShow then |
| rune.CDText:Hide() |
| end |
| rune.Update = true |
| end |
| if not ConfigMode then |
| self.Frame:SetAlpha(InCombat and db.RuneAlphaInCombat or (RuneOnCD and db.RuneAlphaActive or db.RuneAlphaOutCombat)) |
| end |
| if self.Frame:GetAlpha() > 0 then self.Frame:Show() else self.Frame:Hide() end |
| end |
| if db.HideBlizz then RuneFrame:Hide() |
| else RuneFrame:Show() end |
| if not db.Enabled and self:IsEnabled() then self:Disable() |
| elseif db.Enabled and not self:IsEnabled() then self:Enable() end |
| FA:FrameModified("mRunes", "Runes") |
| end |
| -- ~~~~~~~~~~~~~~~~~~~~ |
| -- Create Frames ~~~~~~ |
| -- ~~~~~~~~~~~~~~~~~~~~ |
| function plugin:CreateFuneFrame() |
| local frame = CreateFrame("Frame", "mRunesRuneFrame", UIParent) |
| --BD:EnhanceBackdrop(frame) |
| FA:RegisterAnchor("mRunes", "Runes", "mRunesRunes", frame) |
| self.Runes = {} |
| for i = 1, NrRunes do |
| self.Runes[i] = self:CreateRune(i, frame) |
| end |
| local configFrame = CreateFrame("Frame", nil, frame) |
| configFrame:SetAllPoints() |
| configFrame:SetFrameLevel(self.Runes[1]:GetFrameLevel() + 10) |
| local configText = configFrame:CreateFontString(nil, "OVERLAY", "GameFontNormal") |
| configText:SetAllPoints() |
| configText:SetText("Runes") |
| configText:Hide() |
| frame.ConfigText = configText |
| frame:Show() |
| self.Frame = frame |
| end |
| function plugin:CreateRune(runeID, parent) |
| local rune = CreateFrame("StatusBar", "mRunesRune"..runeID, parent) |
| rune:SetMinMaxValues(0,1) |
| rune:SetValue(1) |
| local runeCooldown = rune:CreateFontString(nil, nil, "GameFontNormal") |
| rune.CDText = runeCooldown |
| rune.id = runeID |
| rune.Update = true |
| rune:Show() |
| return rune |
| end |
| -- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
| -- Options ~~~~~~~~~~~~~~~~~~~~ |
| -- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
| function plugin:GetOptions() |
| return plugin.GetGUI |
| end |
| do |
| local function Callback() |
| plugin:ApplySettings() |
| end |
| local FontFlagList = { |
| ["NONE"] = "None", |
| ["OUTLINE"] = "Outline", |
| ["THICKOUTLINE"] = "Thick Outline", |
| ["MONOCHROME"] = "Monochrome", |
| } |
| local HorizontalAlignList = { |
| ["LEFT"] = "Left", |
| ["CENTER"] = "Center", |
| ["RIGHT"] = "Right", |
| } |
| local TabSelected |
| local LastSelectedTab |
| function plugin:GetGUI() |
| self = plugin |
| local returnGroup = AceGUI:Create("SimpleGroup") |
| returnGroup:SetFullWidth(true) |
| returnGroup:SetLayout("Flow") |
| returnGroup:AddChild(UIF:NewLine(10)) |
| returnGroup:AddChild(UIF:CheckBox("Enabled", db, "Enabled", Callback, nil, 0.2)) |
| returnGroup:AddChild(UIF:CheckBox("Hide default rune frame", db, "HideBlizz", Callback, "Hides the blizzard build in rune frame", 0.8)) |
| local tgroup = UIF:TabGroup() |
| returnGroup:AddChild(tgroup) |
| tgroup:SetTabs({ |
| {text = "Position & Size", value = "PaS"}, |
| {text = "Colors & Alpha", value = "CaA"}, |
| {text = "Font", value = "Font"}, |
| {text = "Ordering", value = "Ordering"}, |
| }) |
| tgroup:SetCallback("OnGroupSelected", TabSelected) |
| tgroup:SelectTab(LastSelectedTab or "PaS") |
| return returnGroup |
| end |
| TabSelected = function(self, event, tab) |
| self:ReleaseChildren() |
| LastSelectedTab = tab |
| if tab == "PaS" then |
| self:AddChild(UIF:Text1("Select a frame to attach to. You can then adjust the relative positioning to that frame via X and Y as well as the anchor points.")) |
| local t = AceGUI:Create("FrameAnchorDropdown") |
| t:SetRelativeWidth(0.5) |
| t:SetList(FA:GetAnchors(plugin.Frame)) |
| t:SetLabel("Anchor") |
| t:SetValue(db.Attached.f) |
| t:SetCallback("OnValueChanged", function(self, event, cat, name, frame) |
| db.Attached.f = cat |
| Callback() |
| end) |
| self:AddChild(t) |
| self:AddChild(UIF:Spacer(10)) |
| self:AddChild(UIF:Text2("Avoid creating circle references!", nil, nil, nil, nil, nil, 0.4)) |
| self:AddChild(UIF:NewLine()) |
| self:AddChild(UIF:Dropdown("Point", db.Attached, "Point", Callback, mRunes:GetAnchorList(), 0.5, true)) |
| self:AddChild(UIF:Dropdown("Relative Point", db.Attached, "RelPoint", Callback, mRunes:GetAnchorList(), 0.5, true)) |
| self:AddChild(UIF:Slider("X", db.Attached, "x", -300, 300, 0.1, Callback, 0.5)) |
| self:AddChild(UIF:Slider("Y", db.Attached, "y", -300, 300, 0.1, Callback, 0.5)) |
| self:AddChild(UIF:Slider("Width", db, "Width", 5, 1000, 0.1, Callback, 0.5)) |
| self:AddChild(UIF:Slider("Height", db, "Height", 5, 200, 0.1, Callback, 0.5)) |
| self:AddChild(UIF:Slider("Space between Runes", db, "RuneSpacing", 0, 100, 0.1, Callback, 0.5)) |
| elseif tab == "CaA" then |
| local group = UIF:InlineGroup2("Rune Colors") |
| self:AddChild(group) |
| group:AddChild(UIF:ColorSelect("Blood", db.RuneColors, 1, Callback, true, 0.25)) |
| group:AddChild(UIF:ColorSelect("Unholy", db.RuneColors, 2, Callback, true, 0.25)) |
| group:AddChild(UIF:ColorSelect("Frost", db.RuneColors, 3, Callback, true, 0.25)) |
| group:AddChild(UIF:ColorSelect("Death", db.RuneColors, 4, Callback, true, 0.25)) |
| group = UIF:InlineGroup2("Alpha") |
| self:AddChild(group) |
| group:AddChild(UIF:Slider("Combat", db, "RuneAlphaInCombat", 0, 1, 0.01, Callback, 0.33)) |
| group:AddChild(UIF:Slider("OOC (Runes on cooldown)", db, "RuneAlphaActive", 0, 1, 0.01, Callback, 0.33)) |
| group:AddChild(UIF:Slider("OOC (No runes on cooldown)", db, "RuneAlphaOutCombat", 0, 1, 0.01, Callback, 0.33)) |
| group = UIF:InlineGroup2("Border and Background") |
| self:AddChild(group) |
| group:AddChild(UIF:LSMDropdown("border", "Border texture", db, "BorderTexture", Callback, 0.5)) |
| group:AddChild(UIF:LSMDropdown("statusbar", "Bar Texture", db, "RuneTexture", Callback, 0.5)) |
| group:AddChild(UIF:ColorSelect("Background Color", db, "FrameColor", Callback, true, 0.5)) |
| group:AddChild(UIF:ColorSelect("Border color", db, "BorderColor", Callback, true, 0.5)) |
| group:AddChild(UIF:Slider("Border Width", db, "BorderWidth", 0, 50, 1, Callback, 0.33)) |
| group:AddChild(UIF:Slider("Border Padding", db, "BorderPadding", 0, 100, 0.1, Callback, 0.33)) |
| group:AddChild(UIF:Slider("Border Insets", db, "BorderInsets", 0, 50, 1, Callback, 0.33)) |
| elseif tab == "Font" then |
| self:AddChild(UIF:Text1("These settings are for the cooldown text on each rune")) |
| self:AddChild(UIF:CheckBox("Show", db, "RuneCooldownShow", Callback, "Toggle if the cooldown text should shown", 0.5)) |
| self:AddChild(UIF:CheckBox("Always Show", db, "RuneCooldownAlwaysShow", Callback, "Toggle if the cooldown text should always be shown, even when it is not on cooldown", 0.5)) |
| self:AddChild(UIF:LSMDropdown("font", "Font", db, "Font", Callback, 0.5)) |
| self:AddChild(UIF:Dropdown("Font Flags", db, "FontFlags", Callback, FontFlagList, 0.5)) |
| self:AddChild(UIF:ColorSelect("Color", db, "FontColor", Callback, false, 0.2)) |
| self:AddChild(UIF:Slider("Size", db, "FontSize", 2, 50, 1, Callback, 0.4)) |
| self:AddChild(UIF:Slider("Margin", db, "RuneCooldownInset", 0, 50, 0.1, Callback, 0.4)) |
| self:AddChild(UIF:Dropdown("Horizontal Alignment", db, "RuneCooldownHorAlign", Callback, HorizontalAlignList, 0.5)) |
| elseif tab == "Ordering" then |
| self:AddChild(UIF:Text1("Runes are sorted first by the value you set here, second by their rune index. So by setting setting both unholy runes to the same sort order they will still be sorted so that unholy rune 1 comes before unholy rune 2.")) |
| for i, rune in pairs(plugin.Runes) do |
| self:AddChild(UIF:Slider(RuneNames[rune.id], db.Rune[rune.id], "Order", 1, 6, 1, Callback, 0.5)) |
| end |
| end |
| self:DoLayout() |
| self.parent:DoLayout() |
| end |
| end |
mRunes/Modules/RunicPower.lua
New file
0,0 → 1,418
\ No newline at end of file
| local _, class = UnitClass("player") |
| if class ~= "DEATHKNIGHT" then |
| return |
| end |
| local plugin = mRunes:NewModule("Runic Power", "AceEvent-3.0") |
| plugin.mRunesPlugin = true |
| local AceGUI = LibStub("AceGUI-3.0") |
| local LSM = LibStub("LibSharedMedia-3.0") |
| local BD = LibStub("LibBackdrop-1.0") |
| local FA = LibStub("LibFrameAnchorRegistry-1.0") |
| local UIF |
| local db |
| local InCombat = false |
| local HaveRP = false |
| local ConfigMode = false |
| local backdrop = { |
| tile = true, |
| tileSize = 16, |
| insets = {}, |
| } |
| plugin.DisplayName = "Runic Power" |
| plugin.DisplayIcon = [[Interface\Icons\Spell_DeathKnight_DarkConviction]] |
| plugin.DisplayOrder = 2 |
| function plugin:OnInitialize() |
| local defaults = { |
| profile = { |
| Enabled = true, |
| Attached = { |
| f = "mRunesRunes", |
| x = 0, |
| y = 0, |
| Point = "TOP", |
| RelPoint = "BOTTOM", |
| }, |
| Width = 330, |
| Height = 20, |
| InternalSpacing = 1, |
| AlphaIncCombat = 1, |
| AlphaOutCombat = 0.2, |
| AlphaActive = 0.5, |
| HorAlign = "LEFT", |
| AlwaysShowText = false, |
| ShowText = true, |
| Font = "accid", |
| FontSize = 16, |
| FontFlags = "OUTLINE", |
| FontColor = {1, 1, 1, 1}, |
| Texture = "HalD", |
| PowerColor = {0, 0.82, 1, 1}, |
| BorderTexture = "None", |
| BorderWidth = 5, |
| BorderInsets = 0, |
| BorderColor = {0, 0, 0, 1}, |
| BorderPadding = 2, |
| BackgroundColor = {0, 0, 0, 0.5}, |
| } |
| } |
| self.db = mRunes.db:RegisterNamespace(self:GetName(), defaults) |
| self.db.RegisterCallback(self, "OnProfileChanged", "ProfileChanged") |
| self.db.RegisterCallback(self, "OnProfileCopied", "ProfileChanged") |
| self.db.RegisterCallback(self, "OnProfileReset", "ProfileChanged") |
| db = self.db.profile |
| self:SetEnabledState(db.Enabled) |
| UIF = LibStub("LibGUIFactory-1.0"):GetFactory("mRunes") |
| if not self.PowerFrame then |
| self:CreatePowerFrame() |
| end |
| end |
| function plugin:OnEnable() |
| self:ApplySettings() |
| self:RegisterEvent("UNIT_MAXRUNIC_POWER", "RunicPowerChange") |
| self:RegisterEvent("UNIT_RUNIC_POWER", "RunicPowerChange") |
| self:RegisterEvent("UNIT_POWER", "RunicPowerChange") |
| self:RegisterEvent("UNIT_MAXPOWER", "RunicPowerChange") |
| mRunes.RegisterCallback(self, "EnteringCombat") |
| mRunes.RegisterCallback(self, "LeavingCombat") |
| mRunes.RegisterCallback(self, "ToggleConfigMode") |
| if UnitAffectingCombat("player") then |
| self:EnteringCombat("EnteringCombat") |
| else |
| self:LeavingCombat("LeavingCombat") |
| end |
| mRunes:RegisterOnUpdate(self.PowerFrame, self.RunicPowerChange, 0.1) |
| end |
| function plugin:OnDisable() |
| mRunes:UnregisterOnUpdate(self.PowerFrame, self.RunicPowerChange) |
| mRunes.UnregiserAllCallback(self) |
| if self.PowerFrame then mRunes.FadeOut(self.PowerFrame) end |
| end |
| function plugin:ProfileChanged() |
| db = self.db.profile |
| self:ApplySettings() |
| end |
| -- ~~~~~~~~~~~~~~~~~~~~ |
| -- Callbacks ~~~~~~~~~~ |
| -- ~~~~~~~~~~~~~~~~~~~~ |
| function plugin:EnteringCombat(event) |
| mRunes.FadeIn(self.PowerFrame, false, db.AlphaIncCombat) |
| InCombat = true |
| HaveRP = false |
| end |
| function plugin:LeavingCombat(event) |
| if UnitPower("player") <= 0 then mRunes.FadeOut(self.PowerFrame, db.AlphaOutCombat) end |
| InCombat = false |
| end |
| function plugin:EnterWorld(...) |
| end |
| function plugin:ToggleConfigMode(event, enable) |
| ConfigMode = enable |
| if enable then |
| self.PowerFrame.text:Show() |
| self.PowerFrame.ConfigText:Show() |
| mRunes.FadeIn(self.PowerFrame, false, 1) |
| self.PowerFrame.bar:SetValue(0.7) |
| self.PowerFrame.text:SetText(75) |
| else |
| self.PowerFrame.text:Hide() |
| self.PowerFrame.ConfigText:Hide() |
| self.PowerFrame.bar:SetValue(0) |
| self.PowerFrame.text:SetText() |
| if InCombat then |
| mRunes.FadeIn(self.PowerFrame, true, db.AlphaIncCombat) |
| elseif HaveRP then |
| mRunes.FadeIn(self.PowerFrame, true, db.AlphaActive) |
| else |
| mRunes.FadeIn(self.PowerFrame, true, db.AlphaOutCombat) |
| end |
| end |
| end |
| -- ~~~~~~~~~~~~~~~~~~~~ |
| -- Events ~~~~~~~~~~~~~ |
| -- ~~~~~~~~~~~~~~~~~~~~ |
| function plugin:RunicPowerChange(event, unit) |
| if ConfigMode then return end |
| self = plugin |
| if unit and unit ~= "player" then return end |
| local power = UnitPower("player") |
| local maxPower = UnitPowerMax("player") |
| local p = power / maxPower |
| local haveRP = false |
| local oldHaveRP = HaveRP |
| if power > 0 then |
| haveRP = true |
| self.PowerFrame.bar:SetValue(p) |
| self.PowerFrame.text:SetFormattedText("%d", power) |
| if db.ShowText and not self.PowerFrame.text:IsShown() then self.PowerFrame.text:Show() end |
| else |
| mRunes:UnregisterOnUpdate(self.PowerFrame, self.RunicPowerChange) |
| self.PowerFrame.bar:SetValue(0) |
| self.PowerFrame.text:SetFormattedText("%d", 0) |
| if not db.AlwaysShowText and not ConfigMode then |
| if self.PowerFrame.text:IsShown() then self.PowerFrame.text:Hide() end |
| elseif db.ShowText then |
| if not self.PowerFrame.text:IsShown() then self.PowerFrame.text:Show() end |
| else |
| if self.PowerFrame.text:IsShown() then self.PowerFrame.text:Hide() end |
| end |
| end |
| if not InCombat then |
| HaveRP = haveRP |
| if HaveRP and (HaveRP ~= oldHaveRP) then |
| local currAlpha = self.PowerFrame:GetAlpha() |
| if currAlpha < db.AlphaActive then |
| mRunes.FadeIn(self.PowerFrame, false, db.AlphaActive) |
| else |
| mRunes.FadeOut(self.PowerFrame, db.AlphaActive) |
| local t = 2 |
| end |
| elseif not HaveRP and (HaveRP ~= oldHaveRP) then |
| mRunes.FadeOut(self.PowerFrame, db.AlphaOutCombat) |
| end |
| end |
| end |
| -- ~~~~~~~~~~~~~~~~~~~~ |
| -- Settings ~~~~~~~~~~~ |
| -- ~~~~~~~~~~~~~~~~~~~~ |
| function plugin:ApplySettings() |
| local PowerFrame = self.PowerFrame |
| if PowerFrame then |
| local anchor = FA:GetAnchor(db.Attached.f) |
| PowerFrame:ClearAllPoints() |
| PowerFrame:SetPoint(db.Attached.Point, anchor, db.Attached.RelPoint, db.Attached.x, db.Attached.y) |
| PowerFrame:SetWidth(db.Width) |
| PowerFrame:SetHeight(db.Height) |
| backdrop.insets.left = db.BorderInsets |
| backdrop.insets.right = db.BorderInsets |
| backdrop.insets.top = db.BorderInsets |
| backdrop.insets.bottom = db.BorderInsets |
| backdrop.edgeFile = LSM:Fetch("border", db.BorderTexture) |
| backdrop.edgeSize = db.BorderWidth |
| backdrop.bgFile = LSM:Fetch("background", "Solid") |
| PowerFrame:SetBackdrop(backdrop) |
| PowerFrame:SetBackdropColor(unpack(db.BackgroundColor)) |
| PowerFrame:SetBackdropBorderColor(unpack(db.BorderColor)) |
| local leftinset, rightinset = 0, 0 |
| if db.HorAlign == "LEFT" then |
| leftinset = db.InternalSpacing |
| elseif db.HorAlign == "RIGHT" then |
| rightinset = -db.InternalSpacing |
| end |
| PowerFrame.text:SetPoint("TOPLEFT", leftinset, 0) |
| PowerFrame.text:SetPoint("BOTTOMRIGHT", rightinset, 0) |
| PowerFrame.text:SetFont(LSM:Fetch("font", db.Font), db.FontSize, db.FontFlags) |
| PowerFrame.text:SetTextColor(unpack(db.FontColor)) |
| PowerFrame.text:SetJustifyH(db.HorAlign) |
| PowerFrame.text:SetJustifyV("MIDDLE") |
| local bar = PowerFrame.bar |
| bar:ClearAllPoints() |
| bar:SetPoint("TOPLEFT", db.BorderPadding, -db.BorderPadding) |
| bar:SetPoint("BOTTOMRIGHT", -db.BorderPadding, db.BorderPadding) |
| bar:SetStatusBarTexture(LSM:Fetch("statusbar", db.Texture)) |
| bar:GetStatusBarTexture():SetHorizTile(false) |
| bar:SetStatusBarColor(unpack(db.PowerColor)) |
| if not ConfigMode then |
| PowerFrame:SetAlpha(InCombat and db.AlphaIncCombat or (HaveRP and db.AlphaActive or db.AlphaOutCombat)) |
| end |
| if PowerFrame:GetAlpha() > 0 then PowerFrame:Show() else PowerFrame:Hide() end |
| if db.AlwaysShowText and db.ShowText then |
| PowerFrame.text:Show() |
| elseif not db.ShowText then |
| PowerFrame.text:Hide() |
| end |
| self:RunicPowerChange("UNIT_RUNIC_POWER", "player") |
| end |
| if not db.Enabled and self:IsEnabled() then self:Disable() |
| elseif db.Enabled and not self:IsEnabled() then self:Enable() end |
| end |
| -- ~~~~~~~~~~~~~~~~~~~~ |
| -- Create Frames ~~~~~~ |
| -- ~~~~~~~~~~~~~~~~~~~~ |
| function plugin:CreatePowerFrame() |
| local frame = CreateFrame("Frame", nil, UIParent) |
| --BD:EnhanceBackdrop(frame) |
| FA:RegisterAnchor("mRunes", "Runic Power", "mRunesRunicPower", frame) |
| local bar = CreateFrame("StatusBar", nil, frame) |
| bar:SetMinMaxValues(0,1) |
| frame.bar = bar |
| local text = bar:CreateFontString(nil, nil, "GameFontNormal") |
| frame.text = text |
| local configFrame = CreateFrame("Frame", nil, frame) |
| configFrame:SetAllPoints() |
| configFrame:SetFrameLevel(bar:GetFrameLevel() + 10) |
| local configText = configFrame:CreateFontString(nil, "OVERLAY", "GameFontNormal") |
| configText:SetAllPoints() |
| configText:SetText("Runic Power") |
| configText:Hide() |
| frame.ConfigText = configText |
| self.PowerFrame = frame |
| end |
| -- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
| -- Options ~~~~~~~~~~~~~~~~~~~~ |
| -- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
| function plugin:GetOptions() |
| return plugin.GetGUI |
| end |
| do |
| local function Callback() |
| plugin:ApplySettings() |
| end |
| local FontFlagList = { |
| ["NONE"] = "None", |
| ["OUTLINE"] = "Outline", |
| ["THICKOUTLINE"] = "Thick Outline", |
| ["MONOCHROME"] = "Monochrome", |
| } |
| local VerticalAlignList = { |
| ["TOP"] = "Top", |
| ["MIDDLE"] = "Middle", |
| ["BOTTOM"] = "Bottom", |
| } |
| local HorizontalAlignList = { |
| ["LEFT"] = "Left", |
| ["CENTER"] = "Center", |
| ["RIGHT"] = "Right", |
| } |
| local TabSelected |
| local LastTablSelected |
| function plugin:GetGUI() |
| self = plugin |
| local returnGroup = AceGUI:Create("SimpleGroup") |
| returnGroup:SetFullWidth(true) |
| returnGroup:SetLayout("Flow") |
| returnGroup:AddChild(UIF:NewLine(10)) |
| returnGroup:AddChild(UIF:CheckBox("Enabled", db, "Enabled", Callback, nil, 0.33)) |
| local tgroup = UIF:TabGroup() |
| returnGroup:AddChild(tgroup) |
| tgroup:SetTabs({ |
| {text = "Position & Size", value = "PaS"}, |
| {text = "Colors & Alpha", value = "CaA"}, |
| {text = "Font", value = "Font"}, |
| }) |
| tgroup:SetCallback("OnGroupSelected", TabSelected) |
| tgroup:SelectTab(LastTablSelected or "PaS") |
| return returnGroup |
| end |
| TabSelected = function(self, event, tab) |
| self:ReleaseChildren() |
| LastTablSelected = tab |
| if tab == "PaS" then |
| self:AddChild(UIF:Text1("Select a frame to attach to. You can then adjust the relative positioning to that frame via X and Y as well as the anchor points.")) |
| local t = AceGUI:Create("FrameAnchorDropdown") |
| t:SetRelativeWidth(0.5) |
| t:SetList(FA:GetAnchors(plugin.PowerFrame)) |
| t:SetLabel("Anchor") |
| t:SetValue(db.Attached.f) |
| t:SetCallback("OnValueChanged", function(self, event, cat, name, frame) |
| db.Attached.f = cat |
| Callback() |
| end) |
| self:AddChild(t) |
| self:AddChild(UIF:Spacer(10)) |
| self:AddChild(UIF:Text2("Avoid creating circle references!", nil, nil, nil, nil, nil, 0.4)) |
| self:AddChild(UIF:NewLine()) |
| self:AddChild(UIF:Dropdown("Point", db.Attached, "Point", Callback, mRunes:GetAnchorList(), 0.5, true)) |
| self:AddChild(UIF:Dropdown("Relative Point", db.Attached, "RelPoint", Callback, mRunes:GetAnchorList(), 0.5, true)) |
| self:AddChild(UIF:Slider("X", db.Attached, "x", -300, 300, 0.1, Callback, 0.5)) |
| self:AddChild(UIF:Slider("Y", db.Attached, "y", -300, 300, 0.1, Callback, 0.5)) |
| self:AddChild(UIF:Slider("Width", db, "Width", 5, 1000, 0.1, Callback, 0.5)) |
| self:AddChild(UIF:Slider("Height", db, "Height", 5, 200, 0.1, Callback, 0.5)) |
| elseif tab == "CaA" then |
| local group = UIF:InlineGroup2("Bar Color") |
| self:AddChild(group) |
| group:AddChild(UIF:ColorSelect("Runic Power color", db, "PowerColor", Callback, true, 1.0)) |
| group = UIF:InlineGroup2("Alpha") |
| self:AddChild(group) |
| group:AddChild(UIF:Slider("In combat", db, "AlphaIncCombat", 0, 1, 0.01, Callback, 0.33)) |
| group:AddChild(UIF:Slider("OOC (RP > 0)", db, "AlphaActive", 0, 1, 0.01, Callback, 0.33)) |
| group:AddChild(UIF:Slider("OOC (RP = 0)", db, "AlphaOutCombat", 0, 1, 0.01, Callback, 0.33)) |
| group = UIF:InlineGroup2("Border and Background") |
| self:AddChild(group) |
| group:AddChild(UIF:LSMDropdown("border", "Border texture", db, "BorderTexture", Callback, 0.5)) |
| group:AddChild(UIF:LSMDropdown("statusbar", "Bar Texture", db, "Texture", Callback, 0.5)) |
| group:AddChild(UIF:ColorSelect("Background Color", db, "BackgroundColor", Callback, true, 0.5)) |
| group:AddChild(UIF:ColorSelect("Border color", db, "BorderColor", Callback, true, 0.5)) |
| group:AddChild(UIF:Slider("Border Width", db, "BorderWidth", 0, 50, 1, Callback, 0.33)) |
| group:AddChild(UIF:Slider("Border Padding", db, "BorderPadding", 0, 100, 0.1, Callback, 0.33)) |
| group:AddChild(UIF:Slider("Border Insets", db, "BorderInsets", 0, 50, 1, Callback, 0.33)) |
| elseif tab == "Font" then |
| self:AddChild(UIF:Text1("These settings are for the text display of current runic power.")) |
| self:AddChild(UIF:CheckBox("Show", db, "ShowText", Callback, "Toggle if the runic power text should be shown.", 0.5)) |
| self:AddChild(UIF:CheckBox("Always Show", db, "AlwaysShowText", Callback, "Toggle if the runic power text should always be shown. If not it will be hidden when the runc power is at 0", 0.5)) |
| self:AddChild(UIF:LSMDropdown("font", "Font", db, "Font", Callback, 0.5)) |
| self:AddChild(UIF:Dropdown("Font Flags", db, "FontFlags", Callback, FontFlagList, 0.5)) |
| self:AddChild(UIF:ColorSelect("Color", db, "FontColor", Callback, false, 0.2)) |
| self:AddChild(UIF:Slider("Size", db, "FontSize", 2, 50, 1, Callback, 0.4)) |
| self:AddChild(UIF:Slider("Margin", db, "InternalSpacing", 0, 50, 0.1, Callback, 0.4)) |
| self:AddChild(UIF:Dropdown("Horizontal Align", db, "HorAlign", Callback, HorizontalAlignList, 0.5)) |
| end |
| self:DoLayout() |
| self.parent:DoLayout() |
| end |
| end |
mRunes/Modules/Timers.lua
New file
0,0 → 1,825
\ No newline at end of file
| local _, class = UnitClass("player") |
| if class ~= "DEATHKNIGHT" then |
| return |
| end |
| local plugin = mRunes:NewModule("Timers", "AceEvent-3.0") |
| plugin.mRunesPlugin = true |
| local AceGUI = LibStub("AceGUI-3.0") |
| local LSM = LibStub("LibSharedMedia-3.0") |
| local BD = LibStub("LibBackdrop-1.0") |
| local FA = LibStub("LibFrameAnchorRegistry-1.0") |
| local UIF |
| local db |
| local LUnitDebuff = UnitDebuff |
| local LUnitBuff = UnitBuff |
| local InCombat = false |
| local ConfigMode = false |
| local Bars = { |
| } |
| local Spells = { |
| { |
| id = "FrostFever", |
| spell = 59921 |
| }, |
| { |
| id = "BloodPlague", |
| spell = 59879 |
| }, |
| { |
| id = "ScarletFever", |
| spell = 81130, |
| talent = { |
| tab = 1, |
| index = 6, |
| }, |
| }, |
| { |
| id = "UnholyBlight", |
| spell = 50536, |
| talent = { |
| tab = 3, |
| index = 13, |
| }, |
| }, |
| { |
| id = "EbonPlague", |
| spell = 65142, |
| talent = { |
| tab = 3, |
| index = 17, |
| } |
| }, |
| { |
| id = "ShadowInfustion", |
| spell = 91342, |
| talent = { |
| tab = 3, |
| index = 10, |
| }, |
| unit = "pet", |
| type = "buff", |
| showStacks = true, |
| }, |
| { |
| id = "DarkTransformation", |
| spell = 93426, |
| talent = { |
| tab = 3, |
| index = 16, |
| }, |
| unit = "pet", |
| type = "buff", |
| }, |
| { |
| id = "FreezingFog", |
| spell = 59052, |
| talent = { |
| tab = 2, |
| index = 11, |
| }, |
| type = "buff", |
| unit = "player", |
| }, |
| { |
| id = "KillingMachine", |
| spell = 51124, |
| talent = { |
| tab = 2, |
| index = 10, |
| }, |
| type = "buff", |
| unit = "player", |
| }, |
| { |
| id = "SuddenDoom", |
| spell = 81340, |
| talent = { |
| tab = 3, |
| index = 18, |
| }, |
| type = "buff", |
| unit = "player", |
| }, |
| { |
| id = "BloodSwarm", |
| spell = 81141, |
| talent = { |
| tab = 1, |
| index = 19, |
| }, |
| type = "buff", |
| unit = "player", |
| }, |
| { |
| id = "RunicCorruption", |
| spell = 51460, |
| talent = { |
| tab = 3, |
| index = 7, |
| }, |
| type = "buff", |
| unit = "player", |
| } |
| } |
| -- local name, icon, tier, column, currentRank, maxRank = GetTalentInfo(tab, i, isnotplayer) |
| local backdrop = { |
| tile = true, |
| tileSize = 16, |
| insets = {}, |
| } |
| plugin.DisplayName = "Timers" |
| plugin.DisplayIcon = [[Interface\Icons\spell_deathknight_bloodplague]] |
| plugin.DisplayOrder = 3 |
| function plugin:OnInitialize() |
| local defaults = { |
| profile = { |
| Enabled = true, |
| Bar = { |
| ["**"] = { |
| Attached = { |
| f = nil, |
| x = 0, |
| y = 0, |
| OffSetY = 0, |
| Point = "TOP", |
| RelPoint = "BOTTOM", |
| StretchToParent = true, |
| }, |
| Enabled = true, |
| DisableOnMissingTalent = true, |
| NotCountMissing = true, |
| RelativeHeight = 1, |
| Color = {1, 1, 1, 1}, |
| Order = 1, |
| ShowName = true, |
| ShowTime = true, |
| Width = 330, |
| Height = 25, |
| BarSpacing = 2, |
| AlphaIncCombat = 1, |
| AlphaOutCombat = 0.0, |
| ShowIcon = true, |
| Texture = "HalD", |
| BorderTexture = "None", |
| BorderWidth = 5, |
| BorderInsets = 0, |
| BorderPadding = 0, |
| BorderColor = {0, 0, 0, 1}, |
| BackgroundColor = {0, 0, 0, 0.5}, |
| Font = "accid", |
| FontSize = 16, |
| FontFlags = "OUTLINE", |
| FontColor = {1, 1, 1, 1}, |
| HorAlign = "LEFT", |
| InternalSpacing = 2, |
| UseGlobals = true, |
| }, |
| ["Global"] = { |
| }, |
| ["FrostFever"] = { |
| Color = {12/255, 146/255, 237/255, 1}, |
| }, |
| ["BloodPlague"] = { |
| Color = {255/255, 0/255, 228/255, 1}, |
| }, |
| ["ScarletFever"] = { |
| Color = {208/255, 77/255, 0/255, 1}, |
| }, |
| ["EbonPlague"] = { |
| Color = {169/255, 0/255, 255/255, 1}, |
| }, |
| ["ShadowInfustion"] = { |
| Color = {8/255, 153/255, 32/255, 1}, |
| }, |
| ["DarkTransformation"] = { |
| Color = {8/255, 153/255, 32/255, 1}, |
| }, |
| ["SuddenDoom"] = { |
| Color = {255/255, 0/255, 69/255, 1}, |
| }, |
| ["UnholyBlight"] = { |
| Color = {115/255, 255/255, 59/255, 1}, |
| }, |
| ["KillingMachine"] = { |
| Color = {54/255, 255/255, 232/255, 1}, |
| }, |
| ["FreezingFog"] = { |
| Color = {0/255, 145/255, 255/255, 1}, |
| }, |
| ["RunicCorruption"] = { |
| Color = {253/255, 36/255, 255/255, 1}, |
| }, |
| ["BloodSwarm"] = { |
| Color = {255/255, 219/255, 0/255, 1}, |
| }, |
| }, |
| } |
| } |
| for i, data in pairs(Spells) do |
| defaults.profile.Bar[data.id] = defaults.profile.Bar[data.id] or {} |
| defaults.profile.Bar[data.id].NotCountMissing = data.NotCountMissing |
| end |
| self.db = mRunes.db:RegisterNamespace(self:GetName(), defaults) |
| self.db.RegisterCallback(self, "OnProfileChanged", "ProfileChanged") |
| self.db.RegisterCallback(self, "OnProfileCopied", "ProfileChanged") |
| self.db.RegisterCallback(self, "OnProfileReset", "ProfileChanged") |
| db = self.db.profile |
| self:SetEnabledState(db.Enabled) |
| UIF = LibStub("LibGUIFactory-1.0"):GetFactory("mRunes") |
| if not self.DiseaseFrame then |
| self:CreateDiseaseFrame() |
| end |
| end |
| function plugin:OnEnable() |
| self:RegisterEvent("UNIT_AURA") |
| self:RegisterEvent("PLAYER_TARGET_CHANGED") |
| self:RegisterEvent("PLAYER_TALENT_UPDATE", "ApplySettings") |
| mRunes.RegisterCallback(self, "EnteringCombat") |
| mRunes.RegisterCallback(self, "LeavingCombat") |
| mRunes.RegisterCallback(self, "ToggleConfigMode") |
| FA.RegisterCallback(self, "FrameUnregistered", "ApplySettings") |
| self:ApplySettings() |
| mRunes:RegisterOnUpdate(self, self.Update) |
| self:UNIT_AURA("UNIT_AURA", "target") |
| self:UNIT_AURA("UNIT_AURA", "pet") |
| end |
| function plugin:OnDisable() |
| mRunes:UnregisterOnUpdate(self, self.Update) |
| mRunes.UnregisterAllCallbacks(self) |
| end |
| function plugin:ProfileChanged(event) |
| db = self.db.profile |
| for i, bar in pairs(Bars) do |
| bar.db = db.Bar[bar.id] |
| end |
| self:ApplySettings() |
| end |
| -- ~~~~~~~~~~~~~~~~~~~~ |
| -- Callbacks ~~~~~~~~~~ |
| -- ~~~~~~~~~~~~~~~~~~~~ |
| function plugin:EnteringCombat(event) |
| if UnitExists("target") and UnitReaction("player", "target") < 5 then |
| end |
| InCombat = true |
| end |
| function plugin:LeavingCombat(event) |
| InCombat = false |
| end |
| function plugin:ToggleConfigMode(event, enable) |
| ConfigMode = enable |
| self:ApplySettings() |
| end |
| function plugin:Update() |
| local t = GetTime() |
| for name, bar in pairs(Bars) do |
| local bdb = bar.db |
| if bdb.Enabled then |
| if bar.duration then |
| local dur = bar.expires - t |
| if dur < 0 then |
| bar.expires = nil |
| bar.duration = nil |
| bar.stacks = nil |
| bar:SetValue(0) |
| bar.text:SetText() |
| if not self:ShouldShow(bar) and bar.background:IsShown() then |
| bar.background:Hide() |
| bar.background:SetHeight(0.01) |
| plugin:ReAnchor() |
| end |
| else |
| bar:SetValue(dur / bar.duration) |
| if bdb.UseGlobals then bdb = db.Bar.Global end |
| if bdb.ShowTime and bdb.ShowName then |
| bar.text:SetFormattedText("%s %s: %.1f", bar.SpellName, bar.ShowStacks and ("(%d)"):format(bar.stacks) or "", dur) |
| elseif bdb.ShowTime then |
| bar.text:SetFormattedText("%s %.1f ", bar.ShowStacks and ("(%d)"):format(bar.stacks) or "", dur) |
| elseif bdb.ShowName then |
| bar.text:SetFormattedText("%s %s", bar.SpellName, bar.ShowStacks and ("(%d)"):format(bar.stacks) or "") |
| else |
| bar.text:SetText() |
| end |
| end |
| end |
| end |
| end |
| end |
| -- ~~~~~~~~~~~~~~~~~~~~ |
| -- Events ~~~~~~~~~~~~~ |
| -- ~~~~~~~~~~~~~~~~~~~~ |
| function plugin:UNIT_AURA(event, unit) |
| if ConfigMode then return end |
| if unit == "target" or unit == "pet" or unit == "player" then |
| for i, bar in pairs(Bars) do |
| if unit == bar.Unit then |
| local bdb = bar.db |
| local BuffFunc = bar.Type == "debuff" and LUnitDebuff or LUnitBuff |
| local name, rank, icon, count, atype, duration, expires, caster, stealable, shouldConsolidate, spellId = BuffFunc(unit, bar.SpellName) |
| if name and caster == "player" then |
| bar.expires = expires |
| bar.duration = duration |
| bar.stacks = count |
| if self:ShouldShow(bar) and not bar.background:IsShown() then |
| bar.background:Show() |
| bar.background:SetHeight(bdb.Height) |
| self:ReAnchor() |
| end |
| else |
| bar.expires = nil |
| bar.duration = nil |
| bar.stacks = nil |
| bar:SetValue(0) |
| bar.text:SetText() |
| if not self:ShouldShow(bar) and bar.background:IsShown() then |
| bar.background:Hide() |
| bar.background:SetHeight(0.01) |
| self:ReAnchor() |
| end |
| end |
| end |
| end |
| end |
| end |
| function plugin:PLAYER_TARGET_CHANGED(event) |
| self:UNIT_AURA("UNIT_AURA", "target") |
| end |
| -- ~~~~~~~~~~~~~~~~~~~~ |
| -- Settings ~~~~~~~~~~~ |
| -- ~~~~~~~~~~~~~~~~~~~~ |
| local SortedBars = {} |
| local function SortBars(a, b) |
| return a.db.Order < b.db.Order |
| end |
| function plugin:ApplySettings() |
| for i, b in pairs(Spells) do |
| local bar = Bars[i] |
| local bdb = bar.db |
| local frame = bar.background |
| -- Cannot be global |
| bar:SetStatusBarColor(unpack(bdb.Color)) |
| -- Can be globla |
| if bdb.UseGlobals then |
| bdb = db.Bar.Global |
| end |
| backdrop.insets.left = bdb.BorderInsets |
| backdrop.insets.right = bdb.BorderInsets |
| backdrop.insets.top = bdb.BorderInsets |
| backdrop.insets.bottom = bdb.BorderInsets |
| backdrop.edgeFile = LSM:Fetch("border", bdb.BorderTexture) |
| backdrop.edgeSize = bdb.BorderWidth |
| backdrop.bgFile = LSM:Fetch("background", "Solid") |
| frame:SetBackdrop(backdrop) |
| frame:SetBackdropColor(unpack(bdb.BackgroundColor)) |
| frame:SetBackdropBorderColor(unpack(bdb.BorderColor)) |
| bar:SetStatusBarTexture(LSM:Fetch("statusbar", bdb.Texture)) |
| local leftinset, rightinset = 0, 0 |
| if bdb.HorAlign == "LEFT" then |
| leftinset = bdb.InternalSpacing |
| elseif bdb.HorAlign == "RIGHT" then |
| rightinset = -bdb.InternalSpacing |
| end |
| bar.text:SetPoint("TOPLEFT", leftinset, 0) |
| bar.text:SetPoint("BOTTOMRIGHT", rightinset, 0) |
| bar.text:SetFont(LSM:Fetch("font", bdb.Font), bdb.FontSize, bdb.FontFlags) |
| bar.text:SetTextColor(unpack(bdb.FontColor)) |
| bar.text:SetJustifyH(bdb.HorAlign) |
| bar.text:SetJustifyV("MIDDLE") |
| if ConfigMode then |
| for _, bar in pairs(Bars) do |
| local min, max = bar:GetMinMaxValues() |
| bar.background:SetHeight(bar.db.Height) |
| bar.background:Show() |
| bar:SetValue(math.random(50, 70) / 100) |
| bar.text:SetFormattedText("%s "..(bdb.ShowTime and "%.1f" or ""), bdb.ShowName and bar.SpellName or "", math.random(10, 40 * 100) / 100) |
| end |
| else |
| for _, bar in pairs(Bars) do |
| bar:SetValue(0) |
| end |
| end |
| end |
| self:ReAnchor() |
| if not db.Enabled and self:IsEnabled() then self:Disable() |
| elseif db.Enabled and not self:IsEnabled() then self:Enable() end |
| end |
| function plugin:ReAnchor() |
| for i, b in pairs(Spells) do |
| local bar = Bars[i] |
| local bdb = bar.db |
| local anchor |
| if bdb.Attached.f then |
| anchor = FA:GetAnchor(bdb.Attached.f) |
| end |
| if not anchor then |
| anchor = i == 1 and FA:GetAnchor("mRunesRunicPower") or Bars[i-1].background |
| end |
| local frame = bar.background |
| frame:ClearAllPoints() |
| local offset = (bdb.UseGlobals and db.Bar.Global.Attached.OffSetY or bdb.Attached.OffSetY) |
| if bdb.Attached.Point == "TOPLEFT" or bdb.Attached.Point == "TOPRIGHT" or bdb.Attached.Point == "TOP" then |
| offset = -offset |
| end |
| frame:SetPoint(bdb.Attached.Point, anchor, bdb.Attached.RelPoint, bdb.Attached.x, bdb.Attached.y + offset) |
| if bdb.Attached.StretchToParent then |
| frame:SetPoint("LEFT", anchor) |
| frame:SetPoint("RIGHT", anchor) |
| else |
| frame:SetWidth(bdb.UseGlobals and db.Bar.Globa.Width or bdb.Width) |
| end |
| if bdb.UseGlobals then bdb = db.Bar.Global end |
| if self:ShouldShow(bar) and not bar.background:IsShown() then |
| frame:Show() |
| frame:SetHeight(bdb.Height) |
| elseif not self:ShouldShow(bar) and bar.background:IsShown() then |
| frame:Hide() |
| frame:SetHeight(0.01) |
| elseif self:ShouldShow(bar) then |
| frame:SetHeight(bdb.Height) |
| end |
| bar:ClearAllPoints() |
| if bdb.ShowIcon then |
| bar.icon:ClearAllPoints() |
| bar.icon:SetPoint("TOPLEFT", frame, "TOPLEFT", bdb.BorderPadding, -bdb.BorderPadding) |
| bar.icon:SetHeight(frame:GetHeight() - bdb.BorderPadding * 2) |
| bar.icon:SetWidth(frame:GetHeight() - bdb.BorderPadding * 2) |
| bar.icon:SetTexture(bar.SpellIcon) |
| bar.icon:Show() |
| bar:SetPoint("TOPLEFT", bar.icon, "TOPRIGHT", 2, 0) |
| bar:SetPoint("BOTTOMRIGHT", frame, "BOTTOMRIGHT", -bdb.BorderPadding, bdb.BorderPadding) |
| else |
| bar.icon:Hide() |
| bar:SetPoint("TOPLEFT", frame, bdb.BorderPadding, -bdb.BorderPadding) |
| bar:SetPoint("BOTTOMRIGHT", frame, -bdb.BorderPadding, bdb.BorderPadding) |
| end |
| bar:SetMinMaxValues(0, 1) |
| end |
| end |
| function plugin:ShouldShow(bar) |
| local bdb = bar.db |
| if not bdb.Enabled then return false end |
| if ConfigMode then return true end |
| if bar.Restriction and bdb.DisableOnMissingTalent then |
| if bar.Restriction.type == "TALENT" then |
| local name, icon, tier, column, currentRank, maxRank = GetTalentInfo(bar.Restriction.tab, bar.Restriction.index, false) |
| if not name or currentRank == 0 then |
| return false |
| end |
| end |
| end |
| if bdb.NotCountMissing and not bar.duration then |
| return false |
| end |
| if bar.Unit == "target" and (not InCombat or not UnitExists("target") or UnitReaction("player", "target") > 4)then |
| return false |
| end |
| return true |
| end |
| -- ~~~~~~~~~~~~~~~~~~~~ |
| -- Create Frames ~~~~~~ |
| -- ~~~~~~~~~~~~~~~~~~~~ |
| function plugin:CreateDiseaseFrame() |
| for s, data in pairs(Spells) do |
| local spellID = (type(data.spell) == "table") and data.spell[1] or data.spell |
| local spellName, _, spellIcon = GetSpellInfo(spellID) |
| if spellName then |
| local bar = self:CreateBar(UIParent, data.id, spellName) |
| bar.Spell = spellID |
| bar.SpellName = spellName |
| bar.SpellIcon = spellIcon |
| bar.Unit = data.unit or "target" |
| bar.Type = data.type or "debuff" |
| bar.ShowStacks = data.showStacks |
| bar.NotCountMissing = data.NotCountMissing |
| bar.db = db.Bar[data.id] |
| bar.id = data.id |
| if data.talent then |
| bar.Restriction = { |
| type = "TALENT", |
| tab = data.talent.tab, |
| index = data.talent.index, |
| } |
| end |
| Bars[s] = bar |
| end |
| end |
| end |
| function plugin:CreateBar(parent, BarName, SpellName) |
| local frame = CreateFrame("Frame", "mRunes"..BarName.."Background", parent) |
| local bar = CreateFrame("StatusBar", "mRunes"..BarName.."Bar", frame) |
| --BD:EnhanceBackdrop(frame) |
| bar.background = frame |
| FA:RegisterAnchor("mRunes\001Timers", SpellName, "mRunesTimer"..BarName, frame) |
| local text = bar:CreateFontString(nil, nil, "GameFontNormal") |
| bar.text = text |
| local icon = frame:CreateTexture(nil, "ARTOWORK") |
| icon:SetTexCoord(0.08, 0.92, 0.08, 0.92) |
| bar.icon = icon |
| bar:SetFrameLevel(bar.background:GetFrameLevel() + 1) |
| return bar |
| end |
| -- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
| -- Options ~~~~~~~~~~~~~~~~~~~~ |
| -- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
| function plugin:GetOptions() |
| return plugin.GetGUI |
| end |
| do |
| local function Callback() |
| plugin:ApplySettings() |
| end |
| local FontFlagList = { |
| ["NONE"] = "None", |
| ["OUTLINE"] = "Outline", |
| ["THICKOUTLINE"] = "Thick Outline", |
| ["MONOCHROME"] = "Monochrome", |
| } |
| local VerticalAlignList = { |
| ["TOP"] = "Top", |
| ["MIDDLE"] = "Middle", |
| ["BOTTOM"] = "Bottom", |
| } |
| local HorizontalAlignList = { |
| ["LEFT"] = "Left", |
| ["CENTER"] = "Center", |
| ["RIGHT"] = "Right", |
| } |
| local TabSelected |
| local LastTabSelected |
| local BarSelected |
| local LastBarSelected |
| local GlobalSettings |
| local BarTabs = {} |
| function plugin:GetGUI() |
| self = plugin |
| local returnGroup = AceGUI:Create("SimpleGroup") |
| returnGroup:SetFullWidth(true) |
| returnGroup:SetLayout("Flow") |
| returnGroup:AddChild(UIF:NewLine(10)) |
| returnGroup:AddChild(UIF:CheckBox("Enabled", db, "Enabled", Callback, nil, 0.33)) |
| wipe(BarTabs) |
| for name, bar in pairs(Bars) do |
| BarTabs[bar.id] = {text = bar.SpellName, value = bar.id, icon = bar.SpellIcon} |
| if not bar.db.UseGlobals then BarTabs[bar.id].text = "** "..bar.SpellName end |
| end |
| BarTabs["1"] = {text = "Global", value = "1"} |
| table.sort(BarTabs, function(a, b) return a.text < b.text end) |
| local tgroup = UIF:DropdownGroup("Spells") |
| tgroup:SetLayout("Flow") |
| returnGroup:AddChild(tgroup) |
| tgroup:SetGroupList(BarTabs) |
| tgroup:SetCallback("OnGroupSelected", BarSelected) |
| tgroup:SetGroup(LastBarSelected or "1") |
| return returnGroup |
| end |
| BarSelected = function(self, event, tab) |
| self:ReleaseChildren() |
| LastBarSelected = tab |
| if tab == "1" then |
| GlobalSettings(self) |
| else |
| local bar |
| for _, b in pairs(Bars) do |
| if b.id == tab then |
| bar = b |
| break |
| end |
| end |
| local title = UIF:Title2(bar.SpellName) |
| title:SetImageSize(30, 30) |
| title:SetImage(bar.SpellIcon) |
| self:AddChild(title) |
| self:AddChild(UIF:CheckBox("Enabled", bar.db, "Enabled", Callback, nil, 0.3)) |
| self:AddChild(UIF:ColorSelect("Color", bar.db, "Color", Callback, true, 0.2)) |
| self:AddChild(UIF:CheckBox("Use globals", bar.db, "UseGlobals", Callback, "Overrides font, texture, name and time settings.", 0.5)) |
| local tgroup = UIF:TabGroup() |
| tgroup:SetTabs( |
| { |
| {text = "Anchoring and Size", value = "anchor"}, |
| {text = "Font", value = "font"}, |
| {text = "Texture and Colors", value = "tex"}, |
| } |
| ) |
| self:AddChild(tgroup) |
| tgroup.userdata.bar = bar |
| tgroup:SetCallback("OnGroupSelected", TabSelected) |
| tgroup:SelectTab(LastSelectedTab or "anchor") |
| end |
| end |
| TabSelected = function(self, event, tab) |
| self:ReleaseChildren() |
| LastSelectedTab = tab |
| local bar = self.userdata.bar |
| local bdb = self.userdata.bar.db |
| if tab == "anchor" then |
| self:AddChild(UIF:Text1("Select a frame to attach to. You can then adjust the relative positioning to that frame via X and Y as well as the anchor points.")) |
| self:AddChild(UIF:CheckBox("Spell Icon", bdb, "ShowIcon", Callback, "Show the icon for the spell on the left side of the bar", 0.5)) |
| local t = AceGUI:Create("FrameAnchorDropdown") |
| t:SetRelativeWidth(0.5) |
| t:SetList(FA:GetAnchors(bar.background)) |
| t:SetLabel("Anchor") |
| t:SetValue(bdb.Attached.f) |
| t:SetCallback("OnValueChanged", function(self, event, cat, name, frame) |
| bdb.Attached.f = cat |
| Callback() |
| end) |
| self:AddChild(t) |
| self:AddChild(UIF:NewLine()) |
| self:AddChild(UIF:Dropdown("Point", bdb.Attached, "Point", Callback, mRunes:GetAnchorList(), 0.5, true)) |
| self:AddChild(UIF:Dropdown("Relative Point", bdb.Attached, "RelPoint", Callback, mRunes:GetAnchorList(), 0.5, true)) |
| self:AddChild(UIF:CheckBox("Stretch to anchor", bdb.Attached, "StretchToParent", function() |
| plugin:ApplySettings() |
| TabSelected(self, event, tab) |
| end, "Will override X-postion and width, and instead stretch the timer to whatever it is anchored to", 1)) |
| local sliderx = UIF:Slider("X", bdb.Attached, "x", -1500, 1500, 0.1, Callback, 0.5) |
| sliderx:SetDisabled(bdb.Attached.StretchToParent) |
| self:AddChild(sliderx) |
| local sliderw = UIF:Slider("Width", bdb, "Width", 5, 1000, 0.1, Callback, 0.5) |
| sliderw:SetDisabled(bdb.Attached.StretchToParent) |
| self:AddChild(sliderw) |
| self:AddChild(UIF:Slider("Y", bdb.Attached, "y", -1500, 1500, 0.1, Callback, 0.5)) |
| self:AddChild(UIF:Slider("Height", bdb, "Height", 5, 200, 0.1, Callback, 0.5)) |
| self:AddChild(UIF:CheckBox("Name", bdb, "ShowName", Callback, "Toggle display of spellname on the bar", 0.5)) |
| self:AddChild(UIF:CheckBox("Time", bdb, "ShowTime", Callback, "Toggle display of remaining time", 0.5)) |
| self:AddChild(UIF:CheckBox("Collapse when missing", bdb, "NotCountMissing", Callback, "Toggle if the bars should collapse and take up no space when the the spell is missing", 0.5)) |
| if bar.Restriction then |
| if bar.Restriction.type == "TALENT" then |
| self:AddChild(UIF:CheckBox("Disable when missing talent", bdb, "DisableOnMissingTalent", Callback, "This will disable this bar if the talent for it is missing", 0.8)) |
| end |
| self:AddChild(UIF:NewLine()) |
| end |
| elseif tab == "font" then |
| self:AddChild(UIF:LSMDropdown("font", "Font", bdb, "Font", Callback, 0.5)) |
| self:AddChild(UIF:Dropdown("Font Flags", bdb, "FontFlags", Callback, FontFlagList, 0.5)) |
| self:AddChild(UIF:ColorSelect("Color", bdb, "FontColor", Callback, false, 0.2)) |
| self:AddChild(UIF:Slider("Size", bdb, "FontSize", 2, 50, 1, Callback, 0.4)) |
| self:AddChild(UIF:Slider("Margin", bdb, "InternalSpacing", 0, 50, 0.1, Callback, 0.4)) |
| self:AddChild(UIF:Dropdown("Horizontal Align", bdb, "HorAlign", Callback, HorizontalAlignList, 0.5)) |
| elseif tab == "tex" then |
| group = UIF:InlineGroup2("Border and Background") |
| self:AddChild(group) |
| group:AddChild(UIF:LSMDropdown("border", "Border texture", bdb, "BorderTexture", Callback, 0.5)) |
| group:AddChild(UIF:LSMDropdown("statusbar", "Bar Texture", bdb, "Texture", Callback, 0.5)) |
| group:AddChild(UIF:ColorSelect("Background Color", bdb, "BackgroundColor", Callback, true, 0.5)) |
| group:AddChild(UIF:ColorSelect("Border color", bdb, "BorderColor", Callback, true, 0.5)) |
| group:AddChild(UIF:Slider("Border Width", bdb, "BorderWidth", 1, 50, 1, Callback, 0.33)) |
| group:AddChild(UIF:Slider("Border Padding", bdb, "BorderPadding", 0, 100, 0.1, Callback, 0.33)) |
| group:AddChild(UIF:Slider("Border Insets", bdb, "BorderInsets", 0, 50, 1, Callback, 0.33)) |
| end |
| self.parent.parent.parent:DoLayout() |
| self.parent.parent.parent:FixScroll() |
| end |
| GlobalSettings = function(self) |
| local bdb = db.Bar.Global |
| self:AddChild(UIF:CheckBox("Name", bdb, "ShowName", Callback, "Toggle display of spellname on the bar", 0.33)) |
| self:AddChild(UIF:CheckBox("Time", bdb, "ShowTime", Callback, "Toggle display of remaining time", 0.32)) |
| self:AddChild(UIF:CheckBox("Spell Icon", bdb, "ShowIcon", Callback, "Show the icon for the spell on the left side of the bar", 0.33)) |
| self:AddChild(UIF:Slider("Height", bdb, "Height", 5, 200, 0.1, Callback, 0.5)) |
| self:AddChild(UIF:Slider("Offset Y", bdb.Attached, "OffSetY", -200, 200, 0.1, Callback, 0.5)) |
| local group = UIF:InlineGroup("Font") |
| self:AddChild(group) |
| group:AddChild(UIF:ColorSelect("Color", bdb, "FontColor", Callback, false, 0.2)) |
| group:AddChild(UIF:Slider("Size", bdb, "FontSize", 2, 50, 1, Callback, 0.8)) |
| group:AddChild(UIF:LSMDropdown("font", "Font", bdb, "Font", Callback, 0.5)) |
| group:AddChild(UIF:Dropdown("Font Flags", bdb, "FontFlags", Callback, FontFlagList, 0.5)) |
| group:AddChild(UIF:Dropdown("Horizontal Align", bdb, "HorAlign", Callback, HorizontalAlignList, 0.5)) |
| group:AddChild(UIF:Slider("Margin", bdb, "InternalSpacing", 0, 50, 0.1, Callback, 0.5)) |
| local group = UIF:InlineGroup("Texture") |
| self:AddChild(group) |
| group:AddChild(UIF:LSMDropdown("border", "Border texture", bdb, "BorderTexture", Callback, 0.5)) |
| group:AddChild(UIF:LSMDropdown("statusbar", "Bar Texture", bdb, "Texture", Callback, 0.5)) |
| group:AddChild(UIF:ColorSelect("Background Color", bdb, "BackgroundColor", Callback, true, 0.5)) |
| group:AddChild(UIF:ColorSelect("Border color", bdb, "BorderColor", Callback, true, 0.5)) |
| group:AddChild(UIF:Slider("Border Width", bdb, "BorderWidth", 1, 50, 1, Callback, 0.33)) |
| group:AddChild(UIF:Slider("Border Padding", bdb, "BorderPadding", 0, 100, 0.1, Callback, 0.33)) |
| group:AddChild(UIF:Slider("Border Insets", bdb, "BorderInsets", 0, 50, 1, Callback, 0.33)) |
| self.parent.parent:DoLayout() |
| self.parent.parent:FixScroll() |
| end |
| end |
mRunes/Modules/Procs.lua
--- mRunes/Libs/LibGUIFactory-1.0/lib.xml (revision 0)
+++ mRunes/Libs/LibGUIFactory-1.0/lib.xml (revision 8)
@@ -0,0 +1,19 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
mRunes/Libs/LibGUIFactory-1.0/Widgets/UIF-CheckBox.lua
New file
0,0 → 1,52
| local AceGUI = LibStub("AceGUI-3.0") |
| -------------------------- |
| -- Check Box -- |
| -------------------------- |
| --[[ |
| Events : |
| OnValueChanged |
| ]] |
| do |
| local Type = "UIF-CheckBox" |
| local Version = 4 |
| local function SetFont(self, font, size, flags) |
| self.text:SetFont(font, size, flags) |
| end |
| local function SetFontColor(self, color) |
| self.newColor = color |
| self.text:SetTextColor(unpack(color)) |
| end |
| local function SetDisabled(self, disabled) |
| self.oldSetDisable(self, disabled) |
| if not disabled and self.newColor then |
| self.text:SetTextColor(unpack(self.newColor)) |
| end |
| end |
| local function SetValue(self, value) |
| self.oldSetValue(self, value) |
| SetDisabled(self, self.disabled) |
| end |
| local function Constructor() |
| local self = AceGUI:Create("CheckBox") |
| self.type = Type |
| self.oldSetDisable = self.SetDisabled |
| self.oldSetValue = self.SetValue |
| self.SetDisabled = SetDisabled |
| self.SetValue = SetValue |
| self.SetFont = SetFont |
| self.SetFontColor = SetFontColor |
| return self |
| end |
| AceGUI:RegisterWidgetType(Type,Constructor,Version) |
| end |
mRunes/Libs/LibGUIFactory-1.0/Widgets/UIF-DropDownGroup.lua
New file
0,0 → 1,221
| local AceGUI = LibStub("AceGUI-3.0") |
| -- Lua APIs |
| local assert, pairs, type = assert, pairs, type |
| -- WoW APIs |
| local CreateFrame = CreateFrame |
| --[[ |
| Selection Group controls all have an interface to select a group for thier contents |
| None of them will auto size to thier contents, and should usually be used with a scrollframe |
| unless you know that the controls will fit inside |
| ]] |
| -------------------------- |
| -- Dropdown Group -- |
| -------------------------- |
| --[[ |
| Events : |
| OnGroupSelected |
| ]] |
| do |
| local Type = "UIF-DropdownGroup" |
| local Version = 13 |
| local function OnAcquire(self) |
| self.dropdown:SetText("") |
| self:SetDropdownWidth(200) |
| self:SetTitle("") |
| end |
| local function OnRelease(self) |
| self.frame:ClearAllPoints() |
| self.frame:Hide() |
| self.dropdown.list = nil |
| self.status = nil |
| for k in pairs(self.localstatus) do |
| self.localstatus[k] = nil |
| end |
| self.titletext:SetFontObject("GameFontNormal") |
| self.border:SetBackdropBorderColor(0.4,0.4,0.4) |
| end |
| local PaneBackdrop = { |
| bgFile = "Interface\\ChatFrame\\ChatFrameBackground", |
| edgeFile = "Interface\\Tooltips\\UI-Tooltip-Border", |
| tile = true, tileSize = 16, edgeSize = 16, |
| insets = { left = 3, right = 3, top = 5, bottom = 3 } |
| } |
| local function SetBorderColor(self, color) |
| self.border:SetBackdropBorderColor(unpack(color)) |
| end |
| local function SetFont(self, font, size, flags) |
| if not self.fontO then |
| self.fontO = CreateFont("UIFDropdownFont") |
| self.fontO:SetFont(font, size, flags) |
| end |
| self.titletext:SetFontObject(self.fontO) |
| end |
| local function SetFontColor(self, color) |
| local font, size, flags = GameFontNormal:GetFont() |
| if not self.fontO then |
| self.fontO = CreateFont("UIFDropdownFont") |
| self.fontO:SetFont(font, size, flags) |
| self.fontO:SetTextColor(unpack(color)) |
| end |
| self.titletext:SetFontObject(self.fontO) |
| end |
| local function SetTitle(self,title) |
| self.titletext:SetText(title) |
| self.dropdown.frame:ClearAllPoints() |
| if title and title ~= "" then |
| self.dropdown.frame:SetPoint("TOPRIGHT", self.frame, "TOPRIGHT", -2, 0) |
| else |
| self.dropdown.frame:SetPoint("TOPLEFT", self.frame, "TOPLEFT", -1, 0) |
| end |
| end |
| local function SelectedGroup(self,event,value) |
| local group = self.parentgroup |
| local status = group.status or group.localstatus |
| status.selected = value |
| self.parentgroup:Fire("OnGroupSelected", value) |
| end |
| local function SetGroupList(self,list) |
| self.dropdown:SetList(list) |
| end |
| -- called to set an external table to store status in |
| local function SetStatusTable(self, status) |
| assert(type(status) == "table") |
| self.status = status |
| end |
| local function SetGroup(self,group) |
| self.dropdown:SetValue(group) |
| local status = self.status or self.localstatus |
| status.selected = group |
| self:Fire("OnGroupSelected", group) |
| end |
| local function OnWidthSet(self, width) |
| local content = self.content |
| local contentwidth = width - 26 |
| if contentwidth < 0 then |
| contentwidth = 0 |
| end |
| content:SetWidth(contentwidth) |
| content.width = contentwidth |
| end |
| local function OnHeightSet(self, height) |
| local content = self.content |
| local contentheight = height - 63 |
| if contentheight < 0 then |
| contentheight = 0 |
| end |
| content:SetHeight(contentheight) |
| content.height = contentheight |
| end |
| local function LayoutFinished(self, width, height) |
| self:SetHeight((height or 0) + 63) |
| end |
| local function SetDropdownWidth(self, width) |
| self.dropdown:SetWidth(width) |
| end |
| local function SetDropdownWidget(self, dropdown) |
| self.dropdown:Release() |
| self.dropdown = dropdown |
| dropdown.frame:SetParent(self.frame) |
| dropdown.frame:SetFrameLevel(dropdown.frame:GetFrameLevel() + 2) |
| dropdown.parentgroup = self |
| dropdown:SetCallback("OnValueChanged",SelectedGroup) |
| dropdown.frame:SetPoint("TOPLEFT",self.frame,"TOPLEFT", -1, 0) |
| dropdown.frame:Show() |
| dropdown:SetLabel("") |
| end |
| local function Constructor() |
| local frame = CreateFrame("Frame") |
| local self = {} |
| self.type = Type |
| self.OnRelease = OnRelease |
| self.OnAcquire = OnAcquire |
| self.SetTitle = SetTitle |
| self.SetGroupList = SetGroupList |
| self.SetGroup = SetGroup |
| self.SetStatusTable = SetStatusTable |
| self.SetDropdownWidth = SetDropdownWidth |
| self.OnWidthSet = OnWidthSet |
| self.OnHeightSet = OnHeightSet |
| self.LayoutFinished = LayoutFinished |
| self.SetFont = SetFont |
| self.SetFontColor = SetFontColor |
| self.SetBorderColor = SetBorderColor |
| self.SetDropdownWidget = SetDropdownWidget |
| self.localstatus = {} |
| self.frame = frame |
| frame.obj = self |
| frame:SetHeight(100) |
| frame:SetWidth(100) |
| frame:SetFrameStrata("FULLSCREEN_DIALOG") |
| local titletext = frame:CreateFontString(nil, "OVERLAY", "GameFontNormal") |
| titletext:SetPoint("TOPLEFT", frame, "TOPLEFT", 4, -5) |
| titletext:SetPoint("TOPRIGHT", frame, "TOPRIGHT", -4, -5) |
| titletext:SetJustifyH("LEFT") |
| titletext:SetHeight(18) |
| self.titletext = titletext |
| local dropdown = AceGUI:Create("Dropdown") |
| self.dropdown = dropdown |
| dropdown.frame:SetParent(frame) |
| dropdown.frame:SetFrameLevel(dropdown.frame:GetFrameLevel() + 2) |
| dropdown.parentgroup = self |
| dropdown:SetCallback("OnValueChanged",SelectedGroup) |
| dropdown.frame:SetPoint("TOPLEFT",frame,"TOPLEFT", -1, 0) |
| dropdown.frame:Show() |
| dropdown:SetLabel("") |
| local border = CreateFrame("Frame",nil,frame) |
| self.border = border |
| border:SetPoint("TOPLEFT",frame,"TOPLEFT",0,-26) |
| border:SetPoint("BOTTOMRIGHT",frame,"BOTTOMRIGHT",0,3) |
| border:SetBackdrop(PaneBackdrop) |
| border:SetBackdropColor(0.1,0.1,0.1,0.5) |
| border:SetBackdropBorderColor(0.4,0.4,0.4) |
| --Container Support |
| local content = CreateFrame("Frame",nil,border) |
| self.content = content |
| content.obj = self |
| content:SetPoint("TOPLEFT",border,"TOPLEFT",10,-10) |
| content:SetPoint("BOTTOMRIGHT",border,"BOTTOMRIGHT",-10,10) |
| AceGUI:RegisterAsContainer(self) |
| return self |
| end |
| AceGUI:RegisterWidgetType(Type,Constructor,Version) |
| end |
mRunes/Libs/LibGUIFactory-1.0/Widgets/UIF-Frame.lua
New file
0,0 → 1,332
| local AceGUI = LibStub("AceGUI-3.0") |
| -- Lua APIs |
| local pairs, assert, type = pairs, assert, type |
| -- WoW APIs |
| local CreateFrame, UIParent = CreateFrame, UIParent |
| ---------------- |
| -- Main Frame -- |
| ---------------- |
| --[[ |
| Events : |
| OnClose |
| ]] |
| do |
| local Type = "UIF-Frame" |
| local Version = 11 |
| local FrameBackdrop = { |
| bgFile="Interface\\ChatFrame\\ChatFrameBackground", |
| edgeFile="Interface\\Tooltips\\UI-Tooltip-Border", |
| tile = true, tileSize = 32, edgeSize = 16, |
| insets = { left = 3, right = 3, top = 3, bottom = 3 } |
| } |
| local PaneBackdrop = { |
| bgFile = "Interface\\ChatFrame\\ChatFrameBackground", |
| edgeFile = "Interface\\Tooltips\\UI-Tooltip-Border", |
| tile = true, tileSize = 16, edgeSize = 16, |
| insets = { left = 3, right = 3, top = 5, bottom = 3 } |
| } |
| local function frameOnClose(this) |
| this.obj:Fire("OnClose") |
| end |
| local function closeOnClick(this) |
| this.obj:Hide() |
| end |
| local function frameOnMouseDown(this) |
| AceGUI:ClearFocus() |
| end |
| local function titleOnMouseDown(this) |
| this:GetParent():StartMoving() |
| AceGUI:ClearFocus() |
| end |
| local function frameOnMouseUp(this) |
| local frame = this:GetParent() |
| frame:StopMovingOrSizing() |
| local self = frame.obj |
| local status = self.status or self.localstatus |
| status.width = frame:GetWidth() |
| status.height = frame:GetHeight() |
| status.top = frame:GetTop() |
| status.left = frame:GetLeft() |
| end |
| local function sizerseOnMouseDown(this) |
| this:GetParent():StartSizing("BOTTOMRIGHT") |
| AceGUI:ClearFocus() |
| end |
| local function sizersOnMouseDown(this) |
| this:GetParent():StartSizing("BOTTOM") |
| AceGUI:ClearFocus() |
| end |
| local function sizereOnMouseDown(this) |
| this:GetParent():StartSizing("RIGHT") |
| AceGUI:ClearFocus() |
| end |
| local function SetTitle(self,title) |
| self.titletext:SetText(title) |
| end |
| local function Hide(self) |
| self.frame:Hide() |
| end |
| local function Show(self) |
| self.frame:Show() |
| end |
| local function OnAcquire(self) |
| self.frame:SetParent(UIParent) |
| self.frame:SetFrameStrata("FULLSCREEN_DIALOG") |
| self:ApplyStatus() |
| end |
| local function OnRelease(self) |
| self.status = nil |
| for k in pairs(self.localstatus) do |
| self.localstatus[k] = nil |
| end |
| if self.oldButton then |
| self.closebutton:Release() |
| self.closebutton = self.oldButton |
| self.oldButton = nil |
| end |
| self.titletext:SetFontObject("GameFontNormal") |
| self.frame:SetBackdropColor(0,0,0,0.5) |
| self.frame:SetBackdropBorderColor(1,1,1,1) |
| self.title:SetBackdropColor(0,0,0,1) |
| self.title:SetBackdropBorderColor(1, 1, 1, 1) |
| self.statustext:SetText() |
| end |
| local function SetTitleFont(self, font, size, flags) |
| self.fontO = self.fontO or UIFFrameFont or CreateFont("UIFFrameFont") |
| self.fontO:SetFont(font, size, flags) |
| self.titletext:SetFontObject("UIFFrameFont") |
| end |
| local function SetTitleFontColor(self, color) |
| local font, size, flags = GameFontNormal:GetFont() |
| if not self.fontO then |
| self.fontO = UIFFrameFont or CreateFont("UIFFrameFont") |
| self.fontO:SetFont(font, size, flags) |
| end |
| self.fontO:SetTextColor(unpack(color)) |
| end |
| local function SetBorderColor(self, color) |
| self.frame:SetBackdropBorderColor(unpack(color)) |
| self.title:SetBackdropBorderColor(unpack(color)) |
| end |
| local function SetBackColor(self, color) |
| local r, g, b = unpack(color) |
| self.frame:SetBackdropColor(unpack(color)) |
| self.title:SetBackdropColor(r, g, b, 1) |
| end |
| local function SetButton(self, closebutton) |
| self.oldButton = self.closebutton |
| self.oldButton:Hide() |
| self.closebutton = closebutton |
| closebutton.frame:SetParent(self.frame) |
| closebutton:SetCallback("OnClick", closeOnClick) |
| closebutton.frame:ClearAllPoints() |
| closebutton.frame:SetPoint("BOTTOMRIGHT", -27, 17) |
| closebutton.frame:SetHeight(20) |
| closebutton.frame:SetWidth(100) |
| closebutton.frame:SetText(CLOSE) |
| --closebutton.frame:SetFrameLevel(c) |
| --closebutton.frame:SetFrameStrata("TOOLTIP") |
| closebutton.obj = self |
| closebutton.frame:Show() |
| end |
| -- called to set an external table to store status in |
| local function SetStatusTable(self, status) |
| assert(type(status) == "table") |
| self.status = status |
| self:ApplyStatus() |
| end |
| local function ApplyStatus(self) |
| local status = self.status or self.localstatus |
| local frame = self.frame |
| self:SetWidth(status.width or 700) |
| self:SetHeight(status.height or 500) |
| if status.top and status.left then |
| frame:SetPoint("TOP",UIParent,"BOTTOM",0,status.top) |
| frame:SetPoint("LEFT",UIParent,"LEFT",status.left,0) |
| else |
| frame:SetPoint("CENTER",UIParent,"CENTER") |
| end |
| end |
| local function OnWidthSet(self, width) |
| local content = self.content |
| local contentwidth = width - 34 |
| if contentwidth < 0 then |
| contentwidth = 0 |
| end |
| content:SetWidth(contentwidth) |
| content.width = contentwidth |
| end |
| local function OnHeightSet(self, height) |
| local content = self.content |
| local contentheight = height - 57 |
| if contentheight < 0 then |
| contentheight = 0 |
| end |
| content:SetHeight(contentheight) |
| content.height = contentheight |
| end |
| local function Constructor() |
| local frame = CreateFrame("Frame",nil,UIParent) |
| local self = {} |
| self.type = Type |
| self.Hide = Hide |
| self.Show = Show |
| self.SetTitle = SetTitle |
| self.OnRelease = OnRelease |
| self.OnAcquire = OnAcquire |
| self.SetStatusTable = SetStatusTable |
| self.ApplyStatus = ApplyStatus |
| self.OnWidthSet = OnWidthSet |
| self.OnHeightSet = OnHeightSet |
| self.SetButton = SetButton |
| self.SetTitleFont = SetTitleFont |
| self.SetTitleFontColor = SetTitleFontColor |
| self.SetBorderColor = SetBorderColor |
| self.SetBackColor = SetBackColor |
| self.localstatus = {} |
| self.frame = frame |
| frame.obj = self |
| frame:SetWidth(700) |
| frame:SetHeight(500) |
| frame:SetPoint("CENTER",UIParent,"CENTER",0,0) |
| frame:EnableMouse() |
| frame:SetMovable(true) |
| frame:SetResizable(true) |
| frame:SetFrameStrata("FULLSCREEN_DIALOG") |
| frame:SetScript("OnMouseDown", frameOnMouseDown) |
| frame:SetBackdrop(FrameBackdrop) |
| frame:SetBackdropColor(0,0,0,0.5) |
| frame:SetScript("OnHide",frameOnClose) |
| frame:SetMinResize(400,200) |
| frame:SetToplevel(true) |
| local closebutton = CreateFrame("Button",nil,frame,"UIPanelButtonTemplate") |
| closebutton:SetScript("OnClick", closeOnClick) |
| closebutton:SetPoint("BOTTOMRIGHT",frame,"BOTTOMRIGHT",-27,17) |
| closebutton:SetHeight(20) |
| closebutton:SetWidth(100) |
| closebutton:SetText(CLOSE) |
| self.closebutton = closebutton |
| closebutton.obj = self |
| local title = CreateFrame("Frame",nil,frame) |
| local titletext = title:CreateFontString(nil,"OVERLAY","GameFontNormal") |
| titletext:SetPoint("CENTER",frame,"TOP") |
| self.title = title |
| title:EnableMouse() |
| title:SetScript("OnMouseDown",titleOnMouseDown) |
| title:SetScript("OnMouseUp", frameOnMouseUp) |
| title:SetBackdrop(PaneBackdrop) |
| title:SetPoint("TOPLEFT",titletext,"TOPLEFT", -10, 5) |
| title:SetPoint("BOTTOMRIGHT",titletext,"BOTTOMRIGHT", 10, -10) |
| title:SetBackdropColor(0,0,0,1) |
| title:SetBackdropBorderColor(1,1,1,1) |
| self.titletext = titletext |
| local statustext = frame:CreateFontString(nil, "OVERLAY", "GameFontNormal") |
| statustext:SetPoint("LEFT", frame, "BOTTOMLEFT", 17, 20) |
| self.statustext = statustext |
| local sizer_se = CreateFrame("Frame",nil,frame) |
| sizer_se:SetPoint("BOTTOMRIGHT",frame,"BOTTOMRIGHT",0,0) |
| sizer_se:SetWidth(25) |
| sizer_se:SetHeight(25) |
| sizer_se:EnableMouse() |
| sizer_se:SetScript("OnMouseDown",sizerseOnMouseDown) |
| sizer_se:SetScript("OnMouseUp", frameOnMouseUp) |
| self.sizer_se = sizer_se |
| local line1 = sizer_se:CreateTexture(nil, "BACKGROUND") |
| self.line1 = line1 |
| line1:SetWidth(14) |
| line1:SetHeight(14) |
| line1:SetPoint("BOTTOMRIGHT", -8, 8) |
| line1:SetTexture("Interface\\Tooltips\\UI-Tooltip-Border") |
| local x = 0.1 * 14/17 |
| line1:SetTexCoord(0.05 - x, 0.5, 0.05, 0.5 + x, 0.05, 0.5 - x, 0.5 + x, 0.5) |
| local line2 = sizer_se:CreateTexture(nil, "BACKGROUND") |
| self.line2 = line2 |
| line2:SetWidth(8) |
| line2:SetHeight(8) |
| line2:SetPoint("BOTTOMRIGHT", -8, 8) |
| line2:SetTexture("Interface\\Tooltips\\UI-Tooltip-Border") |
| local x = 0.1 * 8/17 |
| line2:SetTexCoord(0.05 - x, 0.5, 0.05, 0.5 + x, 0.05, 0.5 - x, 0.5 + x, 0.5) |
| local sizer_s = CreateFrame("Frame",nil,frame) |
| sizer_s:SetPoint("BOTTOMRIGHT",frame,"BOTTOMRIGHT",-25,0) |
| sizer_s:SetPoint("BOTTOMLEFT",frame,"BOTTOMLEFT",0,0) |
| sizer_s:SetHeight(25) |
| sizer_s:EnableMouse() |
| sizer_s:SetScript("OnMouseDown",sizersOnMouseDown) |
| sizer_s:SetScript("OnMouseUp", frameOnMouseUp) |
| self.sizer_s = sizer_s |
| local sizer_e = CreateFrame("Frame",nil,frame) |
| sizer_e:SetPoint("BOTTOMRIGHT",frame,"BOTTOMRIGHT",0,25) |
| sizer_e:SetPoint("TOPRIGHT",frame,"TOPRIGHT",0,0) |
| sizer_e:SetWidth(25) |
| sizer_e:EnableMouse() |
| sizer_e:SetScript("OnMouseDown",sizereOnMouseDown) |
| sizer_e:SetScript("OnMouseUp", frameOnMouseUp) |
| self.sizer_e = sizer_e |
| --Container Support |
| local content = CreateFrame("Frame",nil,frame) |
| self.content = content |
| content.obj = self |
| content:SetPoint("TOPLEFT",frame,"TOPLEFT",17,-27) |
| content:SetPoint("BOTTOMRIGHT",frame,"BOTTOMRIGHT",-17,40) |
| AceGUI:RegisterAsContainer(self) |
| return self |
| end |
| AceGUI:RegisterWidgetType(Type,Constructor,Version) |
| end |
mRunes/Libs/LibGUIFactory-1.0/Widgets/UIF-Button.lua
New file
0,0 → 1,33
| local AceGUI = LibStub("AceGUI-3.0") |
| -- WoW APIs |
| local _G = _G |
| local CreateFrame, UIParent = CreateFrame, UIParent |
| -------------------------- |
| -- Button -- |
| -------------------------- |
| do |
| local Type = "UIF-Button" |
| local Version = 3 |
| local function SetFont(self, font, fontSize, flags) |
| self.text:SetFont(font, fontSize, flags) |
| end |
| local function SetFontColor(self, color) |
| self.text:SetTextColor(unpack(color)) |
| end |
| local function Constructor() |
| local self = AceGUI:Create("Button") |
| self.type = Type |
| self.SetFont = SetFont |
| self.SetFontColor = SetFontColor |
| return self |
| end |
| AceGUI:RegisterWidgetType(Type,Constructor,Version) |
| end |
mRunes/Libs/LibGUIFactory-1.0/Widgets/UIF-InlineGroup.lua
New file
0,0 → 1,125
\ No newline at end of file
| local Type, Version = "UIF-InlineGroup", 4 |
| local AceGUI = LibStub and LibStub("AceGUI-3.0", true) |
| if not AceGUI or (AceGUI.GetWidgetVersion and AceGUI:GetWidgetVersion(Type) or 0) >= Version then return end |
| -- Lua APIs |
| local pairs = pairs |
| -- WoW APIs |
| local CreateFrame, UIParent = CreateFrame, UIParent |
| --[[----------------------------------------------------------------------------- |
| Methods |
| -------------------------------------------------------------------------------]] |
| local methods = { |
| ["OnAcquire"] = function(self) |
| self:SetWidth(300) |
| self:SetHeight(100) |
| end, |
| -- ["OnRelease"] = nil, |
| ["SetTitle"] = function(self,title) |
| self.titletext:SetText(title) |
| end, |
| ["LayoutFinished"] = function(self, width, height) |
| if self.noAutoHeight then return end |
| self:SetHeight((height or 0) + 40) |
| end, |
| ["OnWidthSet"] = function(self, width) |
| local content = self.content |
| local contentwidth = width - 20 |
| if contentwidth < 0 then |
| contentwidth = 0 |
| end |
| content:SetWidth(contentwidth) |
| content.width = contentwidth |
| end, |
| ["OnHeightSet"] = function(self, height) |
| local content = self.content |
| local contentheight = height - 20 |
| if contentheight < 0 then |
| contentheight = 0 |
| end |
| content:SetHeight(contentheight) |
| content.height = contentheight |
| end, |
| ["SetFont"] = function(self, font, size, flags) |
| self.titletext:SetFont(font, size, flags) |
| end, |
| ["SetFontColor"] = function(self, color) |
| self.titletext:SetTextColor(unpack(color)) |
| end, |
| ["SetBGTexture"] = function(self, texture) |
| PaneBackdrop.bgFile = texture |
| self.border:SetBackdrop(PaneBackdrop) |
| end, |
| ["SetBorderTexture"] = function(self, texture) |
| PaneBackdrop.edgeFile = texture |
| self.border:SetBackdrop(PaneBackdrop) |
| end, |
| ["SetBGColor"] = function(self, color) |
| self.border:SetBackdropColor(unpack(color)) |
| end, |
| ["SetBorderColor"] = function(self, color) |
| self.border:SetBackdropBorderColor(unpack(color)) |
| end, |
| } |
| --[[----------------------------------------------------------------------------- |
| Constructor |
| -------------------------------------------------------------------------------]] |
| local PaneBackdrop = { |
| bgFile = "Interface\\ChatFrame\\ChatFrameBackground", |
| edgeFile = "Interface\\Tooltips\\UI-Tooltip-Border", |
| tile = true, tileSize = 16, edgeSize = 16, |
| insets = { left = 3, right = 3, top = 5, bottom = 3 } |
| } |
| local function Constructor() |
| local frame = CreateFrame("Frame", nil, UIParent) |
| frame:SetFrameStrata("FULLSCREEN_DIALOG") |
| local titletext = frame:CreateFontString(nil, "OVERLAY", "GameFontNormal") |
| titletext:SetPoint("TOPLEFT", 14, 0) |
| titletext:SetPoint("TOPRIGHT", -14, 0) |
| titletext:SetJustifyH("LEFT") |
| titletext:SetHeight(18) |
| local border = CreateFrame("Frame", nil, frame) |
| border:SetPoint("TOPLEFT", 0, -17) |
| border:SetPoint("BOTTOMRIGHT", -1, 3) |
| border:SetBackdrop(PaneBackdrop) |
| border:SetBackdropColor(0.1, 0.1, 0.1, 0.5) |
| border:SetBackdropBorderColor(0.4, 0.4, 0.4) |
| --Container Support |
| local content = CreateFrame("Frame", nil, border) |
| content:SetPoint("TOPLEFT", 10, -10) |
| content:SetPoint("BOTTOMRIGHT", -10, 10) |
| local widget = { |
| frame = frame, |
| content = content, |
| titletext = titletext, |
| border = border, |
| type = Type |
| } |
| for method, func in pairs(methods) do |
| widget[method] = func |
| end |
| return AceGUI:RegisterAsContainer(widget) |
| end |
| AceGUI:RegisterWidgetType(Type, Constructor, Version) |
mRunes/Libs/LibGUIFactory-1.0/Widgets/UIF-DropDown.lua
New file
0,0 → 1,298
| local AceGUI = LibStub("AceGUI-3.0") |
| local function fixlevels(parent,...) |
| local i = 1 |
| local child = select(i, ...) |
| while child do |
| child:SetFrameLevel(parent:GetFrameLevel()+1) |
| fixlevels(child, child:GetChildren()) |
| i = i + 1 |
| child = select(i, ...) |
| end |
| end |
| local function fixstrata(strata, parent, ...) |
| local i = 1 |
| local child = select(i, ...) |
| parent:SetFrameStrata(strata) |
| while child do |
| fixstrata(strata, child, child:GetChildren()) |
| i = i + 1 |
| child = select(i, ...) |
| end |
| end |
| do |
| local widgetType = "UIFDropdown-Pullout" |
| local widgetVersion = 107 |
| -- exported |
| local function AddItem(self, item) |
| self.items[#self.items + 1] = item |
| local h = 0 |
| for i, item in pairs(self.items) do |
| h = h + item.frame:GetHeight() |
| end |
| self.itemFrame:SetHeight(h) |
| self.frame:SetHeight(min(h + 34, self.maxHeight)) -- +34: 20 for scrollFrame placement (10 offset) and +14 for item placement |
| item.frame:SetPoint("LEFT", self.itemFrame, "LEFT") |
| item.frame:SetPoint("RIGHT", self.itemFrame, "RIGHT") |
| item:SetPullout(self) |
| item:SetOnEnter(OnEnter) |
| end |
| -- exported |
| local function Open(self, point, relFrame, relPoint, x, y) |
| local items = self.items |
| local frame = self.frame |
| local itemFrame = self.itemFrame |
| frame:SetPoint(point, relFrame, relPoint, x, y) |
| local height = 8 |
| for i, item in pairs(items) do |
| if i == 1 then |
| item:SetPoint("TOP", itemFrame, "TOP", 0, -2) |
| else |
| item:SetPoint("TOP", items[i-1].frame, "BOTTOM", 0, 1) |
| end |
| item:Show() |
| height = height + item.frame:GetHeight() |
| end |
| itemFrame:SetHeight(height) |
| fixstrata("TOOLTIP", frame, frame:GetChildren()) |
| frame:Show() |
| self:Fire("OnOpen") |
| end |
| -- exported |
| local function SetMaxHeight(self, height) |
| self.maxHeight = height or defaultMaxHeight |
| if self.frame:GetHeight() > height then |
| self.frame:SetHeight(height) |
| elseif (self.itemFrame:GetHeight() + 34) < height then |
| self.frame:SetHeight(self.itemFrame:GetHeight() + 34) -- see :AddItem |
| end |
| end |
| --[[ Constructor ]]-- |
| local function Constructor() |
| local self = AceGUI:Create("Dropdown-Pullout") |
| self.type = widgetType |
| self.AddItem = AddItem |
| self.Open = Open |
| self.SetMaxHeight = SetMaxHeight |
| AceGUI:RegisterAsWidget(self) |
| return self |
| end |
| AceGUI:RegisterWidgetType(widgetType, Constructor, widgetVersion) |
| end |
| do |
| local widgetType = "UIF-Dropdown" |
| local widgetVersion = 22 |
| local function OnPulloutOpen(this) |
| local self = this.userdata.obj |
| local value = self.value |
| if not self.multiselect then |
| for i, item in this:IterateItems() do |
| item:SetValue(item.userdata.value == value) |
| end |
| end |
| self.open = true |
| end |
| local function OnPulloutClose(this) |
| local self = this.userdata.obj |
| self.open = nil |
| self:Fire("OnClosed") |
| end |
| local function OnAcquire(self) |
| local pullout = AceGUI:Create("UIFDropdown-Pullout") |
| self.pullout = pullout |
| pullout.userdata.obj = self |
| pullout:SetCallback("OnClose", OnPulloutClose) |
| pullout:SetCallback("OnOpen", OnPulloutOpen) |
| self.pullout.frame:SetFrameLevel(self.frame:GetFrameLevel() + 1) |
| fixlevels(self.pullout.frame, self.pullout.frame:GetChildren()) |
| self:SetHeight(44) |
| self:SetWidth(200) |
| end |
| local function ShowMultiText(self) |
| local text |
| for i, widget in self.pullout:IterateItems() do |
| if widget.type == "Dropdown-Item-Toggle" or widget.type == "UIFDropdown-Item-Toggle" then |
| if widget:GetValue() then |
| if text then |
| text = text..", "..widget:GetText() |
| else |
| text = widget:GetText() |
| end |
| end |
| end |
| end |
| self:SetText(text) |
| end |
| local function SetFont(self, font, size, flags) |
| self.text:SetFont(font, size, flags) |
| end |
| local function SetFontColor(self, color) |
| self.text:SetTextColor(unpack(color)) |
| end |
| local function SetItemFont(self, font, size, flags) |
| self.ItemFont = self.ItemFont or UIFDropdownItemFont or CreateFont("UIFDropdownItemFont") |
| self.ItemFont:SetFont(font, size, flags) |
| self.UseCustonItemFont = true |
| end |
| local function SetItemFontColor(self, color) |
| local font, size, flags = GameFontNormalSmall:GetFont() |
| if not self.ItemFont then |
| self.ItemFont = self.ItemFont or UIFDropdownItemFont or CreateFont("UIFDropdownItemFont") |
| self.ItemFont:SetFont(font, size, flags) |
| end |
| self.ItemFont:SetTextColor(unpack(color)) |
| self.UseCustonItemFont = true |
| end |
| local function OnItemValueChanged(this, event, checked) |
| local self = this.userdata.obj |
| if self.multiselect then |
| self:Fire("OnValueChanged", this.userdata.value, checked) |
| ShowMultiText(self) |
| else |
| if checked then |
| self:SetValue(this.userdata.value) |
| self:Fire("OnValueChanged", this.userdata.value) |
| else |
| this:SetValue(true) |
| end |
| if self.open then |
| self.pullout:Close() |
| end |
| end |
| end |
| local function SetValue(self, value) |
| if self.list then |
| if type(self.list[value]) == "table" then |
| self:SetText(self.list[value].text or "") |
| else |
| self:SetText(self.list[value] or "") |
| end |
| end |
| self.value = value |
| end |
| local function AddListItem(self, value, text, icon, disabled) |
| local item = AceGUI:Create("UIFDropdown-Item-Toggle") |
| if self.UseCustonItemFont then |
| item:SetFont("UIFDropdownItemFont") |
| end |
| if disabled then |
| item:SetDisabled(disabled) |
| end |
| item:SetIcon(icon) |
| item:SetText(text) |
| item.userdata.obj = self |
| item.userdata.value = value |
| item:SetCallback("OnValueChanged", OnItemValueChanged) |
| self.pullout:AddItem(item) |
| end |
| local function AddCloseButton(self) |
| if not self.hasClose then |
| local close = AceGUI:Create("Dropdown-Item-Execute") |
| close:SetText(CLOSE) |
| self.pullout:AddItem(close) |
| self.hasClose = true |
| end |
| end |
| local sortlist = {} |
| local function SetList(self, list) |
| self.list = list |
| self.pullout:Clear() |
| self.hasClose = nil |
| if not list then return end |
| for v in pairs(list) do |
| sortlist[#sortlist + 1] = v |
| end |
| table.sort(sortlist) |
| for i, value in pairs(sortlist) do |
| if type(list[value]) == "table" then |
| AddListItem(self, list[value].value, list[value].text, list[value].icon, list[value].disabled) |
| else |
| AddListItem(self, value, list[value]) |
| end |
| sortlist[i] = nil |
| end |
| if self.multiselect then |
| ShowMultiText(self) |
| AddCloseButton(self) |
| end |
| end |
| local function SetMultiselect(self, multi) |
| self.multiselect = multi |
| if multi then |
| ShowMultiText(self) |
| AddCloseButton(self) |
| end |
| end |
| local function SetItemValue(self, item, value) |
| if not self.multiselect then return end |
| for i, widget in self.pullout:IterateItems() do |
| if widget.userdata.value == item then |
| if widget.SetValue then |
| widget:SetValue(value) |
| end |
| end |
| end |
| ShowMultiText(self) |
| end |
| local function Constructor() |
| local self = AceGUI:Create("Dropdown") |
| self.type = widgetType |
| self.OnAcquire = OnAcquire |
| self.SetItemFont = SetItemFont |
| self.SetFont = SetFont |
| self.SetFontColor = SetFontColor |
| self.SetItemFontColor = SetItemFontColor |
| self.SetList = SetList |
| self.AddListItem = AddListItem |
| self.SetValue = SetValue |
| self.SetMultiselect = SetMultiselect |
| self.SetItemValue = SetItemValue |
| AceGUI:RegisterAsWidget(self) |
| return self |
| end |
| AceGUI:RegisterWidgetType(widgetType, Constructor, widgetVersion) |
| end |
mRunes/Libs/LibGUIFactory-1.0/Widgets/UIF-TreeGroup.lua
New file
0,0 → 1,414
| local AceGUI = LibStub("AceGUI-3.0") |
| local new, del |
| do |
| local pool = setmetatable({},{__mode='k'}) |
| function new() |
| local t = next(pool) |
| if t then |
| pool[t] = nil |
| return t |
| else |
| return {} |
| end |
| end |
| function del(t) |
| for k in pairs(t) do |
| t[k] = nil |
| end |
| pool[t] = true |
| end |
| end |
| do |
| local Type = "UIF-TreeGroup" |
| local Version = 32 |
| local function OnRelease(self) |
| self.frame:ClearAllPoints() |
| self.frame:Hide() |
| self.status = nil |
| for k, v in pairs(self.localstatus) do |
| if k == "groups" then |
| for k2 in pairs(v) do |
| v[k2] = nil |
| end |
| else |
| self.localstatus[k] = nil |
| end |
| end |
| self.localstatus.scrollvalue = 0 |
| self.localstatus.treewidth = DEFAULT_TREE_WIDTH |
| self.localstatus.treesizable = DEFAULT_TREE_SIZABLE |
| self.tree = nil |
| end |
| local function BuildUniqueValue(...) |
| local n = select('#', ...) |
| if n == 1 then |
| return ... |
| else |
| return (...).."\001"..BuildUniqueValue(select(2,...)) |
| end |
| end |
| local function GetTableData(t, key, entry) |
| for i, v in pairs(t) do |
| if v[key] == entry then return v end |
| end |
| end |
| local function FindInTree(tree, ...) |
| local n = select("#", ...) |
| for i, data in pairs(tree) do |
| local t = ... |
| if data.value == t and n == 1 then |
| return data |
| elseif data.value == t then |
| if data.children and n > 1 then |
| return FindInTree(data.children, select(2, ...)) |
| end |
| end |
| end |
| end |
| local function AddLevel(t, d) |
| local newLevel = {value = d.value, text = d.text, order = d.order or #t + 100, disabled = d.disabled} |
| tinsert(t, newLevel) |
| table.sort(t, function(a, b) return a.order < b.order end) |
| return newLevel |
| end |
| local function AddGroup(self, path, group, icon, re) |
| local tree = re or self.tree |
| if not tree then |
| tree = {} |
| self.tree = tree |
| end |
| local buildPath |
| for i, PathPart in pairs(path) do |
| buildPath = buildPath and buildPath.."\001"..PathPart.value or PathPart.value |
| local existingData = FindInTree(self.tree, string.split("\001", buildPath)) |
| if not existingData then |
| local t = AddLevel(tree, PathPart) |
| if not path[i + 1] then |
| t.icon = icon |
| t.group = group |
| else |
| t.children = t.children or {} |
| tree = t.children |
| end |
| else |
| if not path[i + 1] then |
| if existingData.group then |
| error("Overwriting "..PathPart.text) |
| end |
| existingData.group = group |
| existingData.icon = icon |
| else |
| existingData.children = existingData.children or {} |
| tree = existingData.children |
| end |
| end |
| end |
| self:RefreshTree() |
| end |
| local function Select(self, uniquevalue, ...) |
| self.filter = false |
| local status = self.status or self.localstatus |
| local groups = status.groups |
| for i = 1, select('#', ...) do |
| groups[BuildUniqueValue(select(i, ...))] = true |
| end |
| status.selected = uniquevalue |
| self:RefreshTree() |
| local data = FindInTree(self.tree, string.split("\001", uniquevalue)) |
| if data then |
| self:ReleaseChildren() |
| if data.group then |
| local scroll = AceGUI:Create("ScrollFrame") |
| scroll:SetLayout("Flow") |
| self:AddChild(scroll) |
| scroll:AddChildren(data.group()) |
| scroll:DoLauout() |
| scroll:FixScroll() |
| self:DoLayout() |
| end |
| end |
| self:Fire("OnGroupSelected", uniquevalue) |
| end |
| local function SetSelected(self, value) |
| local status = self.status or self.localstatus |
| if status.selected ~= value then |
| status.selected = value |
| local data = FindInTree(self.tree, string.split("\001", value)) |
| if data then |
| self:ReleaseChildren() |
| if data.group then |
| local scroll = AceGUI:Create("ScrollFrame") |
| scroll:SetLayout("Flow") |
| self:AddChild(scroll) |
| scroll:AddChildren(data.group()) |
| scroll:FixScroll() |
| end |
| end |
| self:Fire("OnGroupSelected", value) |
| end |
| end |
| local function SetFont(self, font, size, flags) |
| self.fontO = self.fontO or CreateFont("UIFTreeFont") |
| self.fontO:SetFont(font, size, flags) |
| self.fontOH = self.fontOH or CreateFont("UIFTreeFontH") |
| self.fontOH:SetFont(font, size + 3, "OUTLINE") |
| self.useCustomFont = true |
| end |
| local function SetFontColor(self, color) |
| local font, size = GameFontNormal:GetFont() |
| if not self.fontO then |
| self.fontO = self.fontO or CreateFont("UIFTreeFont") |
| self.fontO:SetFont(font, size, "") |
| end |
| if not self.fontOH then |
| self.fontOH = self.fontOH or CreateFont("UIFTreeFontH") |
| local font, size = GameFontNormal:GetFont() |
| self.fontOH:SetFont(font, size + 3, "OUTLINE") |
| end |
| self.fontO:SetTextColor(unpack(color)) |
| self.fontOH:SetTextColor(unpack(color)) |
| self.useCustomFont = true |
| end |
| local function SetSubFont(self, font, size, flags) |
| self.subFont = self.subFont or CreateFont("UIFTreeSubFont") |
| self.subFont:SetFont(font, size, flags) |
| self.subFontH = self.subFontH or CreateFont("UIFTreeSubFontH") |
| self.subFontH:SetFont(font, size + 3, "OUTLINE") |
| self.useCustomSubFont = true |
| end |
| local function SetSubColor(self, color) |
| local font, size = GameFontNormal:GetFont() |
| if not self.subFont then |
| self.subFont = self.subFont or CreateFont("UIFTreeSubFont") |
| self.subFont:SetFont(font, size, "") |
| end |
| if not self.subFontH then |
| self.subFontH = self.subFontH or CreateFont("UIFTreeSubFontH") |
| self.subFontH:SetFont(font, size + 3, "OUTLINE") |
| end |
| self.subFontH:SetTextColor(unpack(color)) |
| self.subFont:SetTextColor(unpack(color)) |
| self.useCustomSubFont = true |
| end |
| local function FirstFrameUpdate(this) |
| local self = this.obj |
| this:SetScript("OnUpdate",nil) |
| self:RefreshTree() |
| end |
| local function ResizeUpdate(this) |
| this.obj:RefreshTree() |
| end |
| local function UpdateButton(button, treeline, selected, canExpand, isExpanded) |
| local self = button.obj |
| local toggle = button.toggle |
| local frame = self.frame |
| local text = treeline.text or "" |
| local icon = treeline.icon |
| local iconCoords = treeline.iconCoords |
| local level = treeline.level |
| local value = treeline.value |
| local uniquevalue = treeline.uniquevalue |
| local disabled = treeline.disabled |
| button.treeline = treeline |
| button.value = value |
| button.uniquevalue = uniquevalue |
| if selected then |
| button:LockHighlight() |
| button.selected = true |
| else |
| button:UnlockHighlight() |
| button.selected = false |
| end |
| local normalTexture = button:GetNormalTexture() |
| local line = button.line |
| button.level = level |
| if ( level == 1 ) then |
| button:SetNormalFontObject("GameFontNormal") |
| button:SetHighlightFontObject("GameFontHighlight") |
| button.text:SetPoint("LEFT", (icon and 16 or 0) + 8, 2) |
| if self.useCustomFont then |
| button:SetNormalFontObject("UIFTreeFont") |
| button:SetHighlightFontObject("UIFTreeFontH") |
| end |
| else |
| button:SetNormalFontObject("GameFontHighlightSmall") |
| button:SetHighlightFontObject("GameFontHighlightSmall") |
| button.text:SetPoint("LEFT", (icon and 16 or 0) + 8 * level, 2) |
| if self.useCustomSubFont then |
| button:SetNormalFontObject("UIFTreeSubFont") |
| button:SetHighlightFontObject("UIFTreeSubFontH") |
| end |
| end |
| if disabled then |
| button:EnableMouse(false) |
| button.text:SetText("|cff808080"..text..FONT_COLOR_CODE_CLOSE) |
| else |
| button.text:SetText(text) |
| button:EnableMouse(true) |
| end |
| if icon then |
| button.icon:SetTexture(icon) |
| button.icon:SetPoint("LEFT", button, "LEFT", 8 * level, (level == 1) and 0 or 1) |
| else |
| button.icon:SetTexture(nil) |
| end |
| if iconCoords then |
| button.icon:SetTexCoord(unpack(iconCoords)) |
| else |
| button.icon:SetTexCoord(0, 1, 0, 1) |
| end |
| if canExpand then |
| if not isExpanded then |
| toggle:SetNormalTexture("Interface\\Buttons\\UI-PlusButton-UP") |
| toggle:SetPushedTexture("Interface\\Buttons\\UI-PlusButton-DOWN") |
| else |
| toggle:SetNormalTexture("Interface\\Buttons\\UI-MinusButton-UP") |
| toggle:SetPushedTexture("Interface\\Buttons\\UI-MinusButton-DOWN") |
| end |
| toggle:Show() |
| else |
| toggle:Hide() |
| end |
| end |
| local function RefreshTree(self) |
| local buttons = self.buttons |
| local lines = self.lines |
| for i, v in ipairs(buttons) do |
| v:Hide() |
| end |
| while lines[1] do |
| local t = tremove(lines) |
| for k in pairs(t) do |
| t[k] = nil |
| end |
| del(t) |
| end |
| if not self.tree then return end |
| --Build the list of visible entries from the tree and status tables |
| local status = self.status or self.localstatus |
| local groupstatus = status.groups |
| local tree = self.tree |
| local treeframe = self.treeframe |
| self:BuildLevel(tree, 1) |
| local numlines = #lines |
| local maxlines = (floor(((self.treeframe:GetHeight()or 0) - 20 ) / 18)) |
| local first, last |
| if numlines <= maxlines then |
| --the whole tree fits in the frame |
| status.scrollvalue = 0 |
| self:ShowScroll(false) |
| first, last = 1, numlines |
| else |
| self:ShowScroll(true) |
| --scrolling will be needed |
| self.noupdate = true |
| self.scrollbar:SetMinMaxValues(0, numlines - maxlines) |
| --check if we are scrolled down too far |
| if numlines - status.scrollvalue < maxlines then |
| status.scrollvalue = numlines - maxlines |
| self.scrollbar:SetValue(status.scrollvalue) |
| end |
| self.noupdate = nil |
| first, last = status.scrollvalue+1, status.scrollvalue + maxlines |
| end |
| local buttonnum = 1 |
| for i = first, last do |
| local line = lines[i] |
| local button = buttons[buttonnum] |
| if not button then |
| button = self:CreateButton() |
| buttons[buttonnum] = button |
| button:SetParent(treeframe) |
| button:SetFrameLevel(treeframe:GetFrameLevel()+1) |
| button:ClearAllPoints() |
| if i == 1 then |
| if self.showscroll then |
| button:SetPoint("TOPRIGHT", self.treeframe,"TOPRIGHT",-22,-10) |
| button:SetPoint("TOPLEFT", self.treeframe, "TOPLEFT", 0, -10) |
| else |
| button:SetPoint("TOPRIGHT", self.treeframe,"TOPRIGHT",0,-10) |
| button:SetPoint("TOPLEFT", self.treeframe, "TOPLEFT", 0, -10) |
| end |
| else |
| button:SetPoint("TOPRIGHT", buttons[buttonnum-1], "BOTTOMRIGHT",0,0) |
| button:SetPoint("TOPLEFT", buttons[buttonnum-1], "BOTTOMLEFT",0,0) |
| end |
| end |
| UpdateButton(button, line, status.selected == line.uniquevalue, line.hasChildren, groupstatus[line.uniquevalue] ) |
| button:Show() |
| buttonnum = buttonnum + 1 |
| end |
| end |
| local function SetBorderColor(self, color) |
| self.border:SetBackdropBorderColor(unpack(color)) |
| self.treeframe:SetBackdropBorderColor(unpack(color)) |
| end |
| local function Constructor() |
| local self = AceGUI:Create("TreeGroup") |
| self.type = Type |
| self.OnRelease = OnRelease |
| self.AddGroup = AddGroup |
| self.SetSelected = SetSelected |
| self.Select = Select |
| self.RefreshTree = RefreshTree |
| self.SetFont = SetFont |
| self.SetFontColor = SetFontColor |
| self.SetSubFont = SetSubFont |
| self.SetSubColor = SetSubColor |
| self.SetBorderColor = SetBorderColor |
| return self |
| end |
| AceGUI:RegisterWidgetType(Type,Constructor,Version) |
| end |
mRunes/Libs/LibGUIFactory-1.0/Widgets/UIF-ColorSelect.lua
New file
0,0 → 1,47
| local AceGUI = LibStub("AceGUI-3.0") |
| -- WoW APIs |
| local CreateFrame, UIParent = CreateFrame, UIParent |
| -- Global vars/functions that we don't upvalue since they might get hooked, or upgraded |
| -- List them here for Mikk's FindGlobals script |
| -- GLOBALS: ShowUIPanel, HideUIPanel, ColorPickerFrame, OpacitySliderFrame |
| -------------------------- |
| -- ColorPicker -- |
| -------------------------- |
| do |
| local Type = "UIF-ColorPicker" |
| local Version = 3 |
| local function SetFont(self, font, size, flags) |
| self.text:SetFont(font, size, flags) |
| end |
| local function SetFontColor(self, color) |
| self.newColor = color |
| self.text:SetTextColor(unpack(color)) |
| end |
| local function SetDisabled(self, disabled) |
| self.oldSetDisable(self, disabled) |
| if not disabled and self.newColor then |
| self.text:SetTextColor(unpack(self.newColor)) |
| end |
| end |
| local function Constructor() |
| local self = AceGUI:Create("ColorPicker") |
| self.type = Type |
| self.oldSetDisable = self.SetDisabled |
| self.SetDisabled = SetDisabled |
| self.SetFont = SetFont |
| self.SetFontColor = SetFontColor |
| return self |
| end |
| AceGUI:RegisterWidgetType(Type,Constructor,Version) |
| end |
mRunes/Libs/LibGUIFactory-1.0/Widgets/UIF-DropDownItems.lua
New file
0,0 → 1,55
| local AceGUI = LibStub("AceGUI-3.0") |
| do |
| local widgetType = "UIFDropdown-Item-Toggle" |
| local widgetVersion = 5 |
| local function SetFont(self, font) |
| if _G[font] and _G[font].GetFont then |
| self.text:SetFontObject(font) |
| self.text:SetTextColor(_G[font]:GetTextColor()) |
| local fontHeight = select(2, _G[font]:GetFont()) |
| if fontHeight > self.frame:GetHeight() then |
| self.frame:SetHeight(fontHeight + 4) |
| self.highlight:SetHeight(fontHeight) |
| end |
| end |
| end |
| local function SetIcon(self, icon) |
| self.icon:SetTexture(icon) |
| if self.icon:GetTexture() then |
| self.icon:Show() |
| self.icon:SetWidth(self.frame:GetHeight() - 4) |
| else |
| self.icon:SetWidth(1) |
| self.icon:Hide() |
| end |
| end |
| local function Constructor() |
| local self = AceGUI:Create("Dropdown-Item-Toggle") |
| self.type = widgetType |
| local icon = self.frame:CreateTexture(nil, "OVERLAY") |
| icon:SetPoint("TOPLEFT", self.frame, "TOPLEFT", 18, -2) |
| icon:SetPoint("BOTTOMLEFT", self.frame, "BOTTOMLEFT", 18, 2 ) |
| icon:Hide() |
| icon:SetWidth(1) |
| icon:SetTexCoord(0.07, 0.93, 0.07, 0.93) |
| self.icon = icon |
| self.check:SetPoint("LEFT", icon, "RIGHT", 2, 0) |
| self.text:SetPoint("TOPLEFT", self.check, "TOPRIGHT", 2, 0) |
| self.SetFont = SetFont |
| self.SetIcon = SetIcon |
| AceGUI:RegisterAsWidget(self) |
| return self |
| end |
| AceGUI:RegisterWidgetType(widgetType, Constructor, widgetVersion) |
| end |
mRunes/Libs/LibGUIFactory-1.0/Widgets/UIF-Label.lua
New file
0,0 → 1,46
| local AceGUI = LibStub("AceGUI-3.0") |
| do |
| local Type = "UIF-Label" |
| local Version = 2 |
| local function OnRelease(self) |
| self.background:Hide() |
| end |
| local function SetBackground(self, color) |
| self.background:SetTexture(unpack(color)) |
| self.background:Show() |
| end |
| local function Constructor() |
| local self = AceGUI:Create("Label") |
| self.type = Type |
| local frame = CreateFrame("Frame", nil, UIParent) |
| frame:Hide() |
| local t = frame:CreateTexture(nil, "BACKGROUND") |
| t:SetAllPoints() |
| t:Hide() |
| self.background = t |
| self.frame:SetParent(frame) |
| self.frame:Show() |
| self.frame:ClearAllPoints() |
| self.frame:SetAllPoints() |
| self.textframe = self.frame |
| self.frame = frame |
| self.label:SetJustifyV("MIDDLE") |
| self.SetBackground = SetBackground |
| self.OnRelease = OnRelease |
| AceGUI:RegisterAsWidget(self) |
| return self |
| end |
| AceGUI:RegisterWidgetType(Type,Constructor,Version) |
| end |
mRunes/Libs/LibGUIFactory-1.0/Widgets/UIF-NewLine.lua
New file
0,0 → 1,28
| local AceGUI = LibStub("AceGUI-3.0") |
| do |
| local Type = "UIF-NewLine" |
| local Version = 1 |
| local function OnAcquire(sefl) |
| end |
| local function OnRelease(self) |
| end |
| local function Constructor() |
| local frame = CreateFrame("Frame") |
| self = {} |
| self.type = Type |
| self.frame = frame |
| self.OnAcquire = OnAcquire |
| self.OnRelease = OnRelease |
| AceGUI:RegisterAsWidget(self) |
| return self |
| end |
| AceGUI:RegisterWidgetType(Type,Constructor,Version) |
| end |
mRunes/Libs/LibGUIFactory-1.0/Widgets/UIF-Slider.lua
New file
0,0 → 1,81
| local AceGUI = LibStub("AceGUI-3.0") |
| -- Lua APIs |
| local min, max, floor = math.min, math.max, math.floor |
| local tonumber = tonumber |
| -- WoW APIs |
| local CreateFrame, UIParent = CreateFrame, UIParent |
| -- Global vars/functions that we don't upvalue since they might get hooked, or upgraded |
| -- List them here for Mikk's FindGlobals script |
| -- GLOBALS: GameFontHighlightSmall |
| -------------------------- |
| -- Slider -- |
| -------------------------- |
| do |
| local Type = "UIF-Slider" |
| local Version = 3 |
| local function OnAcquire(self) |
| self.OldOnAcquire(self) |
| self.slider:EnableMouseWheel(true) |
| end |
| local function SetDisabled(self, disabled) |
| self.oldSetDisable(self, disabled) |
| if not disabled and self.newColor then |
| self.label:SetTextColor(unpack(self.newColor)) |
| self.lowtext:SetTextColor(unpack(self.newColor)) |
| self.hightext:SetTextColor(unpack(self.newColor)) |
| end |
| end |
| local function SetFont(self, font, size, flags) |
| self.label:SetFont(font, size, flags) |
| self.lowtext:SetFont(font, size, flags) |
| self.hightext:SetFont(font, size, flags) |
| self.editbox:SetFont(font, size, "none") |
| end |
| local function SetFontColor(self, color) |
| self.newColor = color |
| self.label:SetTextColor(unpack(color)) |
| self.lowtext:SetTextColor(unpack(color)) |
| self.hightext:SetTextColor(unpack(color)) |
| end |
| local function Slider_OnMouseWheel(frame, v) |
| local self = frame.obj |
| if not self.disabled and IsShiftKeyDown() then |
| local value = self.value |
| if v > 0 then |
| value = min(value + (IsControlKeyDown() and 4 * self.step or self.step or 1), self.max) |
| else |
| value = max(value - (IsControlKeyDown() and 4 * self.step or self.step or 1), self.min) |
| end |
| self.slider:SetValue(value) |
| end |
| end |
| local function Constructor() |
| local self = AceGUI:Create("Slider") |
| self.type = Type |
| self.oldSetDisable = self.SetDisabled |
| self.SetDisabled = SetDisabled |
| self.SetFont = SetFont |
| self.SetFontColor = SetFontColor |
| self.OldOnAcquire = self.OnAcquire |
| self.OnAcquire = OnAcquire |
| self.slider:SetScript("OnMouseWheel", Slider_OnMouseWheel) |
| return self |
| end |
| AceGUI:RegisterWidgetType(Type,Constructor,Version) |
| end |
mRunes/Libs/LibGUIFactory-1.0/Widgets/UIF-TabGroup.lua
New file
0,0 → 1,41
| local AceGUI = LibStub("AceGUI-3.0") |
| do |
| local Type = "UIF-TabGroup" |
| local Version = 3 |
| local function SetFont(self, font, size, flags) |
| self.titletext:SetFont(font, size, flags) |
| end |
| local function SetFontColor(self, color) |
| self.titletext:SetTextColor(unpack(color)) |
| end |
| local function SetBorderColor(self, color) |
| self.border:SetBackdropBorderColor(unpack(color)) |
| end |
| local function SetBackColor(self, color) |
| self.border:SetBackdropColor(unpack(color)) |
| end |
| local function Constructor() |
| local self = AceGUI:Create("TabGroup") |
| self.type = Type |
| self.SetBorderColor = SetBorderColor |
| self.SetBackColor = SetBackColor |
| self.SetFont = SetFont |
| self.SetFontColor = SetFontColor |
| self.border:ClearAllPoints() |
| self.border:SetPoint("TOPLEFT",self.titletext,"TOPLEFT",1,0) |
| self.border:SetPoint("BOTTOMRIGHT",self.frame,"BOTTOMRIGHT",-1,3) |
| return self |
| end |
| AceGUI:RegisterWidgetType(Type,Constructor,Version) |
| end |
mRunes/Libs/LibGUIFactory-1.0/LibGUIFactory-1.0.lua
New file
0,0 → 1,1094
\ No newline at end of file
| local UIF_MAJOR, UIF_MINOR = "LibGUIFactory-1.0", 26 |
| local UIF, oldminor = LibStub:NewLibrary(UIF_MAJOR, UIF_MINOR) |
| if not UIF then return end |
| local AceGUI = LibStub("AceGUI-3.0") |
| local LSM = LibStub("LibSharedMedia-3.0") |
| UIF.factories = UIF.factories or {} |
| UIF.embeds = {} |
| local InternalDrop, InternalButton |
| -- |
| local function AddEmbed(name, func) |
| UIF.embeds[name] = func |
| end |
| local function Embed(obj) |
| for name, func in pairs(UIF.embeds) do |
| obj[name] = func |
| end |
| end |
| local function RecCheck(i, value, obj) |
| if not obj then return end |
| if type(value) == "table" then |
| if (obj[i]) then |
| assert(type(obj[i]) == "table", ("%q must be a table"):format(i)) |
| for subOpt, subValue in pairs(value) do |
| RecCheck(subOpt, subValue, obj[i]) |
| end |
| end |
| end |
| if type(obj) == "table" and obj[i] then |
| assert(type(obj[i]) == type(value), ("obj[%q] must be of type %s"):format(opt, type(value))) |
| if type(obj[i]) == "table" then |
| obj[i] = obj[i] or value |
| end |
| end |
| end |
| local function ValidateAndInsertDefaults(obj) |
| assert(obj and type(obj) == "table", "The provided object to be embeded with UIF-function must be a table") |
| -- For each in the defaults |
| for opt, value in pairs(UIF.defaults) do |
| -- If its a table |
| if type(value) == "table" then |
| -- Check if the incomming table have this index |
| if obj[opt] then |
| -- Check sp the type of the value is the same |
| assert(type(obj[opt]) == "table", ("[%q] must be a %s"):format(opt, type(value))) |
| -- For each subTable do the same check |
| for subOpt, subValue in pairs(value) do |
| RecCheck(subOpt, subValue, obj[subOpt]) |
| end |
| end |
| else |
| if obj[opt] then |
| assert(type(obj[opt]) == type(value), ("obj[%q] must be of type %s"):format(opt, type(value))) |
| end |
| end |
| obj[opt] = obj[opt] or value |
| end |
| for opt, _ in pairs(obj) do |
| assert(UIF.defaults[opt], ("The setting %q is not a vailid setting"):format(opt)) |
| end |
| end |
| function UIF:GetFactory(name, obj) |
| assert(not obj or type(obj) == "table", "Invalid factory object, it must be either nil or a table") |
| if self.factories[name] then return self.factories[name] end |
| newObj = {} |
| newObj.s = obj |
| newObj.name = name |
| ValidateAndInsertDefaults(newObj.s) |
| Embed(newObj) |
| self.factories[name] = newObj |
| return newObj |
| end |
| function UIF:UpdateFactory(name, obj) |
| assert(type(obj) == "table" or not obj, "Invalid factory object, it must be either nil or a table") |
| assert(self.factories[name], ("The factory %s does not exist"):format(name)) |
| ValidateAndInsertDefaults(obj) |
| end |
| local function OnMouseEnter(widget, event) |
| local title, text = widget:GetUserData("enterTitle"), widget:GetUserData("enterText") |
| GameTooltip:SetOwner(widget.frame) |
| if title then |
| GameTooltip:AddLine(title) |
| end |
| GameTooltip:AddLine(text) |
| GameTooltip:Show() |
| end |
| local function OnMouseLeave(wdiget, event) |
| GameTooltip:Hide() |
| end |
| local function SetMouseOver(self, widget, title, text) |
| widget:SetUserData("enterTitle", title) |
| widget:SetUserData("enterText", text) |
| widget:SetCallback("OnEnter", OnMouseEnter) |
| widget:SetCallback("OnLeave", OnMouseLeave) |
| end |
| AddEmbed("SetMouseOver", SetMouseOver) |
| ---------------------- |
| -- Changing widget Methods |
| -- Used for update on release widgets |
| local function UpdateTrigger(widget, event, ...) |
| local self = widget:GetUserData("self") |
| local db = widget:GetUserData("db") |
| local key = widget:GetUserData("key") |
| local func = widget:GetUserData("extraCallback") |
| local TriggerGlobalUpdate = widget:GetUserData("TriggerGlobalUpdate") |
| if db then |
| if select("#", ...) > 1 then |
| for i = 1, select("#", ...) do |
| db[key] = db[key] or {} |
| if type(db[key]) ~= "table" then |
| db[key] = {} |
| end |
| db[key][i] = select(i, ...) |
| end |
| else |
| if widget.min then |
| local value = ... |
| if value < widget.min then value = widget.min end |
| if value > widget.max then value = widget.max end |
| db[key] = value |
| else |
| db[key] = ... |
| end |
| end |
| end |
| if widget.SetValue then |
| if widget.min then |
| local value = ... |
| if value < widget.min then value = widget.min end |
| if value > widget.max then value = widget.max end |
| widget:SetValue(value) |
| if widget.editbox then |
| widget.editbox:ClearFocus() |
| end |
| else |
| widget:SetValue(...) |
| end |
| end |
| if func then func(widget, event, ...) end |
| if widget.SetColor then |
| widget:SetColor(...) |
| end |
| if TriggerGlobalUpdate then |
| if self.valuesChangedCallback then |
| for i, func in pairs(self.valuesChangedCallback) do |
| func(self) |
| end |
| end |
| end |
| end |
| local function ConfirmPupup(widget, event, ...) |
| if not StaticPopupDialogs["AEGUIFACTORY_CONFIRM_DIALOG"] then |
| StaticPopupDialogs["AEGUIFACTORY_CONFIRM_DIALOG"] = {} |
| end |
| local t = StaticPopupDialogs["AEGUIFACTORY_CONFIRM_DIALOG"] |
| for k in pairs(t) do |
| t[k] = nil |
| end |
| t.text = "Are you sure?" |
| t.button1 = ACCEPT |
| t.button2 = CANCEL |
| local data = {...} |
| local dialog, oldstrata |
| t.OnAccept = function() |
| UpdateTrigger(widget, event, unpack(data)) |
| if dialog and oldstrata then |
| dialog:SetFrameStrata(oldstrata) |
| end |
| end |
| t.OnCancel = function() |
| if dialog and oldstrata then |
| dialog:SetFrameStrata(oldstrata) |
| end |
| local self = widget:GetUserData("self") |
| local TriggerGlobalUpdate = widget:GetUserData("TriggerGlobalUpdate") |
| if TriggerGlobalUpdate then |
| if self.valuesChangedCallback then |
| for i, func in pairs(self.valuesChangedCallback) do |
| func(self) |
| end |
| end |
| end |
| end |
| for i = 1, select('#', ...) do |
| t[i] = select(i, ...) or false |
| end |
| t.timeout = 0 |
| t.whileDead = 1 |
| t.hideOnEscape = 1 |
| dialog = StaticPopup_Show("AEGUIFACTORY_CONFIRM_DIALOG") |
| if dialog then |
| oldstrata = dialog:GetFrameStrata() |
| dialog:SetFrameStrata("TOOLTIP") |
| end |
| end |
| local function SetGUIOption(widget, event, ...) |
| local self = widget:GetUserData("self") |
| local db = widget:GetUserData("db") |
| local key = widget:GetUserData("key") |
| local UpdateOnMouseUp = widget:GetUserData("UpdateOnMouseUP") |
| local TriggerGlobalUpdate = widget:GetUserData("TriggerGlobalUpdate") |
| local func = widget:GetUserData("extraCallback") |
| local confirm = widget:GetUserData("confirm") |
| if confirm then ConfirmPupup(widget, event, ...) return end |
| if db and key then |
| if select("#", ...) > 1 then |
| for i = 1, select("#", ...) do |
| db[key] = db[key] or {} |
| if type(db[key]) ~= "table" then |
| db[key] = {} |
| end |
| db[key][i] = select(i, ...) |
| end |
| else |
| if widget.min then |
| local value = ... |
| if value < widget.min then value = widget.min end |
| if value > widget.max then value = widget.max end |
| db[key] = value |
| else |
| db[key] = ... |
| end |
| end |
| elseif db then |
| local item, value = ... |
| db[item] = value |
| end |
| if key and widget.SetValue then |
| if widget.min then |
| local value = ... |
| if value < widget.min then value = widget.min end |
| if value > widget.max then value = widget.max end |
| widget:SetValue(value) |
| else |
| widget:SetValue(...) |
| end |
| end |
| if widget.SetColor then |
| widget:SetColor(...) |
| end |
| if func then func(widget, event, ...) end |
| if TriggerGlobalUpdate then |
| if self.valuesChangedCallback and not UpdateOnMouseUp then |
| for i, func in pairs(self.valuesChangedCallback) do |
| func(self) |
| end |
| end |
| end |
| if key then AceGUI:ClearFocus() end |
| end |
| -- Internal |
| -- Get Label now supports a callback setting, incase you set to interactive so you can pass in an onClick handler to the label |
| local function GetLabel(lType, self, text, color, size, font, flags, interactive, relativeWidth, callback) |
| if text then assert(type(text) == "string" or type(text) == "number", ("%s-GuiFactory. %q must be a string or number"):format(self.name, "text")) end |
| if color then assert(type(color) == "table" and color[1] and #color > 2 and |
| type(color[1]) == "number" and |
| type(color[2]) == "number" and |
| type(color[3]) == "number", ("%s-GuiFactory. %q must be a numeric indexed table with at least 3 values, each of numeric type"):format(self.name, "color")) end |
| if size then assert(type(size) == "number", ("%s-GuiFactory. %q must be a number"):format(self.name, "size")) end |
| if font then assert(type(font) == "string", ("%s-GuiFactory. %q must be a string"):format(self.name, "font")) end |
| if flags then assert(type(flags) == "string", ("%s-GuiFactory. %q must be a string"):format(self.name, "flags")) end |
| local s = self.s[lType] |
| color = color or s.fontColor or self.s.fontColor |
| local label |
| if interactive then |
| label = AceGUI:Create("InteractiveLabel") |
| label:SetCallback("OnClick", SetGUIOption) |
| label:SetUserData("extraCallback", callback) |
| else |
| label = AceGUI:Create("UIF-Label") |
| end |
| label:SetImage([[Interface\Icons\Achievement_Dungeon_Ulduar77_25man]], 0, 1, 0, 1) |
| label:SetImageSize(0, 0) |
| label:SetImage(nil) |
| label:SetFont(font or s.font or self.s.font, size or s.fontSize or self.s.fontSize, flags or s.fontFlags or self.s.fontFlags) |
| label:SetColor(unpack(color)) |
| label:SetText(text) |
| label:SetRelativeWidth(relativeWidth or 1) |
| return label |
| end |
| -------------------- |
| -- Labels |
| --- Create a TitleX object (Title1, Title2, Title3) |
| -- @paramsig [self ,] text [, color] [, size] [, font] [, flags] [, interactive] |
| -- @pram self Table that is the factory itself (optional when called with :Title1(..) |
| -- @param text Text to put in the label |
| -- @param color Table with 4 values 0.0-1.0 representing the RGB-value of the color |
| -- @param size Size of the font to use |
| -- @param font The fontfile to use |
| -- @param flags Font flags (THICKOUTLINE, OUTLINE, MONOCROME, NONE) |
| -- @interactive Boolean to tell if it should be an interactive text, meaning it triggers OnEnter and so on. |
| local function Title1(...) |
| return GetLabel("Title1", ...) |
| end |
| local function Title2(...) |
| return GetLabel("Title2", ...) |
| end |
| local function Title3(...) |
| return GetLabel("Title3", ...) |
| end |
| AddEmbed("Title1", Title1) |
| AddEmbed("Title2", Title2) |
| AddEmbed("Title3", Title3) |
| AddEmbed("Title", Title1) |
| AddEmbed("MainTitleLabel", Title1) |
| local function Text1(...) |
| return GetLabel("Text1", ...) |
| end |
| local function Text2(...) |
| return GetLabel("Text2", ...) |
| end |
| local function Text3(...) |
| return GetLabel("Text3", ...) |
| end |
| AddEmbed("Text1", Text1) |
| AddEmbed("Text2", Text2) |
| AddEmbed("Text3", Text3) |
| AddEmbed("NormalText", Text1) |
| --- Create a ListLevel1 object (ListLevel1, ListLevel2, ListLevel3) |
| -- @paramsig [self ,] text [, color] [, size] [, font] [, flags] [, interactive] |
| -- @pram self Table that is the factory itself (optional when called with :Title1(..) |
| -- @param text Text to put in the label |
| -- @param color Table with 4 values 0.0-1.0 representing the RGB-value of the color |
| -- @param size Size of the font to use |
| -- @param font The fontfile to use |
| -- @param flags Font flags (THICKOUTLINE, OUTLINE, MONOCROME, NONE) |
| -- @interactive Boolean to tell if it should be an interactive text, meaning it triggers OnEnter and so on. |
| local function ListLevel1(self, text, color, size, font, flags, interactive) |
| return GetLabel("ListLevel1", self, text, color, size, font, flags, interactive) |
| end |
| local function ListLevel1(self, text, color, size, font, flags, interactive) |
| return GetLabel("ListLevel2", self, text, color, size, font, flags, interactive) |
| end |
| local function ListLevel1(self, text, color, size, font, flags, interactive) |
| return GetLabel("ListLevel3", self, text, color, size, font, flags, interactive) |
| end |
| AddEmbed("ListLevel1", ListLevel1) |
| AddEmbed("ListLevel3", ListLevel2) |
| AddEmbed("ListLevel2", ListLevel3) |
| AddEmbed("ListText", ListLevel1) |
| --------------------- |
| -- Frame |
| -- Create a main window for your GUI |
| -- @paramsig [self, ] text |
| -- @param self Table that is the factory itself, should not be passed when used lik Factory:Frame(...) |
| -- @param text Text to put in the title area of the window |
| local function Frame(self, text) |
| local s = self.s["Frame"] |
| local group = AceGUI:Create("UIF-Frame") |
| group:SetTitleFont(s.font or self.s.font, s.fontSize or self.s.fontSize, s.fontFlags or self.s.fontFlags) |
| group:SetTitleFontColor(s.fontColor or self.s.fontColor) |
| group:SetBorderColor(s.borderColor or self.s.borderColor) |
| group:SetBackColor(s.bgColor or self.s.bgColor) |
| group:SetTitle(text) |
| local button = self:Button("") |
| group:SetButton(button) |
| return group |
| end |
| AddEmbed("Frame", Frame) |
| --------------------- |
| -- Dropdown group |
| local function DropdownGroup(self, text) |
| local s = self.s["DropdownGroup"] |
| local group = AceGUI:Create("UIF-DropdownGroup") |
| group:SetFullWidth(true) |
| group:SetFont(s.font or self.s.font, s.fontSize or self.s.fontSize, s.fontFlags or self.s.fontFlags) |
| group:SetFontColor(s.fontColor or self.s.fontColor) |
| group:SetBorderColor(s.borderColor or self.s.borderColor) |
| group:SetTitle(text) |
| local drop = InternalDrop(self) |
| group:SetDropdownWidget(drop) |
| return group |
| end |
| AddEmbed("DropdownGroup", DropdownGroup) |
| ---------------------- |
| -- Tree group |
| local function TreeGroup(self) |
| local s = self.s["TreeGroup"] |
| local group = AceGUI:Create("UIF-TreeGroup") |
| group:SetFullWidth(true) |
| group:SetFont(s.font or self.s.font, s.fontSize or self.s.fontSize, s.fontFlags or self.s.fontFlags) |
| group:SetFontColor(s.fontColor or self.s.fontColor) |
| group:SetSubFont(s.subFont or self.s.font, s.subFontSize or self.s.fontSize, s.subFontFlags or self.s.fontFlags) |
| group:SetSubColor(s.subColor or self.s.fontColor) |
| group:SetBorderColor(s.borderColor or self.s.borderColor) |
| return group |
| end |
| AddEmbed("TreeGroup", TreeGroup) |
| ---------------------- |
| -- Tab group |
| local function TGroup(tType, self, text) |
| if text then assert(type(text) == "string", ("%s-GuiFactory. %q must be a string"):format(self.name, "text")) end |
| local s = self.s[tType] |
| local group = AceGUI:Create("UIF-TabGroup") |
| group:SetBorderColor(s.borderColor or self.s.borderColor) |
| group:SetBackColor(s.bgColor) |
| group:SetFont(s.font or self.s.font, s.fontSize or self.s.fontSize, s.fontFlags or self.s.fontFlags) |
| group:SetFontColor(s.fontColor or self.s.fontColor) |
| group:SetTitle(text) |
| group:SetFullWidth(true) |
| group:SetLayout("Flow") |
| return group |
| end |
| local function TabGroup1(self, text) |
| return TGroup("TabGroup1", self, text) |
| end |
| local function TabGroup2(self, text) |
| return TGroup("TabGroup2", self, text) |
| end |
| local function TabGroup2(self, text) |
| return TGroup("TabGroup3", self, text) |
| end |
| AddEmbed("TabGroup1", TabGroup1) |
| AddEmbed("TabGroup", TabGroup1) -- Backwards compability |
| AddEmbed("TabGroup2", TabGroup2) |
| AddEmbed("TabGroup3", TabGroup3) |
| ---------------------- |
| -- Inline group |
| local function IGroup(gType, self, text, bgColor, borderColor) |
| if text then assert(type(text) == "string", ("%s-GuiFactory. %q must be a string"):format(self.name, "text")) end |
| if bgColor then assert(type(bgColor) == "table" and #bgColor > 2 and |
| type(bgColor[1]) == "number" and |
| type(bgColor[2]) == "number" and |
| type(bgColor[3]) == "number", ("%s-GuiFactory. %q must be a numeric indexed table with at least 3 values, each of numeric type"):format(self.name, "bgColor")) end |
| if borderColor then assert(type(borderColor) == "table" and #borderColor > 2 and |
| type(borderColor[1]) == "number" and |
| type(borderColor[2]) == "number" and |
| type(borderColor[3]) == "number", ("%s-GuiFactory. %q must be a numeric indexed table with at least 3 values, each of numeric type"):format(self.name, "borderColor")) end |
| local s = self.s[gType] |
| local group = AceGUI:Create("UIF-InlineGroup") |
| group:SetLayout("Flow") |
| group:SetFullWidth(true) |
| group:SetTitle(text) |
| group:SetFont(s.font or self.s.font, s.fontSize or self.s.fontSize, s.fontFlags or self.s.fontFlags) |
| group:SetFontColor(s.fontColor or self.s.fontColor) |
| group:SetBGColor(bgColor or s.bgColor or self.s.bgColor) |
| group:SetBorderColor(borderColor or s.borderColor or self.s.borderColor) |
| return group |
| end |
| local function InlineGroup1(self, text, bgColor, borderColor) |
| return IGroup("InlineGroup1", self, text, bgColor, borderColor) |
| end |
| local function InlineGroup2(self, text, bgColor, borderColor) |
| return IGroup("InlineGroup2", self, text, bgColor, borderColor) |
| end |
| local function InlineGroup3(self, text, bgColor, borderColor) |
| return IGroup("InlineGroup3", self, text, bgColor, borderColor) |
| end |
| AddEmbed("InlineGroup1", InlineGroup1) |
| AddEmbed("InlineGroup2", InlineGroup2) |
| AddEmbed("InlineGroup3", InlineGroup3) |
| AddEmbed("InlineGroup", InlineGroup1) |
| -- Mewline |
| local function NewLine(self, height) |
| local t = AceGUI:Create("UIF-NewLine") |
| t:SetHeight(height or 2) |
| t:SetFullWidth(true) |
| return t |
| end |
| AddEmbed("NewLine", NewLine) |
| local function Spacer(self, width) |
| local t = AceGUI:Create("UIF-NewLine") |
| t:SetWidth(width or 2) |
| t:SetFullWidth(false) |
| t:SetHeight(10) |
| return t |
| end |
| AddEmbed("Spacer", Spacer) |
| -- Changing Widgets |
| local function Slider(self, text, db, key, min, max, step, callback, relativeWidth) |
| assert(text and type(text) == "string", ("%s-GuiFactory. %q must be a string"):format(self.name, "text")) |
| assert(db and type(db) == "table", ("%s-GuiFactory. %q must be a table"):format(self.name, "db")) |
| assert(key, ("%s-GuiFactory. %q must be supplied"):format(self.name, "key")) |
| assert(db[key], ("%s-GuiFactory. %q does not contain %q"):format(self.name, "db", key)) |
| if callback then assert(type(callback) == "function", ("%s-GuiFactory. %q must be a function"):format(self.name, "callback")) end |
| if min then assert(type(min) == "number", ("%s-GuiFactory. %q must be a number"):format(self.name, "min")) end |
| if max then assert(type(max) == "number", ("%s-GuiFactory. %q must be a number"):format(self.name, "max")) end |
| if step then assert(type(step) == "number", ("%s-GuiFactory. %q must be a number"):format(self.name, "step")) end |
| if relativeWidth then assert(type(relativeWidth) == "number", ("%s-GuiFactory. %q must be a number"):format(self.name, "relativeWidth")) end |
| local s = self.s["Slider"] |
| local slider = AceGUI:Create("UIF-Slider") |
| slider:SetLabel(text) |
| slider:SetFont(s.font or self.s.font, s.fontSize or self.s.fontSize, s.fontFlags or self.s.fontFlags) |
| slider:SetFontColor(s.fontColor or self.s.fontColor) |
| slider:SetSliderValues(min or 0, max or 100, step or 1) |
| slider:SetValue(db[key]) |
| slider:SetUserData("db", db) |
| slider:SetUserData("key", key) |
| slider:SetUserData("extraCallback", callback) |
| slider:SetUserData("self", self) |
| slider:SetUserData("UpdateOnMouseUP", true) |
| slider:SetCallback("OnValueChanged", SetGUIOption) |
| slider:SetCallback("OnMouseUp", UpdateTrigger) |
| if relativeWidth then slider:SetRelativeWidth(relativeWidth) end |
| return slider |
| end |
| AddEmbed("Slider", Slider) |
| local function PositionSlider(self, type, text, db, key, step, callback, relativeWidth) |
| local min, max |
| if string.lower(type) == "x" then |
| min = -floor(GetScreenWidth() * UIParent:GetEffectiveScale()) |
| max = floor(GetScreenWidth() * UIParent:GetEffectiveScale()) |
| else |
| min = -floor(GetScreenHeight() * UIParent:GetEffectiveScale()) |
| max = floor(GetScreenHeight() * UIParent:GetEffectiveScale()) |
| end |
| return Slider(self, text, db, key, min, max, step, callback, relativeWidth) |
| end |
| AddEmbed("PositionSlider", PositionSlider) |
| local function CheckBox(self, text, db, key, callback, description, relativeWidth, globalUpdate) |
| assert(text and type(text) == "string", ("%s-GuiFactory. %q must be a string"):format(self.name, "text")) |
| assert(db and type(db) == "table", ("%s-GuiFactory. %q must be a table"):format(self.name, "db")) |
| assert(key, ("%s-GuiFactory. %q must be supplied"):format(self.name, "key")) |
| if callback then assert(type(callback) == "function", ("%s-GuiFactory. %q must be a function"):format(self.name, "callback")) end |
| if relativeWidth then assert(type(relativeWidth) == "number", ("%s-GuiFactory. %q must be a number"):format(self.name, "relativeWidth")) end |
| local s = self.s["CheckBox"] |
| local check = AceGUI:Create("UIF-CheckBox") |
| check:SetFullWidth(true) |
| check:SetLabel(text) |
| check:SetValue(db[key]) |
| check:SetFont(s.font or self.s.font, s.fontSize or self.s.fontSize, s.fontFlags or self.s.fontFlags) |
| check:SetFontColor(s.fontColor or self.s.fontColor) |
| if description then |
| check:SetDescription(description) |
| end |
| check:SetUserData("db", db) |
| check:SetUserData("key", key) |
| check:SetUserData("extraCallback", callback) |
| check:SetUserData("self", self) |
| check:SetUserData("TriggerGlobalUpdate", globalUpdate) |
| check:SetCallback("OnValueChanged", SetGUIOption) |
| if relativeWidth then check:SetRelativeWidth(relativeWidth) end |
| return check |
| end |
| AddEmbed("CheckBox", CheckBox) |
| local function ColorSelect(self, text, db, key, callback, hasAlpha, relativeWidth) |
| assert(text and type(text) == "string", ("%s-GuiFactory. %q must be a string"):format(self.name, "text")) |
| assert(db and type(db) == "table", ("%s-GuiFactory. %q must be a table"):format(self.name, "db")) |
| assert(key, ("%s-GuiFactory. %q must be supplied"):format(self.name, "key")) |
| if callback then assert(type(callback) == "function", ("%s-GuiFactory. %q must be a function"):format(self.name, "callback")) end |
| if hasAlpha then assert(hasAlpha and type(hasAlpha) == "boolean", ("%s-GuiFactory. %q must be a boolean"):format(self.name, "hasAlpha")) end |
| if relativeWidth then assert(type(relativeWidth) == "number", ("%s-GuiFactory. %q must be a number"):format(self.name, "relativeWidth")) end |
| local s = self.s["CheckBox"] |
| local color = AceGUI:Create("UIF-ColorPicker") |
| color:SetLabel(text) |
| color:SetFont(s.font or self.s.font, s.fontSize or self.s.fontSize, s.fontFlags or self.s.fontFlags) |
| color:SetFontColor(s.fontColor or self.s.fontColor) |
| if db[key] and type(db[key]) == "table" then |
| color:SetColor(unpack(db[key])) |
| end |
| color:SetHasAlpha(hasAlpha) |
| color:SetUserData("db", db) |
| color:SetUserData("key", key) |
| color:SetUserData("extraCallback", callback) |
| color:SetUserData("self", self) |
| color:SetCallback("OnValueChanged", SetGUIOption) |
| color:SetUserData("UpdateOnMouseUP", true) |
| color:SetCallback("OnValueConfirmed", UpdateTrigger) |
| if relativeWidth then color:SetRelativeWidth(relativeWidth) end |
| return color |
| end |
| AddEmbed("ColorSelect", ColorSelect) |
| ----------------------- |
| -- Other |
| InternalButton = function(self) |
| local s = self.s["Button"] |
| local color = color or s.fontColor or self.s.fontColor |
| local button = AceGUI:Create("UIF-Button") |
| button:SetText(text) |
| button:SetFont(font or s.font or self.s.font, size or s.fontSize or self.s.fontSize, flags or s.fontFlags or self.s.fontFlags) |
| button:SetFontColor(color) |
| return button |
| end |
| local function Button(self, text, callback, font, size, flags, color, relativeWidth) |
| assert(text and type(text) == "string", ("%s-GuiFactory. %q must be a string"):format(self.name, "text")) |
| if color then assert(type(color) == "table" and color[1] and #color > 2 and |
| type(color[1]) == "number" and |
| type(color[2]) == "number" and |
| type(color[3]) == "number", ("%s-GuiFactory. %q must be a numeric indexed table with at least 3 values, each of numeric type"):format(self.name, "color")) end |
| if size then assert(type(size) == "number", ("%s-GuiFactory. %q must be a number"):format(self.name, "size")) end |
| if font then assert(type(font) == "string", ("%s-GuiFactory. %q must be a string"):format(self.name, "font")) end |
| if flags then assert(type(flags) == "string", ("%s-GuiFactory. %q must be a string"):format(self.name, "flags")) end |
| local s = self.s["Button"] |
| color = color or s.fontColor or self.s.fontColor |
| local button = AceGUI:Create("UIF-Button") |
| button:SetText(text) |
| button:SetFont(font or s.font or self.s.font, size or s.fontSize or self.s.fontSize, flags or s.fontFlags or self.s.fontFlags) |
| button:SetFontColor(color) |
| button:SetUserData("self", self) |
| button:SetUserData("extraCallback", callback) |
| button:SetCallback("OnClick", SetGUIOption) |
| button:SetUserData("UpdateOnMouseUP", true) |
| button:SetCallback("OnMouseUp", UpdateTrigger) |
| if not relativeWidth then |
| button:SetWidth(button.text:GetStringWidth() + 30) |
| else |
| button:SetRelativeWidth(relativeWidth) |
| end |
| return button |
| end |
| AddEmbed("Button", Button) |
| ---------------------- |
| -- Dropdown |
| InternalDrop = function(self, text, callback, list, relativeWidth) |
| local s = self.s["Dropdown"] |
| local drop = AceGUI:Create("UIF-Dropdown") |
| drop:SetItemFont(s.itemFont or self.s.font, s.itemFontSize or self.s.fontSize, s.itemFontFlags or self.s.fontFlags) |
| drop:SetItemFontColor(s.itemFontColor or self.s.fontColor) |
| drop:SetFont(s.font or self.s.font, s.fontSize or self.s.fontSize, s.fontFlags or self.s.fontFlags) |
| drop:SetFontColor(s.fontColor or self.s.fontColor) |
| drop:SetUserData("self", self) |
| drop:SetLabel(text) |
| drop:SetList(list) |
| drop:SetUserData("extraCallback", callback) |
| drop:SetCallback("OnValueChanged", SetGUIOption) |
| if relativeWidth then drop:SetRelativeWidth(relativeWidth) end |
| return drop |
| end |
| AddEmbed("SimpleDropdown", InternalDrop) |
| local function Dropdown(self, text, db, key, callback, list, relativeWidth, globalUpdate) |
| assert(text and type(text) == "string", ("%s-GuiFactory. %q must be a string"):format(self.name, "text")) |
| assert(db and type(db) == "table", ("%s-GuiFactory. %q must be a table"):format(self.name, "db")) |
| assert(key, ("%s-GuiFactory. %q must be supplied"):format(self.name, "key")) |
| if callback then assert(type(callback) == "function", ("%s-GuiFactory. %q must be a function"):format(self.name, "callback")) end |
| if relativeWidth then assert(type(relativeWidth) == "number", ("%s-GuiFactory. %q must be a number"):format(self.name, "relativeWidth")) end |
| local drop = InternalDrop(self) |
| drop:SetLabel(text) |
| drop:SetUserData("db", db) |
| drop:SetUserData("key", key) |
| drop:SetUserData("self", self) |
| drop:SetList(list) |
| drop:SetUserData("extraCallback", callback) |
| drop:SetCallback("OnValueChanged", SetGUIOption) |
| drop:SetValue(db[key]) |
| drop:SetUserData("TriggerGlobalUpdate", globalUpdate) |
| if relativeWidth then drop:SetRelativeWidth(relativeWidth) end |
| return drop |
| end |
| AddEmbed("Dropdown", Dropdown) |
| local function MultiSelectDropdown(self, text, db, callback, list, relativeWidth) |
| assert(text and type(text) == "string", ("%s-GuiFactory. %q must be a string"):format(self.name, "text")) |
| assert(db and type(db) == "table", ("%s-GuiFactory. %q must be a table"):format(self.name, "db")) |
| if callback then assert(type(callback) == "function", ("%s-GuiFactory. %q must be a function"):format(self.name, "callback")) end |
| if relativeWidth then assert(type(relativeWidth) == "number", ("%s-GuiFactory. %q must be a number"):format(self.name, "relativeWidth")) end |
| local drop = InternalDrop(self) |
| drop:SetLabel(text) |
| drop:SetMultiselect(true) |
| drop:SetUserData("db", db) |
| drop:SetUserData("self", self) |
| if list then |
| drop:SetList(list) |
| for i in pairs(list) do |
| if db[i] then drop:SetItemValue(i, true) end |
| end |
| end |
| drop:SetUserData("extraCallback", callback) |
| drop:SetCallback("OnValueChanged", SetGUIOption) |
| if relativeWidth then drop:SetRelativeWidth(relativeWidth) end |
| return drop |
| end |
| AddEmbed("MultiSelectDropdown", MultiSelectDropdown) |
| local function LSMDropdown(self, dtype, text, db, key, callback, relativeWidth) |
| assert(text and type(text) == "string", ("%s-GuiFactory. %q must be a string"):format(self.name, "text")) |
| assert(db and type(db) == "table", ("%s-GuiFactory. %q must be a table"):format(self.name, "db")) |
| assert(key, ("%s-GuiFactory. %q must be supplied"):format(self.name, "key")) |
| if callback then assert(type(callback) == "function", ("%s-GuiFactory. %q must be a function"):format(self.name, "callback")) end |
| if relativeWidth then assert(type(relativeWidth) == "number", ("%s-GuiFactory. %q must be a number"):format(self.name, "relativeWidth")) end |
| local drop |
| local dtype = string.lower(dtype) |
| if dtype == "statusbar" then |
| drop = AceGUI:Create("LSM30_Statusbar") |
| drop:SetList(LSM:HashTable("statusbar")) |
| elseif dtype == "font" then |
| drop = AceGUI:Create("LSM30_Font") |
| drop:SetList(LSM:HashTable("font")) |
| elseif dtype == "background" then |
| drop = AceGUI:Create("LSM30_Background") |
| drop:SetList(LSM:HashTable("background")) |
| elseif dtype == "border" then |
| drop = AceGUI:Create("LSM30_Border") |
| drop:SetList(LSM:HashTable("border")) |
| elseif dtype == "sound" then |
| drop = AceGUI:Create("LSM30_Sound") |
| drop:SetList(LSM:HashTable("sound")) |
| else |
| assert(drop ~= nil, ("%s-GuiFactory. %q is not a valid LSM dropdown."):format(self.name, "dtype")) |
| end |
| drop:SetLabel(text) |
| drop:SetValue(db[key]) |
| drop:SetUserData("db", db) |
| drop:SetUserData("key", key) |
| drop:SetUserData("extraCallback", callback) |
| drop:SetUserData("self", self) |
| drop:SetCallback("OnValueChanged", SetGUIOption) |
| if relativeWidth then drop:SetRelativeWidth(relativeWidth) end |
| return drop |
| end |
| AddEmbed("LSMDropdown", LSMDropdown) |
| -- Profile |
| local AceProfileOption |
| do |
| local function GetAllPorfiles(db) |
| local profiles = { |
| ["Default"] = "Default", |
| [db.keys.char] = db.keys.char, |
| [db.keys.realm] = db.keys.realm, |
| [db.keys.class] = UnitClass("player") |
| } |
| local ExistingProfiles = {} |
| local count = 0 |
| for i, profileName in pairs(db:GetProfiles()) do |
| profiles[profileName] = profileName |
| count = count + 1 |
| end |
| return profiles, count |
| end |
| local function GetExistingProfiles(db, nocurrent) |
| local profiles = {} |
| local currentProfile = db:GetCurrentProfile() |
| local count = 0 |
| for i, profileName in pairs(db:GetProfiles()) do |
| if not (nocurrent and profileName == currentProfile) then |
| profiles[profileName] = profileName |
| count = count + 1 |
| end |
| end |
| return profiles, count |
| end |
| local function RefreshProfileLists(widget) |
| local SelectProfile = widget:GetUserData("SelectProfile") |
| if not SelectProfile then return end |
| local CopyProfile = widget:GetUserData("CopyProfile") |
| local DeleteProfile = widget:GetUserData("DeleteProfile") |
| local db = SelectProfile:GetUserData("Database") |
| local profiles, count = GetAllPorfiles(db) |
| SelectProfile:SetList(profiles) |
| SelectProfile:SetValue(db:GetCurrentProfile()) |
| profiles, count = GetExistingProfiles(db, true) |
| CopyProfile:SetList(profiles) |
| CopyProfile:SetDisabled(count == 0) |
| CopyProfile:SetValue() |
| DeleteProfile:SetList(profiles) |
| DeleteProfile:SetDisabled(count == 0) |
| DeleteProfile:SetValue() |
| end |
| -- Create a group containing options to handle AceDB-3.0 profiles. |
| -- @paramsig [self ,] db |
| -- @param self Table that is the factory itself, Not required when used via Factory:AceProfileOption(...) |
| -- @param db AceDB-3.0 database object to create the profile options for. |
| AceProfileOption = function(self, db) |
| assert(db and db.ResetDB, ("%s-GuiFactory. %q must proper AceDB object."):format(self.name, "db")) |
| local group = self:InlineGroup("Profile Settings") |
| local profiles, count, text |
| local SelectProfile = InternalDrop(self) |
| SelectProfile:SetLabel("Profiles") |
| SelectProfile:SetUserData("Database", db) |
| SelectProfile:SetCallback("OnValueChanged", function(widget, event, value) |
| widget:GetUserData("Database"):SetProfile(value) |
| RefreshProfileLists(group) |
| end) |
| group:AddChild(SelectProfile) |
| local ResetProfile = InternalButton(self) |
| ResetProfile:SetText("Reset") |
| ResetProfile:SetWidth(ResetProfile.text:GetStringWidth() + 30) |
| ResetProfile:SetUserData("Database", db) |
| ResetProfile:SetUserData("self", self) |
| ResetProfile:SetUserData("extraCallback", function(widget, event) |
| widget:GetUserData("Database"):ResetProfile() |
| end) |
| ResetProfile:SetCallback("OnClick", SetGUIOption) |
| ResetProfile:SetUserData("confirm", true) |
| group:AddChild(ResetProfile) |
| group:AddChild(self:NewLine(15)) |
| group:AddChild(self:NormalText("Copy a profile and replace the current profiles settings.")) |
| local CopyProfile = InternalDrop(self) |
| CopyProfile:SetLabel("Copy Profile") |
| CopyProfile:SetUserData("Database", db) |
| CopyProfile:SetCallback("OnValueChanged", function(widget, event, value) |
| local db = widget:GetUserData("Database") |
| db:CopyProfile(value) |
| RefreshProfileLists(group) |
| end) |
| group:AddChild(CopyProfile) |
| group:AddChild(self:NewLine(15)) |
| group:AddChild(self:NormalText("Delete one of the existing profiles")) |
| local DeleteProfile = InternalDrop(self) |
| DeleteProfile:SetLabel("Delete Profile") |
| DeleteProfile:SetUserData("Database", db) |
| DeleteProfile:SetUserData("self", self) |
| DeleteProfile:SetUserData("extraCallback", function(widget, event, value) |
| local db = widget:GetUserData("Database") |
| if value then |
| db:DeleteProfile(value) |
| end |
| RefreshProfileLists(group) |
| end) |
| DeleteProfile:SetCallback("OnValueChanged", SetGUIOption) |
| DeleteProfile:SetUserData("confirm", true) |
| group:AddChild(DeleteProfile) |
| group:AddChild(self:NewLine(15)) |
| group:AddChild(self:NormalText("Create a new profile, it will then become the active profile.")) |
| local CreateProfile = AceGUI:Create("EditBox") |
| CreateProfile:SetLabel("Create Profile") |
| CreateProfile:SetUserData("Database", db) |
| CreateProfile:SetCallback("OnEnterPressed", function(widget, event, value) |
| local db = widget:GetUserData("Database") |
| db:SetProfile(value) |
| widget.editbox:ClearFocus() |
| widget:SetText() |
| RefreshProfileLists(group) |
| end) |
| group:AddChild(CreateProfile) |
| group:SetUserData("SelectProfile", SelectProfile) |
| group:SetUserData("CopyProfile", CopyProfile) |
| group:SetUserData("DeleteProfile", DeleteProfile) |
| RefreshProfileLists(group) |
| return group |
| end |
| end |
| AddEmbed("AceProfileOption", AceProfileOption) |
| local function SetValuesChangedCallback(self, func) |
| assert(type(func) == "function", "The callback must be a function") |
| self.valuesChangedCallback = self.valuesChangedCallback or {} |
| tinsert(self.valuesChangedCallback, func) |
| end |
| AddEmbed("SetValuesChangedCallback", SetValuesChangedCallback) |
| for fName, factory in pairs(UIF.factories) do |
| Embed(factory) |
| end |
| -- Defaults |
| local defaultFont, defualtFondSize, defaultFontFlags = GameFontNormal:GetFont() |
| UIF.defaults = { |
| font = defaultFont, |
| fontSize = defualtFondSize, |
| fontColor = {177/255, 219/255, 255/255}, |
| fontFlags = defaultFontFlags, |
| borderColor = {0.2,0.3,0.37,1}, |
| bgColor = {0.11,0.16,0.19,1}, |
| MainTitle = { |
| fontSize = 30, |
| fontColor = {0.4, 0.6, 0.8}, |
| fontFlags = "OUTLINE" |
| }, |
| -- Titles |
| Title1 = { |
| fontSize = 30, |
| fontColor = {255/255, 248/255, 53/255}, |
| fontFlags = "OUTLINE" |
| }, |
| Title2 = { |
| fontSize = 20, |
| fontColor = {18/255, 157/255, 143/255}, |
| fontFlags = "OUTLINE" |
| }, |
| Title3 = { |
| fontSize = 18, |
| fontColor = {18/255, 157/255, 143/255}, |
| fontFlags = "OUTLINE" |
| }, |
| -- Mornal texts |
| Text1 = { |
| fontSize = 16, |
| fontColor = {177/255, 219/255, 255/255}, |
| }, |
| Text2 = { |
| }, |
| Text3 = { |
| }, |
| -- Lists |
| ListLevel1 = { |
| fontSize = 16, |
| fontColor = {0.96, 0.93, 0.49}, |
| }, |
| ListLevel2 = { |
| }, |
| ListLevel3 = { |
| }, |
| -- Frame |
| Frame = { |
| fontSize = 25, |
| bgColor = {0.11,0.16,0.19,0.8}, |
| }, |
| DropdownGroup = { |
| }, |
| Dropdown = { |
| itemFontSize = 18, |
| }, |
| TreeGroup = { |
| fontColor = {0.4, 0.6, 0.8}, |
| }, |
| TabGroup1 = { |
| fontSize = 20, |
| tabFontSize = 35, |
| bgColor = {0.11,0.16,0.19,1}, |
| borderColor = {0.2,0.3,0.37,1}, |
| }, |
| TabGroup2 = { |
| fontSize = 20, |
| fontFlags = "OUTLINE", |
| bgColor = {40/255, 45/255, 70/255}, |
| borderColor = {81/255, 96/255, 106/255}, |
| fontColor = {207/255, 218/255, 85/255}, |
| }, |
| TabGroup3 = { |
| fontSize = 20, |
| fontFlags = "OUTLINE", |
| bgColor = {40/255, 45/255, 70/255}, |
| borderColor = {81/255, 96/255, 106/255}, |
| fontColor = {207/255, 218/255, 85/255}, |
| }, |
| InlineGroup1 = { |
| fontFlags = "OUTLINE", |
| fontSize = 22, |
| }, |
| InlineGroup2 = { |
| bgColor = {40/255, 45/255, 70/255}, |
| borderColor = {81/255, 96/255, 106/255}, |
| fontColor = {207/255, 218/255, 85/255}, |
| fontSize = 22, |
| }, |
| InlineGroup3 = { |
| bgColor = {40/255, 55/255, 75/255}, |
| borderColor = {81/255, 96/255, 106/255}, |
| fontColor = {207/255, 100/255, 85/255}, |
| fontSize = 20, |
| }, |
| Button = { |
| }, |
| Slider = { |
| }, |
| CheckBox = { |
| }, |
| } |
mRunes/Libs/LibGUIFactory-1.0/LibGUIFactory-1.0.toc
New file
0,0 → 1,11
\ No newline at end of file
| ## Interface: 40000 |
| ## Title: Lib: GUIFactory-1.0 |
| ## Author: mangeg |
| ## OptionalDeps: LibStub, Ace3, LibSharedMedia-3.0 |
| ## X-Category: Library |
| ## X-Curse-Packaged-Version: r30 |
| ## X-Curse-Project-Name: LibGUIFactory-1.0 |
| ## X-Curse-Project-ID: gui-factory-1-0 |
| ## X-Curse-Repository-ID: wow/gui-factory-1-0/mainline |
| lib.xml |
mRunes/Libs/LibFrameAnchorRegistry-1.0/LibFrameAnchorRegistry-1.0.lua
New file
0,0 → 1,159
\ No newline at end of file
| -- "FrameModified" params: ident |
| -- "FrameRegistered" param: category, name, frame, ident |
| local MAJOR_VERSION = "LibFrameAnchorRegistry-1.0" |
| local MINOR_VERSION = 3 |
| if not LibStub then error(MAJOR_VERSION .. " requires LibStub.") end |
| local lib = LibStub:NewLibrary(MAJOR_VERSION, MINOR_VERSION) |
| if not lib then return end |
| lib.callbacks = lib.callbacks or LibStub("CallbackHandler-1.0"):New(lib) |
| lib.frames = lib.frames or {} |
| --- Register a new anchor freame |
| -- @param category The category that this frame will belong to. To make sub-categories add them together separated with '\001' ('MyCat\001MySubCat'). |
| -- @param name The name of the anchor. |
| -- @param ident Unique identifyer for the frame. |
| -- @param frame The actual frame that is to be the anchor. |
| -- @usage lib:RegisterAnchor("NewCategory", "TheAnchor", frame) |
| function lib:RegisterAnchor(category, name, ident, frame) |
| if not category then error("Usage: LibFrameAnchor:RegisterAnchor(category, name, ident, frame): 'category' - valid category expected.", 2) end |
| if not name or type(name) ~= "string" then error("Usage: LibFrameAnchor:RegisterAnchor(category, name, ident, frame): 'name' - name expected.", 2) end |
| if not ident or type(ident) ~= "string" then error("Usage: LibFrameAnchor:RegisterAnchor(category, name, ident, frame): 'ident' - unique identifyer expected", 2) end |
| if not frame or not frame.GetObjectType then error("Usage: LibFrameAnchor:RegisterAnchor(category, name, ident, frame): 'frame' - frame type expected.", 2) end |
| for i, data in pairs(lib.frames) do |
| if data.ident == ident then |
| error("LibFrameAnchor:RegisterAnchor(category, name, ident, frame): 'ident' - Identifyer allready exists", 2) |
| end |
| end |
| tinsert(lib.frames, {category = category, name = name, ident = ident, frame = frame}) |
| lib.callbacks:Fire("FrameRegistered", category, name, frame, ident) |
| end |
| --- Unregister an anchor |
| -- @param ident Identification for the frame to unregister. |
| function lib:UnregisterAnchor(ident) |
| if not ident or type(ident) ~= "string" then error("Usage: LibFrameAnchorRegistry:UnregisterAnchor(ident): 'ident' - string expected", 2) end |
| for i, data in pairs(lib.frames) do |
| if data.ident == ident then |
| lib.callbacks:Fire("FrameUnregistered", ident) |
| tremove(lib.frames, i) |
| break |
| end |
| end |
| end |
| --- Get a full list of all anchors. |
| -- @param frame The frame that is going to be anchored. If passed it wont show up itself in the lists if it is also registered as an anchor. |
| -- @return table Format: ret['CategoryName'][1..n] { name, disabled, frame }. Disabled indicates that this frame cannot be anchored to as it would create a circular reference. |
| function lib:GetAnchors(frame) |
| if not frame or not frame.GetObjectType then |
| error("Usage: LibFrameAnchor:GetAnchors(frame): 'frame' - frame type expected.", 2) |
| end |
| local ret = {} |
| for i, data in pairs(lib.frames) do |
| if data.frame ~= frame then |
| tinsert(ret, { |
| category = data.category, |
| name = data.name, |
| frame = data.frame, |
| ident = data.ident, |
| disabled = FindReference(frame, data.frame), |
| }) |
| -- Dummy index for AceConfig dropdown to work properly when setting value. |
| ret[data.ident] = true |
| end |
| end |
| return ret |
| end |
| --- Get an anchor frame |
| -- @param ident The unique identifyer of the frame. |
| -- @return frame The anchor frame requested. |
| function lib:GetAnchor(ident) |
| for _, data in pairs(lib.frames) do |
| if data.ident == ident then |
| return data.frame |
| end |
| end |
| return UIParent |
| end |
| --- Notify the library that a frame that is registered as anchor have changed in some way. |
| -- Triggers FrameModified callback for addons listening to it so they can act properly on it. |
| -- @param category The category. |
| -- @param name Name of the anchor. |
| function lib:FrameModified(ident) |
| for _, data in pairs(lib.frames) do |
| if data.ident == ident then |
| lib.callbacks:Fire("FrameModified", ident) |
| end |
| end |
| end |
| FindReference = function(frame, target) |
| local n = target:GetNumPoints() |
| for i = 0, n do |
| local point, rel, relPoint, x, y = target:GetPoint(i) |
| if not rel then |
| rel = target:GetParent() |
| end |
| if rel == frame then |
| return true |
| elseif rel then |
| return FindReference(frame, rel) |
| end |
| end |
| return false |
| end |
| local AnchorList = {} |
| function lib:GetAnchorList() |
| AnchorList = AnchorList or {} |
| AnchorList["TOPLEFT"] = "Top left" |
| AnchorList["TOP"] = "Top" |
| AnchorList["TOPRIGHT"] = "Top Right" |
| AnchorList["RIGHT"] = "Right" |
| AnchorList["BOTTOMRIGHT"] = "Bottom right" |
| AnchorList["BOTTOM"] = "Bottom" |
| AnchorList["BOTTOMLEFT"] = "Bottom left" |
| AnchorList["LEFT"] = "Left" |
| AnchorList["CENTER"] = "Center" |
| return AnchorList |
| end |
| lib:RegisterAnchor("Blizzard", "Minimap", "BlizzMinimap", Minimap) |
| lib:RegisterAnchor("Blizzard", "Screen (UIParent)", "BlizzUIParent", UIParent) |
| lib:RegisterAnchor("Blizzard", "UnitFrame - Player", "BlizzUnitFramePlayer", PlayerFrame) |
| lib:RegisterAnchor("Blizzard", "UnitFrame - Target", "BlizzUnitFrameTarget", TargetFrame) |
| lib:RegisterAnchor("Blizzard", "World Frame", "BlizzWorldFrame", WorldFrame) |
| lib:RegisterAnchor("Blizzard", "Chat Frame", "BlizzChatFrame", ChatFrame1) |
| lib:RegisterAnchor("Blizzard", "Quest Tracker", "BlizzardWatchFrame", WatchFrame) |
| lib.frame = lib.frame or CreateFrame("Frame") |
| lib.frame:Hide() |
| lib.frame:SetScript("OnEvent", function(self, event, ...) |
| self:UnregisterEvent("PLAYER_ENTERING_WORLD") |
| if PitBull4_Frames_player then lib:RegisterAnchor("PitBull4", "Player", "PibBull4Player", PitBull4_Frames_player) end |
| if PitBull4_Frames_target then lib:RegisterAnchor("PitBull4", "Target", "PibBull4Target", PitBull4_Frames_target) end |
| if PitBull4_Frames_pet then lib:RegisterAnchor("PitBull4", "Pet", "PibBull4Pet", PitBull4_Frames_pet) end |
| if PitBull4_Frames_targettarget then lib:RegisterAnchor("PitBull4", "Target of Target", "PibBull4TargetOfTarget", PitBull4_Frames_targettarget) end |
| if PitBull4_Frames_focus then lib:RegisterAnchor("PitBull4", "Focus", "PibBull4Focus", PitBull4_Frames_focus) end |
| if PitBull4_Frames_focustarget then lib:RegisterAnchor("PitBull4", "Focus Target", "PibBull4FocusTarget", PitBull4_Frames_focustarget) end |
| end) |
| lib.frame:RegisterEvent("PLAYER_ENTERING_WORLD") |
| local FindReference |
mRunes/Libs/LibFrameAnchorRegistry-1.0/LibFrameAnchorRegistry-1.0.toc
New file
0,0 → 1,12
| ## Interface: 40000 |
| ## Title: Lib: FrameAnchorRegistry-1.0 |
| ## Notes: Library to handle and store information about frame that are possible targets to anchor other frames to. |
| ## Author: maangeg |
| ## OptionalDeps: LibStub, CallbackHandler-1.0 |
| ## X-Category: Library |
| ## X-Curse-Packaged-Version: 0.1b-2-gf7ee88a |
| ## X-Curse-Project-Name: LibFrameAnchorRegistry-1.0 |
| ## X-Curse-Project-ID: libframeanchorregistry-1-0 |
| ## X-Curse-Repository-ID: wow/libframeanchorregistry-1-0/mainline |
| lib.xml |
mRunes/Libs/LibFrameAnchorRegistry-1.0/lib.xml
New file
0,0 → 1,7
| <Ui xmlns="http://www.blizzard.com/wow/ui/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.blizzard.com/wow/ui/ |
| ..\FrameXML\UI.xsd"> |
| <Script file="LibFrameAnchorRegistry-1.0.lua"/> |
| <Script file="DropdownFrameWidget.lua"/> |
| </Ui> |
mRunes/Libs/LibFrameAnchorRegistry-1.0/DropdownFrameWidget.lua
New file
0,0 → 1,163
\ No newline at end of file
| do |
| --[[----------------------------------------------------------------------------- |
| Button Widget |
| Graphical Button. |
| -------------------------------------------------------------------------------]] |
| local Type, Version = "FrameAnchorDropdown", 2 |
| local AceGUI = LibStub and LibStub("AceGUI-3.0", true) |
| if not AceGUI or (AceGUI:GetWidgetVersion(Type) or 0) >= Version then return end |
| -- Lua APIs |
| local pairs, tsort = pairs, table.sort |
| -- WoW APIs |
| local _G = _G |
| local PlaySound, CreateFrame, UIParent = PlaySound, CreateFrame, UIParent |
| --[[----------------------------------------------------------------------------- |
| Callbacks |
| -------------------------------------------------------------------------------]] |
| local function ItemSelected(self, selected) |
| self.userdata.obj:SetValue(self.userdata.value) |
| end |
| --[[----------------------------------------------------------------------------- |
| Scripts |
| -------------------------------------------------------------------------------]] |
| --[[----------------------------------------------------------------------------- |
| Methods |
| -------------------------------------------------------------------------------]] |
| local function IterateMenues(self, value) |
| local container = self.type == "FrameAnchorDropdown" and self.pullout or self.submenu |
| for i, sub in container:IterateItems() do |
| if sub.type == "Dropdown-Item-Toggle" then |
| if sub.userdata.value ~= value then |
| sub:SetValue(false) |
| else |
| sub:SetValue(true) |
| sub.userdata.obj:SetText(table.concat({("\001"):split(sub.userdata.category)}, "->") .. ": " .. sub.userdata.name) |
| end |
| elseif sub.type == "Dropdown-Item-Menu" then |
| IterateMenues(sub, value) |
| end |
| end |
| end |
| local function GetMenu(self, ...) |
| local n = select("#", ...) |
| local cat = ... |
| local m |
| local container = self.type == "FrameAnchorDropdown" and self.pullout or self.submenu |
| for i, menu in container:IterateItems() do |
| if menu.userdata.value == cat then |
| m = menu |
| break |
| end |
| end |
| if not m then |
| m = AceGUI:Create("Dropdown-Item-Menu") |
| m.userdata.value = cat |
| m.SetValue = function() end |
| m:SetText(cat) |
| if m.submenu then |
| m.submenu = nil |
| end |
| if not m.submenu then |
| local sub = AceGUI:Create("Dropdown-Pullout") |
| m:SetMenu(sub) |
| m.OnRelease = function(self) |
| if self.submenu then |
| self.submenu:Release() |
| end |
| end |
| end |
| container:AddItem(m) |
| end |
| if n > 1 then |
| return GetMenu(m, select(2, ...)) |
| end |
| return m |
| end |
| local sortlist = {} |
| local function ListSort(a, b) |
| if a.category == b.category then |
| return a.name < b.name |
| else |
| return a.category < b.category |
| end |
| end |
| local methods = { |
| ["SetValue"] = function(self, value) |
| if value then |
| IterateMenues(self, value) |
| end |
| if self.open then |
| --self.pullout:Close() |
| end |
| self:Fire("OnValueChanged", value) |
| end, |
| ["SetList"] = function(self, list) |
| self.pullout:Clear() |
| self.hasClose = nil |
| wipe(sortlist) |
| for i, d in pairs(list) do |
| if type(d) == "table" then |
| tinsert(sortlist, d) |
| end |
| end |
| tsort(sortlist, ListSort) |
| for i, data in ipairs(sortlist) do |
| self:AddItem(data) |
| end |
| end, |
| ["AddItem"] = function(self, data) |
| -- create submenu |
| local m = GetMenu(self, ("\001"):split(data.category)) |
| local subCheck = AceGUI:Create("Dropdown-Item-Toggle") |
| subCheck.userdata.value = data.ident |
| subCheck.userdata.category = data.category |
| subCheck.userdata.name = data.name |
| subCheck.userdata.obj = self |
| subCheck:SetText(data.name) |
| subCheck:SetDisabled(data.disabled) |
| subCheck:SetValue(false) |
| subCheck:SetCallback("OnValueChanged", ItemSelected) |
| m.submenu:AddItem(subCheck) |
| end, |
| } |
| --[[----------------------------------------------------------------------------- |
| Constructor |
| -------------------------------------------------------------------------------]] |
| local function Constructor() |
| local count = AceGUI:GetNextWidgetNum(Type) |
| local widget = AceGUI:Create("Dropdown") |
| widget.type = Type |
| for method, func in pairs(methods) do |
| widget[method] = func |
| end |
| return AceGUI:RegisterAsWidget(widget) |
| end |
| AceGUI:RegisterWidgetType(Type, Constructor, Version) |
| end |
mRunes/Libs/LibStub/LibStub.lua
New file
0,0 → 1,30
| -- LibStub is a simple versioning stub meant for use in Libraries. http://www.wowace.com/wiki/LibStub for more info |
| -- LibStub is hereby placed in the Public Domain Credits: Kaelten, Cladhaire, ckknight, Mikk, Ammo, Nevcairiel, joshborke |
| local LIBSTUB_MAJOR, LIBSTUB_MINOR = "LibStub", 2 -- NEVER MAKE THIS AN SVN REVISION! IT NEEDS TO BE USABLE IN ALL REPOS! |
| local LibStub = _G[LIBSTUB_MAJOR] |
| if not LibStub or LibStub.minor < LIBSTUB_MINOR then |
| LibStub = LibStub or {libs = {}, minors = {} } |
| _G[LIBSTUB_MAJOR] = LibStub |
| LibStub.minor = LIBSTUB_MINOR |
| function LibStub:NewLibrary(major, minor) |
| assert(type(major) == "string", "Bad argument #2 to `NewLibrary' (string expected)") |
| minor = assert(tonumber(strmatch(minor, "%d+")), "Minor version must either be a number or contain a number.") |
| local oldminor = self.minors[major] |
| if oldminor and oldminor >= minor then return nil end |
| self.minors[major], self.libs[major] = minor, self.libs[major] or {} |
| return self.libs[major], oldminor |
| end |
| function LibStub:GetLibrary(major, silent) |
| if not self.libs[major] and not silent then |
| error(("Cannot find a library instance of %q."):format(tostring(major)), 2) |
| end |
| return self.libs[major], self.minors[major] |
| end |
| function LibStub:IterateLibraries() return pairs(self.libs) end |
| setmetatable(LibStub, { __call = LibStub.GetLibrary }) |
| end |
mRunes/Libs/LibStub/LibStub.toc
New file
0,0 → 1,13
| ## Interface: 20400 |
| ## Title: Lib: LibStub |
| ## Notes: Universal Library Stub |
| ## Credits: Kaelten, Cladhaire, ckknight, Mikk, Ammo, Nevcairiel |
| ## X-Website: http://jira.wowace.com/browse/LS |
| ## X-Category: Library |
| ## X-License: Public Domain |
| ## X-Curse-Packaged-Version: 1.0 |
| ## X-Curse-Project-Name: LibStub |
| ## X-Curse-Project-ID: libstub |
| ## X-Curse-Repository-ID: wow/libstub/mainline |
| LibStub.lua |
mRunes/Libs/AceGUI-3.0-SharedMediaWidgets/BackgroundWidget.lua
New file
0,0 → 1,231
| -- Widget is based on the AceGUIWidget-DropDown.lua supplied with AceGUI-3.0 |
| -- Widget created by Yssaril |
| local AceGUI = LibStub("AceGUI-3.0") |
| local Media = LibStub("LibSharedMedia-3.0") |
| local AGSMW = LibStub("AceGUISharedMediaWidgets-1.0") |
| do |
| local widgetType = "LSM30_Background" |
| local widgetVersion = 9 |
| local contentFrameCache = {} |
| local function ReturnSelf(self) |
| self:ClearAllPoints() |
| self:Hide() |
| self.check:Hide() |
| table.insert(contentFrameCache, self) |
| end |
| local function ContentOnClick(this, button) |
| local self = this.obj |
| self:Fire("OnValueChanged", this.text:GetText()) |
| if self.dropdown then |
| self.dropdown = AGSMW:ReturnDropDownFrame(self.dropdown) |
| end |
| end |
| local function ContentOnEnter(this, button) |
| local self = this.obj |
| local text = this.text:GetText() |
| local background = self.list[text] ~= text and self.list[text] or Media:Fetch('background',text) |
| self.dropdown.bgTex:SetTexture(background) |
| end |
| local function GetContentLine() |
| local frame |
| if next(contentFrameCache) then |
| frame = table.remove(contentFrameCache) |
| else |
| frame = CreateFrame("Button", nil, UIParent) |
| --frame:SetWidth(200) |
| frame:SetHeight(18) |
| frame:SetHighlightTexture([[Interface\QuestFrame\UI-QuestTitleHighlight]], "ADD") |
| frame:SetScript("OnClick", ContentOnClick) |
| frame:SetScript("OnEnter", ContentOnEnter) |
| local check = frame:CreateTexture("OVERLAY") |
| check:SetWidth(16) |
| check:SetHeight(16) |
| check:SetPoint("LEFT",frame,"LEFT",1,-1) |
| check:SetTexture("Interface\\Buttons\\UI-CheckBox-Check") |
| check:Hide() |
| frame.check = check |
| local text = frame:CreateFontString(nil,"OVERLAY","GameFontWhite") |
| local font, size = text:GetFont() |
| text:SetFont(font,size,"OUTLINE") |
| text:SetPoint("LEFT", check, "RIGHT", 1, 0) |
| text:SetPoint("RIGHT", frame, "RIGHT", -2, 0) |
| text:SetJustifyH("LEFT") |
| text:SetText("Test Test Test Test Test Test Test") |
| frame.text = text |
| frame.ReturnSelf = ReturnSelf |
| end |
| frame:Show() |
| return frame |
| end |
| local function OnAcquire(self) |
| self:SetHeight(44) |
| self:SetWidth(200) |
| end |
| local function OnRelease(self) |
| self:SetText("") |
| self:SetLabel("") |
| self:SetDisabled(false) |
| self.value = nil |
| self.list = nil |
| self.open = nil |
| self.hasClose = nil |
| self.frame:ClearAllPoints() |
| self.frame:Hide() |
| end |
| local function SetValue(self, value) -- Set the value to an item in the List. |
| if self.list then |
| self:SetText(value or "") |
| end |
| self.value = value |
| end |
| local function GetValue(self) |
| return self.value |
| end |
| local function SetList(self, list) -- Set the list of values for the dropdown (key => value pairs) |
| self.list = list or Media:HashTable("background") |
| end |
| local function SetText(self, text) -- Set the text displayed in the box. |
| self.frame.text:SetText(text or "") |
| local background = self.list[text] ~= text and self.list[text] or Media:Fetch('background',text) |
| self.frame.displayButton:SetBackdrop({bgFile = background, |
| edgeFile = "Interface/Tooltips/UI-Tooltip-Border", |
| edgeSize = 16, |
| insets = { left = 4, right = 4, top = 4, bottom = 4 }}) |
| end |
| local function SetLabel(self, text) -- Set the text for the label. |
| self.frame.label:SetText(text or "") |
| end |
| local function AddItem(self, key, value) -- Add an item to the list. |
| self.list = self.list or {} |
| self.list[key] = value |
| end |
| local SetItemValue = AddItem -- Set the value of a item in the list. <<same as adding a new item>> |
| local function SetMultiselect(self, flag) end -- Toggle multi-selecting. <<Dummy function to stay inline with the dropdown API>> |
| local function GetMultiselect() return false end-- Query the multi-select flag. <<Dummy function to stay inline with the dropdown API>> |
| local function SetItemDisabled(self, key) end-- Disable one item in the list. <<Dummy function to stay inline with the dropdown API>> |
| local function SetDisabled(self, disabled) -- Disable the widget. |
| self.disabled = disabled |
| if disabled then |
| self.frame:Disable() |
| self.frame.displayButton:SetBackdropColor(.2,.2,.2,1) |
| else |
| self.frame:Enable() |
| self.frame.displayButton:SetBackdropColor(1,1,1,1) |
| end |
| end |
| local function textSort(a,b) |
| return string.upper(a) < string.upper(b) |
| end |
| local sortedlist = {} |
| local function ToggleDrop(this) |
| local self = this.obj |
| if self.dropdown then |
| self.dropdown = AGSMW:ReturnDropDownFrame(self.dropdown) |
| AceGUI:ClearFocus() |
| else |
| AceGUI:SetFocus(self) |
| self.dropdown = AGSMW:GetDropDownFrame() |
| self.dropdown:SetPoint("TOPLEFT", self.frame, "BOTTOMLEFT") |
| for k, v in pairs(self.list) do |
| sortedlist[#sortedlist+1] = k |
| end |
| table.sort(sortedlist, textSort) |
| for i, k in ipairs(sortedlist) do |
| local f = GetContentLine() |
| f.text:SetText(k) |
| --print(k) |
| if k == self.value then |
| f.check:Show() |
| end |
| f.obj = self |
| f.dropdown = self.dropdown |
| self.dropdown:AddFrame(f) |
| end |
| wipe(sortedlist) |
| end |
| end |
| local function ClearFocus(self) |
| if self.dropdown then |
| self.dropdown = AGSMW:ReturnDropDownFrame(self.dropdown) |
| end |
| end |
| local function OnHide(this) |
| local self = this.obj |
| if self.dropdown then |
| self.dropdown = AGSMW:ReturnDropDownFrame(self.dropdown) |
| end |
| end |
| local function Drop_OnEnter(this) |
| this.obj:Fire("OnEnter") |
| end |
| local function Drop_OnLeave(this) |
| this.obj:Fire("OnLeave") |
| end |
| local function Constructor() |
| local frame = AGSMW:GetBaseFrameWithWindow() |
| local self = {} |
| self.type = widgetType |
| self.frame = frame |
| frame.obj = self |
| frame.dropButton.obj = self |
| frame.dropButton:SetScript("OnEnter", Drop_OnEnter) |
| frame.dropButton:SetScript("OnLeave", Drop_OnLeave) |
| frame.dropButton:SetScript("OnClick",ToggleDrop) |
| frame:SetScript("OnHide", OnHide) |
| self.alignoffset = 31 |
| self.OnRelease = OnRelease |
| self.OnAcquire = OnAcquire |
| self.ClearFocus = ClearFocus |
| self.SetText = SetText |
| self.SetValue = SetValue |
| self.GetValue = GetValue |
| self.SetList = SetList |
| self.SetLabel = SetLabel |
| self.SetDisabled = SetDisabled |
| self.AddItem = AddItem |
| self.SetMultiselect = SetMultiselect |
| self.GetMultiselect = GetMultiselect |
| self.SetItemValue = SetItemValue |
| self.SetItemDisabled = SetItemDisabled |
| self.ToggleDrop = ToggleDrop |
| AceGUI:RegisterAsWidget(self) |
| return self |
| end |
| AceGUI:RegisterWidgetType(widgetType, Constructor, widgetVersion) |
| end |
mRunes/Libs/AceGUI-3.0-SharedMediaWidgets/prototypes.lua
New file
0,0 → 1,267
| -- Widget created by Yssaril |
| --[===[@debug@ |
| local DataVersion = 9001 -- dev version always overwrites everything else :) |
| --@end-debug@]===] |
| --@non-debug@ |
| local DataVersion = 37 |
| --@end-non-debug@ |
| local AGSMW = LibStub:NewLibrary("AceGUISharedMediaWidgets-1.0", DataVersion) |
| if not AGSMW then |
| return -- already loaded and no upgrade necessary |
| end |
| LoadAddOn("LibSharedMedia-3.0") |
| local AceGUI = LibStub("AceGUI-3.0") |
| local Media = LibStub("LibSharedMedia-3.0") |
| AGSMW = AGSMW or {} |
| AceGUIWidgetLSMlists = { |
| ['font'] = Media:HashTable("font"), |
| ['sound'] = Media:HashTable("sound"), |
| ['statusbar'] = Media:HashTable("statusbar"), |
| ['border'] = Media:HashTable("border"), |
| ['background'] = Media:HashTable("background"), |
| } |
| do |
| local function disable(frame) |
| frame.label:SetTextColor(.5,.5,.5) |
| frame.text:SetTextColor(.5,.5,.5) |
| frame.dropButton:Disable() |
| if frame.displayButtonFont then |
| frame.displayButtonFont:SetTextColor(.5,.5,.5) |
| frame.displayButton:Disable() |
| end |
| end |
| local function enable(frame) |
| frame.label:SetTextColor(1,.82,0) |
| frame.text:SetTextColor(1,1,1) |
| frame.dropButton:Enable() |
| if frame.displayButtonFont then |
| frame.displayButtonFont:SetTextColor(1,1,1) |
| frame.displayButton:Enable() |
| end |
| end |
| local displayButtonBackdrop = { |
| edgeFile = "Interface/Tooltips/UI-Tooltip-Border", |
| tile = true, tileSize = 16, edgeSize = 16, |
| insets = { left = 4, right = 4, top = 4, bottom = 4 }, |
| } |
| -- create or retrieve BaseFrame |
| function AGSMW:GetBaseFrame() |
| local frame = CreateFrame("Frame", nil, UIParent) |
| frame:SetHeight(44) |
| frame:SetWidth(200) |
| frame:SetPoint("CENTER", UIParent, "CENTER") |
| local label = frame:CreateFontString(nil,"OVERLAY","GameFontNormalSmall") |
| label:SetPoint("TOPLEFT",frame,"TOPLEFT",0,0) |
| label:SetPoint("TOPRIGHT",frame,"TOPRIGHT",0,0) |
| label:SetJustifyH("LEFT") |
| label:SetHeight(18) |
| label:SetText("") |
| frame.label = label |
| local DLeft = frame:CreateTexture(nil, "ARTWORK") |
| DLeft:SetWidth(25) |
| DLeft:SetHeight(64) |
| DLeft:SetPoint("BOTTOMLEFT", frame, "BOTTOMLEFT", -17, -21) |
| DLeft:SetTexture([[Interface\Glues\CharacterCreate\CharacterCreate-LabelFrame]]) |
| DLeft:SetTexCoord(0, 0.1953125, 0, 1) |
| frame.DLeft = DLeft |
| local DRight = frame:CreateTexture(nil, "ARTWORK") |
| DRight:SetWidth(25) |
| DRight:SetHeight(64) |
| DRight:SetPoint("TOP", DLeft, "TOP") |
| DRight:SetPoint("RIGHT", frame, "RIGHT", 17, 0) |
| DRight:SetTexture([[Interface\Glues\CharacterCreate\CharacterCreate-LabelFrame]]) |
| DRight:SetTexCoord(0.8046875, 1, 0, 1) |
| frame.DRight = DRight |
| local DMiddle = frame:CreateTexture(nil, "ARTWORK") |
| DMiddle:SetHeight(64) |
| DMiddle:SetPoint("TOP", DLeft, "TOP") |
| DMiddle:SetPoint("LEFT", DLeft, "RIGHT") |
| DMiddle:SetPoint("RIGHT", DRight, "LEFT") |
| DMiddle:SetTexture([[Interface\Glues\CharacterCreate\CharacterCreate-LabelFrame]]) |
| DMiddle:SetTexCoord(0.1953125, 0.8046875, 0, 1) |
| frame.DMiddle = DMiddle |
| local text = frame:CreateFontString(nil,"OVERLAY","GameFontHighlightSmall") |
| text:SetPoint("RIGHT",DRight,"RIGHT",-43,1) |
| text:SetPoint("LEFT",DLeft,"LEFT",26,1) |
| text:SetJustifyH("RIGHT") |
| text:SetHeight(18) |
| text:SetText("") |
| frame.text = text |
| local dropButton = CreateFrame("Button", nil, frame) |
| dropButton:SetWidth(24) |
| dropButton:SetHeight(24) |
| dropButton:SetPoint("TOPRIGHT", DRight, "TOPRIGHT", -16, -18) |
| dropButton:SetNormalTexture([[Interface\ChatFrame\UI-ChatIcon-ScrollDown-Up]]) |
| dropButton:SetPushedTexture([[Interface\ChatFrame\UI-ChatIcon-ScrollDown-Down]]) |
| dropButton:SetDisabledTexture([[Interface\ChatFrame\UI-ChatIcon-ScrollDown-Disabled]]) |
| dropButton:SetHighlightTexture([[Interface\Buttons\UI-Common-MouseHilight]], "ADD") |
| frame.dropButton = dropButton |
| frame.Disable = disable |
| frame.Enable = enable |
| return frame |
| end |
| function AGSMW:GetBaseFrameWithWindow() |
| local frame = self:GetBaseFrame() |
| local displayButton = CreateFrame("Button", nil, frame) |
| displayButton:SetHeight(42) |
| displayButton:SetWidth(42) |
| displayButton:SetPoint("TOPLEFT", frame, "TOPLEFT", 1, -2) |
| displayButton:SetBackdrop(displayButtonBackdrop) |
| displayButton:SetBackdropBorderColor(.5, .5, .5) |
| frame.displayButton = displayButton |
| frame.label:SetPoint("TOPLEFT",displayButton,"TOPRIGHT",1,2) |
| frame.DLeft:SetPoint("BOTTOMLEFT", displayButton, "BOTTOMRIGHT", -17, -20) |
| return frame |
| end |
| end |
| do |
| local sliderBackdrop = { |
| ["bgFile"] = [[Interface\Buttons\UI-SliderBar-Background]], |
| ["edgeFile"] = [[Interface\Buttons\UI-SliderBar-Border]], |
| ["tile"] = true, |
| ["edgeSize"] = 8, |
| ["tileSize"] = 8, |
| ["insets"] = { |
| ["left"] = 3, |
| ["right"] = 3, |
| ["top"] = 3, |
| ["bottom"] = 3, |
| }, |
| } |
| local frameBackdrop = { |
| bgFile=[[Interface\DialogFrame\UI-DialogBox-Background-Dark]], |
| edgeFile = [[Interface\DialogFrame\UI-DialogBox-Border]], |
| tile = true, tileSize = 32, edgeSize = 32, |
| insets = { left = 11, right = 12, top = 12, bottom = 9 }, |
| } |
| local function OnMouseWheel(self, dir) |
| self.slider:SetValue(self.slider:GetValue()+(15*dir*-1)) |
| end |
| local function AddFrame(self, frame) |
| frame:SetParent(self.contentframe) |
| local strata = self:GetFrameStrata() |
| frame:SetFrameStrata(strata) |
| local level = self:GetFrameLevel() + 100 |
| frame:SetFrameLevel(level) |
| if next(self.contentRepo) then |
| frame:SetPoint("TOPLEFT", self.contentRepo[#self.contentRepo], "BOTTOMLEFT", 0, 0) |
| frame:SetPoint("RIGHT", self.contentframe, "RIGHT", 0, 0) |
| self.contentframe:SetHeight(self.contentframe:GetHeight() + frame:GetHeight()) |
| self.contentRepo[#self.contentRepo+1] = frame |
| else |
| self.contentframe:SetHeight(frame:GetHeight()) |
| frame:SetPoint("TOPLEFT", self.contentframe, "TOPLEFT", 0, 0) |
| frame:SetPoint("RIGHT", self.contentframe, "RIGHT", 0, 0) |
| self.contentRepo[1] = frame |
| end |
| if self.contentframe:GetHeight() > UIParent:GetHeight()*2/5 - 20 then |
| self.scrollframe:SetWidth(146) |
| self:SetHeight(UIParent:GetHeight()*2/5) |
| self.slider:Show() |
| self:SetScript("OnMouseWheel", OnMouseWheel) |
| self.scrollframe:UpdateScrollChildRect() |
| self.slider:SetMinMaxValues(0, self.contentframe:GetHeight()-self.scrollframe:GetHeight()) |
| else |
| self.scrollframe:SetWidth(160) |
| self:SetHeight(self.contentframe:GetHeight()+25) |
| self.slider:Hide() |
| self:SetScript("OnMouseWheel", nil) |
| self.scrollframe:UpdateScrollChildRect() |
| self.slider:SetMinMaxValues(0, 0) |
| end |
| self.contentframe:SetWidth(self.scrollframe:GetWidth()) |
| end |
| local function ClearFrames(self) |
| for i, frame in ipairs(self.contentRepo) do |
| frame:ReturnSelf() |
| self.contentRepo[i] = nil |
| end |
| end |
| local function slider_OnValueChanged(self, value) |
| self.frame.scrollframe:SetVerticalScroll(value) |
| end |
| local DropDownCache = {} |
| function AGSMW:GetDropDownFrame() |
| local frame |
| if next(DropDownCache) then |
| frame = table.remove(DropDownCache) |
| else |
| frame = CreateFrame("Frame", nil, UIParent) |
| frame:SetClampedToScreen(true) |
| frame:SetWidth(188) |
| frame:SetBackdrop(frameBackdrop) |
| frame:SetFrameStrata("TOOLTIP") |
| frame:EnableMouseWheel(true) |
| local contentframe = CreateFrame("Frame", nil, frame) |
| contentframe:SetWidth(160) |
| contentframe:SetHeight(0) |
| frame.contentframe = contentframe |
| local scrollframe = CreateFrame("ScrollFrame", nil, frame) |
| scrollframe:SetPoint("TOPLEFT", frame, "TOPLEFT", 14, -13) |
| scrollframe:SetPoint("BOTTOM", frame, "BOTTOM", 0, 12) |
| scrollframe:SetWidth(160) |
| scrollframe:SetScrollChild(contentframe) |
| frame.scrollframe = scrollframe |
| local bgTex = frame:CreateTexture(nil, "ARTWORK") |
| bgTex:SetAllPoints(scrollframe) |
| frame.bgTex = bgTex |
| frame.AddFrame = AddFrame |
| frame.ClearFrames = ClearFrames |
| frame.contentRepo = {} -- store all our frames in here so we can get rid of them later |
| local slider = CreateFrame("Slider", nil, scrollframe) |
| slider:SetOrientation("VERTICAL") |
| slider:SetPoint("TOPRIGHT", frame, "TOPRIGHT", -14, -10) |
| slider:SetPoint("BOTTOMRIGHT", frame, "BOTTOMRIGHT", -14, 10) |
| slider:SetBackdrop(sliderBackdrop) |
| slider:SetThumbTexture([[Interface\Buttons\UI-SliderBar-Button-Vertical]]) |
| slider:SetMinMaxValues(0, 1) |
| --slider:SetValueStep(1) |
| slider:SetWidth(12) |
| slider.frame = frame |
| slider:SetScript("OnValueChanged", slider_OnValueChanged) |
| frame.slider = slider |
| end |
| frame:SetHeight(UIParent:GetHeight()*2/5) |
| frame.slider:SetValue(0) |
| frame:Show() |
| return frame |
| end |
| function AGSMW:ReturnDropDownFrame(frame) |
| ClearFrames(frame) |
| frame:ClearAllPoints() |
| frame:Hide() |
| frame:SetBackdrop(frameBackdrop) |
| frame.bgTex:SetTexture(nil) |
| table.insert(DropDownCache, frame) |
| return nil |
| end |
| end |
mRunes/Libs/AceGUI-3.0-SharedMediaWidgets/Libs/CallbackHandler-1.0/CallbackHandler-1.0.lua
New file
0,0 → 1,239
| --[[ $Id: CallbackHandler-1.0.lua 3 2008-09-29 16:54:20Z nevcairiel $ ]] |
| local MAJOR, MINOR = "CallbackHandler-1.0", 3 |
| local CallbackHandler = LibStub:NewLibrary(MAJOR, MINOR) |
| if not CallbackHandler then return end -- No upgrade needed |
| local meta = {__index = function(tbl, key) tbl[key] = {} return tbl[key] end} |
| local type = type |
| local pcall = pcall |
| local pairs = pairs |
| local assert = assert |
| local concat = table.concat |
| local loadstring = loadstring |
| local next = next |
| local select = select |
| local type = type |
| local xpcall = xpcall |
| local function errorhandler(err) |
| return geterrorhandler()(err) |
| end |
| local function CreateDispatcher(argCount) |
| local code = [[ |
| local next, xpcall, eh = ... |
| local method, ARGS |
| local function call() method(ARGS) end |
| local function dispatch(handlers, ...) |
| local index |
| index, method = next(handlers) |
| if not method then return end |
| local OLD_ARGS = ARGS |
| ARGS = ... |
| repeat |
| xpcall(call, eh) |
| index, method = next(handlers, index) |
| until not method |
| ARGS = OLD_ARGS |
| end |
| return dispatch |
| ]] |
| local ARGS, OLD_ARGS = {}, {} |
| for i = 1, argCount do ARGS[i], OLD_ARGS[i] = "arg"..i, "old_arg"..i end |
| code = code:gsub("OLD_ARGS", concat(OLD_ARGS, ", ")):gsub("ARGS", concat(ARGS, ", ")) |
| return assert(loadstring(code, "safecall Dispatcher["..argCount.."]"))(next, xpcall, errorhandler) |
| end |
| local Dispatchers = setmetatable({}, {__index=function(self, argCount) |
| local dispatcher = CreateDispatcher(argCount) |
| rawset(self, argCount, dispatcher) |
| return dispatcher |
| end}) |
| -------------------------------------------------------------------------- |
| -- CallbackHandler:New |
| -- |
| -- target - target object to embed public APIs in |
| -- RegisterName - name of the callback registration API, default "RegisterCallback" |
| -- UnregisterName - name of the callback unregistration API, default "UnregisterCallback" |
| -- UnregisterAllName - name of the API to unregister all callbacks, default "UnregisterAllCallbacks". false == don't publish this API. |
| function CallbackHandler:New(target, RegisterName, UnregisterName, UnregisterAllName, OnUsed, OnUnused) |
| -- TODO: Remove this after beta has gone out |
| assert(not OnUsed and not OnUnused, "ACE-80: OnUsed/OnUnused are deprecated. Callbacks are now done to registry.OnUsed and registry.OnUnused") |
| RegisterName = RegisterName or "RegisterCallback" |
| UnregisterName = UnregisterName or "UnregisterCallback" |
| if UnregisterAllName==nil then -- false is used to indicate "don't want this method" |
| UnregisterAllName = "UnregisterAllCallbacks" |
| end |
| -- we declare all objects and exported APIs inside this closure to quickly gain access |
| -- to e.g. function names, the "target" parameter, etc |
| -- Create the registry object |
| local events = setmetatable({}, meta) |
| local registry = { recurse=0, events=events } |
| -- registry:Fire() - fires the given event/message into the registry |
| function registry:Fire(eventname, ...) |
| if not rawget(events, eventname) or not next(events[eventname]) then return end |
| local oldrecurse = registry.recurse |
| registry.recurse = oldrecurse + 1 |
| Dispatchers[select('#', ...) + 1](events[eventname], eventname, ...) |
| registry.recurse = oldrecurse |
| if registry.insertQueue and oldrecurse==0 then |
| -- Something in one of our callbacks wanted to register more callbacks; they got queued |
| for eventname,callbacks in pairs(registry.insertQueue) do |
| local first = not rawget(events, eventname) or not next(events[eventname]) -- test for empty before. not test for one member after. that one member may have been overwritten. |
| for self,func in pairs(callbacks) do |
| events[eventname][self] = func |
| -- fire OnUsed callback? |
| if first and registry.OnUsed then |
| registry.OnUsed(registry, target, eventname) |
| first = nil |
| end |
| end |
| end |
| registry.insertQueue = nil |
| end |
| end |
| -- Registration of a callback, handles: |
| -- self["method"], leads to self["method"](self, ...) |
| -- self with function ref, leads to functionref(...) |
| -- "addonId" (instead of self) with function ref, leads to functionref(...) |
| -- all with an optional arg, which, if present, gets passed as first argument (after self if present) |
| target[RegisterName] = function(self, eventname, method, ... --[[actually just a single arg]]) |
| if type(eventname) ~= "string" then |
| error("Usage: "..RegisterName.."(eventname, method[, arg]): 'eventname' - string expected.", 2) |
| end |
| method = method or eventname |
| local first = not rawget(events, eventname) or not next(events[eventname]) -- test for empty before. not test for one member after. that one member may have been overwritten. |
| if type(method) ~= "string" and type(method) ~= "function" then |
| error("Usage: "..RegisterName.."(\"eventname\", \"methodname\"): 'methodname' - string or function expected.", 2) |
| end |
| local regfunc |
| if type(method) == "string" then |
| -- self["method"] calling style |
| if type(self) ~= "table" then |
| error("Usage: "..RegisterName.."(\"eventname\", \"methodname\"): self was not a table?", 2) |
| elseif self==target then |
| error("Usage: "..RegisterName.."(\"eventname\", \"methodname\"): do not use Library:"..RegisterName.."(), use your own 'self'", 2) |
| elseif type(self[method]) ~= "function" then |
| error("Usage: "..RegisterName.."(\"eventname\", \"methodname\"): 'methodname' - method '"..tostring(method).."' not found on self.", 2) |
| end |
| if select("#",...)>=1 then -- this is not the same as testing for arg==nil! |
| local arg=select(1,...) |
| regfunc = function(...) self[method](self,arg,...) end |
| else |
| regfunc = function(...) self[method](self,...) end |
| end |
| else |
| -- function ref with self=object or self="addonId" |
| if type(self)~="table" and type(self)~="string" then |
| error("Usage: "..RegisterName.."(self or \"addonId\", eventname, method): 'self or addonId': table or string expected.", 2) |
| end |
| if select("#",...)>=1 then -- this is not the same as testing for arg==nil! |
| local arg=select(1,...) |
| regfunc = function(...) method(arg,...) end |
| else |
| regfunc = method |
| end |
| end |
| if events[eventname][self] or registry.recurse<1 then |
| -- if registry.recurse<1 then |
| -- we're overwriting an existing entry, or not currently recursing. just set it. |
| events[eventname][self] = regfunc |
| -- fire OnUsed callback? |
| if registry.OnUsed and first then |
| registry.OnUsed(registry, target, eventname) |
| end |
| else |
| -- we're currently processing a callback in this registry, so delay the registration of this new entry! |
| -- yes, we're a bit wasteful on garbage, but this is a fringe case, so we're picking low implementation overhead over garbage efficiency |
| registry.insertQueue = registry.insertQueue or setmetatable({},meta) |
| registry.insertQueue[eventname][self] = regfunc |
| end |
| end |
| -- Unregister a callback |
| target[UnregisterName] = function(self, eventname) |
| if not self or self==target then |
| error("Usage: "..UnregisterName.."(eventname): bad 'self'", 2) |
| end |
| if type(eventname) ~= "string" then |
| error("Usage: "..UnregisterName.."(eventname): 'eventname' - string expected.", 2) |
| end |
| if rawget(events, eventname) and events[eventname][self] then |
| events[eventname][self] = nil |
| -- Fire OnUnused callback? |
| if registry.OnUnused and not next(events[eventname]) then |
| registry.OnUnused(registry, target, eventname) |
| end |
| end |
| if registry.insertQueue and rawget(registry.insertQueue, eventname) and registry.insertQueue[eventname][self] then |
| registry.insertQueue[eventname][self] = nil |
| end |
| end |
| -- OPTIONAL: Unregister all callbacks for given selfs/addonIds |
| if UnregisterAllName then |
| target[UnregisterAllName] = function(...) |
| if select("#",...)<1 then |
| error("Usage: "..UnregisterAllName.."([whatFor]): missing 'self' or \"addonId\" to unregister events for.", 2) |
| end |
| if select("#",...)==1 and ...==target then |
| error("Usage: "..UnregisterAllName.."([whatFor]): supply a meaningful 'self' or \"addonId\"", 2) |
| end |
| for i=1,select("#",...) do |
| local self = select(i,...) |
| if registry.insertQueue then |
| for eventname, callbacks in pairs(registry.insertQueue) do |
| if callbacks[self] then |
| callbacks[self] = nil |
| end |
| end |
| end |
| for eventname, callbacks in pairs(events) do |
| if callbacks[self] then |
| callbacks[self] = nil |
| -- Fire OnUnused callback? |
| if registry.OnUnused and not next(callbacks) then |
| registry.OnUnused(registry, target, eventname) |
| end |
| end |
| end |
| end |
| end |
| end |
| return registry |
| end |
| -- CallbackHandler purposefully does NOT do explicit embedding. Nor does it |
| -- try to upgrade old implicit embeds since the system is selfcontained and |
| -- relies on closures to work. |
mRunes/Libs/AceGUI-3.0-SharedMediaWidgets/Libs/CallbackHandler-1.0/CallbackHandler-1.0.xml
New file
0,0 → 1,4
\ No newline at end of file
| <Ui xmlns="http://www.blizzard.com/wow/ui/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.blizzard.com/wow/ui/ |
| ..\FrameXML\UI.xsd"> |
| <Script file="CallbackHandler-1.0.lua"/> |
| </Ui> |
mRunes/Libs/AceGUI-3.0-SharedMediaWidgets/Libs/AceGUI-3.0/widgets/AceGUIContainer-SimpleGroup.lua
New file
0,0 → 1,69
| --[[----------------------------------------------------------------------------- |
| SimpleGroup Container |
| Simple container widget that just groups widgets. |
| -------------------------------------------------------------------------------]] |
| local Type, Version = "SimpleGroup", 20 |
| local AceGUI = LibStub and LibStub("AceGUI-3.0", true) |
| if not AceGUI or (AceGUI:GetWidgetVersion(Type) or 0) >= Version then return end |
| -- Lua APIs |
| local pairs = pairs |
| -- WoW APIs |
| local CreateFrame, UIParent = CreateFrame, UIParent |
| --[[----------------------------------------------------------------------------- |
| Methods |
| -------------------------------------------------------------------------------]] |
| local methods = { |
| ["OnAcquire"] = function(self) |
| self:SetWidth(300) |
| self:SetHeight(100) |
| end, |
| -- ["OnRelease"] = nil, |
| ["LayoutFinished"] = function(self, width, height) |
| if self.noAutoHeight then return end |
| self:SetHeight(height or 0) |
| end, |
| ["OnWidthSet"] = function(self, width) |
| local content = self.content |
| content:SetWidth(width) |
| content.width = width |
| end, |
| ["OnHeightSet"] = function(self, height) |
| local content = self.content |
| content:SetHeight(height) |
| content.height = height |
| end |
| } |
| --[[----------------------------------------------------------------------------- |
| Constructor |
| -------------------------------------------------------------------------------]] |
| local function Constructor() |
| local frame = CreateFrame("Frame", nil, UIParent) |
| frame:SetFrameStrata("FULLSCREEN_DIALOG") |
| --Container Support |
| local content = CreateFrame("Frame", nil, frame) |
| content:SetPoint("TOPLEFT") |
| content:SetPoint("BOTTOMRIGHT") |
| local widget = { |
| frame = frame, |
| content = content, |
| type = Type |
| } |
| for method, func in pairs(methods) do |
| widget[method] = func |
| end |
| return AceGUI:RegisterAsContainer(widget) |
| end |
| AceGUI:RegisterWidgetType(Type, Constructor, Version) |
mRunes/Libs/AceGUI-3.0-SharedMediaWidgets/Libs/AceGUI-3.0/widgets/AceGUIContainer-Window.lua
New file
0,0 → 1,331
| local AceGUI = LibStub("AceGUI-3.0") |
| -- Lua APIs |
| local pairs, assert, type = pairs, assert, type |
| -- WoW APIs |
| local PlaySound = PlaySound |
| local CreateFrame, UIParent = CreateFrame, UIParent |
| -- Global vars/functions that we don't upvalue since they might get hooked, or upgraded |
| -- List them here for Mikk's FindGlobals script |
| -- GLOBALS: GameFontNormal |
| ---------------- |
| -- Main Frame -- |
| ---------------- |
| --[[ |
| Events : |
| OnClose |
| ]] |
| do |
| local Type = "Window" |
| local Version = 4 |
| local function frameOnClose(this) |
| this.obj:Fire("OnClose") |
| end |
| local function closeOnClick(this) |
| PlaySound("gsTitleOptionExit") |
| this.obj:Hide() |
| end |
| local function frameOnMouseDown(this) |
| AceGUI:ClearFocus() |
| end |
| local function titleOnMouseDown(this) |
| this:GetParent():StartMoving() |
| AceGUI:ClearFocus() |
| end |
| local function frameOnMouseUp(this) |
| local frame = this:GetParent() |
| frame:StopMovingOrSizing() |
| local self = frame.obj |
| local status = self.status or self.localstatus |
| status.width = frame:GetWidth() |
| status.height = frame:GetHeight() |
| status.top = frame:GetTop() |
| status.left = frame:GetLeft() |
| end |
| local function sizerseOnMouseDown(this) |
| this:GetParent():StartSizing("BOTTOMRIGHT") |
| AceGUI:ClearFocus() |
| end |
| local function sizersOnMouseDown(this) |
| this:GetParent():StartSizing("BOTTOM") |
| AceGUI:ClearFocus() |
| end |
| local function sizereOnMouseDown(this) |
| this:GetParent():StartSizing("RIGHT") |
| AceGUI:ClearFocus() |
| end |
| local function sizerOnMouseUp(this) |
| this:GetParent():StopMovingOrSizing() |
| end |
| local function SetTitle(self,title) |
| self.titletext:SetText(title) |
| end |
| local function SetStatusText(self,text) |
| -- self.statustext:SetText(text) |
| end |
| local function Hide(self) |
| self.frame:Hide() |
| end |
| local function Show(self) |
| self.frame:Show() |
| end |
| local function OnAcquire(self) |
| self.frame:SetParent(UIParent) |
| self.frame:SetFrameStrata("FULLSCREEN_DIALOG") |
| self:ApplyStatus() |
| self:EnableResize(true) |
| self:Show() |
| end |
| local function OnRelease(self) |
| self.status = nil |
| for k in pairs(self.localstatus) do |
| self.localstatus[k] = nil |
| end |
| end |
| -- called to set an external table to store status in |
| local function SetStatusTable(self, status) |
| assert(type(status) == "table") |
| self.status = status |
| self:ApplyStatus() |
| end |
| local function ApplyStatus(self) |
| local status = self.status or self.localstatus |
| local frame = self.frame |
| self:SetWidth(status.width or 700) |
| self:SetHeight(status.height or 500) |
| if status.top and status.left then |
| frame:SetPoint("TOP",UIParent,"BOTTOM",0,status.top) |
| frame:SetPoint("LEFT",UIParent,"LEFT",status.left,0) |
| else |
| frame:SetPoint("CENTER",UIParent,"CENTER") |
| end |
| end |
| local function OnWidthSet(self, width) |
| local content = self.content |
| local contentwidth = width - 34 |
| if contentwidth < 0 then |
| contentwidth = 0 |
| end |
| content:SetWidth(contentwidth) |
| content.width = contentwidth |
| end |
| local function OnHeightSet(self, height) |
| local content = self.content |
| local contentheight = height - 57 |
| if contentheight < 0 then |
| contentheight = 0 |
| end |
| content:SetHeight(contentheight) |
| content.height = contentheight |
| end |
| local function EnableResize(self, state) |
| local func = state and "Show" or "Hide" |
| self.sizer_se[func](self.sizer_se) |
| self.sizer_s[func](self.sizer_s) |
| self.sizer_e[func](self.sizer_e) |
| end |
| local function Constructor() |
| local frame = CreateFrame("Frame",nil,UIParent) |
| local self = {} |
| self.type = "Window" |
| self.Hide = Hide |
| self.Show = Show |
| self.SetTitle = SetTitle |
| self.OnRelease = OnRelease |
| self.OnAcquire = OnAcquire |
| self.SetStatusText = SetStatusText |
| self.SetStatusTable = SetStatusTable |
| self.ApplyStatus = ApplyStatus |
| self.OnWidthSet = OnWidthSet |
| self.OnHeightSet = OnHeightSet |
| self.EnableResize = EnableResize |
| self.localstatus = {} |
| self.frame = frame |
| frame.obj = self |
| frame:SetWidth(700) |
| frame:SetHeight(500) |
| frame:SetPoint("CENTER",UIParent,"CENTER",0,0) |
| frame:EnableMouse() |
| frame:SetMovable(true) |
| frame:SetResizable(true) |
| frame:SetFrameStrata("FULLSCREEN_DIALOG") |
| frame:SetScript("OnMouseDown", frameOnMouseDown) |
| frame:SetScript("OnHide",frameOnClose) |
| frame:SetMinResize(240,240) |
| frame:SetToplevel(true) |
| local titlebg = frame:CreateTexture(nil, "BACKGROUND") |
| titlebg:SetTexture([[Interface\PaperDollInfoFrame\UI-GearManager-Title-Background]]) |
| titlebg:SetPoint("TOPLEFT", 9, -6) |
| titlebg:SetPoint("BOTTOMRIGHT", frame, "TOPRIGHT", -28, -24) |
| local dialogbg = frame:CreateTexture(nil, "BACKGROUND") |
| dialogbg:SetTexture([[Interface\Tooltips\UI-Tooltip-Background]]) |
| dialogbg:SetPoint("TOPLEFT", 8, -24) |
| dialogbg:SetPoint("BOTTOMRIGHT", -6, 8) |
| dialogbg:SetVertexColor(0, 0, 0, .75) |
| local topleft = frame:CreateTexture(nil, "BORDER") |
| topleft:SetTexture([[Interface\PaperDollInfoFrame\UI-GearManager-Border]]) |
| topleft:SetWidth(64) |
| topleft:SetHeight(64) |
| topleft:SetPoint("TOPLEFT") |
| topleft:SetTexCoord(0.501953125, 0.625, 0, 1) |
| local topright = frame:CreateTexture(nil, "BORDER") |
| topright:SetTexture([[Interface\PaperDollInfoFrame\UI-GearManager-Border]]) |
| topright:SetWidth(64) |
| topright:SetHeight(64) |
| topright:SetPoint("TOPRIGHT") |
| topright:SetTexCoord(0.625, 0.75, 0, 1) |
| local top = frame:CreateTexture(nil, "BORDER") |
| top:SetTexture([[Interface\PaperDollInfoFrame\UI-GearManager-Border]]) |
| top:SetHeight(64) |
| top:SetPoint("TOPLEFT", topleft, "TOPRIGHT") |
| top:SetPoint("TOPRIGHT", topright, "TOPLEFT") |
| top:SetTexCoord(0.25, 0.369140625, 0, 1) |
| local bottomleft = frame:CreateTexture(nil, "BORDER") |
| bottomleft:SetTexture([[Interface\PaperDollInfoFrame\UI-GearManager-Border]]) |
| bottomleft:SetWidth(64) |
| bottomleft:SetHeight(64) |
| bottomleft:SetPoint("BOTTOMLEFT") |
| bottomleft:SetTexCoord(0.751953125, 0.875, 0, 1) |
| local bottomright = frame:CreateTexture(nil, "BORDER") |
| bottomright:SetTexture([[Interface\PaperDollInfoFrame\UI-GearManager-Border]]) |
| bottomright:SetWidth(64) |
| bottomright:SetHeight(64) |
| bottomright:SetPoint("BOTTOMRIGHT") |
| bottomright:SetTexCoord(0.875, 1, 0, 1) |
| local bottom = frame:CreateTexture(nil, "BORDER") |
| bottom:SetTexture([[Interface\PaperDollInfoFrame\UI-GearManager-Border]]) |
| bottom:SetHeight(64) |
| bottom:SetPoint("BOTTOMLEFT", bottomleft, "BOTTOMRIGHT") |
| bottom:SetPoint("BOTTOMRIGHT", bottomright, "BOTTOMLEFT") |
| bottom:SetTexCoord(0.376953125, 0.498046875, 0, 1) |
| local left = frame:CreateTexture(nil, "BORDER") |
| left:SetTexture([[Interface\PaperDollInfoFrame\UI-GearManager-Border]]) |
| left:SetWidth(64) |
| left:SetPoint("TOPLEFT", topleft, "BOTTOMLEFT") |
| left:SetPoint("BOTTOMLEFT", bottomleft, "TOPLEFT") |
| left:SetTexCoord(0.001953125, 0.125, 0, 1) |
| local right = frame:CreateTexture(nil, "BORDER") |
| right:SetTexture([[Interface\PaperDollInfoFrame\UI-GearManager-Border]]) |
| right:SetWidth(64) |
| right:SetPoint("TOPRIGHT", topright, "BOTTOMRIGHT") |
| right:SetPoint("BOTTOMRIGHT", bottomright, "TOPRIGHT") |
| right:SetTexCoord(0.1171875, 0.2421875, 0, 1) |
| local close = CreateFrame("Button", nil, frame, "UIPanelCloseButton") |
| close:SetPoint("TOPRIGHT", 2, 1) |
| close:SetScript("OnClick", closeOnClick) |
| self.closebutton = close |
| close.obj = self |
| local titletext = frame:CreateFontString(nil, "ARTWORK") |
| titletext:SetFontObject(GameFontNormal) |
| titletext:SetPoint("TOPLEFT", 12, -8) |
| titletext:SetPoint("TOPRIGHT", -32, -8) |
| self.titletext = titletext |
| local title = CreateFrame("Button", nil, frame) |
| title:SetPoint("TOPLEFT", titlebg) |
| title:SetPoint("BOTTOMRIGHT", titlebg) |
| title:EnableMouse() |
| title:SetScript("OnMouseDown",titleOnMouseDown) |
| title:SetScript("OnMouseUp", frameOnMouseUp) |
| self.title = title |
| local sizer_se = CreateFrame("Frame",nil,frame) |
| sizer_se:SetPoint("BOTTOMRIGHT",frame,"BOTTOMRIGHT",0,0) |
| sizer_se:SetWidth(25) |
| sizer_se:SetHeight(25) |
| sizer_se:EnableMouse() |
| sizer_se:SetScript("OnMouseDown",sizerseOnMouseDown) |
| sizer_se:SetScript("OnMouseUp", sizerOnMouseUp) |
| self.sizer_se = sizer_se |
| local line1 = sizer_se:CreateTexture(nil, "BACKGROUND") |
| self.line1 = line1 |
| line1:SetWidth(14) |
| line1:SetHeight(14) |
| line1:SetPoint("BOTTOMRIGHT", -8, 8) |
| line1:SetTexture("Interface\\Tooltips\\UI-Tooltip-Border") |
| local x = 0.1 * 14/17 |
| line1:SetTexCoord(0.05 - x, 0.5, 0.05, 0.5 + x, 0.05, 0.5 - x, 0.5 + x, 0.5) |
| local line2 = sizer_se:CreateTexture(nil, "BACKGROUND") |
| self.line2 = line2 |
| line2:SetWidth(8) |
| line2:SetHeight(8) |
| line2:SetPoint("BOTTOMRIGHT", -8, 8) |
| line2:SetTexture("Interface\\Tooltips\\UI-Tooltip-Border") |
| local x = 0.1 * 8/17 |
| line2:SetTexCoord(0.05 - x, 0.5, 0.05, 0.5 + x, 0.05, 0.5 - x, 0.5 + x, 0.5) |
| local sizer_s = CreateFrame("Frame",nil,frame) |
| sizer_s:SetPoint("BOTTOMRIGHT",frame,"BOTTOMRIGHT",-25,0) |
| sizer_s:SetPoint("BOTTOMLEFT",frame,"BOTTOMLEFT",0,0) |
| sizer_s:SetHeight(25) |
| sizer_s:EnableMouse() |
| sizer_s:SetScript("OnMouseDown",sizersOnMouseDown) |
| sizer_s:SetScript("OnMouseUp", sizerOnMouseUp) |
| self.sizer_s = sizer_s |
| local sizer_e = CreateFrame("Frame",nil,frame) |
| sizer_e:SetPoint("BOTTOMRIGHT",frame,"BOTTOMRIGHT",0,25) |
| sizer_e:SetPoint("TOPRIGHT",frame,"TOPRIGHT",0,0) |
| sizer_e:SetWidth(25) |
| sizer_e:EnableMouse() |
| sizer_e:SetScript("OnMouseDown",sizereOnMouseDown) |
| sizer_e:SetScript("OnMouseUp", sizerOnMouseUp) |
| self.sizer_e = sizer_e |
| --Container Support |
| local content = CreateFrame("Frame",nil,frame) |
| self.content = content |
| content.obj = self |
| content:SetPoint("TOPLEFT",frame,"TOPLEFT",12,-32) |
| content:SetPoint("BOTTOMRIGHT",frame,"BOTTOMRIGHT",-12,13) |
| AceGUI:RegisterAsContainer(self) |
| return self |
| end |
| AceGUI:RegisterWidgetType(Type,Constructor,Version) |
| end |
mRunes/Libs/AceGUI-3.0-SharedMediaWidgets/Libs/AceGUI-3.0/widgets/AceGUIContainer-ScrollFrame.lua
New file
0,0 → 1,203
| --[[----------------------------------------------------------------------------- |
| ScrollFrame Container |
| Plain container that scrolls its content and doesn't grow in height. |
| -------------------------------------------------------------------------------]] |
| local Type, Version = "ScrollFrame", 21 |
| local AceGUI = LibStub and LibStub("AceGUI-3.0", true) |
| if not AceGUI or (AceGUI:GetWidgetVersion(Type) or 0) >= Version then return end |
| -- Lua APIs |
| local pairs, assert, type = pairs, assert, type |
| local min, max, floor, abs = math.min, math.max, math.floor, math.abs |
| -- WoW APIs |
| local CreateFrame, UIParent = CreateFrame, UIParent |
| --[[----------------------------------------------------------------------------- |
| Support functions |
| -------------------------------------------------------------------------------]] |
| local function FixScrollOnUpdate(frame) |
| frame:SetScript("OnUpdate", nil) |
| frame.obj:FixScroll() |
| end |
| --[[----------------------------------------------------------------------------- |
| Scripts |
| -------------------------------------------------------------------------------]] |
| local function ScrollFrame_OnMouseWheel(frame, value) |
| frame.obj:MoveScroll(value) |
| end |
| local function ScrollFrame_OnSizeChanged(frame) |
| frame:SetScript("OnUpdate", FixScrollOnUpdate) |
| end |
| local function ScrollBar_OnScrollValueChanged(frame, value) |
| frame.obj:SetScroll(value) |
| end |
| --[[----------------------------------------------------------------------------- |
| Methods |
| -------------------------------------------------------------------------------]] |
| local methods = { |
| ["OnAcquire"] = function(self) |
| self:SetScroll(0) |
| end, |
| ["OnRelease"] = function(self) |
| self.status = nil |
| for k in pairs(self.localstatus) do |
| self.localstatus[k] = nil |
| end |
| self.scrollframe:SetPoint("BOTTOMRIGHT") |
| self.scrollbar:Hide() |
| self.scrollBarShown = nil |
| self.content.height, self.content.width = nil, nil |
| end, |
| ["SetScroll"] = function(self, value) |
| local status = self.status or self.localstatus |
| local viewheight = self.scrollframe:GetHeight() |
| local height = self.content:GetHeight() |
| local offset |
| if viewheight > height then |
| offset = 0 |
| else |
| offset = floor((height - viewheight) / 1000.0 * value) |
| end |
| self.content:ClearAllPoints() |
| self.content:SetPoint("TOPLEFT", 0, offset) |
| self.content:SetPoint("TOPRIGHT", 0, offset) |
| status.offset = offset |
| status.scrollvalue = value |
| end, |
| ["MoveScroll"] = function(self, value) |
| local status = self.status or self.localstatus |
| local height, viewheight = self.scrollframe:GetHeight(), self.content:GetHeight() |
| if self.scrollBarShown then |
| local diff = height - viewheight |
| local delta = 1 |
| if value < 0 then |
| delta = -1 |
| end |
| self.scrollbar:SetValue(min(max(status.scrollvalue + delta*(1000/(diff/45)),0), 1000)) |
| end |
| end, |
| ["FixScroll"] = function(self) |
| if self.updateLock then return end |
| self.updateLock = true |
| local status = self.status or self.localstatus |
| local height, viewheight = self.scrollframe:GetHeight(), self.content:GetHeight() |
| local offset = status.offset or 0 |
| local curvalue = self.scrollbar:GetValue() |
| -- Give us a margin of error of 2 pixels to stop some conditions that i would blame on floating point inaccuracys |
| -- No-one is going to miss 2 pixels at the bottom of the frame, anyhow! |
| if viewheight < height + 2 then |
| if self.scrollBarShown then |
| self.scrollBarShown = nil |
| self.scrollbar:Hide() |
| self.scrollbar:SetValue(0) |
| self.scrollframe:SetPoint("BOTTOMRIGHT") |
| self:DoLayout() |
| end |
| else |
| if not self.scrollBarShown then |
| self.scrollBarShown = true |
| self.scrollbar:Show() |
| self.scrollframe:SetPoint("BOTTOMRIGHT", -20, 0) |
| self:DoLayout() |
| end |
| local value = (offset / (viewheight - height) * 1000) |
| if value > 1000 then value = 1000 end |
| self.scrollbar:SetValue(value) |
| self:SetScroll(value) |
| if value < 1000 then |
| self.content:ClearAllPoints() |
| self.content:SetPoint("TOPLEFT", 0, offset) |
| self.content:SetPoint("TOPRIGHT", 0, offset) |
| status.offset = offset |
| end |
| end |
| self.updateLock = nil |
| end, |
| ["LayoutFinished"] = function(self, width, height) |
| self.content:SetHeight(height or 0 + 20) |
| self.scrollframe:SetScript("OnUpdate", FixScrollOnUpdate) |
| end, |
| ["SetStatusTable"] = function(self, status) |
| assert(type(status) == "table") |
| self.status = status |
| if not status.scrollvalue then |
| status.scrollvalue = 0 |
| end |
| end, |
| ["OnWidthSet"] = function(self, width) |
| local content = self.content |
| content.width = width |
| end, |
| ["OnHeightSet"] = function(self, height) |
| local content = self.content |
| content.height = height |
| end |
| } |
| --[[----------------------------------------------------------------------------- |
| Constructor |
| -------------------------------------------------------------------------------]] |
| local function Constructor() |
| local frame = CreateFrame("Frame", nil, UIParent) |
| local num = AceGUI:GetNextWidgetNum(Type) |
| local scrollframe = CreateFrame("ScrollFrame", nil, frame) |
| scrollframe:SetPoint("TOPLEFT") |
| scrollframe:SetPoint("BOTTOMRIGHT") |
| scrollframe:EnableMouseWheel(true) |
| scrollframe:SetScript("OnMouseWheel", ScrollFrame_OnMouseWheel) |
| scrollframe:SetScript("OnSizeChanged", ScrollFrame_OnSizeChanged) |
| local scrollbar = CreateFrame("Slider", ("AceConfigDialogScrollFrame%dScrollBar"):format(num), scrollframe, "UIPanelScrollBarTemplate") |
| scrollbar:SetPoint("TOPLEFT", scrollframe, "TOPRIGHT", 4, -16) |
| scrollbar:SetPoint("BOTTOMLEFT", scrollframe, "BOTTOMRIGHT", 4, 16) |
| scrollbar:SetMinMaxValues(0, 1000) |
| scrollbar:SetValueStep(1) |
| scrollbar:SetValue(0) |
| scrollbar:SetWidth(16) |
| scrollbar:Hide() |
| -- set the script as the last step, so it doesn't fire yet |
| scrollbar:SetScript("OnValueChanged", ScrollBar_OnScrollValueChanged) |
| local scrollbg = scrollbar:CreateTexture(nil, "BACKGROUND") |
| scrollbg:SetAllPoints(scrollbar) |
| scrollbg:SetTexture(0, 0, 0, 0.4) |
| --Container Support |
| local content = CreateFrame("Frame", nil, scrollframe) |
| content:SetPoint("TOPLEFT") |
| content:SetPoint("TOPRIGHT") |
| content:SetHeight(400) |
| scrollframe:SetScrollChild(content) |
| local widget = { |
| localstatus = { scrollvalue = 0 }, |
| scrollframe = scrollframe, |
| scrollbar = scrollbar, |
| content = content, |
| frame = frame, |
| type = Type |
| } |
| for method, func in pairs(methods) do |
| widget[method] = func |
| end |
| scrollframe.obj, scrollbar.obj = widget, widget |
| return AceGUI:RegisterAsContainer(widget) |
| end |
| AceGUI:RegisterWidgetType(Type, Constructor, Version) |
mRunes/Libs/AceGUI-3.0-SharedMediaWidgets/Libs/AceGUI-3.0/widgets/AceGUIContainer-DropDownGroup.lua
New file
0,0 → 1,157
| --[[----------------------------------------------------------------------------- |
| DropdownGroup Container |
| Container controlled by a dropdown on the top. |
| -------------------------------------------------------------------------------]] |
| local Type, Version = "DropdownGroup", 20 |
| local AceGUI = LibStub and LibStub("AceGUI-3.0", true) |
| if not AceGUI or (AceGUI:GetWidgetVersion(Type) or 0) >= Version then return end |
| -- Lua APIs |
| local assert, pairs, type = assert, pairs, type |
| -- WoW APIs |
| local CreateFrame = CreateFrame |
| --[[----------------------------------------------------------------------------- |
| Scripts |
| -------------------------------------------------------------------------------]] |
| local function SelectedGroup(self, event, value) |
| local group = self.parentgroup |
| local status = group.status or group.localstatus |
| status.selected = value |
| self.parentgroup:Fire("OnGroupSelected", value) |
| end |
| --[[----------------------------------------------------------------------------- |
| Methods |
| -------------------------------------------------------------------------------]] |
| local methods = { |
| ["OnAcquire"] = function(self) |
| self.dropdown:SetText("") |
| self:SetDropdownWidth(200) |
| self:SetTitle("") |
| end, |
| ["OnRelease"] = function(self) |
| self.dropdown.list = nil |
| self.status = nil |
| for k in pairs(self.localstatus) do |
| self.localstatus[k] = nil |
| end |
| end, |
| ["SetTitle"] = function(self, title) |
| self.titletext:SetText(title) |
| self.dropdown.frame:ClearAllPoints() |
| if title and title ~= "" then |
| self.dropdown.frame:SetPoint("TOPRIGHT", -2, 0) |
| else |
| self.dropdown.frame:SetPoint("TOPLEFT", -1, 0) |
| end |
| end, |
| ["SetGroupList"] = function(self,list) |
| self.dropdown:SetList(list) |
| end, |
| ["SetStatusTable"] = function(self, status) |
| assert(type(status) == "table") |
| self.status = status |
| end, |
| ["SetGroup"] = function(self,group) |
| self.dropdown:SetValue(group) |
| local status = self.status or self.localstatus |
| status.selected = group |
| self:Fire("OnGroupSelected", group) |
| end, |
| ["OnWidthSet"] = function(self, width) |
| local content = self.content |
| local contentwidth = width - 26 |
| if contentwidth < 0 then |
| contentwidth = 0 |
| end |
| content:SetWidth(contentwidth) |
| content.width = contentwidth |
| end, |
| ["OnHeightSet"] = function(self, height) |
| local content = self.content |
| local contentheight = height - 63 |
| if contentheight < 0 then |
| contentheight = 0 |
| end |
| content:SetHeight(contentheight) |
| content.height = contentheight |
| end, |
| ["LayoutFinished"] = function(self, width, height) |
| self:SetHeight((height or 0) + 63) |
| end, |
| ["SetDropdownWidth"] = function(self, width) |
| self.dropdown:SetWidth(width) |
| end |
| } |
| --[[----------------------------------------------------------------------------- |
| Constructor |
| -------------------------------------------------------------------------------]] |
| local PaneBackdrop = { |
| bgFile = "Interface\\ChatFrame\\ChatFrameBackground", |
| edgeFile = "Interface\\Tooltips\\UI-Tooltip-Border", |
| tile = true, tileSize = 16, edgeSize = 16, |
| insets = { left = 3, right = 3, top = 5, bottom = 3 } |
| } |
| local function Constructor() |
| local frame = CreateFrame("Frame") |
| frame:SetHeight(100) |
| frame:SetWidth(100) |
| frame:SetFrameStrata("FULLSCREEN_DIALOG") |
| local titletext = frame:CreateFontString(nil, "OVERLAY", "GameFontNormal") |
| titletext:SetPoint("TOPLEFT", 4, -5) |
| titletext:SetPoint("TOPRIGHT", -4, -5) |
| titletext:SetJustifyH("LEFT") |
| titletext:SetHeight(18) |
| local dropdown = AceGUI:Create("Dropdown") |
| dropdown.frame:SetParent(frame) |
| dropdown.frame:SetFrameLevel(dropdown.frame:GetFrameLevel() + 2) |
| dropdown:SetCallback("OnValueChanged", SelectedGroup) |
| dropdown.frame:SetPoint("TOPLEFT", -1, 0) |
| dropdown.frame:Show() |
| dropdown:SetLabel("") |
| local border = CreateFrame("Frame", nil, frame) |
| border:SetPoint("TOPLEFT", 0, -26) |
| border:SetPoint("BOTTOMRIGHT", 0, 3) |
| border:SetBackdrop(PaneBackdrop) |
| border:SetBackdropColor(0.1,0.1,0.1,0.5) |
| border:SetBackdropBorderColor(0.4,0.4,0.4) |
| --Container Support |
| local content = CreateFrame("Frame", nil, border) |
| content:SetPoint("TOPLEFT", 10, -10) |
| content:SetPoint("BOTTOMRIGHT", -10, 10) |
| local widget = { |
| frame = frame, |
| localstatus = {}, |
| titletext = titletext, |
| dropdown = dropdown, |
| border = border, |
| content = content, |
| type = Type |
| } |
| for method, func in pairs(methods) do |
| widget[method] = func |
| end |
| dropdown.parentgroup = widget |
| return AceGUI:RegisterAsContainer(widget) |
| end |
| AceGUI:RegisterWidgetType(Type, Constructor, Version) |
mRunes/Libs/AceGUI-3.0-SharedMediaWidgets/Libs/AceGUI-3.0/widgets/AceGUIWidget-DropDown-Items.lua
New file
0,0 → 1,465
| --[[ $Id: AceGUIWidget-DropDown-Items.lua 916 2010-03-15 12:24:36Z nevcairiel $ ]]-- |
| local AceGUI = LibStub("AceGUI-3.0") |
| -- Lua APIs |
| local select, assert = select, assert |
| -- WoW APIs |
| local PlaySound = PlaySound |
| local CreateFrame = CreateFrame |
| local function fixlevels(parent,...) |
| local i = 1 |
| local child = select(i, ...) |
| while child do |
| child:SetFrameLevel(parent:GetFrameLevel()+1) |
| fixlevels(child, child:GetChildren()) |
| i = i + 1 |
| child = select(i, ...) |
| end |
| end |
| local function fixstrata(strata, parent, ...) |
| local i = 1 |
| local child = select(i, ...) |
| parent:SetFrameStrata(strata) |
| while child do |
| fixstrata(strata, child, child:GetChildren()) |
| i = i + 1 |
| child = select(i, ...) |
| end |
| end |
| -- ItemBase is the base "class" for all dropdown items. |
| -- Each item has to use ItemBase.Create(widgetType) to |
| -- create an initial 'self' value. |
| -- ItemBase will add common functions and ui event handlers. |
| -- Be sure to keep basic usage when you override functions. |
| local ItemBase = { |
| -- NOTE: The ItemBase version is added to each item's version number |
| -- to ensure proper updates on ItemBase changes. |
| -- Use at least 1000er steps. |
| version = 1000, |
| counter = 0, |
| } |
| function ItemBase.Frame_OnEnter(this) |
| local self = this.obj |
| if self.useHighlight then |
| self.highlight:Show() |
| end |
| self:Fire("OnEnter") |
| if self.specialOnEnter then |
| self.specialOnEnter(self) |
| end |
| end |
| function ItemBase.Frame_OnLeave(this) |
| local self = this.obj |
| self.highlight:Hide() |
| self:Fire("OnLeave") |
| if self.specialOnLeave then |
| self.specialOnLeave(self) |
| end |
| end |
| -- exported, AceGUI callback |
| function ItemBase.OnAcquire(self) |
| self.frame:SetToplevel(true) |
| self.frame:SetFrameStrata("FULLSCREEN_DIALOG") |
| end |
| -- exported, AceGUI callback |
| function ItemBase.OnRelease(self) |
| self:SetDisabled(false) |
| self.pullout = nil |
| self.frame:SetParent(nil) |
| self.frame:ClearAllPoints() |
| self.frame:Hide() |
| end |
| -- exported |
| -- NOTE: this is called by a Dropdown-Pullout. |
| -- Do not call this method directly |
| function ItemBase.SetPullout(self, pullout) |
| self.pullout = pullout |
| self.frame:SetParent(nil) |
| self.frame:SetParent(pullout.itemFrame) |
| self.parent = pullout.itemFrame |
| fixlevels(pullout.itemFrame, pullout.itemFrame:GetChildren()) |
| end |
| -- exported |
| function ItemBase.SetText(self, text) |
| self.text:SetText(text or "") |
| end |
| -- exported |
| function ItemBase.GetText(self) |
| return self.text:GetText() |
| end |
| -- exported |
| function ItemBase.SetPoint(self, ...) |
| self.frame:SetPoint(...) |
| end |
| -- exported |
| function ItemBase.Show(self) |
| self.frame:Show() |
| end |
| -- exported |
| function ItemBase.Hide(self) |
| self.frame:Hide() |
| end |
| -- exported |
| function ItemBase.SetDisabled(self, disabled) |
| self.disabled = disabled |
| if disabled then |
| self.useHighlight = false |
| self.text:SetTextColor(.5, .5, .5) |
| else |
| self.useHighlight = true |
| self.text:SetTextColor(1, 1, 1) |
| end |
| end |
| -- exported |
| -- NOTE: this is called by a Dropdown-Pullout. |
| -- Do not call this method directly |
| function ItemBase.SetOnLeave(self, func) |
| self.specialOnLeave = func |
| end |
| -- exported |
| -- NOTE: this is called by a Dropdown-Pullout. |
| -- Do not call this method directly |
| function ItemBase.SetOnEnter(self, func) |
| self.specialOnEnter = func |
| end |
| function ItemBase.Create(type) |
| -- NOTE: Most of the following code is copied from AceGUI-3.0/Dropdown widget |
| local count = AceGUI:GetNextWidgetNum(type) |
| local frame = CreateFrame("Button", "AceGUI30DropDownItem"..count) |
| local self = {} |
| self.frame = frame |
| frame.obj = self |
| self.type = type |
| self.useHighlight = true |
| frame:SetHeight(17) |
| frame:SetFrameStrata("FULLSCREEN_DIALOG") |
| local text = frame:CreateFontString(nil,"OVERLAY","GameFontNormalSmall") |
| text:SetTextColor(1,1,1) |
| text:SetJustifyH("LEFT") |
| text:SetPoint("TOPLEFT",frame,"TOPLEFT",18,0) |
| text:SetPoint("BOTTOMRIGHT",frame,"BOTTOMRIGHT",-8,0) |
| self.text = text |
| local highlight = frame:CreateTexture(nil, "OVERLAY") |
| highlight:SetTexture("Interface\\QuestFrame\\UI-QuestTitleHighlight") |
| highlight:SetBlendMode("ADD") |
| highlight:SetHeight(14) |
| highlight:ClearAllPoints() |
| highlight:SetPoint("RIGHT",frame,"RIGHT",-3,0) |
| highlight:SetPoint("LEFT",frame,"LEFT",5,0) |
| highlight:Hide() |
| self.highlight = highlight |
| local check = frame:CreateTexture("OVERLAY") |
| check:SetWidth(16) |
| check:SetHeight(16) |
| check:SetPoint("LEFT",frame,"LEFT",3,-1) |
| check:SetTexture("Interface\\Buttons\\UI-CheckBox-Check") |
| check:Hide() |
| self.check = check |
| local sub = frame:CreateTexture("OVERLAY") |
| sub:SetWidth(16) |
| sub:SetHeight(16) |
| sub:SetPoint("RIGHT",frame,"RIGHT",-3,-1) |
| sub:SetTexture("Interface\\ChatFrame\\ChatFrameExpandArrow") |
| sub:Hide() |
| self.sub = sub |
| frame:SetScript("OnEnter", ItemBase.Frame_OnEnter) |
| frame:SetScript("OnLeave", ItemBase.Frame_OnLeave) |
| self.OnAcquire = ItemBase.OnAcquire |
| self.OnRelease = ItemBase.OnRelease |
| self.SetPullout = ItemBase.SetPullout |
| self.GetText = ItemBase.GetText |
| self.SetText = ItemBase.SetText |
| self.SetDisabled = ItemBase.SetDisabled |
| self.SetPoint = ItemBase.SetPoint |
| self.Show = ItemBase.Show |
| self.Hide = ItemBase.Hide |
| self.SetOnLeave = ItemBase.SetOnLeave |
| self.SetOnEnter = ItemBase.SetOnEnter |
| return self |
| end |
| --[[ |
| Template for items: |
| -- Item: |
| -- |
| do |
| local widgetType = "Dropdown-Item-" |
| local widgetVersion = 1 |
| local function Constructor() |
| local self = ItemBase.Create(widgetType) |
| AceGUI:RegisterAsWidget(self) |
| return self |
| end |
| AceGUI:RegisterWidgetType(widgetType, Constructor, widgetVersion + ItemBase.version) |
| end |
| --]] |
| -- Item: Header |
| -- A single text entry. |
| -- Special: Different text color and no highlight |
| do |
| local widgetType = "Dropdown-Item-Header" |
| local widgetVersion = 1 |
| local function OnEnter(this) |
| local self = this.obj |
| self:Fire("OnEnter") |
| if self.specialOnEnter then |
| self.specialOnEnter(self) |
| end |
| end |
| local function OnLeave(this) |
| local self = this.obj |
| self:Fire("OnLeave") |
| if self.specialOnLeave then |
| self.specialOnLeave(self) |
| end |
| end |
| -- exported, override |
| local function SetDisabled(self, disabled) |
| ItemBase.SetDisabled(self, disabled) |
| if not disabled then |
| self.text:SetTextColor(1, 1, 0) |
| end |
| end |
| local function Constructor() |
| local self = ItemBase.Create(widgetType) |
| self.SetDisabled = SetDisabled |
| self.frame:SetScript("OnEnter", OnEnter) |
| self.frame:SetScript("OnLeave", OnLeave) |
| self.text:SetTextColor(1, 1, 0) |
| AceGUI:RegisterAsWidget(self) |
| return self |
| end |
| AceGUI:RegisterWidgetType(widgetType, Constructor, widgetVersion + ItemBase.version) |
| end |
| -- Item: Execute |
| -- A simple button |
| do |
| local widgetType = "Dropdown-Item-Execute" |
| local widgetVersion = 1 |
| local function Frame_OnClick(this, button) |
| local self = this.obj |
| if self.disabled then return end |
| self:Fire("OnClick") |
| if self.pullout then |
| self.pullout:Close() |
| end |
| end |
| local function Constructor() |
| local self = ItemBase.Create(widgetType) |
| self.frame:SetScript("OnClick", Frame_OnClick) |
| AceGUI:RegisterAsWidget(self) |
| return self |
| end |
| AceGUI:RegisterWidgetType(widgetType, Constructor, widgetVersion + ItemBase.version) |
| end |
| -- Item: Toggle |
| -- Some sort of checkbox for dropdown menus. |
| -- Does not close the pullout on click. |
| do |
| local widgetType = "Dropdown-Item-Toggle" |
| local widgetVersion = 3 |
| local function UpdateToggle(self) |
| if self.value then |
| self.check:Show() |
| else |
| self.check:Hide() |
| end |
| end |
| local function OnRelease(self) |
| ItemBase.OnRelease(self) |
| self:SetValue(nil) |
| end |
| local function Frame_OnClick(this, button) |
| local self = this.obj |
| if self.disabled then return end |
| self.value = not self.value |
| if self.value then |
| PlaySound("igMainMenuOptionCheckBoxOn") |
| else |
| PlaySound("igMainMenuOptionCheckBoxOff") |
| end |
| UpdateToggle(self) |
| self:Fire("OnValueChanged", self.value) |
| end |
| -- exported |
| local function SetValue(self, value) |
| self.value = value |
| UpdateToggle(self) |
| end |
| -- exported |
| local function GetValue(self) |
| return self.value |
| end |
| local function Constructor() |
| local self = ItemBase.Create(widgetType) |
| self.frame:SetScript("OnClick", Frame_OnClick) |
| self.SetValue = SetValue |
| self.GetValue = GetValue |
| self.OnRelease = OnRelease |
| AceGUI:RegisterAsWidget(self) |
| return self |
| end |
| AceGUI:RegisterWidgetType(widgetType, Constructor, widgetVersion + ItemBase.version) |
| end |
| -- Item: Menu |
| -- Shows a submenu on mouse over |
| -- Does not close the pullout on click |
| do |
| local widgetType = "Dropdown-Item-Menu" |
| local widgetVersion = 2 |
| local function OnEnter(this) |
| local self = this.obj |
| self:Fire("OnEnter") |
| if self.specialOnEnter then |
| self.specialOnEnter(self) |
| end |
| self.highlight:Show() |
| if not self.disabled and self.submenu then |
| self.submenu:Open("TOPLEFT", self.frame, "TOPRIGHT", self.pullout:GetRightBorderWidth(), 0, self.frame:GetFrameLevel() + 100) |
| end |
| end |
| local function OnHide(this) |
| local self = this.obj |
| if self.submenu then |
| self.submenu:Close() |
| end |
| end |
| -- exported |
| local function SetMenu(self, menu) |
| assert(menu.type == "Dropdown-Pullout") |
| self.submenu = menu |
| end |
| -- exported |
| local function CloseMenu(self) |
| self.submenu:Close() |
| end |
| local function Constructor() |
| local self = ItemBase.Create(widgetType) |
| self.sub:Show() |
| self.frame:SetScript("OnEnter", OnEnter) |
| self.frame:SetScript("OnHide", OnHide) |
| self.SetMenu = SetMenu |
| self.CloseMenu = CloseMenu |
| AceGUI:RegisterAsWidget(self) |
| return self |
| end |
| AceGUI:RegisterWidgetType(widgetType, Constructor, widgetVersion + ItemBase.version) |
| end |
| -- Item: Separator |
| -- A single line to separate items |
| do |
| local widgetType = "Dropdown-Item-Separator" |
| local widgetVersion = 1 |
| -- exported, override |
| local function SetDisabled(self, disabled) |
| ItemBase.SetDisabled(self, disabled) |
| self.useHighlight = false |
| end |
| local function Constructor() |
| local self = ItemBase.Create(widgetType) |
| self.SetDisabled = SetDisabled |
| local line = self.frame:CreateTexture(nil, "OVERLAY") |
| line:SetHeight(1) |
| line:SetTexture(.5, .5, .5) |
| line:SetPoint("LEFT", self.frame, "LEFT", 10, 0) |
| line:SetPoint("RIGHT", self.frame, "RIGHT", -10, 0) |
| self.text:Hide() |
| self.useHighlight = false |
| AceGUI:RegisterAsWidget(self) |
| return self |
| end |
| AceGUI:RegisterWidgetType(widgetType, Constructor, widgetVersion + ItemBase.version) |
| end |
mRunes/Libs/AceGUI-3.0-SharedMediaWidgets/Libs/AceGUI-3.0/widgets/AceGUIWidget-Button.lua
New file
0,0 → 1,92
| --[[----------------------------------------------------------------------------- |
| Button Widget |
| Graphical Button. |
| -------------------------------------------------------------------------------]] |
| local Type, Version = "Button", 20 |
| local AceGUI = LibStub and LibStub("AceGUI-3.0", true) |
| if not AceGUI or (AceGUI:GetWidgetVersion(Type) or 0) >= Version then return end |
| -- Lua APIs |
| local pairs = pairs |
| -- WoW APIs |
| local _G = _G |
| local PlaySound, CreateFrame, UIParent = PlaySound, CreateFrame, UIParent |
| --[[----------------------------------------------------------------------------- |
| Scripts |
| -------------------------------------------------------------------------------]] |
| local function Button_OnClick(frame, ...) |
| PlaySound("igMainMenuOption") |
| frame.obj:Fire("OnClick", ...) |
| AceGUI:ClearFocus() |
| end |
| local function Control_OnEnter(frame) |
| frame.obj:Fire("OnEnter") |
| end |
| local function Control_OnLeave(frame) |
| frame.obj:Fire("OnLeave") |
| end |
| --[[----------------------------------------------------------------------------- |
| Methods |
| -------------------------------------------------------------------------------]] |
| local methods = { |
| ["OnAcquire"] = function(self) |
| -- restore default values |
| self:SetHeight(24) |
| self:SetWidth(200) |
| self:SetDisabled(false) |
| self:SetText() |
| end, |
| -- ["OnRelease"] = nil, |
| ["SetText"] = function(self, text) |
| self.text:SetText(text) |
| end, |
| ["SetDisabled"] = function(self, disabled) |
| self.disabled = disabled |
| if disabled then |
| self.frame:Disable() |
| else |
| self.frame:Enable() |
| end |
| end |
| } |
| --[[----------------------------------------------------------------------------- |
| Constructor |
| -------------------------------------------------------------------------------]] |
| local function Constructor() |
| local name = "AceGUI30Button" .. AceGUI:GetNextWidgetNum(Type) |
| local frame = CreateFrame("Button", name, UIParent, "UIPanelButtonTemplate2") |
| frame:Hide() |
| frame:EnableMouse(true) |
| frame:SetScript("OnClick", Button_OnClick) |
| frame:SetScript("OnEnter", Control_OnEnter) |
| frame:SetScript("OnLeave", Control_OnLeave) |
| local text = frame:GetFontString() |
| text:ClearAllPoints() |
| text:SetPoint("TOPLEFT", 15, -1) |
| text:SetPoint("BOTTOMRIGHT", -15, 1) |
| text:SetJustifyV("MIDDLE") |
| local widget = { |
| text = text, |
| frame = frame, |
| type = Type |
| } |
| for method, func in pairs(methods) do |
| widget[method] = func |
| end |
| return AceGUI:RegisterAsWidget(widget) |
| end |
| AceGUI:RegisterWidgetType(Type, Constructor, Version) |
mRunes/Libs/AceGUI-3.0-SharedMediaWidgets/Libs/AceGUI-3.0/widgets/AceGUIContainer-TreeGroup.lua
New file
0,0 → 1,670
| --[[----------------------------------------------------------------------------- |
| TreeGroup Container |
| Container that uses a tree control to switch between groups. |
| -------------------------------------------------------------------------------]] |
| local Type, Version = "TreeGroup", 30 |
| local AceGUI = LibStub and LibStub("AceGUI-3.0", true) |
| if not AceGUI or (AceGUI:GetWidgetVersion(Type) or 0) >= Version then return end |
| -- Lua APIs |
| local next, pairs, ipairs, assert, type = next, pairs, ipairs, assert, type |
| local math_min, math_max, floor = math.min, math.max, floor |
| local select, tremove, unpack = select, table.remove, unpack |
| -- WoW APIs |
| local CreateFrame, UIParent = CreateFrame, UIParent |
| -- Global vars/functions that we don't upvalue since they might get hooked, or upgraded |
| -- List them here for Mikk's FindGlobals script |
| -- GLOBALS: GameTooltip, FONT_COLOR_CODE_CLOSE |
| -- Recycling functions |
| local new, del |
| do |
| local pool = setmetatable({},{__mode='k'}) |
| function new() |
| local t = next(pool) |
| if t then |
| pool[t] = nil |
| return t |
| else |
| return {} |
| end |
| end |
| function del(t) |
| for k in pairs(t) do |
| t[k] = nil |
| end |
| pool[t] = true |
| end |
| end |
| local DEFAULT_TREE_WIDTH = 175 |
| local DEFAULT_TREE_SIZABLE = true |
| --[[----------------------------------------------------------------------------- |
| Support functions |
| -------------------------------------------------------------------------------]] |
| local function GetButtonUniqueValue(line) |
| local parent = line.parent |
| if parent and parent.value then |
| return GetButtonUniqueValue(parent).."\001"..line.value |
| else |
| return line.value |
| end |
| end |
| local function UpdateButton(button, treeline, selected, canExpand, isExpanded) |
| local self = button.obj |
| local toggle = button.toggle |
| local frame = self.frame |
| local text = treeline.text or "" |
| local icon = treeline.icon |
| local iconCoords = treeline.iconCoords |
| local level = treeline.level |
| local value = treeline.value |
| local uniquevalue = treeline.uniquevalue |
| local disabled = treeline.disabled |
| button.treeline = treeline |
| button.value = value |
| button.uniquevalue = uniquevalue |
| if selected then |
| button:LockHighlight() |
| button.selected = true |
| else |
| button:UnlockHighlight() |
| button.selected = false |
| end |
| local normalTexture = button:GetNormalTexture() |
| local line = button.line |
| button.level = level |
| if ( level == 1 ) then |
| button:SetNormalFontObject("GameFontNormal") |
| button:SetHighlightFontObject("GameFontHighlight") |
| button.text:SetPoint("LEFT", (icon and 16 or 0) + 8, 2) |
| else |
| button:SetNormalFontObject("GameFontHighlightSmall") |
| button:SetHighlightFontObject("GameFontHighlightSmall") |
| button.text:SetPoint("LEFT", (icon and 16 or 0) + 8 * level, 2) |
| end |
| if disabled then |
| button:EnableMouse(false) |
| button.text:SetText("|cff808080"..text..FONT_COLOR_CODE_CLOSE) |
| else |
| button.text:SetText(text) |
| button:EnableMouse(true) |
| end |
| if icon then |
| button.icon:SetTexture(icon) |
| button.icon:SetPoint("LEFT", 8 * level, (level == 1) and 0 or 1) |
| else |
| button.icon:SetTexture(nil) |
| end |
| if iconCoords then |
| button.icon:SetTexCoord(unpack(iconCoords)) |
| else |
| button.icon:SetTexCoord(0, 1, 0, 1) |
| end |
| if canExpand then |
| if not isExpanded then |
| toggle:SetNormalTexture("Interface\\Buttons\\UI-PlusButton-UP") |
| toggle:SetPushedTexture("Interface\\Buttons\\UI-PlusButton-DOWN") |
| else |
| toggle:SetNormalTexture("Interface\\Buttons\\UI-MinusButton-UP") |
| toggle:SetPushedTexture("Interface\\Buttons\\UI-MinusButton-DOWN") |
| end |
| toggle:Show() |
| else |
| toggle:Hide() |
| end |
| end |
| local function ShouldDisplayLevel(tree) |
| local result = false |
| for k, v in ipairs(tree) do |
| if v.children == nil and v.visible ~= false then |
| result = true |
| elseif v.children then |
| result = result or ShouldDisplayLevel(v.children) |
| end |
| if result then return result end |
| end |
| return false |
| end |
| local function addLine(self, v, tree, level, parent) |
| local line = new() |
| line.value = v.value |
| line.text = v.text |
| line.icon = v.icon |
| line.iconCoords = v.iconCoords |
| line.disabled = v.disabled |
| line.tree = tree |
| line.level = level |
| line.parent = parent |
| line.visible = v.visible |
| line.uniquevalue = GetButtonUniqueValue(line) |
| if v.children then |
| line.hasChildren = true |
| else |
| line.hasChildren = nil |
| end |
| self.lines[#self.lines+1] = line |
| return line |
| end |
| --fire an update after one frame to catch the treeframes height |
| local function FirstFrameUpdate(frame) |
| local self = frame.obj |
| frame:SetScript("OnUpdate", nil) |
| self:RefreshTree() |
| end |
| local function BuildUniqueValue(...) |
| local n = select('#', ...) |
| if n == 1 then |
| return ... |
| else |
| return (...).."\001"..BuildUniqueValue(select(2,...)) |
| end |
| end |
| --[[----------------------------------------------------------------------------- |
| Scripts |
| -------------------------------------------------------------------------------]] |
| local function Expand_OnClick(frame) |
| local button = frame.button |
| local self = button.obj |
| local status = (self.status or self.localstatus).groups |
| status[button.uniquevalue] = not status[button.uniquevalue] |
| self:RefreshTree() |
| end |
| local function Button_OnClick(frame) |
| local self = frame.obj |
| self:Fire("OnClick", frame.uniquevalue, frame.selected) |
| if not frame.selected then |
| self:SetSelected(frame.uniquevalue) |
| frame.selected = true |
| frame:LockHighlight() |
| self:RefreshTree() |
| end |
| AceGUI:ClearFocus() |
| end |
| local function Button_OnDoubleClick(button) |
| local self = button.obj |
| local status = self.status or self.localstatus |
| local status = (self.status or self.localstatus).groups |
| status[button.uniquevalue] = not status[button.uniquevalue] |
| self:RefreshTree() |
| end |
| local function Button_OnEnter(frame) |
| local self = frame.obj |
| self:Fire("OnButtonEnter", frame.uniquevalue, frame) |
| if self.enabletooltips then |
| GameTooltip:SetOwner(frame, "ANCHOR_NONE") |
| GameTooltip:SetPoint("LEFT",frame,"RIGHT") |
| GameTooltip:SetText(frame.text:GetText() or "", 1, .82, 0, 1) |
| GameTooltip:Show() |
| end |
| end |
| local function Button_OnLeave(frame) |
| local self = frame.obj |
| self:Fire("OnButtonLeave", frame.uniquevalue, frame) |
| if self.enabletooltips then |
| GameTooltip:Hide() |
| end |
| end |
| local function OnScrollValueChanged(frame, value) |
| if frame.obj.noupdate then return end |
| local self = frame.obj |
| local status = self.status or self.localstatus |
| status.scrollvalue = value |
| self:RefreshTree() |
| AceGUI:ClearFocus() |
| end |
| local function Tree_OnSizeChanged(frame) |
| frame.obj:RefreshTree() |
| end |
| local function Tree_OnMouseWheel(frame, delta) |
| local self = frame.obj |
| if self.showscroll then |
| local scrollbar = self.scrollbar |
| local min, max = scrollbar:GetMinMaxValues() |
| local value = scrollbar:GetValue() |
| local newvalue = math_min(max,math_max(min,value - delta)) |
| if value ~= newvalue then |
| scrollbar:SetValue(newvalue) |
| end |
| end |
| end |
| local function Dragger_OnLeave(frame) |
| frame:SetBackdropColor(1, 1, 1, 0) |
| end |
| local function Dragger_OnEnter(frame) |
| frame:SetBackdropColor(1, 1, 1, 0.8) |
| end |
| local function Dragger_OnMouseDown(frame) |
| local treeframe = frame:GetParent() |
| treeframe:StartSizing("RIGHT") |
| end |
| local function Dragger_OnMouseUp(frame) |
| local treeframe = frame:GetParent() |
| local self = treeframe.obj |
| local frame = treeframe:GetParent() |
| treeframe:StopMovingOrSizing() |
| --treeframe:SetScript("OnUpdate", nil) |
| treeframe:SetUserPlaced(false) |
| --Without this :GetHeight will get stuck on the current height, causing the tree contents to not resize |
| treeframe:SetHeight(0) |
| treeframe:SetPoint("TOPLEFT", frame, "TOPLEFT",0,0) |
| treeframe:SetPoint("BOTTOMLEFT", frame, "BOTTOMLEFT",0,0) |
| local status = self.status or self.localstatus |
| status.treewidth = treeframe:GetWidth() |
| treeframe.obj:Fire("OnTreeResize",treeframe:GetWidth()) |
| -- recalculate the content width |
| treeframe.obj:OnWidthSet(status.fullwidth) |
| -- update the layout of the content |
| treeframe.obj:DoLayout() |
| end |
| --[[----------------------------------------------------------------------------- |
| Methods |
| -------------------------------------------------------------------------------]] |
| local methods = { |
| ["OnAcquire"] = function(self) |
| self:SetTreeWidth(DEFAULT_TREE_WIDTH, DEFAULT_TREE_SIZABLE) |
| self:EnableButtonTooltips(true) |
| end, |
| ["OnRelease"] = function(self) |
| self.status = nil |
| for k, v in pairs(self.localstatus) do |
| if k == "groups" then |
| for k2 in pairs(v) do |
| v[k2] = nil |
| end |
| else |
| self.localstatus[k] = nil |
| end |
| end |
| self.localstatus.scrollvalue = 0 |
| self.localstatus.treewidth = DEFAULT_TREE_WIDTH |
| self.localstatus.treesizable = DEFAULT_TREE_SIZABLE |
| end, |
| ["EnableButtonTooltips"] = function(self, enable) |
| self.enabletooltips = enable |
| end, |
| ["CreateButton"] = function(self) |
| local num = AceGUI:GetNextWidgetNum("TreeGroupButton") |
| local button = CreateFrame("Button", ("AceGUI30TreeButton%d"):format(num), self.treeframe, "OptionsListButtonTemplate") |
| button.obj = self |
| local icon = button:CreateTexture(nil, "OVERLAY") |
| icon:SetWidth(14) |
| icon:SetHeight(14) |
| button.icon = icon |
| button:SetScript("OnClick",Button_OnClick) |
| button:SetScript("OnDoubleClick", Button_OnDoubleClick) |
| button:SetScript("OnEnter",Button_OnEnter) |
| button:SetScript("OnLeave",Button_OnLeave) |
| button.toggle.button = button |
| button.toggle:SetScript("OnClick",Expand_OnClick) |
| return button |
| end, |
| ["SetStatusTable"] = function(self, status) |
| assert(type(status) == "table") |
| self.status = status |
| if not status.groups then |
| status.groups = {} |
| end |
| if not status.scrollvalue then |
| status.scrollvalue = 0 |
| end |
| if not status.treewidth then |
| status.treewidth = DEFAULT_TREE_WIDTH |
| end |
| if not status.treesizable then |
| status.treesizable = DEFAULT_TREE_SIZABLE |
| end |
| self:SetTreeWidth(status.treewidth,status.treesizable) |
| self:RefreshTree() |
| end, |
| --sets the tree to be displayed |
| ["SetTree"] = function(self, tree, filter) |
| self.filter = filter |
| if tree then |
| assert(type(tree) == "table") |
| end |
| self.tree = tree |
| self:RefreshTree() |
| end, |
| ["BuildLevel"] = function(self, tree, level, parent) |
| local groups = (self.status or self.localstatus).groups |
| local hasChildren = self.hasChildren |
| for i, v in ipairs(tree) do |
| if v.children then |
| if not self.filter or ShouldDisplayLevel(v.children) then |
| local line = addLine(self, v, tree, level, parent) |
| if groups[line.uniquevalue] then |
| self:BuildLevel(v.children, level+1, line) |
| end |
| end |
| elseif v.visible ~= false or not self.filter then |
| addLine(self, v, tree, level, parent) |
| end |
| end |
| end, |
| ["RefreshTree"] = function(self) |
| local buttons = self.buttons |
| local lines = self.lines |
| for i, v in ipairs(buttons) do |
| v:Hide() |
| end |
| while lines[1] do |
| local t = tremove(lines) |
| for k in pairs(t) do |
| t[k] = nil |
| end |
| del(t) |
| end |
| if not self.tree then return end |
| --Build the list of visible entries from the tree and status tables |
| local status = self.status or self.localstatus |
| local groupstatus = status.groups |
| local tree = self.tree |
| local treeframe = self.treeframe |
| self:BuildLevel(tree, 1) |
| local numlines = #lines |
| local maxlines = (floor(((self.treeframe:GetHeight()or 0) - 20 ) / 18)) |
| local first, last |
| if numlines <= maxlines then |
| --the whole tree fits in the frame |
| status.scrollvalue = 0 |
| self:ShowScroll(false) |
| first, last = 1, numlines |
| else |
| self:ShowScroll(true) |
| --scrolling will be needed |
| self.noupdate = true |
| self.scrollbar:SetMinMaxValues(0, numlines - maxlines) |
| --check if we are scrolled down too far |
| if numlines - status.scrollvalue < maxlines then |
| status.scrollvalue = numlines - maxlines |
| self.scrollbar:SetValue(status.scrollvalue) |
| end |
| self.noupdate = nil |
| first, last = status.scrollvalue+1, status.scrollvalue + maxlines |
| end |
| local buttonnum = 1 |
| for i = first, last do |
| local line = lines[i] |
| local button = buttons[buttonnum] |
| if not button then |
| button = self:CreateButton() |
| buttons[buttonnum] = button |
| button:SetParent(treeframe) |
| button:SetFrameLevel(treeframe:GetFrameLevel()+1) |
| button:ClearAllPoints() |
| if i == 1 then |
| if self.showscroll then |
| button:SetPoint("TOPRIGHT", self.treeframe,"TOPRIGHT",-22,-10) |
| button:SetPoint("TOPLEFT", self.treeframe, "TOPLEFT", 0, -10) |
| else |
| button:SetPoint("TOPRIGHT", self.treeframe,"TOPRIGHT",0,-10) |
| button:SetPoint("TOPLEFT", self.treeframe, "TOPLEFT", 0, -10) |
| end |
| else |
| button:SetPoint("TOPRIGHT", buttons[buttonnum-1], "BOTTOMRIGHT",0,0) |
| button:SetPoint("TOPLEFT", buttons[buttonnum-1], "BOTTOMLEFT",0,0) |
| end |
| end |
| UpdateButton(button, line, status.selected == line.uniquevalue, line.hasChildren, groupstatus[line.uniquevalue] ) |
| button:Show() |
| buttonnum = buttonnum + 1 |
| end |
| end, |
| ["SetSelected"] = function(self, value) |
| local status = self.status or self.localstatus |
| if status.selected ~= value then |
| status.selected = value |
| self:Fire("OnGroupSelected", value) |
| end |
| end, |
| ["Select"] = function(self, uniquevalue, ...) |
| self.filter = false |
| local status = self.status or self.localstatus |
| local groups = status.groups |
| for i = 1, select('#', ...) do |
| groups[BuildUniqueValue(select(i, ...))] = true |
| end |
| status.selected = uniquevalue |
| self:RefreshTree() |
| self:Fire("OnGroupSelected", uniquevalue) |
| end, |
| ["SelectByPath"] = function(self, ...) |
| self:Select(BuildUniqueValue(...), ...) |
| end, |
| ["SelectByValue"] = function(self, uniquevalue) |
| self:Select(uniquevalue, ("\001"):split(uniquevalue)) |
| end, |
| ["ShowScroll"] = function(self, show) |
| self.showscroll = show |
| if show then |
| self.scrollbar:Show() |
| if self.buttons[1] then |
| self.buttons[1]:SetPoint("TOPRIGHT", self.treeframe,"TOPRIGHT",-22,-10) |
| end |
| else |
| self.scrollbar:Hide() |
| if self.buttons[1] then |
| self.buttons[1]:SetPoint("TOPRIGHT", self.treeframe,"TOPRIGHT",0,-10) |
| end |
| end |
| end, |
| ["OnWidthSet"] = function(self, width) |
| local content = self.content |
| local treeframe = self.treeframe |
| local status = self.status or self.localstatus |
| status.fullwidth = width |
| local contentwidth = width - status.treewidth - 20 |
| if contentwidth < 0 then |
| contentwidth = 0 |
| end |
| content:SetWidth(contentwidth) |
| content.width = contentwidth |
| local maxtreewidth = math_min(400, width - 50) |
| if maxtreewidth > 100 and status.treewidth > maxtreewidth then |
| self:SetTreeWidth(maxtreewidth, status.treesizable) |
| end |
| treeframe:SetMaxResize(maxtreewidth, 1600) |
| end, |
| ["OnHeightSet"] = function(self, height) |
| local content = self.content |
| local contentheight = height - 20 |
| if contentheight < 0 then |
| contentheight = 0 |
| end |
| content:SetHeight(contentheight) |
| content.height = contentheight |
| end, |
| ["SetTreeWidth"] = function(self, treewidth, resizable) |
| if not resizable then |
| if type(treewidth) == 'number' then |
| resizable = false |
| elseif type(treewidth) == 'boolean' then |
| resizable = treewidth |
| treewidth = DEFAULT_TREE_WIDTH |
| else |
| resizable = false |
| treewidth = DEFAULT_TREE_WIDTH |
| end |
| end |
| self.treeframe:SetWidth(treewidth) |
| self.dragger:EnableMouse(resizable) |
| local status = self.status or self.localstatus |
| status.treewidth = treewidth |
| status.treesizable = resizable |
| -- recalculate the content width |
| if status.fullwidth then |
| self:OnWidthSet(status.fullwidth) |
| end |
| end, |
| ["LayoutFinished"] = function(self, width, height) |
| if self.noAutoHeight then return end |
| self:SetHeight((height or 0) + 20) |
| end |
| } |
| --[[----------------------------------------------------------------------------- |
| Constructor |
| -------------------------------------------------------------------------------]] |
| local PaneBackdrop = { |
| bgFile = "Interface\\ChatFrame\\ChatFrameBackground", |
| edgeFile = "Interface\\Tooltips\\UI-Tooltip-Border", |
| tile = true, tileSize = 16, edgeSize = 16, |
| insets = { left = 3, right = 3, top = 5, bottom = 3 } |
| } |
| local DraggerBackdrop = { |
| bgFile = "Interface\\Tooltips\\UI-Tooltip-Background", |
| edgeFile = nil, |
| tile = true, tileSize = 16, edgeSize = 0, |
| insets = { left = 3, right = 3, top = 7, bottom = 7 } |
| } |
| local function Constructor() |
| local num = AceGUI:GetNextWidgetNum(Type) |
| local frame = CreateFrame("Frame", nil, UIParent) |
| local treeframe = CreateFrame("Frame", nil, frame) |
| treeframe:SetPoint("TOPLEFT") |
| treeframe:SetPoint("BOTTOMLEFT") |
| treeframe:SetWidth(DEFAULT_TREE_WIDTH) |
| treeframe:EnableMouseWheel(true) |
| treeframe:SetBackdrop(PaneBackdrop) |
| treeframe:SetBackdropColor(0.1, 0.1, 0.1, 0.5) |
| treeframe:SetBackdropBorderColor(0.4, 0.4, 0.4) |
| treeframe:SetResizable(true) |
| treeframe:SetMinResize(100, 1) |
| treeframe:SetMaxResize(400, 1600) |
| treeframe:SetScript("OnUpdate", FirstFrameUpdate) |
| treeframe:SetScript("OnSizeChanged", Tree_OnSizeChanged) |
| treeframe:SetScript("OnMouseWheel", Tree_OnMouseWheel) |
| local dragger = CreateFrame("Frame", nil, treeframe) |
| dragger:SetWidth(8) |
| dragger:SetPoint("TOP", treeframe, "TOPRIGHT") |
| dragger:SetPoint("BOTTOM", treeframe, "BOTTOMRIGHT") |
| dragger:SetBackdrop(DraggerBackdrop) |
| dragger:SetBackdropColor(1, 1, 1, 0) |
| dragger:SetScript("OnEnter", Dragger_OnEnter) |
| dragger:SetScript("OnLeave", Dragger_OnLeave) |
| dragger:SetScript("OnMouseDown", Dragger_OnMouseDown) |
| dragger:SetScript("OnMouseUp", Dragger_OnMouseUp) |
| local scrollbar = CreateFrame("Slider", ("AceConfigDialogTreeGroup%dScrollBar"):format(num), treeframe, "UIPanelScrollBarTemplate") |
| scrollbar:SetScript("OnValueChanged", nil) |
| scrollbar:SetPoint("TOPRIGHT", -10, -26) |
| scrollbar:SetPoint("BOTTOMRIGHT", -10, 26) |
| scrollbar:SetMinMaxValues(0,0) |
| scrollbar:SetValueStep(1) |
| scrollbar:SetValue(0) |
| scrollbar:SetWidth(16) |
| scrollbar:SetScript("OnValueChanged", OnScrollValueChanged) |
| local scrollbg = scrollbar:CreateTexture(nil, "BACKGROUND") |
| scrollbg:SetAllPoints(scrollbar) |
| scrollbg:SetTexture(0,0,0,0.4) |
| local border = CreateFrame("Frame",nil,frame) |
| border:SetPoint("TOPLEFT", treeframe, "TOPRIGHT") |
| border:SetPoint("BOTTOMRIGHT") |
| border:SetBackdrop(PaneBackdrop) |
| border:SetBackdropColor(0.1, 0.1, 0.1, 0.5) |
| border:SetBackdropBorderColor(0.4, 0.4, 0.4) |
| --Container Support |
| local content = CreateFrame("Frame", nil, border) |
| content:SetPoint("TOPLEFT", 10, -10) |
| content:SetPoint("BOTTOMRIGHT", -10, 10) |
| local widget = { |
| frame = frame, |
| lines = {}, |
| levels = {}, |
| buttons = {}, |
| hasChildren = {}, |
| localstatus = { groups = {}, scrollvalue = 0 }, |
| filter = false, |
| treeframe = treeframe, |
| dragger = dragger, |
| scrollbar = scrollbar, |
| border = border, |
| content = content, |
| type = Type |
| } |
| for method, func in pairs(methods) do |
| widget[method] = func |
| end |
| treeframe.obj, dragger.obj, scrollbar.obj = widget, widget, widget |
| return AceGUI:RegisterAsContainer(widget) |
| end |
| AceGUI:RegisterWidgetType(Type, Constructor, Version) |
mRunes/Libs/AceGUI-3.0-SharedMediaWidgets/Libs/AceGUI-3.0/widgets/AceGUIWidget-ColorPicker.lua
New file
0,0 → 1,186
| --[[----------------------------------------------------------------------------- |
| ColorPicker Widget |
| -------------------------------------------------------------------------------]] |
| local Type, Version = "ColorPicker", 20 |
| local AceGUI = LibStub and LibStub("AceGUI-3.0", true) |
| if not AceGUI or (AceGUI:GetWidgetVersion(Type) or 0) >= Version then return end |
| -- Lua APIs |
| local pairs = pairs |
| -- WoW APIs |
| local CreateFrame, UIParent = CreateFrame, UIParent |
| -- Global vars/functions that we don't upvalue since they might get hooked, or upgraded |
| -- List them here for Mikk's FindGlobals script |
| -- GLOBALS: ShowUIPanel, HideUIPanel, ColorPickerFrame, OpacitySliderFrame |
| --[[----------------------------------------------------------------------------- |
| Support functions |
| -------------------------------------------------------------------------------]] |
| local function ColorCallback(self, r, g, b, a, isAlpha) |
| if not self.HasAlpha then |
| a = 1 |
| end |
| self:SetColor(r, g, b, a) |
| if ColorPickerFrame:IsVisible() then |
| --colorpicker is still open |
| self:Fire("OnValueChanged", r, g, b, a) |
| else |
| --colorpicker is closed, color callback is first, ignore it, |
| --alpha callback is the final call after it closes so confirm now |
| if isAlpha then |
| self:Fire("OnValueConfirmed", r, g, b, a) |
| end |
| end |
| end |
| --[[----------------------------------------------------------------------------- |
| Scripts |
| -------------------------------------------------------------------------------]] |
| local function Control_OnEnter(frame) |
| frame.obj:Fire("OnEnter") |
| end |
| local function Control_OnLeave(frame) |
| frame.obj:Fire("OnLeave") |
| end |
| local function ColorSwatch_OnClick(frame) |
| HideUIPanel(ColorPickerFrame) |
| local self = frame.obj |
| if not self.disabled then |
| ColorPickerFrame:SetFrameStrata("FULLSCREEN_DIALOG") |
| ColorPickerFrame.func = function() |
| local r, g, b = ColorPickerFrame:GetColorRGB() |
| local a = 1 - OpacitySliderFrame:GetValue() |
| ColorCallback(self, r, g, b, a) |
| end |
| ColorPickerFrame.hasOpacity = self.HasAlpha |
| ColorPickerFrame.opacityFunc = function() |
| local r, g, b = ColorPickerFrame:GetColorRGB() |
| local a = 1 - OpacitySliderFrame:GetValue() |
| ColorCallback(self, r, g, b, a, true) |
| end |
| local r, g, b, a = self.r, self.g, self.b, self.a |
| if self.HasAlpha then |
| ColorPickerFrame.opacity = 1 - (a or 0) |
| end |
| ColorPickerFrame:SetColorRGB(r, g, b) |
| ColorPickerFrame.cancelFunc = function() |
| ColorCallback(self, r, g, b, a, true) |
| end |
| ShowUIPanel(ColorPickerFrame) |
| end |
| AceGUI:ClearFocus() |
| end |
| --[[----------------------------------------------------------------------------- |
| Methods |
| -------------------------------------------------------------------------------]] |
| local methods = { |
| ["OnAcquire"] = function(self) |
| self:SetHeight(24) |
| self:SetWidth(200) |
| self:SetHasAlpha(false) |
| self:SetColor(0, 0, 0, 1) |
| self:SetDisabled(nil) |
| self:SetLabel(nil) |
| end, |
| -- ["OnRelease"] = nil, |
| ["SetLabel"] = function(self, text) |
| self.text:SetText(text) |
| end, |
| ["SetColor"] = function(self, r, g, b, a) |
| self.r = r |
| self.g = g |
| self.b = b |
| self.a = a or 1 |
| self.colorSwatch:SetVertexColor(r, g, b, a) |
| end, |
| ["SetHasAlpha"] = function(self, HasAlpha) |
| self.HasAlpha = HasAlpha |
| end, |
| ["SetDisabled"] = function(self, disabled) |
| self.disabled = disabled |
| if self.disabled then |
| self.frame:Disable() |
| self.text:SetTextColor(0.5, 0.5, 0.5) |
| else |
| self.frame:Enable() |
| self.text:SetTextColor(1, 1, 1) |
| end |
| end |
| } |
| --[[----------------------------------------------------------------------------- |
| Constructor |
| -------------------------------------------------------------------------------]] |
| local function Constructor() |
| local frame = CreateFrame("Button", nil, UIParent) |
| frame:Hide() |
| frame:EnableMouse(true) |
| frame:SetScript("OnEnter", Control_OnEnter) |
| frame:SetScript("OnLeave", Control_OnLeave) |
| frame:SetScript("OnClick", ColorSwatch_OnClick) |
| local colorSwatch = frame:CreateTexture(nil, "OVERLAY") |
| colorSwatch:SetWidth(19) |
| colorSwatch:SetHeight(19) |
| colorSwatch:SetTexture("Interface\\ChatFrame\\ChatFrameColorSwatch") |
| colorSwatch:SetPoint("LEFT") |
| local texture = frame:CreateTexture(nil, "BACKGROUND") |
| texture:SetWidth(16) |
| texture:SetHeight(16) |
| texture:SetTexture(1, 1, 1) |
| texture:SetPoint("CENTER", colorSwatch) |
| texture:Show() |
| local checkers = frame:CreateTexture(nil, "BACKGROUND") |
| checkers:SetWidth(14) |
| checkers:SetHeight(14) |
| checkers:SetTexture("Tileset\\Generic\\Checkers") |
| checkers:SetTexCoord(.25, 0, 0.5, .25) |
| checkers:SetDesaturated(true) |
| checkers:SetVertexColor(1, 1, 1, 0.75) |
| checkers:SetPoint("CENTER", colorSwatch) |
| checkers:Show() |
| local text = frame:CreateFontString(nil,"OVERLAY","GameFontHighlight") |
| text:SetHeight(24) |
| text:SetJustifyH("LEFT") |
| text:SetTextColor(1, 1, 1) |
| text:SetPoint("LEFT", colorSwatch, "RIGHT", 2, 0) |
| text:SetPoint("RIGHT") |
| --local highlight = frame:CreateTexture(nil, "HIGHLIGHT") |
| --highlight:SetTexture("Interface\\QuestFrame\\UI-QuestTitleHighlight") |
| --highlight:SetBlendMode("ADD") |
| --highlight:SetAllPoints(frame) |
| local widget = { |
| colorSwatch = colorSwatch, |
| text = text, |
| frame = frame, |
| type = Type |
| } |
| for method, func in pairs(methods) do |
| widget[method] = func |
| end |
| return AceGUI:RegisterAsWidget(widget) |
| end |
| AceGUI:RegisterWidgetType(Type, Constructor, Version) |
mRunes/Libs/AceGUI-3.0-SharedMediaWidgets/Libs/AceGUI-3.0/widgets/AceGUIWidget-InteractiveLabel.lua
New file
0,0 → 1,101
| --[[----------------------------------------------------------------------------- |
| InteractiveLabel Widget |
| -------------------------------------------------------------------------------]] |
| local Type, Version = "InteractiveLabel", 20 |
| local AceGUI = LibStub and LibStub("AceGUI-3.0", true) |
| if not AceGUI or (AceGUI:GetWidgetVersion(Type) or 0) >= Version then return end |
| -- Lua APIs |
| local select, pairs = select, pairs |
| -- WoW APIs |
| local CreateFrame, UIParent = CreateFrame, UIParent |
| -- Global vars/functions that we don't upvalue since they might get hooked, or upgraded |
| -- List them here for Mikk's FindGlobals script |
| -- GLOBALS: GameFontHighlightSmall |
| --[[----------------------------------------------------------------------------- |
| Scripts |
| -------------------------------------------------------------------------------]] |
| local function Control_OnEnter(frame) |
| frame.obj:Fire("OnEnter") |
| end |
| local function Control_OnLeave(frame) |
| frame.obj:Fire("OnLeave") |
| end |
| local function Label_OnClick(frame, button) |
| frame.obj:Fire("OnClick", button) |
| AceGUI:ClearFocus() |
| end |
| --[[----------------------------------------------------------------------------- |
| Methods |
| -------------------------------------------------------------------------------]] |
| local methods = { |
| ["OnAcquire"] = function(self) |
| self:LabelOnAcquire() |
| self:SetHighlight() |
| self:SetHighlightTexCoord() |
| self:SetDisabled(false) |
| end, |
| -- ["OnRelease"] = nil, |
| ["SetHighlight"] = function(self, ...) |
| self.highlight:SetTexture(...) |
| end, |
| ["SetHighlightTexCoord"] = function(self, ...) |
| local c = select("#", ...) |
| if c == 4 or c == 8 then |
| self.highlight:SetTexCoord(...) |
| else |
| self.highlight:SetTexCoord(0, 1, 0, 1) |
| end |
| end, |
| ["SetDisabled"] = function(self,disabled) |
| self.disabled = disabled |
| if disabled then |
| self.frame:EnableMouse(false) |
| self.label:SetTextColor(0.5, 0.5, 0.5) |
| else |
| self.frame:EnableMouse(true) |
| self.label:SetTextColor(1, 1, 1) |
| end |
| end |
| } |
| --[[----------------------------------------------------------------------------- |
| Constructor |
| -------------------------------------------------------------------------------]] |
| local function Constructor() |
| -- create a Label type that we will hijack |
| local label = AceGUI:Create("Label") |
| local frame = label.frame |
| frame:EnableMouse(true) |
| frame:SetScript("OnEnter", Control_OnEnter) |
| frame:SetScript("OnLeave", Control_OnLeave) |
| frame:SetScript("OnMouseDown", Label_OnClick) |
| local highlight = frame:CreateTexture(nil, "HIGHLIGHT") |
| highlight:SetTexture(nil) |
| highlight:SetAllPoints() |
| highlight:SetBlendMode("ADD") |
| label.highlight = highlight |
| label.type = Type |
| label.LabelOnAcquire = label.OnAcquire |
| for method, func in pairs(methods) do |
| label[method] = func |
| end |
| return label |
| end |
| AceGUI:RegisterWidgetType(Type, Constructor, Version) |
mRunes/Libs/AceGUI-3.0-SharedMediaWidgets/Libs/AceGUI-3.0/widgets/AceGUIWidget-Label.lua
New file
0,0 → 1,162
| --[[----------------------------------------------------------------------------- |
| Label Widget |
| Displays text and optionally an icon. |
| -------------------------------------------------------------------------------]] |
| local Type, Version = "Label", 21 |
| local AceGUI = LibStub and LibStub("AceGUI-3.0", true) |
| if not AceGUI or (AceGUI:GetWidgetVersion(Type) or 0) >= Version then return end |
| -- Lua APIs |
| local max, select, pairs = math.max, select, pairs |
| -- WoW APIs |
| local CreateFrame, UIParent = CreateFrame, UIParent |
| -- Global vars/functions that we don't upvalue since they might get hooked, or upgraded |
| -- List them here for Mikk's FindGlobals script |
| -- GLOBALS: GameFontHighlightSmall |
| --[[----------------------------------------------------------------------------- |
| Support functions |
| -------------------------------------------------------------------------------]] |
| local function UpdateImageAnchor(self) |
| if self.resizing then return end |
| local frame = self.frame |
| local width = frame.width or frame:GetWidth() or 0 |
| local image = self.image |
| local label = self.label |
| local height |
| label:ClearAllPoints() |
| image:ClearAllPoints() |
| if self.imageshown then |
| local imagewidth = image:GetWidth() |
| if (width - imagewidth) < 200 or (label:GetText() or "") == "" then |
| -- image goes on top centered when less than 200 width for the text, or if there is no text |
| image:SetPoint("TOP") |
| label:SetPoint("TOP", image, "BOTTOM") |
| label:SetPoint("LEFT") |
| label:SetWidth(width) |
| height = image:GetHeight() + label:GetHeight() |
| else |
| -- image on the left |
| image:SetPoint("TOPLEFT") |
| label:SetPoint("TOPLEFT", image, "TOPRIGHT", 4, 0) |
| label:SetWidth(width - imagewidth - 4) |
| height = max(image:GetHeight(), label:GetHeight()) |
| end |
| else |
| -- no image shown |
| label:SetPoint("TOPLEFT") |
| label:SetWidth(width) |
| height = label:GetHeight() |
| end |
| self.resizing = true |
| frame:SetHeight(height) |
| frame.height = height |
| self.resizing = nil |
| end |
| --[[----------------------------------------------------------------------------- |
| Methods |
| -------------------------------------------------------------------------------]] |
| local methods = { |
| ["OnAcquire"] = function(self) |
| -- set the flag to stop constant size updates |
| self.resizing = true |
| -- height is set dynamically by the text and image size |
| self:SetWidth(200) |
| self:SetText() |
| self:SetImage(nil) |
| self:SetImageSize(16, 16) |
| self:SetColor() |
| self:SetFontObject() |
| -- reset the flag |
| self.resizing = nil |
| -- run the update explicitly |
| UpdateImageAnchor(self) |
| end, |
| -- ["OnRelease"] = nil, |
| ["OnWidthSet"] = function(self, width) |
| UpdateImageAnchor(self) |
| end, |
| ["SetText"] = function(self, text) |
| self.label:SetText(text) |
| UpdateImageAnchor(self) |
| end, |
| ["SetColor"] = function(self, r, g, b) |
| if not (r and g and b) then |
| r, g, b = 1, 1, 1 |
| end |
| self.label:SetVertexColor(r, g, b) |
| end, |
| ["SetImage"] = function(self, path, ...) |
| local image = self.image |
| image:SetTexture(path) |
| if image:GetTexture() then |
| self.imageshown = true |
| local n = select("#", ...) |
| if n == 4 or n == 8 then |
| image:SetTexCoord(...) |
| else |
| image:SetTexCoord(0, 1, 0, 1) |
| end |
| else |
| self.imageshown = nil |
| end |
| UpdateImageAnchor(self) |
| end, |
| ["SetFont"] = function(self, font, height, flags) |
| self.label:SetFont(font, height, flags) |
| end, |
| ["SetFontObject"] = function(self, font) |
| self:SetFont((font or GameFontHighlightSmall):GetFont()) |
| end, |
| ["SetImageSize"] = function(self, width, height) |
| self.image:SetWidth(width) |
| self.image:SetHeight(height) |
| UpdateImageAnchor(self) |
| end, |
| } |
| --[[----------------------------------------------------------------------------- |
| Constructor |
| -------------------------------------------------------------------------------]] |
| local function Constructor() |
| local frame = CreateFrame("Frame", nil, UIParent) |
| frame:Hide() |
| local label = frame:CreateFontString(nil, "BACKGROUND", "GameFontHighlightSmall") |
| label:SetJustifyH("LEFT") |
| label:SetJustifyV("TOP") |
| local image = frame:CreateTexture(nil, "BACKGROUND") |
| -- create widget |
| local widget = { |
| label = label, |
| image = image, |
| frame = frame, |
| type = Type |
| } |
| for method, func in pairs(methods) do |
| widget[method] = func |
| end |
| return AceGUI:RegisterAsWidget(widget) |
| end |
| AceGUI:RegisterWidgetType(Type, Constructor, Version) |
mRunes/Libs/AceGUI-3.0-SharedMediaWidgets/Libs/AceGUI-3.0/widgets/AceGUIWidget-MultiLineEditBox.lua
New file
0,0 → 1,308
| local Type, Version = "MultiLineEditBox", 24 |
| local AceGUI = LibStub and LibStub("AceGUI-3.0", true) |
| if not AceGUI or (AceGUI:GetWidgetVersion(Type) or 0) >= Version then return end |
| -- Lua APIs |
| local pairs = pairs |
| -- WoW APIs |
| local GetCursorInfo, GetSpellInfo, ClearCursor = GetCursorInfo, GetSpellInfo, ClearCursor |
| local CreateFrame, UIParent = CreateFrame, UIParent |
| local _G = _G |
| -- Global vars/functions that we don't upvalue since they might get hooked, or upgraded |
| -- List them here for Mikk's FindGlobals script |
| -- GLOBALS: ACCEPT, ChatFontNormal |
| --[[----------------------------------------------------------------------------- |
| Support functions |
| -------------------------------------------------------------------------------]] |
| local function Layout(self) |
| self:SetHeight(self.numlines * 14 + (self.disablebutton and 19 or 41) + self.labelHeight) |
| if self.labelHeight == 0 then |
| self.scrollBar:SetPoint("TOP", self.frame, "TOP", 0, -23) |
| else |
| self.scrollBar:SetPoint("TOP", self.label, "BOTTOM", 0, -19) |
| end |
| if self.disablebutton then |
| self.scrollBar:SetPoint("BOTTOM", self.frame, "BOTTOM", 0, 21) |
| self.scrollBG:SetPoint("BOTTOMLEFT", 0, 4) |
| else |
| self.scrollBar:SetPoint("BOTTOM", self.button, "TOP", 0, 18) |
| self.scrollBG:SetPoint("BOTTOMLEFT", self.button, "TOPLEFT") |
| end |
| end |
| --[[----------------------------------------------------------------------------- |
| Scripts |
| -------------------------------------------------------------------------------]] |
| local function OnClick(self) -- Button |
| self = self.obj |
| self.editBox:ClearFocus() |
| if not self:Fire("OnEnterPressed", self.editBox:GetText()) then |
| self.button:Disable() |
| end |
| end |
| local function OnCursorChanged(self, _, y, _, cursorHeight) -- EditBox |
| self, y = self.obj.scrollFrame, -y |
| local offset = self:GetVerticalScroll() |
| if y < offset then |
| self:SetVerticalScroll(y) |
| else |
| y = y + cursorHeight - self:GetHeight() |
| if y > offset then |
| self:SetVerticalScroll(y) |
| end |
| end |
| end |
| local function OnEditFocusLost(self) -- EditBox |
| self:HighlightText(0, 0) |
| end |
| local function OnEnter(self) -- EditBox / ScrollFrame |
| self = self.obj |
| if not self.entered then |
| self.entered = true |
| self:Fire("OnEnter") |
| end |
| end |
| local function OnLeave(self) -- EditBox / ScrollFrame |
| self = self.obj |
| if self.entered then |
| self.entered = nil |
| self:Fire("OnLeave") |
| end |
| end |
| local function OnMouseUp(self) -- ScrollFrame |
| self = self.obj.editBox |
| self:SetFocus() |
| self:SetCursorPosition(self:GetNumLetters()) |
| end |
| local function OnReceiveDrag(self) -- EditBox / ScrollFrame |
| local type, id, info = GetCursorInfo() |
| if type == "spell" then |
| info = GetSpellInfo(id, info) |
| elseif type ~= "item" then |
| return |
| end |
| ClearCursor() |
| self = self.obj |
| local editBox = self.editBox |
| if not editBox:HasFocus() then |
| editBox:SetFocus() |
| editBox:SetCursorPosition(editBox:GetNumLetters()) |
| end |
| editBox:Insert(info) |
| self.button:Enable() |
| end |
| local function OnSizeChanged(self, width, height) -- ScrollFrame |
| self.obj.editBox:SetWidth(width) |
| end |
| local function OnTextChanged(self, userInput) -- EditBox |
| if userInput then |
| self = self.obj |
| self:Fire("OnTextChanged", self.editBox:GetText()) |
| self.button:Enable() |
| end |
| end |
| local function OnTextSet(self) -- EditBox |
| self:HighlightText(0, 0) |
| self:SetCursorPosition(self:GetNumLetters()) |
| self:SetCursorPosition(0) |
| self.obj.button:Disable() |
| end |
| local function OnVerticalScroll(self, offset) -- ScrollFrame |
| local editBox = self.obj.editBox |
| editBox:SetHitRectInsets(0, 0, offset, editBox:GetHeight() - offset - self:GetHeight()) |
| end |
| --[[----------------------------------------------------------------------------- |
| Methods |
| -------------------------------------------------------------------------------]] |
| local methods = { |
| ["OnAcquire"] = function(self) |
| self.editBox:SetText("") |
| self:SetDisabled(false) |
| self:SetWidth(200) |
| self:DisableButton(false) |
| self:SetNumLines() |
| self.entered = nil |
| self:SetMaxLetters(0) |
| end, |
| -- ["OnRelease"] = nil, |
| ["SetDisabled"] = function(self, disabled) |
| local editBox = self.editBox |
| if disabled then |
| editBox:ClearFocus() |
| editBox:EnableMouse(false) |
| editBox:SetTextColor(0.5, 0.5, 0.5) |
| self.label:SetTextColor(0.5, 0.5, 0.5) |
| self.scrollFrame:EnableMouse(false) |
| self.button:Disable() |
| else |
| editBox:EnableMouse(true) |
| editBox:SetTextColor(1, 1, 1) |
| self.label:SetTextColor(1, 0.82, 0) |
| self.scrollFrame:EnableMouse(true) |
| end |
| end, |
| ["SetLabel"] = function(self, text) |
| if text and text ~= "" then |
| self.label:SetText(text) |
| if self.labelHeight ~= 10 then |
| self.labelHeight = 10 |
| self.label:Show() |
| end |
| elseif self.labelHeight ~= 0 then |
| self.labelHeight = 0 |
| self.label:Hide() |
| end |
| Layout(self) |
| end, |
| ["SetNumLines"] = function(self, value) |
| if not value or value < 4 then |
| value = 4 |
| end |
| self.numlines = value |
| Layout(self) |
| end, |
| ["SetText"] = function(self, text) |
| self.editBox:SetText(text) |
| end, |
| ["GetText"] = function(self) |
| return self.editBox:GetText() |
| end, |
| ["SetMaxLetters"] = function (self, num) |
| self.editBox:SetMaxLetters(num or 0) |
| end, |
| ["DisableButton"] = function(self, disabled) |
| self.disablebutton = disabled |
| if disabled then |
| self.button:Hide() |
| else |
| self.button:Show() |
| end |
| Layout(self) |
| end |
| } |
| --[[----------------------------------------------------------------------------- |
| Constructor |
| -------------------------------------------------------------------------------]] |
| local backdrop = { |
| bgFile = [[Interface\Tooltips\UI-Tooltip-Background]], |
| edgeFile = [[Interface\Tooltips\UI-Tooltip-Border]], edgeSize = 16, |
| insets = { left = 4, right = 3, top = 4, bottom = 3 } |
| } |
| local function Constructor() |
| local frame = CreateFrame("Frame", nil, UIParent) |
| frame:Hide() |
| local widgetNum = AceGUI:GetNextWidgetNum(Type) |
| local label = frame:CreateFontString(nil, "OVERLAY", "GameFontNormalSmall") |
| label:SetPoint("TOPLEFT", frame, "TOPLEFT", 0, -4) |
| label:SetPoint("TOPRIGHT", frame, "TOPRIGHT", 0, -4) |
| label:SetJustifyH("LEFT") |
| label:SetText(ACCEPT) |
| label:SetHeight(10) |
| local button = CreateFrame("Button", ("%s%dButton"):format(Type, widgetNum), frame, "UIPanelButtonTemplate2") |
| button:SetPoint("BOTTOMLEFT", 0, 4) |
| button:SetHeight(22) |
| button:SetWidth(label:GetStringWidth() + 24) |
| button:SetText(ACCEPT) |
| button:SetScript("OnClick", OnClick) |
| button:Disable() |
| local text = button:GetFontString() |
| text:ClearAllPoints() |
| text:SetPoint("TOPLEFT", button, "TOPLEFT", 5, -5) |
| text:SetPoint("BOTTOMRIGHT", button, "BOTTOMRIGHT", -5, 1) |
| text:SetJustifyV("MIDDLE") |
| local scrollBG = CreateFrame("Frame", nil, frame) |
| scrollBG:SetBackdrop(backdrop) |
| scrollBG:SetBackdropColor(0, 0, 0) |
| scrollBG:SetBackdropBorderColor(0.4, 0.4, 0.4) |
| local scrollFrame = CreateFrame("ScrollFrame", ("%s%dScrollFrame"):format(Type, widgetNum), frame, "UIPanelScrollFrameTemplate") |
| local scrollBar = _G[scrollFrame:GetName() .. "ScrollBar"] |
| scrollBar:ClearAllPoints() |
| scrollBar:SetPoint("TOP", label, "BOTTOM", 0, -19) |
| scrollBar:SetPoint("BOTTOM", button, "TOP", 0, 18) |
| scrollBar:SetPoint("RIGHT", frame, "RIGHT") |
| scrollBG:SetPoint("TOPRIGHT", scrollBar, "TOPLEFT", 0, 19) |
| scrollBG:SetPoint("BOTTOMLEFT", button, "TOPLEFT") |
| scrollFrame:SetPoint("TOPLEFT", scrollBG, "TOPLEFT", 5, -6) |
| scrollFrame:SetPoint("BOTTOMRIGHT", scrollBG, "BOTTOMRIGHT", -4, 4) |
| scrollFrame:SetScript("OnEnter", OnEnter) |
| scrollFrame:SetScript("OnLeave", OnLeave) |
| scrollFrame:SetScript("OnMouseUp", OnMouseUp) |
| scrollFrame:SetScript("OnReceiveDrag", OnReceiveDrag) |
| scrollFrame:SetScript("OnSizeChanged", OnSizeChanged) |
| scrollFrame:HookScript("OnVerticalScroll", OnVerticalScroll) |
| local editBox = CreateFrame("EditBox", nil, scrollFrame) |
| editBox:SetAllPoints() |
| editBox:SetFontObject(ChatFontNormal) |
| editBox:SetMultiLine(true) |
| editBox:EnableMouse(true) |
| editBox:SetAutoFocus(false) |
| editBox:SetCountInvisibleLetters(false) |
| editBox:SetScript("OnCursorChanged", OnCursorChanged) |
| editBox:SetScript("OnEditFocusLost", OnEditFocusLost) |
| editBox:SetScript("OnEnter", OnEnter) |
| editBox:SetScript("OnEscapePressed", editBox.ClearFocus) |
| editBox:SetScript("OnLeave", OnLeave) |
| editBox:SetScript("OnMouseDown", OnReceiveDrag) |
| editBox:SetScript("OnReceiveDrag", OnReceiveDrag) |
| editBox:SetScript("OnTextChanged", OnTextChanged) |
| editBox:SetScript("OnTextSet", OnTextSet) |
| scrollFrame:SetScrollChild(editBox) |
| local widget = { |
| button = button, |
| editBox = editBox, |
| frame = frame, |
| label = label, |
| labelHeight = 10, |
| numlines = 4, |
| scrollBar = scrollBar, |
| scrollBG = scrollBG, |
| scrollFrame = scrollFrame, |
| type = Type |
| } |
| for method, func in pairs(methods) do |
| widget[method] = func |
| end |
| button.obj, editBox.obj, scrollFrame.obj = widget, widget, widget |
| return AceGUI:RegisterAsWidget(widget) |
| end |
| AceGUI:RegisterWidgetType(Type, Constructor, Version) |
mRunes/Libs/AceGUI-3.0-SharedMediaWidgets/Libs/AceGUI-3.0/widgets/AceGUIWidget-Slider.lua
New file
0,0 → 1,281
| --[[----------------------------------------------------------------------------- |
| Slider Widget |
| Graphical Slider, like, for Range values. |
| -------------------------------------------------------------------------------]] |
| local Type, Version = "Slider", 20 |
| local AceGUI = LibStub and LibStub("AceGUI-3.0", true) |
| if not AceGUI or (AceGUI:GetWidgetVersion(Type) or 0) >= Version then return end |
| -- Lua APIs |
| local min, max, floor = math.min, math.max, math.floor |
| local tonumber, pairs = tonumber, pairs |
| -- WoW APIs |
| local PlaySound = PlaySound |
| local CreateFrame, UIParent = CreateFrame, UIParent |
| -- Global vars/functions that we don't upvalue since they might get hooked, or upgraded |
| -- List them here for Mikk's FindGlobals script |
| -- GLOBALS: GameFontHighlightSmall |
| --[[----------------------------------------------------------------------------- |
| Support functions |
| -------------------------------------------------------------------------------]] |
| local function UpdateText(self) |
| local value = self.value or 0 |
| if self.ispercent then |
| self.editbox:SetText(("%s%%"):format(floor(value * 1000 + 0.5) / 10)) |
| else |
| self.editbox:SetText(floor(value * 100 + 0.5) / 100) |
| end |
| end |
| local function UpdateLabels(self) |
| local min, max = (self.min or 0), (self.max or 100) |
| if self.ispercent then |
| self.lowtext:SetFormattedText("%s%%", (min * 100)) |
| self.hightext:SetFormattedText("%s%%", (max * 100)) |
| else |
| self.lowtext:SetText(min) |
| self.hightext:SetText(max) |
| end |
| end |
| --[[----------------------------------------------------------------------------- |
| Scripts |
| -------------------------------------------------------------------------------]] |
| local function Control_OnEnter(frame) |
| frame.obj:Fire("OnEnter") |
| end |
| local function Control_OnLeave(frame) |
| frame.obj:Fire("OnLeave") |
| end |
| local function Frame_OnMouseDown(frame) |
| frame.obj.slider:EnableMouseWheel(true) |
| AceGUI:ClearFocus() |
| end |
| local function Slider_OnValueChanged(frame) |
| local self = frame.obj |
| if not frame.setup then |
| local newvalue = frame:GetValue() |
| if newvalue ~= self.value and not self.disabled then |
| self.value = newvalue |
| self:Fire("OnValueChanged", newvalue) |
| end |
| if self.value then |
| UpdateText(self) |
| end |
| end |
| end |
| local function Slider_OnMouseUp(frame) |
| local self = frame.obj |
| self:Fire("OnMouseUp", self.value) |
| end |
| local function Slider_OnMouseWheel(frame, v) |
| local self = frame.obj |
| if not self.disabled then |
| local value = self.value |
| if v > 0 then |
| value = min(value + (self.step or 1), self.max) |
| else |
| value = max(value - (self.step or 1), self.min) |
| end |
| self.slider:SetValue(value) |
| end |
| end |
| local function EditBox_OnEscapePressed(frame) |
| frame:ClearFocus() |
| end |
| local function EditBox_OnEnterPressed(frame) |
| local self = frame.obj |
| local value = frame:GetText() |
| if self.ispercent then |
| value = value:gsub('%%', '') |
| value = tonumber(value) / 100 |
| else |
| value = tonumber(value) |
| end |
| if value then |
| PlaySound("igMainMenuOptionCheckBoxOn") |
| self.slider:SetValue(value) |
| self:Fire("OnMouseUp", value) |
| end |
| end |
| local function EditBox_OnEnter(frame) |
| frame:SetBackdropBorderColor(0.5, 0.5, 0.5, 1) |
| end |
| local function EditBox_OnLeave(frame) |
| frame:SetBackdropBorderColor(0.3, 0.3, 0.3, 0.8) |
| end |
| --[[----------------------------------------------------------------------------- |
| Methods |
| -------------------------------------------------------------------------------]] |
| local methods = { |
| ["OnAcquire"] = function(self) |
| self:SetWidth(200) |
| self:SetHeight(44) |
| self:SetDisabled(false) |
| self:SetIsPercent(nil) |
| self:SetSliderValues(0,100,1) |
| self:SetValue(0) |
| self.slider:EnableMouseWheel(false) |
| end, |
| -- ["OnRelease"] = nil, |
| ["SetDisabled"] = function(self, disabled) |
| self.disabled = disabled |
| if disabled then |
| self.slider:EnableMouse(false) |
| self.label:SetTextColor(.5, .5, .5) |
| self.hightext:SetTextColor(.5, .5, .5) |
| self.lowtext:SetTextColor(.5, .5, .5) |
| --self.valuetext:SetTextColor(.5, .5, .5) |
| self.editbox:SetTextColor(.5, .5, .5) |
| self.editbox:EnableMouse(false) |
| self.editbox:ClearFocus() |
| else |
| self.slider:EnableMouse(true) |
| self.label:SetTextColor(1, .82, 0) |
| self.hightext:SetTextColor(1, 1, 1) |
| self.lowtext:SetTextColor(1, 1, 1) |
| --self.valuetext:SetTextColor(1, 1, 1) |
| self.editbox:SetTextColor(1, 1, 1) |
| self.editbox:EnableMouse(true) |
| end |
| end, |
| ["SetValue"] = function(self, value) |
| self.slider.setup = true |
| self.slider:SetValue(value) |
| self.value = value |
| UpdateText(self) |
| self.slider.setup = nil |
| end, |
| ["GetValue"] = function(self) |
| return self.value |
| end, |
| ["SetLabel"] = function(self, text) |
| self.label:SetText(text) |
| end, |
| ["SetSliderValues"] = function(self, min, max, step) |
| local frame = self.slider |
| frame.setup = true |
| self.min = min |
| self.max = max |
| self.step = step |
| frame:SetMinMaxValues(min or 0,max or 100) |
| UpdateLabels(self) |
| frame:SetValueStep(step or 1) |
| if self.value then |
| frame:SetValue(self.value) |
| end |
| frame.setup = nil |
| end, |
| ["SetIsPercent"] = function(self, value) |
| self.ispercent = value |
| UpdateLabels(self) |
| UpdateText(self) |
| end |
| } |
| --[[----------------------------------------------------------------------------- |
| Constructor |
| -------------------------------------------------------------------------------]] |
| local SliderBackdrop = { |
| bgFile = "Interface\\Buttons\\UI-SliderBar-Background", |
| edgeFile = "Interface\\Buttons\\UI-SliderBar-Border", |
| tile = true, tileSize = 8, edgeSize = 8, |
| insets = { left = 3, right = 3, top = 6, bottom = 6 } |
| } |
| local ManualBackdrop = { |
| bgFile = "Interface\\ChatFrame\\ChatFrameBackground", |
| edgeFile = "Interface\\ChatFrame\\ChatFrameBackground", |
| tile = true, edgeSize = 1, tileSize = 5, |
| } |
| local function Constructor() |
| local frame = CreateFrame("Frame", nil, UIParent) |
| frame:EnableMouse(true) |
| frame:SetScript("OnMouseDown", Frame_OnMouseDown) |
| local label = frame:CreateFontString(nil, "OVERLAY", "GameFontNormal") |
| label:SetPoint("TOPLEFT") |
| label:SetPoint("TOPRIGHT") |
| label:SetJustifyH("CENTER") |
| label:SetHeight(15) |
| local slider = CreateFrame("Slider", nil, frame) |
| slider:SetOrientation("HORIZONTAL") |
| slider:SetHeight(15) |
| slider:SetHitRectInsets(0, 0, -10, 0) |
| slider:SetBackdrop(SliderBackdrop) |
| slider:SetThumbTexture("Interface\\Buttons\\UI-SliderBar-Button-Horizontal") |
| slider:SetPoint("TOP", label, "BOTTOM") |
| slider:SetPoint("LEFT", 3, 0) |
| slider:SetPoint("RIGHT", -3, 0) |
| slider:SetValue(0) |
| slider:SetScript("OnValueChanged",Slider_OnValueChanged) |
| slider:SetScript("OnEnter", Control_OnEnter) |
| slider:SetScript("OnLeave", Control_OnLeave) |
| slider:SetScript("OnMouseUp", Slider_OnMouseUp) |
| slider:SetScript("OnMouseWheel", Slider_OnMouseWheel) |
| local lowtext = slider:CreateFontString(nil, "ARTWORK", "GameFontHighlightSmall") |
| lowtext:SetPoint("TOPLEFT", slider, "BOTTOMLEFT", 2, 3) |
| local hightext = slider:CreateFontString(nil, "ARTWORK", "GameFontHighlightSmall") |
| hightext:SetPoint("TOPRIGHT", slider, "BOTTOMRIGHT", -2, 3) |
| local editbox = CreateFrame("EditBox", nil, frame) |
| editbox:SetAutoFocus(false) |
| editbox:SetFontObject(GameFontHighlightSmall) |
| editbox:SetPoint("TOP", slider, "BOTTOM") |
| editbox:SetHeight(14) |
| editbox:SetWidth(70) |
| editbox:SetJustifyH("CENTER") |
| editbox:EnableMouse(true) |
| editbox:SetBackdrop(ManualBackdrop) |
| editbox:SetBackdropColor(0, 0, 0, 0.5) |
| editbox:SetBackdropBorderColor(0.3, 0.3, 0.30, 0.80) |
| editbox:SetScript("OnEnter", EditBox_OnEnter) |
| editbox:SetScript("OnLeave", EditBox_OnLeave) |
| editbox:SetScript("OnEnterPressed", EditBox_OnEnterPressed) |
| editbox:SetScript("OnEscapePressed", EditBox_OnEscapePressed) |
| local widget = { |
| label = label, |
| slider = slider, |
| lowtext = lowtext, |
| hightext = hightext, |
| editbox = editbox, |
| alignoffset = 25, |
| frame = frame, |
| type = Type |
| } |
| for method, func in pairs(methods) do |
| widget[method] = func |
| end |
| slider.obj, editbox.obj = widget, widget |
| return AceGUI:RegisterAsWidget(widget) |
| end |
| AceGUI:RegisterWidgetType(Type,Constructor,Version) |
mRunes/Libs/AceGUI-3.0-SharedMediaWidgets/Libs/AceGUI-3.0/widgets/AceGUIContainer-TabGroup.lua
New file
0,0 → 1,348
| --[[----------------------------------------------------------------------------- |
| TabGroup Container |
| Container that uses tabs on top to switch between groups. |
| -------------------------------------------------------------------------------]] |
| local Type, Version = "TabGroup", 30 |
| local AceGUI = LibStub and LibStub("AceGUI-3.0", true) |
| if not AceGUI or (AceGUI:GetWidgetVersion(Type) or 0) >= Version then return end |
| -- Lua APIs |
| local pairs, ipairs, assert, type, wipe = pairs, ipairs, assert, type, wipe |
| -- WoW APIs |
| local PlaySound = PlaySound |
| local CreateFrame, UIParent = CreateFrame, UIParent |
| local _G = _G |
| -- Global vars/functions that we don't upvalue since they might get hooked, or upgraded |
| -- List them here for Mikk's FindGlobals script |
| -- GLOBALS: PanelTemplates_TabResize, PanelTemplates_SetDisabledTabState, PanelTemplates_SelectTab, PanelTemplates_DeselectTab |
| -- local upvalue storage used by BuildTabs |
| local widths = {} |
| local rowwidths = {} |
| local rowends = {} |
| --[[----------------------------------------------------------------------------- |
| Support functions |
| -------------------------------------------------------------------------------]] |
| local function UpdateTabLook(frame) |
| if frame.disabled then |
| PanelTemplates_SetDisabledTabState(frame) |
| elseif frame.selected then |
| PanelTemplates_SelectTab(frame) |
| else |
| PanelTemplates_DeselectTab(frame) |
| end |
| end |
| local function Tab_SetText(frame, text) |
| frame:_SetText(text) |
| local width = frame.obj.frame.width or frame.obj.frame:GetWidth() or 0 |
| PanelTemplates_TabResize(frame, 0, nil, width) |
| end |
| local function Tab_SetSelected(frame, selected) |
| frame.selected = selected |
| UpdateTabLook(frame) |
| end |
| local function Tab_SetDisabled(frame, disabled) |
| frame.disabled = disabled |
| UpdateTabLook(frame) |
| end |
| local function BuildTabsOnUpdate(frame) |
| local self = frame.obj |
| self:BuildTabs() |
| frame:SetScript("OnUpdate", nil) |
| end |
| --[[----------------------------------------------------------------------------- |
| Scripts |
| -------------------------------------------------------------------------------]] |
| local function Tab_OnClick(frame) |
| if not (frame.selected or frame.disabled) then |
| PlaySound("igCharacterInfoTab") |
| frame.obj:SelectTab(frame.value) |
| end |
| end |
| local function Tab_OnEnter(frame) |
| local self = frame.obj |
| self:Fire("OnTabEnter", self.tabs[frame.id].value, frame) |
| end |
| local function Tab_OnLeave(frame) |
| local self = frame.obj |
| self:Fire("OnTabLeave", self.tabs[frame.id].value, frame) |
| end |
| local function Tab_OnShow(frame) |
| _G[frame:GetName().."HighlightTexture"]:SetWidth(frame:GetTextWidth() + 30) |
| end |
| --[[----------------------------------------------------------------------------- |
| Methods |
| -------------------------------------------------------------------------------]] |
| local methods = { |
| ["OnAcquire"] = function(self) |
| self:SetTitle() |
| end, |
| ["OnRelease"] = function(self) |
| self.status = nil |
| for k in pairs(self.localstatus) do |
| self.localstatus[k] = nil |
| end |
| self.tablist = nil |
| for _, tab in pairs(self.tabs) do |
| tab:Hide() |
| end |
| end, |
| ["CreateTab"] = function(self, id) |
| local tabname = ("AceGUITabGroup%dTab%d"):format(self.num, id) |
| local tab = CreateFrame("Button", tabname, self.border, "OptionsFrameTabButtonTemplate") |
| tab.obj = self |
| tab.id = id |
| tab.text = _G[tabname .. "Text"] |
| tab.text:ClearAllPoints() |
| tab.text:SetPoint("LEFT", 14, -3) |
| tab.text:SetPoint("RIGHT", -12, -3) |
| tab:SetScript("OnClick", Tab_OnClick) |
| tab:SetScript("OnEnter", Tab_OnEnter) |
| tab:SetScript("OnLeave", Tab_OnLeave) |
| tab:SetScript("OnShow", Tab_OnShow) |
| tab._SetText = tab.SetText |
| tab.SetText = Tab_SetText |
| tab.SetSelected = Tab_SetSelected |
| tab.SetDisabled = Tab_SetDisabled |
| return tab |
| end, |
| ["SetTitle"] = function(self, text) |
| self.titletext:SetText(text or "") |
| if text and text ~= "" then |
| self.alignoffset = 25 |
| else |
| self.alignoffset = 18 |
| end |
| self:BuildTabs() |
| end, |
| ["SetStatusTable"] = function(self, status) |
| assert(type(status) == "table") |
| self.status = status |
| end, |
| ["SelectTab"] = function(self, value) |
| local status = self.status or self.localstatus |
| local found |
| for i, v in ipairs(self.tabs) do |
| if v.value == value then |
| v:SetSelected(true) |
| found = true |
| else |
| v:SetSelected(false) |
| end |
| end |
| status.selected = value |
| if found then |
| self:Fire("OnGroupSelected",value) |
| end |
| end, |
| ["SetTabs"] = function(self, tabs) |
| self.tablist = tabs |
| self:BuildTabs() |
| end, |
| ["BuildTabs"] = function(self) |
| local hastitle = (self.titletext:GetText() and self.titletext:GetText() ~= "") |
| local status = self.status or self.localstatus |
| local tablist = self.tablist |
| local tabs = self.tabs |
| if not tablist then return end |
| local width = self.frame.width or self.frame:GetWidth() or 0 |
| wipe(widths) |
| wipe(rowwidths) |
| wipe(rowends) |
| --Place Text into tabs and get thier initial width |
| for i, v in ipairs(tablist) do |
| local tab = tabs[i] |
| if not tab then |
| tab = self:CreateTab(i) |
| tabs[i] = tab |
| end |
| tab:Show() |
| tab:SetText(v.text) |
| tab:SetDisabled(v.disabled) |
| tab.value = v.value |
| widths[i] = tab:GetWidth() - 6 --tabs are anchored 10 pixels from the right side of the previous one to reduce spacing, but add a fixed 4px padding for the text |
| end |
| for i = (#tablist)+1, #tabs, 1 do |
| tabs[i]:Hide() |
| end |
| --First pass, find the minimum number of rows needed to hold all tabs and the initial tab layout |
| local numtabs = #tablist |
| local numrows = 1 |
| local usedwidth = 0 |
| for i = 1, #tablist do |
| --If this is not the first tab of a row and there isn't room for it |
| if usedwidth ~= 0 and (width - usedwidth - widths[i]) < 0 then |
| rowwidths[numrows] = usedwidth + 10 --first tab in each row takes up an extra 10px |
| rowends[numrows] = i - 1 |
| numrows = numrows + 1 |
| usedwidth = 0 |
| end |
| usedwidth = usedwidth + widths[i] |
| end |
| rowwidths[numrows] = usedwidth + 10 --first tab in each row takes up an extra 10px |
| rowends[numrows] = #tablist |
| --Fix for single tabs being left on the last row, move a tab from the row above if applicable |
| if numrows > 1 then |
| --if the last row has only one tab |
| if rowends[numrows-1] == numtabs-1 then |
| --if there are more than 2 tabs in the 2nd last row |
| if (numrows == 2 and rowends[numrows-1] > 2) or (rowends[numrows] - rowends[numrows-1] > 2) then |
| --move 1 tab from the second last row to the last, if there is enough space |
| if (rowwidths[numrows] + widths[numtabs-1]) <= width then |
| rowends[numrows-1] = rowends[numrows-1] - 1 |
| rowwidths[numrows] = rowwidths[numrows] + widths[numtabs-1] |
| rowwidths[numrows-1] = rowwidths[numrows-1] - widths[numtabs-1] |
| end |
| end |
| end |
| end |
| --anchor the rows as defined and resize tabs to fill thier row |
| local starttab = 1 |
| for row, endtab in ipairs(rowends) do |
| local first = true |
| for tabno = starttab, endtab do |
| local tab = tabs[tabno] |
| tab:ClearAllPoints() |
| if first then |
| tab:SetPoint("TOPLEFT", self.frame, "TOPLEFT", 0, -(hastitle and 14 or 7)-(row-1)*20 ) |
| first = false |
| else |
| tab:SetPoint("LEFT", tabs[tabno-1], "RIGHT", -10, 0) |
| end |
| end |
| -- equal padding for each tab to fill the available width, |
| -- if the used space is above 75% already |
| local padding = 0 |
| if not (numrows == 1 and rowwidths[1] < width*0.75) then |
| padding = (width - rowwidths[row]) / (endtab - starttab+1) |
| end |
| for i = starttab, endtab do |
| PanelTemplates_TabResize(tabs[i], padding + 4, nil, width) |
| end |
| starttab = endtab + 1 |
| end |
| self.borderoffset = (hastitle and 17 or 10)+((numrows)*20) |
| self.border:SetPoint("TOPLEFT", 1, -self.borderoffset) |
| end, |
| ["OnWidthSet"] = function(self, width) |
| local content = self.content |
| local contentwidth = width - 60 |
| if contentwidth < 0 then |
| contentwidth = 0 |
| end |
| content:SetWidth(contentwidth) |
| content.width = contentwidth |
| self:BuildTabs(self) |
| self.frame:SetScript("OnUpdate", BuildTabsOnUpdate) |
| end, |
| ["OnHeightSet"] = function(self, height) |
| local content = self.content |
| local contentheight = height - (self.borderoffset + 23) |
| if contentheight < 0 then |
| contentheight = 0 |
| end |
| content:SetHeight(contentheight) |
| content.height = contentheight |
| end, |
| ["LayoutFinished"] = function(self, width, height) |
| if self.noAutoHeight then return end |
| self:SetHeight((height or 0) + (self.borderoffset + 23)) |
| end |
| } |
| --[[----------------------------------------------------------------------------- |
| Constructor |
| -------------------------------------------------------------------------------]] |
| local PaneBackdrop = { |
| bgFile = "Interface\\ChatFrame\\ChatFrameBackground", |
| edgeFile = "Interface\\Tooltips\\UI-Tooltip-Border", |
| tile = true, tileSize = 16, edgeSize = 16, |
| insets = { left = 3, right = 3, top = 5, bottom = 3 } |
| } |
| local function Constructor() |
| local num = AceGUI:GetNextWidgetNum(Type) |
| local frame = CreateFrame("Frame",nil,UIParent) |
| frame:SetHeight(100) |
| frame:SetWidth(100) |
| frame:SetFrameStrata("FULLSCREEN_DIALOG") |
| local titletext = frame:CreateFontString(nil,"OVERLAY","GameFontNormal") |
| titletext:SetPoint("TOPLEFT", 14, 0) |
| titletext:SetPoint("TOPRIGHT", -14, 0) |
| titletext:SetJustifyH("LEFT") |
| titletext:SetHeight(18) |
| titletext:SetText("") |
| local border = CreateFrame("Frame", nil, frame) |
| border:SetPoint("TOPLEFT", 1, -27) |
| border:SetPoint("BOTTOMRIGHT", -1, 3) |
| border:SetBackdrop(PaneBackdrop) |
| border:SetBackdropColor(0.1, 0.1, 0.1, 0.5) |
| border:SetBackdropBorderColor(0.4, 0.4, 0.4) |
| local content = CreateFrame("Frame", nil, border) |
| content:SetPoint("TOPLEFT", 10, -7) |
| content:SetPoint("BOTTOMRIGHT", -10, 7) |
| local widget = { |
| num = num, |
| frame = frame, |
| localstatus = {}, |
| alignoffset = 18, |
| titletext = titletext, |
| border = border, |
| borderoffset = 27, |
| tabs = {}, |
| content = content, |
| type = Type |
| } |
| for method, func in pairs(methods) do |
| widget[method] = func |
| end |
| return AceGUI:RegisterAsContainer(widget) |
| end |
| AceGUI:RegisterWidgetType(Type, Constructor, Version) |
mRunes/Libs/AceGUI-3.0-SharedMediaWidgets/Libs/AceGUI-3.0/widgets/AceGUIWidget-Keybinding.lua
New file
0,0 → 1,232
| --[[----------------------------------------------------------------------------- |
| Keybinding Widget |
| Set Keybindings in the Config UI. |
| -------------------------------------------------------------------------------]] |
| local Type, Version = "Keybinding", 22 |
| local AceGUI = LibStub and LibStub("AceGUI-3.0", true) |
| if not AceGUI or (AceGUI:GetWidgetVersion(Type) or 0) >= Version then return end |
| -- Lua APIs |
| local pairs = pairs |
| -- WoW APIs |
| local IsShiftKeyDown, IsControlKeyDown, IsAltKeyDown = IsShiftKeyDown, IsControlKeyDown, IsAltKeyDown |
| local CreateFrame, UIParent = CreateFrame, UIParent |
| -- Global vars/functions that we don't upvalue since they might get hooked, or upgraded |
| -- List them here for Mikk's FindGlobals script |
| -- GLOBALS: NOT_BOUND |
| --[[----------------------------------------------------------------------------- |
| Scripts |
| -------------------------------------------------------------------------------]] |
| local function Control_OnEnter(frame) |
| frame.obj:Fire("OnEnter") |
| end |
| local function Control_OnLeave(frame) |
| frame.obj:Fire("OnLeave") |
| end |
| local function Keybinding_OnClick(frame, button) |
| if button == "LeftButton" or button == "RightButton" then |
| local self = frame.obj |
| if self.waitingForKey then |
| frame:EnableKeyboard(false) |
| self.msgframe:Hide() |
| frame:UnlockHighlight() |
| self.waitingForKey = nil |
| else |
| frame:EnableKeyboard(true) |
| self.msgframe:Show() |
| frame:LockHighlight() |
| self.waitingForKey = true |
| end |
| end |
| AceGUI:ClearFocus() |
| end |
| local ignoreKeys = { |
| ["BUTTON1"] = true, ["BUTTON2"] = true, |
| ["UNKNOWN"] = true, |
| ["LSHIFT"] = true, ["LCTRL"] = true, ["LALT"] = true, |
| ["RSHIFT"] = true, ["RCTRL"] = true, ["RALT"] = true, |
| } |
| local function Keybinding_OnKeyDown(frame, key) |
| local self = frame.obj |
| if self.waitingForKey then |
| local keyPressed = key |
| if keyPressed == "ESCAPE" then |
| keyPressed = "" |
| else |
| if ignoreKeys[keyPressed] then return end |
| if IsShiftKeyDown() then |
| keyPressed = "SHIFT-"..keyPressed |
| end |
| if IsControlKeyDown() then |
| keyPressed = "CTRL-"..keyPressed |
| end |
| if IsAltKeyDown() then |
| keyPressed = "ALT-"..keyPressed |
| end |
| end |
| frame:EnableKeyboard(false) |
| self.msgframe:Hide() |
| frame:UnlockHighlight() |
| self.waitingForKey = nil |
| if not self.disabled then |
| self:SetKey(keyPressed) |
| self:Fire("OnKeyChanged", keyPressed) |
| end |
| end |
| end |
| local function Keybinding_OnMouseDown(frame, button) |
| if button == "LeftButton" or button == "RightButton" then |
| return |
| elseif button == "MiddleButton" then |
| button = "BUTTON3" |
| elseif button == "Button4" then |
| button = "BUTTON4" |
| elseif button == "Button5" then |
| button = "BUTTON5" |
| end |
| Keybinding_OnKeyDown(frame, button) |
| end |
| --[[----------------------------------------------------------------------------- |
| Methods |
| -------------------------------------------------------------------------------]] |
| local methods = { |
| ["OnAcquire"] = function(self) |
| self:SetWidth(200) |
| self:SetLabel("") |
| self:SetKey("") |
| self.waitingForKey = nil |
| self.msgframe:Hide() |
| self:SetDisabled(false) |
| self.button:EnableKeyboard(false) |
| end, |
| -- ["OnRelease"] = nil, |
| ["SetDisabled"] = function(self, disabled) |
| self.disabled = disabled |
| if disabled then |
| self.button:Disable() |
| self.label:SetTextColor(0.5,0.5,0.5) |
| else |
| self.button:Enable() |
| self.label:SetTextColor(1,1,1) |
| end |
| end, |
| ["SetKey"] = function(self, key) |
| if (key or "") == "" then |
| self.button:SetText(NOT_BOUND) |
| self.button:SetNormalFontObject("GameFontNormal") |
| else |
| self.button:SetText(key) |
| self.button:SetNormalFontObject("GameFontHighlight") |
| end |
| end, |
| ["GetKey"] = function(self) |
| local key = self.button:GetText() |
| if key == NOT_BOUND then |
| key = nil |
| end |
| return key |
| end, |
| ["SetLabel"] = function(self, label) |
| self.label:SetText(label or "") |
| if (label or "") == "" then |
| self.alignoffset = nil |
| self:SetHeight(24) |
| else |
| self.alignoffset = 30 |
| self:SetHeight(44) |
| end |
| end, |
| } |
| --[[----------------------------------------------------------------------------- |
| Constructor |
| -------------------------------------------------------------------------------]] |
| local ControlBackdrop = { |
| bgFile = "Interface\\Tooltips\\UI-Tooltip-Background", |
| edgeFile = "Interface\\Tooltips\\UI-Tooltip-Border", |
| tile = true, tileSize = 16, edgeSize = 16, |
| insets = { left = 3, right = 3, top = 3, bottom = 3 } |
| } |
| local function keybindingMsgFixWidth(frame) |
| frame:SetWidth(frame.msg:GetWidth() + 10) |
| frame:SetScript("OnUpdate", nil) |
| end |
| local function Constructor() |
| local name = "AceGUI30KeybindingButton" .. AceGUI:GetNextWidgetNum(Type) |
| local frame = CreateFrame("Frame", nil, UIParent) |
| local button = CreateFrame("Button", name, frame, "UIPanelButtonTemplate2") |
| button:EnableMouse(true) |
| button:RegisterForClicks("AnyDown") |
| button:SetScript("OnEnter", Control_OnEnter) |
| button:SetScript("OnLeave", Control_OnLeave) |
| button:SetScript("OnClick", Keybinding_OnClick) |
| button:SetScript("OnKeyDown", Keybinding_OnKeyDown) |
| button:SetScript("OnMouseDown", Keybinding_OnMouseDown) |
| button:SetPoint("BOTTOMLEFT") |
| button:SetPoint("BOTTOMRIGHT") |
| button:SetHeight(24) |
| button:EnableKeyboard(false) |
| local text = button:GetFontString() |
| text:SetPoint("LEFT", 7, 0) |
| text:SetPoint("RIGHT", -7, 0) |
| local label = frame:CreateFontString(nil, "OVERLAY", "GameFontHighlight") |
| label:SetPoint("TOPLEFT") |
| label:SetPoint("TOPRIGHT") |
| label:SetJustifyH("CENTER") |
| label:SetHeight(18) |
| local msgframe = CreateFrame("Frame", nil, UIParent) |
| msgframe:SetHeight(30) |
| msgframe:SetBackdrop(ControlBackdrop) |
| msgframe:SetBackdropColor(0,0,0) |
| msgframe:SetFrameStrata("FULLSCREEN_DIALOG") |
| msgframe:SetFrameLevel(1000) |
| local msg = msgframe:CreateFontString(nil, "OVERLAY", "GameFontNormal") |
| msg:SetText("Press a key to bind, ESC to clear the binding or click the button again to cancel.") |
| msgframe.msg = msg |
| msg:SetPoint("TOPLEFT", 5, -5) |
| msgframe:SetScript("OnUpdate", keybindingMsgFixWidth) |
| msgframe:SetPoint("BOTTOM", button, "TOP") |
| msgframe:Hide() |
| local widget = { |
| button = button, |
| label = label, |
| msgframe = msgframe, |
| frame = frame, |
| alignoffset = 30, |
| type = Type |
| } |
| for method, func in pairs(methods) do |
| widget[method] = func |
| end |
| button.obj = widget |
| return AceGUI:RegisterAsWidget(widget) |
| end |
| AceGUI:RegisterWidgetType(Type, Constructor, Version) |
mRunes/Libs/AceGUI-3.0-SharedMediaWidgets/Libs/AceGUI-3.0/widgets/AceGUIWidget-CheckBox.lua
New file
0,0 → 1,289
| --[[----------------------------------------------------------------------------- |
| Checkbox Widget |
| -------------------------------------------------------------------------------]] |
| local Type, Version = "CheckBox", 21 |
| local AceGUI = LibStub and LibStub("AceGUI-3.0", true) |
| if not AceGUI or (AceGUI:GetWidgetVersion(Type) or 0) >= Version then return end |
| -- Lua APIs |
| local select, pairs = select, pairs |
| -- WoW APIs |
| local PlaySound = PlaySound |
| local CreateFrame, UIParent = CreateFrame, UIParent |
| -- Global vars/functions that we don't upvalue since they might get hooked, or upgraded |
| -- List them here for Mikk's FindGlobals script |
| -- GLOBALS: SetDesaturation, GameFontHighlight |
| --[[----------------------------------------------------------------------------- |
| Support functions |
| -------------------------------------------------------------------------------]] |
| local function AlignImage(self) |
| local img = self.image:GetTexture() |
| self.text:ClearAllPoints() |
| if not img then |
| self.text:SetPoint("LEFT", self.checkbg, "RIGHT") |
| self.text:SetPoint("RIGHT") |
| else |
| self.text:SetPoint("LEFT", self.image,"RIGHT", 1, 0) |
| self.text:SetPoint("RIGHT") |
| end |
| end |
| --[[----------------------------------------------------------------------------- |
| Scripts |
| -------------------------------------------------------------------------------]] |
| local function Control_OnEnter(frame) |
| frame.obj:Fire("OnEnter") |
| end |
| local function Control_OnLeave(frame) |
| frame.obj:Fire("OnLeave") |
| end |
| local function CheckBox_OnMouseDown(frame) |
| local self = frame.obj |
| if not self.disabled then |
| if self.image:GetTexture() then |
| self.text:SetPoint("LEFT", self.image,"RIGHT", 2, -1) |
| else |
| self.text:SetPoint("LEFT", self.checkbg, "RIGHT", 1, -1) |
| end |
| end |
| AceGUI:ClearFocus() |
| end |
| local function CheckBox_OnMouseUp(frame) |
| local self = frame.obj |
| if not self.disabled then |
| self:ToggleChecked() |
| if self.checked then |
| PlaySound("igMainMenuOptionCheckBoxOn") |
| else -- for both nil and false (tristate) |
| PlaySound("igMainMenuOptionCheckBoxOff") |
| end |
| self:Fire("OnValueChanged", self.checked) |
| AlignImage(self) |
| end |
| end |
| --[[----------------------------------------------------------------------------- |
| Methods |
| -------------------------------------------------------------------------------]] |
| local methods = { |
| ["OnAcquire"] = function(self) |
| self:SetType() |
| self:SetValue(false) |
| self:SetTriState(nil) |
| -- height is calculated from the width and required space for the description |
| self:SetWidth(200) |
| self:SetImage() |
| self:SetDisabled(nil) |
| self:SetDescription(nil) |
| end, |
| -- ["OnRelease"] = nil, |
| ["OnWidthSet"] = function(self, width) |
| if self.desc then |
| self.desc:SetWidth(width - 30) |
| if self.desc:GetText() and self.desc:GetText() ~= "" then |
| self:SetHeight(28 + self.desc:GetHeight()) |
| end |
| end |
| end, |
| ["SetDisabled"] = function(self, disabled) |
| self.disabled = disabled |
| if disabled then |
| self.frame:Disable() |
| self.text:SetTextColor(0.5, 0.5, 0.5) |
| SetDesaturation(self.check, true) |
| else |
| self.frame:Enable() |
| self.text:SetTextColor(1, 1, 1) |
| if self.tristate and self.checked == nil then |
| SetDesaturation(self.check, true) |
| else |
| SetDesaturation(self.check, false) |
| end |
| end |
| end, |
| ["SetValue"] = function(self,value) |
| local check = self.check |
| self.checked = value |
| if value then |
| SetDesaturation(self.check, false) |
| self.check:Show() |
| else |
| --Nil is the unknown tristate value |
| if self.tristate and value == nil then |
| SetDesaturation(self.check, true) |
| self.check:Show() |
| else |
| SetDesaturation(self.check, false) |
| self.check:Hide() |
| end |
| end |
| self:SetDisabled(self.disabled) |
| end, |
| ["GetValue"] = function(self) |
| return self.checked |
| end, |
| ["SetTriState"] = function(self, enabled) |
| self.tristate = enabled |
| self:SetValue(self:GetValue()) |
| end, |
| ["SetType"] = function(self, type) |
| local checkbg = self.checkbg |
| local check = self.check |
| local highlight = self.highlight |
| local size |
| if type == "radio" then |
| size = 16 |
| checkbg:SetTexture("Interface\\Buttons\\UI-RadioButton") |
| checkbg:SetTexCoord(0, 0.25, 0, 1) |
| check:SetTexture("Interface\\Buttons\\UI-RadioButton") |
| check:SetTexCoord(0.25, 0.5, 0, 1) |
| check:SetBlendMode("ADD") |
| highlight:SetTexture("Interface\\Buttons\\UI-RadioButton") |
| highlight:SetTexCoord(0.5, 0.75, 0, 1) |
| else |
| size = 24 |
| checkbg:SetTexture("Interface\\Buttons\\UI-CheckBox-Up") |
| checkbg:SetTexCoord(0, 1, 0, 1) |
| check:SetTexture("Interface\\Buttons\\UI-CheckBox-Check") |
| check:SetTexCoord(0, 1, 0, 1) |
| check:SetBlendMode("BLEND") |
| highlight:SetTexture("Interface\\Buttons\\UI-CheckBox-Highlight") |
| highlight:SetTexCoord(0, 1, 0, 1) |
| end |
| checkbg:SetHeight(size) |
| checkbg:SetWidth(size) |
| end, |
| ["ToggleChecked"] = function(self) |
| local value = self:GetValue() |
| if self.tristate then |
| --cycle in true, nil, false order |
| if value then |
| self:SetValue(nil) |
| elseif value == nil then |
| self:SetValue(false) |
| else |
| self:SetValue(true) |
| end |
| else |
| self:SetValue(not self:GetValue()) |
| end |
| end, |
| ["SetLabel"] = function(self, label) |
| self.text:SetText(label) |
| end, |
| ["SetDescription"] = function(self, desc) |
| if desc then |
| if not self.desc then |
| local desc = self.frame:CreateFontString(nil, "OVERLAY", "GameFontHighlightSmall") |
| desc:ClearAllPoints() |
| desc:SetPoint("TOPLEFT", self.checkbg, "TOPRIGHT", 5, -21) |
| desc:SetWidth(self.frame.width - 30) |
| desc:SetJustifyH("LEFT") |
| desc:SetJustifyV("TOP") |
| self.desc = desc |
| end |
| self.desc:Show() |
| --self.text:SetFontObject(GameFontNormal) |
| self.desc:SetText(desc) |
| self:SetHeight(28 + self.desc:GetHeight()) |
| else |
| if self.desc then |
| self.desc:SetText("") |
| self.desc:Hide() |
| end |
| --self.text:SetFontObject(GameFontHighlight) |
| self:SetHeight(24) |
| end |
| end, |
| ["SetImage"] = function(self, path, ...) |
| local image = self.image |
| image:SetTexture(path) |
| if image:GetTexture() then |
| local n = select("#", ...) |
| if n == 4 or n == 8 then |
| image:SetTexCoord(...) |
| else |
| image:SetTexCoord(0, 1, 0, 1) |
| end |
| end |
| AlignImage(self) |
| end |
| } |
| --[[----------------------------------------------------------------------------- |
| Constructor |
| -------------------------------------------------------------------------------]] |
| local function Constructor() |
| local frame = CreateFrame("Button", nil, UIParent) |
| frame:Hide() |
| frame:EnableMouse(true) |
| frame:SetScript("OnEnter", Control_OnEnter) |
| frame:SetScript("OnLeave", Control_OnLeave) |
| frame:SetScript("OnMouseDown", CheckBox_OnMouseDown) |
| frame:SetScript("OnMouseUp", CheckBox_OnMouseUp) |
| local checkbg = frame:CreateTexture(nil, "ARTWORK") |
| checkbg:SetWidth(24) |
| checkbg:SetHeight(24) |
| checkbg:SetPoint("TOPLEFT") |
| checkbg:SetTexture("Interface\\Buttons\\UI-CheckBox-Up") |
| local check = frame:CreateTexture(nil, "OVERLAY") |
| check:SetAllPoints(checkbg) |
| check:SetTexture("Interface\\Buttons\\UI-CheckBox-Check") |
| local text = frame:CreateFontString(nil, "OVERLAY", "GameFontHighlight") |
| text:SetJustifyH("LEFT") |
| text:SetHeight(18) |
| text:SetPoint("LEFT", checkbg, "RIGHT") |
| text:SetPoint("RIGHT") |
| local highlight = frame:CreateTexture(nil, "HIGHLIGHT") |
| highlight:SetTexture("Interface\\Buttons\\UI-CheckBox-Highlight") |
| highlight:SetBlendMode("ADD") |
| highlight:SetAllPoints(checkbg) |
| local image = frame:CreateTexture(nil, "OVERLAY") |
| image:SetHeight(16) |
| image:SetWidth(16) |
| image:SetPoint("LEFT", checkbg, "RIGHT", 1, 0) |
| local widget = { |
| checkbg = checkbg, |
| check = check, |
| text = text, |
| highlight = highlight, |
| image = image, |
| frame = frame, |
| type = Type |
| } |
| for method, func in pairs(methods) do |
| widget[method] = func |
| end |
| return AceGUI:RegisterAsWidget(widget) |
| end |
| AceGUI:RegisterWidgetType(Type, Constructor, Version) |
mRunes/Libs/AceGUI-3.0-SharedMediaWidgets/Libs/AceGUI-3.0/widgets/AceGUIWidget-Icon.lua
New file
0,0 → 1,144
| --[[----------------------------------------------------------------------------- |
| Icon Widget |
| -------------------------------------------------------------------------------]] |
| local Type, Version = "Icon", 20 |
| local AceGUI = LibStub and LibStub("AceGUI-3.0", true) |
| if not AceGUI or (AceGUI:GetWidgetVersion(Type) or 0) >= Version then return end |
| -- Lua APIs |
| local select, pairs, print = select, pairs, print |
| -- WoW APIs |
| local CreateFrame, UIParent, GetBuildInfo = CreateFrame, UIParent, GetBuildInfo |
| --[[----------------------------------------------------------------------------- |
| Scripts |
| -------------------------------------------------------------------------------]] |
| local function Control_OnEnter(frame) |
| frame.obj:Fire("OnEnter") |
| end |
| local function Control_OnLeave(frame) |
| frame.obj:Fire("OnLeave") |
| end |
| local function Button_OnClick(frame, button) |
| frame.obj:Fire("OnClick", button) |
| AceGUI:ClearFocus() |
| end |
| --[[----------------------------------------------------------------------------- |
| Methods |
| -------------------------------------------------------------------------------]] |
| local methods = { |
| ["OnAcquire"] = function(self) |
| self:SetHeight(110) |
| self:SetWidth(110) |
| self:SetLabel() |
| self:SetImage(nil) |
| self:SetImageSize(64, 64) |
| self:SetDisabled(false) |
| end, |
| -- ["OnRelease"] = nil, |
| ["SetLabel"] = function(self, text) |
| if text and text ~= "" then |
| self.label:Show() |
| self.label:SetText(text) |
| self:SetHeight(self.image:GetHeight() + 25) |
| else |
| self.label:Hide() |
| self:SetHeight(self.image:GetHeight() + 10) |
| end |
| end, |
| ["SetImage"] = function(self, path, ...) |
| local image = self.image |
| image:SetTexture(path) |
| if image:GetTexture() then |
| local n = select("#", ...) |
| if n == 4 or n == 8 then |
| image:SetTexCoord(...) |
| else |
| image:SetTexCoord(0, 1, 0, 1) |
| end |
| end |
| end, |
| ["SetImageSize"] = function(self, width, height) |
| self.image:SetWidth(width) |
| self.image:SetHeight(height) |
| --self.frame:SetWidth(width + 30) |
| if self.label:IsShown() then |
| self:SetHeight(height + 25) |
| else |
| self:SetHeight(height + 10) |
| end |
| end, |
| ["SetDisabled"] = function(self, disabled) |
| self.disabled = disabled |
| if disabled then |
| self.frame:Disable() |
| self.label:SetTextColor(0.5, 0.5, 0.5) |
| self.image:SetVertexColor(0.5, 0.5, 0.5, 0.5) |
| else |
| self.frame:Enable() |
| self.label:SetTextColor(1, 1, 1) |
| self.image:SetVertexColor(1, 1, 1) |
| end |
| end |
| } |
| --[[----------------------------------------------------------------------------- |
| Constructor |
| -------------------------------------------------------------------------------]] |
| local function Constructor() |
| local frame = CreateFrame("Button", nil, UIParent) |
| frame:Hide() |
| frame:EnableMouse(true) |
| frame:SetScript("OnEnter", Control_OnEnter) |
| frame:SetScript("OnLeave", Control_OnLeave) |
| frame:SetScript("OnClick", Button_OnClick) |
| local label = frame:CreateFontString(nil, "BACKGROUND", "GameFontHighlight") |
| label:SetPoint("BOTTOMLEFT") |
| label:SetPoint("BOTTOMRIGHT") |
| label:SetJustifyH("CENTER") |
| label:SetJustifyV("TOP") |
| label:SetHeight(18) |
| local image = frame:CreateTexture(nil, "BACKGROUND") |
| image:SetWidth(64) |
| image:SetHeight(64) |
| image:SetPoint("TOP", 0, -5) |
| local highlight = frame:CreateTexture(nil, "HIGHLIGHT") |
| highlight:SetAllPoints(image) |
| highlight:SetTexture("Interface\\PaperDollInfoFrame\\UI-Character-Tab-Highlight") |
| highlight:SetTexCoord(0, 1, 0.23, 0.77) |
| highlight:SetBlendMode("ADD") |
| local widget = { |
| label = label, |
| image = image, |
| frame = frame, |
| type = Type |
| } |
| for method, func in pairs(methods) do |
| widget[method] = func |
| end |
| -- SetText is deprecated, but keep it around for a while. (say, to WoW 4.0) |
| if (select(4, GetBuildInfo()) < 40000) then |
| widget.SetText = widget.SetLabel |
| else |
| widget.SetText = function(self, ...) print("AceGUI-3.0-Icon: SetText is deprecated! Use SetLabel instead!"); self:SetLabel(...) end |
| end |
| return AceGUI:RegisterAsWidget(widget) |
| end |
| AceGUI:RegisterWidgetType(Type, Constructor, Version) |
mRunes/Libs/AceGUI-3.0-SharedMediaWidgets/Libs/AceGUI-3.0/widgets/AceGUIContainer-BlizOptionsGroup.lua
New file
0,0 → 1,133
| --[[----------------------------------------------------------------------------- |
| BlizOptionsGroup Container |
| Simple container widget for the integration of AceGUI into the Blizzard Interface Options |
| -------------------------------------------------------------------------------]] |
| local Type, Version = "BlizOptionsGroup", 20 |
| local AceGUI = LibStub and LibStub("AceGUI-3.0", true) |
| if not AceGUI or (AceGUI:GetWidgetVersion(Type) or 0) >= Version then return end |
| -- Lua APIs |
| local pairs = pairs |
| -- WoW APIs |
| local CreateFrame = CreateFrame |
| --[[----------------------------------------------------------------------------- |
| Scripts |
| -------------------------------------------------------------------------------]] |
| local function OnShow(frame) |
| frame.obj:Fire("OnShow") |
| end |
| local function OnHide(frame) |
| frame.obj:Fire("OnHide") |
| end |
| --[[----------------------------------------------------------------------------- |
| Support functions |
| -------------------------------------------------------------------------------]] |
| local function okay(frame) |
| frame.obj:Fire("okay") |
| end |
| local function cancel(frame) |
| frame.obj:Fire("cancel") |
| end |
| local function defaults(frame) |
| frame.obj:Fire("defaults") |
| end |
| --[[----------------------------------------------------------------------------- |
| Methods |
| -------------------------------------------------------------------------------]] |
| local methods = { |
| ["OnAcquire"] = function(self) |
| self:SetName() |
| self:SetTitle() |
| end, |
| -- ["OnRelease"] = nil, |
| ["OnWidthSet"] = function(self, width) |
| local content = self.content |
| local contentwidth = width - 63 |
| if contentwidth < 0 then |
| contentwidth = 0 |
| end |
| content:SetWidth(contentwidth) |
| content.width = contentwidth |
| end, |
| ["OnHeightSet"] = function(self, height) |
| local content = self.content |
| local contentheight = height - 26 |
| if contentheight < 0 then |
| contentheight = 0 |
| end |
| content:SetHeight(contentheight) |
| content.height = contentheight |
| end, |
| ["SetName"] = function(self, name, parent) |
| self.frame.name = name |
| self.frame.parent = parent |
| end, |
| ["SetTitle"] = function(self, title) |
| local content = self.content |
| content:ClearAllPoints() |
| if not title or title == "" then |
| content:SetPoint("TOPLEFT", 10, -10) |
| self.label:SetText("") |
| else |
| content:SetPoint("TOPLEFT", 10, -40) |
| self.label:SetText(title) |
| end |
| content:SetPoint("BOTTOMRIGHT", -10, 10) |
| end |
| } |
| --[[----------------------------------------------------------------------------- |
| Constructor |
| -------------------------------------------------------------------------------]] |
| local function Constructor() |
| local frame = CreateFrame("Frame") |
| frame:Hide() |
| -- support functions for the Blizzard Interface Options |
| frame.okay = okay |
| frame.cancel = cancel |
| frame.defaults = defaults |
| frame:SetScript("OnHide", OnHide) |
| frame:SetScript("OnShow", OnShow) |
| local label = frame:CreateFontString(nil, "OVERLAY", "GameFontNormalLarge") |
| label:SetPoint("TOPLEFT", 10, -15) |
| label:SetPoint("BOTTOMRIGHT", frame, "TOPRIGHT", 10, -45) |
| label:SetJustifyH("LEFT") |
| label:SetJustifyV("TOP") |
| --Container Support |
| local content = CreateFrame("Frame", nil, frame) |
| content:SetPoint("TOPLEFT", 10, -10) |
| content:SetPoint("BOTTOMRIGHT", -10, 10) |
| local widget = { |
| label = label, |
| frame = frame, |
| content = content, |
| type = Type |
| } |
| for method, func in pairs(methods) do |
| widget[method] = func |
| end |
| return AceGUI:RegisterAsContainer(widget) |
| end |
| AceGUI:RegisterWidgetType(Type, Constructor, Version) |
mRunes/Libs/AceGUI-3.0-SharedMediaWidgets/Libs/AceGUI-3.0/widgets/AceGUIContainer-Frame.lua
New file
0,0 → 1,298
| --[[----------------------------------------------------------------------------- |
| Frame Container |
| -------------------------------------------------------------------------------]] |
| local Type, Version = "Frame", 21 |
| local AceGUI = LibStub and LibStub("AceGUI-3.0", true) |
| if not AceGUI or (AceGUI:GetWidgetVersion(Type) or 0) >= Version then return end |
| -- Lua APIs |
| local pairs, assert, type = pairs, assert, type |
| local wipe = table.wipe |
| -- WoW APIs |
| local PlaySound = PlaySound |
| local CreateFrame, UIParent = CreateFrame, UIParent |
| -- Global vars/functions that we don't upvalue since they might get hooked, or upgraded |
| -- List them here for Mikk's FindGlobals script |
| -- GLOBALS: CLOSE |
| --[[----------------------------------------------------------------------------- |
| Scripts |
| -------------------------------------------------------------------------------]] |
| local function Button_OnClick(frame) |
| PlaySound("gsTitleOptionExit") |
| frame.obj:Hide() |
| end |
| local function Frame_OnClose(frame) |
| frame.obj:Fire("OnClose") |
| end |
| local function Frame_OnMouseDown(frame) |
| AceGUI:ClearFocus() |
| end |
| local function Title_OnMouseDown(frame) |
| frame:GetParent():StartMoving() |
| AceGUI:ClearFocus() |
| end |
| local function MoverSizer_OnMouseUp(mover) |
| local frame = mover:GetParent() |
| frame:StopMovingOrSizing() |
| local self = frame.obj |
| local status = self.status or self.localstatus |
| status.width = frame:GetWidth() |
| status.height = frame:GetHeight() |
| status.top = frame:GetTop() |
| status.left = frame:GetLeft() |
| end |
| local function SizerSE_OnMouseDown(frame) |
| frame:GetParent():StartSizing("BOTTOMRIGHT") |
| AceGUI:ClearFocus() |
| end |
| local function SizerS_OnMouseDown(frame) |
| frame:GetParent():StartSizing("BOTTOM") |
| AceGUI:ClearFocus() |
| end |
| local function SizerE_OnMouseDown(frame) |
| frame:GetParent():StartSizing("RIGHT") |
| AceGUI:ClearFocus() |
| end |
| local function StatusBar_OnEnter(frame) |
| frame.obj:Fire("OnEnterStatusBar") |
| end |
| local function StatusBar_OnLeave(frame) |
| frame.obj:Fire("OnLeaveStatusBar") |
| end |
| --[[----------------------------------------------------------------------------- |
| Methods |
| -------------------------------------------------------------------------------]] |
| local methods = { |
| ["OnAcquire"] = function(self) |
| self.frame:SetParent(UIParent) |
| self.frame:SetFrameStrata("FULLSCREEN_DIALOG") |
| self:SetTitle() |
| self:SetStatusText() |
| self:ApplyStatus() |
| self:Show() |
| end, |
| ["OnRelease"] = function(self) |
| self.status = nil |
| wipe(self.localstatus) |
| end, |
| ["OnWidthSet"] = function(self, width) |
| local content = self.content |
| local contentwidth = width - 34 |
| if contentwidth < 0 then |
| contentwidth = 0 |
| end |
| content:SetWidth(contentwidth) |
| content.width = contentwidth |
| end, |
| ["OnHeightSet"] = function(self, height) |
| local content = self.content |
| local contentheight = height - 57 |
| if contentheight < 0 then |
| contentheight = 0 |
| end |
| content:SetHeight(contentheight) |
| content.height = contentheight |
| end, |
| ["SetTitle"] = function(self, title) |
| self.titletext:SetText(title) |
| end, |
| ["SetStatusText"] = function(self, text) |
| self.statustext:SetText(text) |
| end, |
| ["Hide"] = function(self) |
| self.frame:Hide() |
| end, |
| ["Show"] = function(self) |
| self.frame:Show() |
| end, |
| -- called to set an external table to store status in |
| ["SetStatusTable"] = function(self, status) |
| assert(type(status) == "table") |
| self.status = status |
| self:ApplyStatus() |
| end, |
| ["ApplyStatus"] = function(self) |
| local status = self.status or self.localstatus |
| local frame = self.frame |
| self:SetWidth(status.width or 700) |
| self:SetHeight(status.height or 500) |
| frame:ClearAllPoints() |
| if status.top and status.left then |
| frame:SetPoint("TOP", UIParent, "BOTTOM", 0, status.top) |
| frame:SetPoint("LEFT", UIParent, "LEFT", status.left, 0) |
| else |
| frame:SetPoint("CENTER") |
| end |
| end |
| } |
| --[[----------------------------------------------------------------------------- |
| Constructor |
| -------------------------------------------------------------------------------]] |
| local FrameBackdrop = { |
| bgFile = "Interface\\DialogFrame\\UI-DialogBox-Background", |
| edgeFile = "Interface\\DialogFrame\\UI-DialogBox-Border", |
| tile = true, tileSize = 32, edgeSize = 32, |
| insets = { left = 8, right = 8, top = 8, bottom = 8 } |
| } |
| local PaneBackdrop = { |
| bgFile = "Interface\\ChatFrame\\ChatFrameBackground", |
| edgeFile = "Interface\\Tooltips\\UI-Tooltip-Border", |
| tile = true, tileSize = 16, edgeSize = 16, |
| insets = { left = 3, right = 3, top = 5, bottom = 3 } |
| } |
| local function Constructor() |
| local frame = CreateFrame("Frame", nil, UIParent) |
| frame:Hide() |
| frame:EnableMouse(true) |
| frame:SetMovable(true) |
| frame:SetResizable(true) |
| frame:SetFrameStrata("FULLSCREEN_DIALOG") |
| frame:SetBackdrop(FrameBackdrop) |
| frame:SetBackdropColor(0, 0, 0, 1) |
| frame:SetMinResize(400, 200) |
| frame:SetToplevel(true) |
| frame:SetScript("OnHide", Frame_OnClose) |
| frame:SetScript("OnMouseDown", Frame_OnMouseDown) |
| local closebutton = CreateFrame("Button", nil, frame, "UIPanelButtonTemplate") |
| closebutton:SetScript("OnClick", Button_OnClick) |
| closebutton:SetPoint("BOTTOMRIGHT", -27, 17) |
| closebutton:SetHeight(20) |
| closebutton:SetWidth(100) |
| closebutton:SetText(CLOSE) |
| local statusbg = CreateFrame("Button", nil, frame) |
| statusbg:SetPoint("BOTTOMLEFT", 15, 15) |
| statusbg:SetPoint("BOTTOMRIGHT", -132, 15) |
| statusbg:SetHeight(24) |
| statusbg:SetBackdrop(PaneBackdrop) |
| statusbg:SetBackdropColor(0.1,0.1,0.1) |
| statusbg:SetBackdropBorderColor(0.4,0.4,0.4) |
| statusbg:SetScript("OnEnter", StatusBar_OnEnter) |
| statusbg:SetScript("OnLeave", StatusBar_OnLeave) |
| local statustext = statusbg:CreateFontString(nil, "OVERLAY", "GameFontNormal") |
| statustext:SetPoint("TOPLEFT", 7, -2) |
| statustext:SetPoint("BOTTOMRIGHT", -7, 2) |
| statustext:SetHeight(20) |
| statustext:SetJustifyH("LEFT") |
| statustext:SetText("") |
| local titlebg = frame:CreateTexture(nil, "OVERLAY") |
| titlebg:SetTexture("Interface\\DialogFrame\\UI-DialogBox-Header") |
| titlebg:SetTexCoord(0.31, 0.67, 0, 0.63) |
| titlebg:SetPoint("TOP", 0, 12) |
| titlebg:SetWidth(100) |
| titlebg:SetHeight(40) |
| local title = CreateFrame("Frame", nil, frame) |
| title:EnableMouse(true) |
| title:SetScript("OnMouseDown", Title_OnMouseDown) |
| title:SetScript("OnMouseUp", MoverSizer_OnMouseUp) |
| title:SetAllPoints(titlebg) |
| local titletext = title:CreateFontString(nil, "OVERLAY", "GameFontNormal") |
| titletext:SetPoint("TOP", titlebg, "TOP", 0, -14) |
| local titlebg_l = frame:CreateTexture(nil, "OVERLAY") |
| titlebg_l:SetTexture("Interface\\DialogFrame\\UI-DialogBox-Header") |
| titlebg_l:SetTexCoord(0.21, 0.31, 0, 0.63) |
| titlebg_l:SetPoint("RIGHT", titlebg, "LEFT") |
| titlebg_l:SetWidth(30) |
| titlebg_l:SetHeight(40) |
| local titlebg_r = frame:CreateTexture(nil, "OVERLAY") |
| titlebg_r:SetTexture("Interface\\DialogFrame\\UI-DialogBox-Header") |
| titlebg_r:SetTexCoord(0.67, 0.77, 0, 0.63) |
| titlebg_r:SetPoint("LEFT", titlebg, "RIGHT") |
| titlebg_r:SetWidth(30) |
| titlebg_r:SetHeight(40) |
| local sizer_se = CreateFrame("Frame", nil, frame) |
| sizer_se:SetPoint("BOTTOMRIGHT") |
| sizer_se:SetWidth(25) |
| sizer_se:SetHeight(25) |
| sizer_se:EnableMouse() |
| sizer_se:SetScript("OnMouseDown",SizerSE_OnMouseDown) |
| sizer_se:SetScript("OnMouseUp", MoverSizer_OnMouseUp) |
| local line1 = sizer_se:CreateTexture(nil, "BACKGROUND") |
| line1:SetWidth(14) |
| line1:SetHeight(14) |
| line1:SetPoint("BOTTOMRIGHT", -8, 8) |
| line1:SetTexture("Interface\\Tooltips\\UI-Tooltip-Border") |
| local x = 0.1 * 14/17 |
| line1:SetTexCoord(0.05 - x, 0.5, 0.05, 0.5 + x, 0.05, 0.5 - x, 0.5 + x, 0.5) |
| local line2 = sizer_se:CreateTexture(nil, "BACKGROUND") |
| line2:SetWidth(8) |
| line2:SetHeight(8) |
| line2:SetPoint("BOTTOMRIGHT", -8, 8) |
| line2:SetTexture("Interface\\Tooltips\\UI-Tooltip-Border") |
| local x = 0.1 * 8/17 |
| line2:SetTexCoord(0.05 - x, 0.5, 0.05, 0.5 + x, 0.05, 0.5 - x, 0.5 + x, 0.5) |
| local sizer_s = CreateFrame("Frame", nil, frame) |
| sizer_s:SetPoint("BOTTOMRIGHT", -25, 0) |
| sizer_s:SetPoint("BOTTOMLEFT") |
| sizer_s:SetHeight(25) |
| sizer_s:EnableMouse(true) |
| sizer_s:SetScript("OnMouseDown", SizerS_OnMouseDown) |
| sizer_s:SetScript("OnMouseUp", MoverSizer_OnMouseUp) |
| local sizer_e = CreateFrame("Frame", nil, frame) |
| sizer_e:SetPoint("BOTTOMRIGHT", 0, 25) |
| sizer_e:SetPoint("TOPRIGHT") |
| sizer_e:SetWidth(25) |
| sizer_e:EnableMouse(true) |
| sizer_e:SetScript("OnMouseDown", SizerE_OnMouseDown) |
| sizer_e:SetScript("OnMouseUp", MoverSizer_OnMouseUp) |
| --Container Support |
| local content = CreateFrame("Frame", nil, frame) |
| content:SetPoint("TOPLEFT", 17, -27) |
| content:SetPoint("BOTTOMRIGHT", -17, 40) |
| local widget = { |
| localstatus = {}, |
| titletext = titletext, |
| statustext = statustext, |
| content = content, |
| frame = frame, |
| type = Type |
| } |
| for method, func in pairs(methods) do |
| widget[method] = func |
| end |
| closebutton.obj, statusbg.obj = widget, widget |
| return AceGUI:RegisterAsContainer(widget) |
| end |
| AceGUI:RegisterWidgetType(Type, Constructor, Version) |
mRunes/Libs/AceGUI-3.0-SharedMediaWidgets/Libs/AceGUI-3.0/widgets/AceGUIContainer-InlineGroup.lua
New file
0,0 → 1,102
| --[[----------------------------------------------------------------------------- |
| InlineGroup Container |
| Simple container widget that creates a visible "box" with an optional title. |
| -------------------------------------------------------------------------------]] |
| local Type, Version = "InlineGroup", 20 |
| local AceGUI = LibStub and LibStub("AceGUI-3.0", true) |
| if not AceGUI or (AceGUI:GetWidgetVersion(Type) or 0) >= Version then return end |
| -- Lua APIs |
| local pairs = pairs |
| -- WoW APIs |
| local CreateFrame, UIParent = CreateFrame, UIParent |
| --[[----------------------------------------------------------------------------- |
| Methods |
| -------------------------------------------------------------------------------]] |
| local methods = { |
| ["OnAcquire"] = function(self) |
| self:SetWidth(300) |
| self:SetHeight(100) |
| end, |
| -- ["OnRelease"] = nil, |
| ["SetTitle"] = function(self,title) |
| self.titletext:SetText(title) |
| end, |
| ["LayoutFinished"] = function(self, width, height) |
| if self.noAutoHeight then return end |
| self:SetHeight((height or 0) + 40) |
| end, |
| ["OnWidthSet"] = function(self, width) |
| local content = self.content |
| local contentwidth = width - 20 |
| if contentwidth < 0 then |
| contentwidth = 0 |
| end |
| content:SetWidth(contentwidth) |
| content.width = contentwidth |
| end, |
| ["OnHeightSet"] = function(self, height) |
| local content = self.content |
| local contentheight = height - 20 |
| if contentheight < 0 then |
| contentheight = 0 |
| end |
| content:SetHeight(contentheight) |
| content.height = contentheight |
| end |
| } |
| --[[----------------------------------------------------------------------------- |
| Constructor |
| -------------------------------------------------------------------------------]] |
| local PaneBackdrop = { |
| bgFile = "Interface\\ChatFrame\\ChatFrameBackground", |
| edgeFile = "Interface\\Tooltips\\UI-Tooltip-Border", |
| tile = true, tileSize = 16, edgeSize = 16, |
| insets = { left = 3, right = 3, top = 5, bottom = 3 } |
| } |
| local function Constructor() |
| local frame = CreateFrame("Frame", nil, UIParent) |
| frame:SetFrameStrata("FULLSCREEN_DIALOG") |
| local titletext = frame:CreateFontString(nil, "OVERLAY", "GameFontNormal") |
| titletext:SetPoint("TOPLEFT", 14, 0) |
| titletext:SetPoint("TOPRIGHT", -14, 0) |
| titletext:SetJustifyH("LEFT") |
| titletext:SetHeight(18) |
| local border = CreateFrame("Frame", nil, frame) |
| border:SetPoint("TOPLEFT", 0, -17) |
| border:SetPoint("BOTTOMRIGHT", -1, 3) |
| border:SetBackdrop(PaneBackdrop) |
| border:SetBackdropColor(0.1, 0.1, 0.1, 0.5) |
| border:SetBackdropBorderColor(0.4, 0.4, 0.4) |
| --Container Support |
| local content = CreateFrame("Frame", nil, border) |
| content:SetPoint("TOPLEFT", 10, -10) |
| content:SetPoint("BOTTOMRIGHT", -10, 10) |
| local widget = { |
| frame = frame, |
| content = content, |
| titletext = titletext, |
| type = Type |
| } |
| for method, func in pairs(methods) do |
| widget[method] = func |
| end |
| return AceGUI:RegisterAsContainer(widget) |
| end |
| AceGUI:RegisterWidgetType(Type, Constructor, Version) |
mRunes/Libs/AceGUI-3.0-SharedMediaWidgets/Libs/AceGUI-3.0/widgets/AceGUIWidget-DropDown.lua
New file
0,0 → 1,707
| --[[ $Id: AceGUIWidget-DropDown.lua 916 2010-03-15 12:24:36Z nevcairiel $ ]]-- |
| local AceGUI = LibStub("AceGUI-3.0") |
| -- Lua APIs |
| local min, max, floor = math.min, math.max, math.floor |
| local select, pairs, ipairs = select, pairs, ipairs |
| local tsort = table.sort |
| -- WoW APIs |
| local PlaySound = PlaySound |
| local UIParent, CreateFrame = UIParent, CreateFrame |
| local _G = _G |
| -- Global vars/functions that we don't upvalue since they might get hooked, or upgraded |
| -- List them here for Mikk's FindGlobals script |
| -- GLOBALS: CLOSE |
| local function fixlevels(parent,...) |
| local i = 1 |
| local child = select(i, ...) |
| while child do |
| child:SetFrameLevel(parent:GetFrameLevel()+1) |
| fixlevels(child, child:GetChildren()) |
| i = i + 1 |
| child = select(i, ...) |
| end |
| end |
| local function fixstrata(strata, parent, ...) |
| local i = 1 |
| local child = select(i, ...) |
| parent:SetFrameStrata(strata) |
| while child do |
| fixstrata(strata, child, child:GetChildren()) |
| i = i + 1 |
| child = select(i, ...) |
| end |
| end |
| do |
| local widgetType = "Dropdown-Pullout" |
| local widgetVersion = 3 |
| --[[ Static data ]]-- |
| local backdrop = { |
| bgFile = "Interface\\ChatFrame\\ChatFrameBackground", |
| edgeFile = "Interface\\DialogFrame\\UI-DialogBox-Border", |
| edgeSize = 32, |
| tileSize = 32, |
| tile = true, |
| insets = { left = 11, right = 12, top = 12, bottom = 11 }, |
| } |
| local sliderBackdrop = { |
| bgFile = "Interface\\Buttons\\UI-SliderBar-Background", |
| edgeFile = "Interface\\Buttons\\UI-SliderBar-Border", |
| tile = true, tileSize = 8, edgeSize = 8, |
| insets = { left = 3, right = 3, top = 3, bottom = 3 } |
| } |
| local defaultWidth = 200 |
| local defaultMaxHeight = 600 |
| --[[ UI Event Handlers ]]-- |
| -- HACK: This should be no part of the pullout, but there |
| -- is no other 'clean' way to response to any item-OnEnter |
| -- Used to close Submenus when an other item is entered |
| local function OnEnter(item) |
| local self = item.pullout |
| for k, v in ipairs(self.items) do |
| if v.CloseMenu and v ~= item then |
| v:CloseMenu() |
| end |
| end |
| end |
| -- See the note in Constructor() for each scroll related function |
| local function OnMouseWheel(this, value) |
| this.obj:MoveScroll(value) |
| end |
| local function OnScrollValueChanged(this, value) |
| this.obj:SetScroll(value) |
| end |
| local function OnSizeChanged(this) |
| this.obj:FixScroll() |
| end |
| --[[ Exported methods ]]-- |
| -- exported |
| local function SetScroll(self, value) |
| local status = self.scrollStatus |
| local frame, child = self.scrollFrame, self.itemFrame |
| local height, viewheight = frame:GetHeight(), child:GetHeight() |
| local offset |
| if height > viewheight then |
| offset = 0 |
| else |
| offset = floor((viewheight - height) / 1000 * value) |
| end |
| child:ClearAllPoints() |
| child:SetPoint("TOPLEFT", frame, "TOPLEFT", 0, offset) |
| child:SetPoint("TOPRIGHT", frame, "TOPRIGHT", self.slider:IsShown() and -12 or 0, offset) |
| status.offset = offset |
| status.scrollvalue = value |
| end |
| -- exported |
| local function MoveScroll(self, value) |
| local status = self.scrollStatus |
| local frame, child = self.scrollFrame, self.itemFrame |
| local height, viewheight = frame:GetHeight(), child:GetHeight() |
| if height > viewheight then |
| self.slider:Hide() |
| else |
| self.slider:Show() |
| local diff = height - viewheight |
| local delta = 1 |
| if value < 0 then |
| delta = -1 |
| end |
| self.slider:SetValue(min(max(status.scrollvalue + delta*(1000/(diff/45)),0), 1000)) |
| end |
| end |
| -- exported |
| local function FixScroll(self) |
| local status = self.scrollStatus |
| local frame, child = self.scrollFrame, self.itemFrame |
| local height, viewheight = frame:GetHeight(), child:GetHeight() |
| local offset = status.offset or 0 |
| if viewheight < height then |
| self.slider:Hide() |
| child:SetPoint("TOPRIGHT", frame, "TOPRIGHT", 0, offset) |
| self.slider:SetValue(0) |
| else |
| self.slider:Show() |
| local value = (offset / (viewheight - height) * 1000) |
| if value > 1000 then value = 1000 end |
| self.slider:SetValue(value) |
| self:SetScroll(value) |
| if value < 1000 then |
| child:ClearAllPoints() |
| child:SetPoint("TOPLEFT", frame, "TOPLEFT", 0, offset) |
| child:SetPoint("TOPRIGHT", frame, "TOPRIGHT", -12, offset) |
| status.offset = offset |
| end |
| end |
| end |
| -- exported, AceGUI callback |
| local function OnAcquire(self) |
| self.frame:SetParent(UIParent) |
| --self.itemFrame:SetToplevel(true) |
| end |
| -- exported, AceGUI callback |
| local function OnRelease(self) |
| self:Clear() |
| self.frame:ClearAllPoints() |
| self.frame:Hide() |
| end |
| -- exported |
| local function AddItem(self, item) |
| self.items[#self.items + 1] = item |
| local h = #self.items * 16 |
| self.itemFrame:SetHeight(h) |
| self.frame:SetHeight(min(h + 34, self.maxHeight)) -- +34: 20 for scrollFrame placement (10 offset) and +14 for item placement |
| item.frame:SetPoint("LEFT", self.itemFrame, "LEFT") |
| item.frame:SetPoint("RIGHT", self.itemFrame, "RIGHT") |
| item:SetPullout(self) |
| item:SetOnEnter(OnEnter) |
| end |
| -- exported |
| local function Open(self, point, relFrame, relPoint, x, y) |
| local items = self.items |
| local frame = self.frame |
| local itemFrame = self.itemFrame |
| frame:SetPoint(point, relFrame, relPoint, x, y) |
| local height = 8 |
| for i, item in pairs(items) do |
| if i == 1 then |
| item:SetPoint("TOP", itemFrame, "TOP", 0, -2) |
| else |
| item:SetPoint("TOP", items[i-1].frame, "BOTTOM", 0, 1) |
| end |
| item:Show() |
| height = height + 16 |
| end |
| itemFrame:SetHeight(height) |
| fixstrata("TOOLTIP", frame, frame:GetChildren()) |
| frame:Show() |
| self:Fire("OnOpen") |
| end |
| -- exported |
| local function Close(self) |
| self.frame:Hide() |
| self:Fire("OnClose") |
| end |
| -- exported |
| local function Clear(self) |
| local items = self.items |
| for i, item in pairs(items) do |
| AceGUI:Release(item) |
| items[i] = nil |
| end |
| end |
| -- exported |
| local function IterateItems(self) |
| return ipairs(self.items) |
| end |
| -- exported |
| local function SetHideOnLeave(self, val) |
| self.hideOnLeave = val |
| end |
| -- exported |
| local function SetMaxHeight(self, height) |
| self.maxHeight = height or defaultMaxHeight |
| if self.frame:GetHeight() > height then |
| self.frame:SetHeight(height) |
| elseif (self.itemFrame:GetHeight() + 34) < height then |
| self.frame:SetHeight(self.itemFrame:GetHeight() + 34) -- see :AddItem |
| end |
| end |
| -- exported |
| local function GetRightBorderWidth(self) |
| return 6 + (self.slider:IsShown() and 12 or 0) |
| end |
| -- exported |
| local function GetLeftBorderWidth(self) |
| return 6 |
| end |
| --[[ Constructor ]]-- |
| local function Constructor() |
| local count = AceGUI:GetNextWidgetNum(widgetType) |
| local frame = CreateFrame("Frame", "AceGUI30Pullout"..count, UIParent) |
| local self = {} |
| self.count = count |
| self.type = widgetType |
| self.frame = frame |
| frame.obj = self |
| self.OnAcquire = OnAcquire |
| self.OnRelease = OnRelease |
| self.AddItem = AddItem |
| self.Open = Open |
| self.Close = Close |
| self.Clear = Clear |
| self.IterateItems = IterateItems |
| self.SetHideOnLeave = SetHideOnLeave |
| self.SetScroll = SetScroll |
| self.MoveScroll = MoveScroll |
| self.FixScroll = FixScroll |
| self.SetMaxHeight = SetMaxHeight |
| self.GetRightBorderWidth = GetRightBorderWidth |
| self.GetLeftBorderWidth = GetLeftBorderWidth |
| self.items = {} |
| self.scrollStatus = { |
| scrollvalue = 0, |
| } |
| self.maxHeight = defaultMaxHeight |
| frame:SetBackdrop(backdrop) |
| frame:SetBackdropColor(0, 0, 0) |
| frame:SetFrameStrata("FULLSCREEN_DIALOG") |
| frame:SetClampedToScreen(true) |
| frame:SetWidth(defaultWidth) |
| frame:SetHeight(self.maxHeight) |
| --frame:SetToplevel(true) |
| -- NOTE: The whole scroll frame code is copied from the AceGUI-3.0 widget ScrollFrame |
| local scrollFrame = CreateFrame("ScrollFrame", nil, frame) |
| local itemFrame = CreateFrame("Frame", nil, scrollFrame) |
| self.scrollFrame = scrollFrame |
| self.itemFrame = itemFrame |
| scrollFrame.obj = self |
| itemFrame.obj = self |
| local slider = CreateFrame("Slider", "AceGUI30PulloutScrollbar"..count, scrollFrame) |
| slider:SetOrientation("VERTICAL") |
| slider:SetHitRectInsets(0, 0, -10, 0) |
| slider:SetBackdrop(sliderBackdrop) |
| slider:SetWidth(8) |
| slider:SetThumbTexture("Interface\\Buttons\\UI-SliderBar-Button-Vertical") |
| slider:SetFrameStrata("FULLSCREEN_DIALOG") |
| self.slider = slider |
| slider.obj = self |
| scrollFrame:SetScrollChild(itemFrame) |
| scrollFrame:SetPoint("TOPLEFT", frame, "TOPLEFT", 6, -12) |
| scrollFrame:SetPoint("BOTTOMRIGHT", frame, "BOTTOMRIGHT", -6, 12) |
| scrollFrame:EnableMouseWheel(true) |
| scrollFrame:SetScript("OnMouseWheel", OnMouseWheel) |
| scrollFrame:SetScript("OnSizeChanged", OnSizeChanged) |
| scrollFrame:SetToplevel(true) |
| scrollFrame:SetFrameStrata("FULLSCREEN_DIALOG") |
| itemFrame:SetPoint("TOPLEFT", scrollFrame, "TOPLEFT", 0, 0) |
| itemFrame:SetPoint("TOPRIGHT", scrollFrame, "TOPRIGHT", -12, 0) |
| itemFrame:SetHeight(400) |
| itemFrame:SetToplevel(true) |
| itemFrame:SetFrameStrata("FULLSCREEN_DIALOG") |
| slider:SetPoint("TOPLEFT", scrollFrame, "TOPRIGHT", -16, 0) |
| slider:SetPoint("BOTTOMLEFT", scrollFrame, "BOTTOMRIGHT", -16, 0) |
| slider:SetScript("OnValueChanged", OnScrollValueChanged) |
| slider:SetMinMaxValues(0, 1000) |
| slider:SetValueStep(1) |
| slider:SetValue(0) |
| scrollFrame:Show() |
| itemFrame:Show() |
| slider:Hide() |
| self:FixScroll() |
| AceGUI:RegisterAsWidget(self) |
| return self |
| end |
| AceGUI:RegisterWidgetType(widgetType, Constructor, widgetVersion) |
| end |
| do |
| local widgetType = "Dropdown" |
| local widgetVersion = 22 |
| --[[ Static data ]]-- |
| --[[ UI event handler ]]-- |
| local function Control_OnEnter(this) |
| this.obj:Fire("OnEnter") |
| end |
| local function Control_OnLeave(this) |
| this.obj:Fire("OnLeave") |
| end |
| local function Dropdown_OnHide(this) |
| local self = this.obj |
| if self.open then |
| self.pullout:Close() |
| end |
| end |
| local function Dropdown_TogglePullout(this) |
| local self = this.obj |
| PlaySound("igMainMenuOptionCheckBoxOn") -- missleading name, but the Blizzard code uses this sound |
| if self.open then |
| self.open = nil |
| self.pullout:Close() |
| AceGUI:ClearFocus() |
| else |
| self.open = true |
| self.pullout:SetWidth(self.frame:GetWidth()) |
| self.pullout:Open("TOPLEFT", self.frame, "BOTTOMLEFT", 0, self.label:IsShown() and -2 or 0) |
| AceGUI:SetFocus(self) |
| end |
| end |
| local function OnPulloutOpen(this) |
| local self = this.userdata.obj |
| local value = self.value |
| if not self.multiselect then |
| for i, item in this:IterateItems() do |
| item:SetValue(item.userdata.value == value) |
| end |
| end |
| self.open = true |
| end |
| local function OnPulloutClose(this) |
| local self = this.userdata.obj |
| self.open = nil |
| self:Fire("OnClosed") |
| end |
| local function ShowMultiText(self) |
| local text |
| for i, widget in self.pullout:IterateItems() do |
| if widget.type == "Dropdown-Item-Toggle" then |
| if widget:GetValue() then |
| if text then |
| text = text..", "..widget:GetText() |
| else |
| text = widget:GetText() |
| end |
| end |
| end |
| end |
| self:SetText(text) |
| end |
| local function OnItemValueChanged(this, event, checked) |
| local self = this.userdata.obj |
| if self.multiselect then |
| self:Fire("OnValueChanged", this.userdata.value, checked) |
| ShowMultiText(self) |
| else |
| if checked then |
| self:SetValue(this.userdata.value) |
| self:Fire("OnValueChanged", this.userdata.value) |
| else |
| this:SetValue(true) |
| end |
| if self.open then |
| self.pullout:Close() |
| end |
| end |
| end |
| --[[ Exported methods ]]-- |
| -- exported, AceGUI callback |
| local function OnAcquire(self) |
| local pullout = AceGUI:Create("Dropdown-Pullout") |
| self.pullout = pullout |
| pullout.userdata.obj = self |
| pullout:SetCallback("OnClose", OnPulloutClose) |
| pullout:SetCallback("OnOpen", OnPulloutOpen) |
| self.pullout.frame:SetFrameLevel(self.frame:GetFrameLevel() + 1) |
| fixlevels(self.pullout.frame, self.pullout.frame:GetChildren()) |
| self:SetHeight(44) |
| self:SetWidth(200) |
| end |
| -- exported, AceGUI callback |
| local function OnRelease(self) |
| if self.open then |
| self.pullout:Close() |
| end |
| AceGUI:Release(self.pullout) |
| self.pullout = nil |
| self:SetText("") |
| self:SetLabel("") |
| self:SetDisabled(false) |
| self:SetMultiselect(false) |
| self.value = nil |
| self.list = nil |
| self.open = nil |
| self.hasClose = nil |
| self.frame:ClearAllPoints() |
| self.frame:Hide() |
| end |
| -- exported |
| local function SetDisabled(self, disabled) |
| self.disabled = disabled |
| if disabled then |
| self.text:SetTextColor(0.5,0.5,0.5) |
| self.button:Disable() |
| self.label:SetTextColor(0.5,0.5,0.5) |
| else |
| self.button:Enable() |
| self.label:SetTextColor(1,.82,0) |
| self.text:SetTextColor(1,1,1) |
| end |
| end |
| -- exported |
| local function ClearFocus(self) |
| if self.open then |
| self.pullout:Close() |
| end |
| end |
| -- exported |
| local function SetText(self, text) |
| self.text:SetText(text or "") |
| end |
| -- exported |
| local function SetLabel(self, text) |
| if text and text ~= "" then |
| self.label:SetText(text) |
| self.label:Show() |
| self.dropdown:SetPoint("TOPLEFT",self.frame,"TOPLEFT",-15,-18) |
| self.frame:SetHeight(44) |
| else |
| self.label:SetText("") |
| self.label:Hide() |
| self.dropdown:SetPoint("TOPLEFT",self.frame,"TOPLEFT",-15,0) |
| self.frame:SetHeight(26) |
| end |
| end |
| -- exported |
| local function SetValue(self, value) |
| if self.list then |
| self:SetText(self.list[value] or "") |
| end |
| self.value = value |
| end |
| -- exported |
| local function GetValue(self) |
| return self.value |
| end |
| -- exported |
| local function SetItemValue(self, item, value) |
| if not self.multiselect then return end |
| for i, widget in self.pullout:IterateItems() do |
| if widget.userdata.value == item then |
| if widget.SetValue then |
| widget:SetValue(value) |
| end |
| end |
| end |
| ShowMultiText(self) |
| end |
| -- exported |
| local function SetItemDisabled(self, item, disabled) |
| for i, widget in self.pullout:IterateItems() do |
| if widget.userdata.value == item then |
| widget:SetDisabled(disabled) |
| end |
| end |
| end |
| local function AddListItem(self, value, text) |
| local item = AceGUI:Create("Dropdown-Item-Toggle") |
| item:SetText(text) |
| item.userdata.obj = self |
| item.userdata.value = value |
| item:SetCallback("OnValueChanged", OnItemValueChanged) |
| self.pullout:AddItem(item) |
| end |
| local function AddCloseButton(self) |
| if not self.hasClose then |
| local close = AceGUI:Create("Dropdown-Item-Execute") |
| close:SetText(CLOSE) |
| self.pullout:AddItem(close) |
| self.hasClose = true |
| end |
| end |
| -- exported |
| local sortlist = {} |
| local function SetList(self, list) |
| self.list = list |
| self.pullout:Clear() |
| self.hasClose = nil |
| if not list then return end |
| for v in pairs(list) do |
| sortlist[#sortlist + 1] = v |
| end |
| tsort(sortlist) |
| for i, value in pairs(sortlist) do |
| AddListItem(self, value, list[value]) |
| sortlist[i] = nil |
| end |
| if self.multiselect then |
| ShowMultiText(self) |
| AddCloseButton(self) |
| end |
| end |
| -- exported |
| local function AddItem(self, value, text) |
| if self.list then |
| self.list[value] = text |
| AddListItem(self, value, text) |
| end |
| end |
| -- exported |
| local function SetMultiselect(self, multi) |
| self.multiselect = multi |
| if multi then |
| ShowMultiText(self) |
| AddCloseButton(self) |
| end |
| end |
| -- exported |
| local function GetMultiselect(self) |
| return self.multiselect |
| end |
| --[[ Constructor ]]-- |
| local function Constructor() |
| local count = AceGUI:GetNextWidgetNum(widgetType) |
| local frame = CreateFrame("Frame", nil, UIParent) |
| local dropdown = CreateFrame("Frame", "AceGUI30DropDown"..count, frame, "UIDropDownMenuTemplate") |
| local self = {} |
| self.type = widgetType |
| self.frame = frame |
| self.dropdown = dropdown |
| self.count = count |
| frame.obj = self |
| dropdown.obj = self |
| self.OnRelease = OnRelease |
| self.OnAcquire = OnAcquire |
| self.ClearFocus = ClearFocus |
| self.SetText = SetText |
| self.SetValue = SetValue |
| self.GetValue = GetValue |
| self.SetList = SetList |
| self.SetLabel = SetLabel |
| self.SetDisabled = SetDisabled |
| self.AddItem = AddItem |
| self.SetMultiselect = SetMultiselect |
| self.GetMultiselect = GetMultiselect |
| self.SetItemValue = SetItemValue |
| self.SetItemDisabled = SetItemDisabled |
| self.alignoffset = 31 |
| frame:SetHeight(44) |
| frame:SetWidth(200) |
| frame:SetScript("OnHide",Dropdown_OnHide) |
| dropdown:ClearAllPoints() |
| dropdown:SetPoint("TOPLEFT",frame,"TOPLEFT",-15,0) |
| dropdown:SetPoint("BOTTOMRIGHT",frame,"BOTTOMRIGHT",17,0) |
| dropdown:SetScript("OnHide", nil) |
| local left = _G[dropdown:GetName() .. "Left"] |
| local middle = _G[dropdown:GetName() .. "Middle"] |
| local right = _G[dropdown:GetName() .. "Right"] |
| middle:ClearAllPoints() |
| right:ClearAllPoints() |
| middle:SetPoint("LEFT", left, "RIGHT", 0, 0) |
| middle:SetPoint("RIGHT", right, "LEFT", 0, 0) |
| right:SetPoint("TOPRIGHT", dropdown, "TOPRIGHT", 0, 17) |
| local button = _G[dropdown:GetName() .. "Button"] |
| self.button = button |
| button.obj = self |
| button:SetScript("OnEnter",Control_OnEnter) |
| button:SetScript("OnLeave",Control_OnLeave) |
| button:SetScript("OnClick",Dropdown_TogglePullout) |
| local text = _G[dropdown:GetName() .. "Text"] |
| self.text = text |
| text.obj = self |
| text:ClearAllPoints() |
| text:SetPoint("RIGHT", right, "RIGHT" ,-43, 2) |
| text:SetPoint("LEFT", left, "LEFT", 25, 2) |
| local label = frame:CreateFontString(nil,"OVERLAY","GameFontNormalSmall") |
| label:SetPoint("TOPLEFT",frame,"TOPLEFT",0,0) |
| label:SetPoint("TOPRIGHT",frame,"TOPRIGHT",0,0) |
| label:SetJustifyH("LEFT") |
| label:SetHeight(18) |
| label:Hide() |
| self.label = label |
| AceGUI:RegisterAsWidget(self) |
| return self |
| end |
| AceGUI:RegisterWidgetType(widgetType, Constructor, widgetVersion) |
| end |
mRunes/Libs/AceGUI-3.0-SharedMediaWidgets/Libs/AceGUI-3.0/widgets/AceGUIWidget-EditBox.lua
New file
0,0 → 1,232
| --[[----------------------------------------------------------------------------- |
| EditBox Widget |
| -------------------------------------------------------------------------------]] |
| local Type, Version = "EditBox", 23 |
| local AceGUI = LibStub and LibStub("AceGUI-3.0", true) |
| if not AceGUI or (AceGUI:GetWidgetVersion(Type) or 0) >= Version then return end |
| -- Lua APIs |
| local tostring, pairs = tostring, pairs |
| -- WoW APIs |
| local PlaySound = PlaySound |
| local GetCursorInfo, ClearCursor, GetSpellInfo = GetCursorInfo, ClearCursor, GetSpellInfo |
| local CreateFrame, UIParent = CreateFrame, UIParent |
| local _G = _G |
| -- Global vars/functions that we don't upvalue since they might get hooked, or upgraded |
| -- List them here for Mikk's FindGlobals script |
| -- GLOBALS: AceGUIEditBoxInsertLink, ChatFontNormal, OKAY |
| --[[----------------------------------------------------------------------------- |
| Support functions |
| -------------------------------------------------------------------------------]] |
| if not AceGUIEditBoxInsertLink then |
| -- upgradeable hook |
| hooksecurefunc("ChatEdit_InsertLink", function(...) return _G.AceGUIEditBoxInsertLink(...) end) |
| end |
| function _G.AceGUIEditBoxInsertLink(text) |
| for i = 1, AceGUI:GetWidgetCount(Type) do |
| local editbox = _G["AceGUI-3.0EditBox"..i] |
| if editbox and editbox:IsVisible() and editbox:HasFocus() then |
| editbox:Insert(text) |
| return true |
| end |
| end |
| end |
| local function ShowButton(self) |
| if not self.disablebutton then |
| self.button:Show() |
| self.editbox:SetTextInsets(0, 20, 3, 3) |
| end |
| end |
| local function HideButton(self) |
| self.button:Hide() |
| self.editbox:SetTextInsets(0, 0, 3, 3) |
| end |
| --[[----------------------------------------------------------------------------- |
| Scripts |
| -------------------------------------------------------------------------------]] |
| local function Control_OnEnter(frame) |
| frame.obj:Fire("OnEnter") |
| end |
| local function Control_OnLeave(frame) |
| frame.obj:Fire("OnLeave") |
| end |
| local function EditBox_OnEscapePressed(frame) |
| AceGUI:ClearFocus() |
| end |
| local function EditBox_OnEnterPressed(frame) |
| local self = frame.obj |
| local value = frame:GetText() |
| local cancel = self:Fire("OnEnterPressed", value) |
| if not cancel then |
| PlaySound("igMainMenuOptionCheckBoxOn") |
| HideButton(self) |
| end |
| end |
| local function EditBox_OnReceiveDrag(frame) |
| local self = frame.obj |
| local type, id, info = GetCursorInfo() |
| if type == "item" then |
| self:SetText(info) |
| self:Fire("OnEnterPressed", info) |
| ClearCursor() |
| elseif type == "spell" then |
| local name = GetSpellInfo(id, info) |
| self:SetText(name) |
| self:Fire("OnEnterPressed", name) |
| ClearCursor() |
| end |
| HideButton(self) |
| AceGUI:ClearFocus() |
| end |
| local function EditBox_OnTextChanged(frame) |
| local self = frame.obj |
| local value = frame:GetText() |
| if tostring(value) ~= tostring(self.lasttext) then |
| self:Fire("OnTextChanged", value) |
| self.lasttext = value |
| ShowButton(self) |
| end |
| end |
| local function Button_OnClick(frame) |
| local editbox = frame.obj.editbox |
| editbox:ClearFocus() |
| EditBox_OnEnterPressed(editbox) |
| end |
| --[[----------------------------------------------------------------------------- |
| Methods |
| -------------------------------------------------------------------------------]] |
| local methods = { |
| ["OnAcquire"] = function(self) |
| -- height is controlled by SetLabel |
| self:SetWidth(200) |
| self:SetDisabled(false) |
| self:SetLabel() |
| self:SetText() |
| self:DisableButton(false) |
| self:SetMaxLetters(0) |
| end, |
| -- ["OnRelease"] = nil, |
| ["SetDisabled"] = function(self, disabled) |
| self.disabled = disabled |
| if disabled then |
| self.editbox:EnableMouse(false) |
| self.editbox:ClearFocus() |
| self.editbox:SetTextColor(0.5,0.5,0.5) |
| self.label:SetTextColor(0.5,0.5,0.5) |
| else |
| self.editbox:EnableMouse(true) |
| self.editbox:SetTextColor(1,1,1) |
| self.label:SetTextColor(1,.82,0) |
| end |
| end, |
| ["SetText"] = function(self, text) |
| self.lasttext = text or "" |
| self.editbox:SetText(text or "") |
| self.editbox:SetCursorPosition(0) |
| HideButton(self) |
| end, |
| ["GetText"] = function(self, text) |
| return self.editbox:GetText() |
| end, |
| ["SetLabel"] = function(self, text) |
| if text and text ~= "" then |
| self.label:SetText(text) |
| self.label:Show() |
| self.editbox:SetPoint("TOPLEFT",self.frame,"TOPLEFT",7,-18) |
| self:SetHeight(44) |
| self.alignoffset = 30 |
| else |
| self.label:SetText("") |
| self.label:Hide() |
| self.editbox:SetPoint("TOPLEFT",self.frame,"TOPLEFT",7,0) |
| self:SetHeight(26) |
| self.alignoffset = 12 |
| end |
| end, |
| ["DisableButton"] = function(self, disabled) |
| self.disablebutton = disabled |
| if disabled then |
| HideButton(self) |
| end |
| end, |
| ["SetMaxLetters"] = function (self, num) |
| self.editbox:SetMaxLetters(num or 0) |
| end |
| } |
| --[[----------------------------------------------------------------------------- |
| Constructor |
| -------------------------------------------------------------------------------]] |
| local function Constructor() |
| local num = AceGUI:GetNextWidgetNum(Type) |
| local frame = CreateFrame("Frame", nil, UIParent) |
| frame:Hide() |
| local editbox = CreateFrame("EditBox", "AceGUI-3.0EditBox"..num, frame, "InputBoxTemplate") |
| editbox:SetAutoFocus(false) |
| editbox:SetFontObject(ChatFontNormal) |
| editbox:SetScript("OnEnter", Control_OnEnter) |
| editbox:SetScript("OnLeave", Control_OnLeave) |
| editbox:SetScript("OnEscapePressed", EditBox_OnEscapePressed) |
| editbox:SetScript("OnEnterPressed", EditBox_OnEnterPressed) |
| editbox:SetScript("OnTextChanged", EditBox_OnTextChanged) |
| editbox:SetScript("OnReceiveDrag", EditBox_OnReceiveDrag) |
| editbox:SetScript("OnMouseDown", EditBox_OnReceiveDrag) |
| editbox:SetTextInsets(0, 0, 3, 3) |
| editbox:SetMaxLetters(256) |
| editbox:SetPoint("BOTTOMLEFT", 6, 0) |
| editbox:SetPoint("BOTTOMRIGHT") |
| editbox:SetHeight(19) |
| local label = frame:CreateFontString(nil, "OVERLAY", "GameFontNormalSmall") |
| label:SetPoint("TOPLEFT", 0, -2) |
| label:SetPoint("TOPRIGHT", 0, -2) |
| label:SetJustifyH("LEFT") |
| label:SetHeight(18) |
| local button = CreateFrame("Button", nil, editbox, "UIPanelButtonTemplate") |
| button:SetWidth(40) |
| button:SetHeight(20) |
| button:SetPoint("RIGHT", -2, 0) |
| button:SetText(OKAY) |
| button:SetScript("OnClick", Button_OnClick) |
| button:Hide() |
| local widget = { |
| alignoffset = 30, |
| editbox = editbox, |
| label = label, |
| button = button, |
| frame = frame, |
| type = Type |
| } |
| for method, func in pairs(methods) do |
| widget[method] = func |
| end |
| editbox.obj, button.obj = widget, widget |
| return AceGUI:RegisterAsWidget(widget) |
| end |
| AceGUI:RegisterWidgetType(Type, Constructor, Version) |
mRunes/Libs/AceGUI-3.0-SharedMediaWidgets/Libs/AceGUI-3.0/widgets/AceGUIWidget-Heading.lua
New file
0,0 → 1,78
| --[[----------------------------------------------------------------------------- |
| Heading Widget |
| -------------------------------------------------------------------------------]] |
| local Type, Version = "Heading", 20 |
| local AceGUI = LibStub and LibStub("AceGUI-3.0", true) |
| if not AceGUI or (AceGUI:GetWidgetVersion(Type) or 0) >= Version then return end |
| -- Lua APIs |
| local pairs = pairs |
| -- WoW APIs |
| local CreateFrame, UIParent = CreateFrame, UIParent |
| --[[----------------------------------------------------------------------------- |
| Methods |
| -------------------------------------------------------------------------------]] |
| local methods = { |
| ["OnAcquire"] = function(self) |
| self:SetText() |
| self:SetFullWidth() |
| self:SetHeight(18) |
| end, |
| -- ["OnRelease"] = nil, |
| ["SetText"] = function(self, text) |
| self.label:SetText(text or "") |
| if text and text ~= "" then |
| self.left:SetPoint("RIGHT", self.label, "LEFT", -5, 0) |
| self.right:Show() |
| else |
| self.left:SetPoint("RIGHT", -3, 0) |
| self.right:Hide() |
| end |
| end |
| } |
| --[[----------------------------------------------------------------------------- |
| Constructor |
| -------------------------------------------------------------------------------]] |
| local function Constructor() |
| local frame = CreateFrame("Frame", nil, UIParent) |
| frame:Hide() |
| local label = frame:CreateFontString(nil, "BACKGROUND", "GameFontNormal") |
| label:SetPoint("TOP") |
| label:SetPoint("BOTTOM") |
| label:SetJustifyH("CENTER") |
| local left = frame:CreateTexture(nil, "BACKGROUND") |
| left:SetHeight(8) |
| left:SetPoint("LEFT", 3, 0) |
| left:SetPoint("RIGHT", label, "LEFT", -5, 0) |
| left:SetTexture("Interface\\Tooltips\\UI-Tooltip-Border") |
| left:SetTexCoord(0.81, 0.94, 0.5, 1) |
| local right = frame:CreateTexture(nil, "BACKGROUND") |
| right:SetHeight(8) |
| right:SetPoint("RIGHT", -3, 0) |
| right:SetPoint("LEFT", label, "RIGHT", 5, 0) |
| right:SetTexture("Interface\\Tooltips\\UI-Tooltip-Border") |
| right:SetTexCoord(0.81, 0.94, 0.5, 1) |
| local widget = { |
| label = label, |
| left = left, |
| right = right, |
| frame = frame, |
| type = Type |
| } |
| for method, func in pairs(methods) do |
| widget[method] = func |
| end |
| return AceGUI:RegisterAsWidget(widget) |
| end |
| AceGUI:RegisterWidgetType(Type, Constructor, Version) |
mRunes/Libs/AceGUI-3.0-SharedMediaWidgets/Libs/AceGUI-3.0/AceGUI-3.0.xml
New file
0,0 → 1,28
| <Ui xmlns="http://www.blizzard.com/wow/ui/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.blizzard.com/wow/ui/ |
| ..\FrameXML\UI.xsd"> |
| <Script file="AceGUI-3.0.lua"/> |
| <!-- Container --> |
| <Script file="widgets\AceGUIContainer-BlizOptionsGroup.lua"/> |
| <Script file="widgets\AceGUIContainer-DropDownGroup.lua"/> |
| <Script file="widgets\AceGUIContainer-Frame.lua"/> |
| <Script file="widgets\AceGUIContainer-InlineGroup.lua"/> |
| <Script file="widgets\AceGUIContainer-ScrollFrame.lua"/> |
| <Script file="widgets\AceGUIContainer-SimpleGroup.lua"/> |
| <Script file="widgets\AceGUIContainer-TabGroup.lua"/> |
| <Script file="widgets\AceGUIContainer-TreeGroup.lua"/> |
| <Script file="widgets\AceGUIContainer-Window.lua"/> |
| <!-- Widgets --> |
| <Script file="widgets\AceGUIWidget-Button.lua"/> |
| <Script file="widgets\AceGUIWidget-CheckBox.lua"/> |
| <Script file="widgets\AceGUIWidget-ColorPicker.lua"/> |
| <Script file="widgets\AceGUIWidget-DropDown.lua"/> |
| <Script file="widgets\AceGUIWidget-DropDown-Items.lua"/> |
| <Script file="widgets\AceGUIWidget-EditBox.lua"/> |
| <Script file="widgets\AceGUIWidget-Heading.lua"/> |
| <Script file="widgets\AceGUIWidget-Icon.lua"/> |
| <Script file="widgets\AceGUIWidget-InteractiveLabel.lua"/> |
| <Script file="widgets\AceGUIWidget-Keybinding.lua"/> |
| <Script file="widgets\AceGUIWidget-Label.lua"/> |
| <Script file="widgets\AceGUIWidget-MultiLineEditBox.lua"/> |
| <Script file="widgets\AceGUIWidget-Slider.lua"/> |
| </Ui> |
mRunes/Libs/AceGUI-3.0-SharedMediaWidgets/Libs/AceGUI-3.0/AceGUI-3.0.lua
New file
0,0 → 1,805
| --- **AceGUI-3.0** provides access to numerous widgets which can be used to create GUIs. |
| -- AceGUI is used by AceConfigDialog to create the option GUIs, but you can use it by itself |
| -- to create any custom GUI. There are more extensive examples in the test suite in the Ace3 |
| -- stand-alone distribution. |
| -- |
| -- **Note**: When using AceGUI-3.0 directly, please do not modify the frames of the widgets directly, |
| -- as any "unknown" change to the widgets will cause addons that get your widget out of the widget pool |
| -- to misbehave. If you think some part of a widget should be modifiable, please open a ticket, and we"ll |
| -- implement a proper API to modify it. |
| -- @usage |
| -- local AceGUI = LibStub("AceGUI-3.0") |
| -- -- Create a container frame |
| -- local f = AceGUI:Create("Frame") |
| -- f:SetCallback("OnClose",function(widget) AceGUI:Release(widget) end) |
| -- f:SetTitle("AceGUI-3.0 Example") |
| -- f:SetStatusText("Status Bar") |
| -- f:SetLayout("Flow") |
| -- -- Create a button |
| -- local btn = AceGUI:Create("Button") |
| -- btn:SetWidth(170) |
| -- btn:SetText("Button !") |
| -- btn:SetCallback("OnClick", function() print("Click!") end) |
| -- -- Add the button to the container |
| -- f:AddChild(btn) |
| -- @class file |
| -- @name AceGUI-3.0 |
| -- @release $Id: AceGUI-3.0.lua 924 2010-05-13 15:12:20Z nevcairiel $ |
| local ACEGUI_MAJOR, ACEGUI_MINOR = "AceGUI-3.0", 33 |
| local AceGUI, oldminor = LibStub:NewLibrary(ACEGUI_MAJOR, ACEGUI_MINOR) |
| if not AceGUI then return end -- No upgrade needed |
| -- Lua APIs |
| local tconcat, tremove, tinsert = table.concat, table.remove, table.insert |
| local select, pairs, next, type = select, pairs, next, type |
| local error, assert, loadstring = error, assert, loadstring |
| local setmetatable, rawget, rawset = setmetatable, rawget, rawset |
| local math_max = math.max |
| -- WoW APIs |
| local UIParent = UIParent |
| -- Global vars/functions that we don't upvalue since they might get hooked, or upgraded |
| -- List them here for Mikk's FindGlobals script |
| -- GLOBALS: geterrorhandler, LibStub |
| --local con = LibStub("AceConsole-3.0",true) |
| AceGUI.WidgetRegistry = AceGUI.WidgetRegistry or {} |
| AceGUI.LayoutRegistry = AceGUI.LayoutRegistry or {} |
| AceGUI.WidgetBase = AceGUI.WidgetBase or {} |
| AceGUI.WidgetContainerBase = AceGUI.WidgetContainerBase or {} |
| AceGUI.WidgetVersions = AceGUI.WidgetVersions or {} |
| -- local upvalues |
| local WidgetRegistry = AceGUI.WidgetRegistry |
| local LayoutRegistry = AceGUI.LayoutRegistry |
| local WidgetVersions = AceGUI.WidgetVersions |
| --[[ |
| xpcall safecall implementation |
| ]] |
| local xpcall = xpcall |
| local function errorhandler(err) |
| return geterrorhandler()(err) |
| end |
| local function CreateDispatcher(argCount) |
| local code = [[ |
| local xpcall, eh = ... |
| local method, ARGS |
| local function call() return method(ARGS) end |
| local function dispatch(func, ...) |
| method = func |
| if not method then return end |
| ARGS = ... |
| return xpcall(call, eh) |
| end |
| return dispatch |
| ]] |
| local ARGS = {} |
| for i = 1, argCount do ARGS[i] = "arg"..i end |
| code = code:gsub("ARGS", tconcat(ARGS, ", ")) |
| return assert(loadstring(code, "safecall Dispatcher["..argCount.."]"))(xpcall, errorhandler) |
| end |
| local Dispatchers = setmetatable({}, {__index=function(self, argCount) |
| local dispatcher = CreateDispatcher(argCount) |
| rawset(self, argCount, dispatcher) |
| return dispatcher |
| end}) |
| Dispatchers[0] = function(func) |
| return xpcall(func, errorhandler) |
| end |
| local function safecall(func, ...) |
| return Dispatchers[select("#", ...)](func, ...) |
| end |
| -- Recycling functions |
| local newWidget, delWidget |
| do |
| -- Version Upgrade in Minor 29 |
| -- Internal Storage of the objects changed, from an array table |
| -- to a hash table, and additionally we introduced versioning on |
| -- the widgets which would discard all widgets from a pre-29 version |
| -- anyway, so we just clear the storage now, and don't try to |
| -- convert the storage tables to the new format. |
| -- This should generally not cause *many* widgets to end up in trash, |
| -- since once dialogs are opened, all addons should be loaded already |
| -- and AceGUI should be on the latest version available on the users |
| -- setup. |
| -- -- nevcairiel - Nov 2nd, 2009 |
| if oldminor and oldminor < 29 and AceGUI.objPools then |
| AceGUI.objPools = nil |
| end |
| AceGUI.objPools = AceGUI.objPools or {} |
| local objPools = AceGUI.objPools |
| --Returns a new instance, if none are available either returns a new table or calls the given contructor |
| function newWidget(type) |
| if not WidgetRegistry[type] then |
| error("Attempt to instantiate unknown widget type", 2) |
| end |
| if not objPools[type] then |
| objPools[type] = {} |
| end |
| local newObj = next(objPools[type]) |
| if not newObj then |
| newObj = WidgetRegistry[type]() |
| newObj.AceGUIWidgetVersion = WidgetVersions[type] |
| else |
| objPools[type][newObj] = nil |
| -- if the widget is older then the latest, don't even try to reuse it |
| -- just forget about it, and grab a new one. |
| if not newObj.AceGUIWidgetVersion or newObj.AceGUIWidgetVersion < WidgetVersions[type] then |
| return newWidget(type) |
| end |
| end |
| return newObj |
| end |
| -- Releases an instance to the Pool |
| function delWidget(obj,type) |
| if not objPools[type] then |
| objPools[type] = {} |
| end |
| if objPools[type][obj] then |
| error("Attempt to Release Widget that is already released", 2) |
| end |
| objPools[type][obj] = true |
| end |
| end |
| ------------------- |
| -- API Functions -- |
| ------------------- |
| -- Gets a widget Object |
| --- Create a new Widget of the given type. |
| -- This function will instantiate a new widget (or use one from the widget pool), and call the |
| -- OnAcquire function on it, before returning. |
| -- @param type The type of the widget. |
| -- @return The newly created widget. |
| function AceGUI:Create(type) |
| if WidgetRegistry[type] then |
| local widget = newWidget(type) |
| if rawget(widget, "Acquire") then |
| widget.OnAcquire = widget.Acquire |
| widget.Acquire = nil |
| elseif rawget(widget, "Aquire") then |
| widget.OnAcquire = widget.Aquire |
| widget.Aquire = nil |
| end |
| if rawget(widget, "Release") then |
| widget.OnRelease = rawget(widget, "Release") |
| widget.Release = nil |
| end |
| if widget.OnAcquire then |
| widget:OnAcquire() |
| else |
| error(("Widget type %s doesn't supply an OnAcquire Function"):format(type)) |
| end |
| -- Set the default Layout ("List") |
| safecall(widget.SetLayout, widget, "List") |
| safecall(widget.ResumeLayout, widget) |
| return widget |
| end |
| end |
| --- Releases a widget Object. |
| -- This function calls OnRelease on the widget and places it back in the widget pool. |
| -- Any data on the widget is being erased, and the widget will be hidden.\\ |
| -- If this widget is a Container-Widget, all of its Child-Widgets will be releases as well. |
| -- @param widget The widget to release |
| function AceGUI:Release(widget) |
| safecall(widget.PauseLayout, widget) |
| widget:Fire("OnRelease") |
| safecall(widget.ReleaseChildren, widget) |
| if widget.OnRelease then |
| widget:OnRelease() |
| -- else |
| -- error(("Widget type %s doesn't supply an OnRelease Function"):format(widget.type)) |
| end |
| for k in pairs(widget.userdata) do |
| widget.userdata[k] = nil |
| end |
| for k in pairs(widget.events) do |
| widget.events[k] = nil |
| end |
| widget.width = nil |
| widget.relWidth = nil |
| widget.height = nil |
| widget.relHeight = nil |
| widget.noAutoHeight = nil |
| widget.frame:ClearAllPoints() |
| widget.frame:Hide() |
| widget.frame:SetParent(UIParent) |
| widget.frame.width = nil |
| widget.frame.height = nil |
| if widget.content then |
| widget.content.width = nil |
| widget.content.height = nil |
| end |
| delWidget(widget, widget.type) |
| end |
| ----------- |
| -- Focus -- |
| ----------- |
| --- Called when a widget has taken focus. |
| -- e.g. Dropdowns opening, Editboxes gaining kb focus |
| -- @param widget The widget that should be focused |
| function AceGUI:SetFocus(widget) |
| if self.FocusedWidget and self.FocusedWidget ~= widget then |
| safecall(self.FocusedWidget.ClearFocus, self.FocusedWidget) |
| end |
| self.FocusedWidget = widget |
| end |
| --- Called when something has happened that could cause widgets with focus to drop it |
| -- e.g. titlebar of a frame being clicked |
| function AceGUI:ClearFocus() |
| if self.FocusedWidget then |
| safecall(self.FocusedWidget.ClearFocus, self.FocusedWidget) |
| self.FocusedWidget = nil |
| end |
| end |
| ------------- |
| -- Widgets -- |
| ------------- |
| --[[ |
| Widgets must provide the following functions |
| OnAcquire() - Called when the object is acquired, should set everything to a default hidden state |
| And the following members |
| frame - the frame or derivitive object that will be treated as the widget for size and anchoring purposes |
| type - the type of the object, same as the name given to :RegisterWidget() |
| Widgets contain a table called userdata, this is a safe place to store data associated with the wigdet |
| It will be cleared automatically when a widget is released |
| Placing values directly into a widget object should be avoided |
| If the Widget can act as a container for other Widgets the following |
| content - frame or derivitive that children will be anchored to |
| The Widget can supply the following Optional Members |
| :OnRelease() - Called when the object is Released, should remove any additional anchors and clear any data |
| :OnWidthSet(width) - Called when the width of the widget is changed |
| :OnHeightSet(height) - Called when the height of the widget is changed |
| Widgets should not use the OnSizeChanged events of thier frame or content members, use these methods instead |
| AceGUI already sets a handler to the event |
| :LayoutFinished(width, height) - called after a layout has finished, the width and height will be the width and height of the |
| area used for controls. These can be nil if the layout used the existing size to layout the controls. |
| ]] |
| -------------------------- |
| -- Widget Base Template -- |
| -------------------------- |
| do |
| local WidgetBase = AceGUI.WidgetBase |
| WidgetBase.SetParent = function(self, parent) |
| local frame = self.frame |
| frame:SetParent(nil) |
| frame:SetParent(parent.content) |
| self.parent = parent |
| end |
| WidgetBase.SetCallback = function(self, name, func) |
| if type(func) == "function" then |
| self.events[name] = func |
| end |
| end |
| WidgetBase.Fire = function(self, name, ...) |
| if self.events[name] then |
| local success, ret = safecall(self.events[name], self, name, ...) |
| if success then |
| return ret |
| end |
| end |
| end |
| WidgetBase.SetWidth = function(self, width) |
| self.frame:SetWidth(width) |
| self.frame.width = width |
| if self.OnWidthSet then |
| self:OnWidthSet(width) |
| end |
| end |
| WidgetBase.SetRelativeWidth = function(self, width) |
| if width <= 0 or width > 1 then |
| error(":SetRelativeWidth(width): Invalid relative width.", 2) |
| end |
| self.relWidth = width |
| self.width = "relative" |
| end |
| WidgetBase.SetHeight = function(self, height) |
| self.frame:SetHeight(height) |
| self.frame.height = height |
| if self.OnHeightSet then |
| self:OnHeightSet(height) |
| end |
| end |
| --[[ WidgetBase.SetRelativeHeight = function(self, height) |
| if height <= 0 or height > 1 then |
| error(":SetRelativeHeight(height): Invalid relative height.", 2) |
| end |
| self.relHeight = height |
| self.height = "relative" |
| end ]] |
| WidgetBase.IsVisible = function(self) |
| return self.frame:IsVisible() |
| end |
| WidgetBase.IsShown= function(self) |
| return self.frame:IsShown() |
| end |
| WidgetBase.Release = function(self) |
| AceGUI:Release(self) |
| end |
| WidgetBase.SetPoint = function(self, ...) |
| return self.frame:SetPoint(...) |
| end |
| WidgetBase.ClearAllPoints = function(self) |
| return self.frame:ClearAllPoints() |
| end |
| WidgetBase.GetNumPoints = function(self) |
| return self.frame:GetNumPoints() |
| end |
| WidgetBase.GetPoint = function(self, ...) |
| return self.frame:GetPoint(...) |
| end |
| WidgetBase.GetUserDataTable = function(self) |
| return self.userdata |
| end |
| WidgetBase.SetUserData = function(self, key, value) |
| self.userdata[key] = value |
| end |
| WidgetBase.GetUserData = function(self, key) |
| return self.userdata[key] |
| end |
| WidgetBase.IsFullHeight = function(self) |
| return self.height == "fill" |
| end |
| WidgetBase.SetFullHeight = function(self, isFull) |
| if isFull then |
| self.height = "fill" |
| else |
| self.height = nil |
| end |
| end |
| WidgetBase.IsFullWidth = function(self) |
| return self.width == "fill" |
| end |
| WidgetBase.SetFullWidth = function(self, isFull) |
| if isFull then |
| self.width = "fill" |
| else |
| self.width = nil |
| end |
| end |
| -- local function LayoutOnUpdate(this) |
| -- this:SetScript("OnUpdate",nil) |
| -- this.obj:PerformLayout() |
| -- end |
| local WidgetContainerBase = AceGUI.WidgetContainerBase |
| WidgetContainerBase.PauseLayout = function(self) |
| self.LayoutPaused = true |
| end |
| WidgetContainerBase.ResumeLayout = function(self) |
| self.LayoutPaused = nil |
| end |
| WidgetContainerBase.PerformLayout = function(self) |
| if self.LayoutPaused then |
| return |
| end |
| safecall(self.LayoutFunc, self.content, self.children) |
| end |
| --call this function to layout, makes sure layed out objects get a frame to get sizes etc |
| WidgetContainerBase.DoLayout = function(self) |
| self:PerformLayout() |
| -- if not self.parent then |
| -- self.frame:SetScript("OnUpdate", LayoutOnUpdate) |
| -- end |
| end |
| WidgetContainerBase.AddChild = function(self, child, beforeWidget) |
| if beforeWidget then |
| local siblingIndex = 1 |
| for _, widget in pairs(self.children) do |
| if widget == beforeWidget then |
| break |
| end |
| siblingIndex = siblingIndex + 1 |
| end |
| tinsert(self.children, siblingIndex, child) |
| else |
| tinsert(self.children, child) |
| end |
| child:SetParent(self) |
| child.frame:Show() |
| self:DoLayout() |
| end |
| WidgetContainerBase.AddChildren = function(self, ...) |
| for i = 1, select("#", ...) do |
| local child = select(i, ...) |
| tinsert(self.children, child) |
| child:SetParent(self) |
| child.frame:Show() |
| end |
| self:DoLayout() |
| end |
| WidgetContainerBase.ReleaseChildren = function(self) |
| local children = self.children |
| for i = 1,#children do |
| AceGUI:Release(children[i]) |
| children[i] = nil |
| end |
| end |
| WidgetContainerBase.SetLayout = function(self, Layout) |
| self.LayoutFunc = AceGUI:GetLayout(Layout) |
| end |
| WidgetContainerBase.SetAutoAdjustHeight = function(self, adjust) |
| if adjust then |
| self.noAutoHeight = nil |
| else |
| self.noAutoHeight = true |
| end |
| end |
| local function FrameResize(this) |
| local self = this.obj |
| if this:GetWidth() and this:GetHeight() then |
| if self.OnWidthSet then |
| self:OnWidthSet(this:GetWidth()) |
| end |
| if self.OnHeightSet then |
| self:OnHeightSet(this:GetHeight()) |
| end |
| end |
| end |
| local function ContentResize(this) |
| if this:GetWidth() and this:GetHeight() then |
| this.width = this:GetWidth() |
| this.height = this:GetHeight() |
| this.obj:DoLayout() |
| end |
| end |
| setmetatable(WidgetContainerBase, {__index=WidgetBase}) |
| --One of these function should be called on each Widget Instance as part of its creation process |
| --- Register a widget-class as a container for newly created widgets. |
| -- @param widget The widget class |
| function AceGUI:RegisterAsContainer(widget) |
| widget.children = {} |
| widget.userdata = {} |
| widget.events = {} |
| widget.base = WidgetContainerBase |
| widget.content.obj = widget |
| widget.frame.obj = widget |
| widget.content:SetScript("OnSizeChanged", ContentResize) |
| widget.frame:SetScript("OnSizeChanged", FrameResize) |
| setmetatable(widget, {__index = WidgetContainerBase}) |
| widget:SetLayout("List") |
| return widget |
| end |
| --- Register a widget-class as a widget. |
| -- @param widget The widget class |
| function AceGUI:RegisterAsWidget(widget) |
| widget.userdata = {} |
| widget.events = {} |
| widget.base = WidgetBase |
| widget.frame.obj = widget |
| widget.frame:SetScript("OnSizeChanged", FrameResize) |
| setmetatable(widget, {__index = WidgetBase}) |
| return widget |
| end |
| end |
| ------------------ |
| -- Widget API -- |
| ------------------ |
| --- Registers a widget Constructor, this function returns a new instance of the Widget |
| -- @param Name The name of the widget |
| -- @param Constructor The widget constructor function |
| -- @param Version The version of the widget |
| function AceGUI:RegisterWidgetType(Name, Constructor, Version) |
| assert(type(Constructor) == "function") |
| assert(type(Version) == "number") |
| local oldVersion = WidgetVersions[Name] |
| if oldVersion and oldVersion >= Version then return end |
| WidgetVersions[Name] = Version |
| WidgetRegistry[Name] = Constructor |
| end |
| --- Registers a Layout Function |
| -- @param Name The name of the layout |
| -- @param LayoutFunc Reference to the layout function |
| function AceGUI:RegisterLayout(Name, LayoutFunc) |
| assert(type(LayoutFunc) == "function") |
| if type(Name) == "string" then |
| Name = Name:upper() |
| end |
| LayoutRegistry[Name] = LayoutFunc |
| end |
| --- Get a Layout Function from the registry |
| -- @param Name The name of the layout |
| function AceGUI:GetLayout(Name) |
| if type(Name) == "string" then |
| Name = Name:upper() |
| end |
| return LayoutRegistry[Name] |
| end |
| AceGUI.counts = AceGUI.counts or {} |
| --- A type-based counter to count the number of widgets created. |
| -- This is used by widgets that require a named frame, e.g. when a Blizzard |
| -- Template requires it. |
| -- @param type The widget type |
| function AceGUI:GetNextWidgetNum(type) |
| if not self.counts[type] then |
| self.counts[type] = 0 |
| end |
| self.counts[type] = self.counts[type] + 1 |
| return self.counts[type] |
| end |
| --- Return the number of created widgets for this type. |
| -- In contrast to GetNextWidgetNum, the number is not incremented. |
| -- @param type The widget type |
| function AceGUI:GetWidgetCount(type) |
| return self.counts[type] or 0 |
| end |
| --- Return the version of the currently registered widget type. |
| -- @param type The widget type |
| function AceGUI:GetWidgetVersion(type) |
| return WidgetVersions[type] |
| end |
| ------------- |
| -- Layouts -- |
| ------------- |
| --[[ |
| A Layout is a func that takes 2 parameters |
| content - the frame that widgets will be placed inside |
| children - a table containing the widgets to layout |
| ]] |
| -- Very simple Layout, Children are stacked on top of each other down the left side |
| AceGUI:RegisterLayout("List", |
| function(content, children) |
| local height = 0 |
| local width = content.width or content:GetWidth() or 0 |
| for i = 1, #children do |
| local child = children[i] |
| local frame = child.frame |
| frame:ClearAllPoints() |
| frame:Show() |
| if i == 1 then |
| frame:SetPoint("TOPLEFT", content) |
| else |
| frame:SetPoint("TOPLEFT", children[i-1].frame, "BOTTOMLEFT") |
| end |
| if child.width == "fill" then |
| child:SetWidth(width) |
| frame:SetPoint("RIGHT", content) |
| if child.DoLayout then |
| child:DoLayout() |
| end |
| elseif child.width == "relative" then |
| child:SetWidth(width * child.relWidth) |
| if child.DoLayout then |
| child:DoLayout() |
| end |
| end |
| height = height + (frame.height or frame:GetHeight() or 0) |
| end |
| safecall(content.obj.LayoutFinished, content.obj, nil, height) |
| end) |
| -- A single control fills the whole content area |
| AceGUI:RegisterLayout("Fill", |
| function(content, children) |
| if children[1] then |
| children[1]:SetWidth(content:GetWidth() or 0) |
| children[1]:SetHeight(content:GetHeight() or 0) |
| children[1].frame:SetAllPoints(content) |
| children[1].frame:Show() |
| safecall(content.obj.LayoutFinished, content.obj, nil, children[1].frame:GetHeight()) |
| end |
| end) |
| AceGUI:RegisterLayout("Flow", |
| function(content, children) |
| --used height so far |
| local height = 0 |
| --width used in the current row |
| local usedwidth = 0 |
| --height of the current row |
| local rowheight = 0 |
| local rowoffset = 0 |
| local lastrowoffset |
| local width = content.width or content:GetWidth() or 0 |
| --control at the start of the row |
| local rowstart |
| local rowstartoffset |
| local lastrowstart |
| local isfullheight |
| local frameoffset |
| local lastframeoffset |
| local oversize |
| for i = 1, #children do |
| local child = children[i] |
| oversize = nil |
| local frame = child.frame |
| local frameheight = frame.height or frame:GetHeight() or 0 |
| local framewidth = frame.width or frame:GetWidth() or 0 |
| lastframeoffset = frameoffset |
| -- HACK: Why did we set a frameoffset of (frameheight / 2) ? |
| -- That was moving all widgets half the widgets size down, is that intended? |
| -- Actually, it seems to be neccessary for many cases, we'll leave it in for now. |
| -- If widgets seem to anchor weirdly with this, provide a valid alignoffset for them. |
| -- TODO: Investigate moar! |
| frameoffset = child.alignoffset or (frameheight / 2) |
| if child.width == "relative" then |
| framewidth = width * child.relWidth |
| end |
| frame:Show() |
| frame:ClearAllPoints() |
| if i == 1 then |
| -- anchor the first control to the top left |
| frame:SetPoint("TOPLEFT", content) |
| rowheight = frameheight |
| rowoffset = frameoffset |
| rowstart = frame |
| rowstartoffset = frameoffset |
| usedwidth = framewidth |
| if usedwidth > width then |
| oversize = true |
| end |
| else |
| -- if there isn't available width for the control start a new row |
| -- if a control is "fill" it will be on a row of its own full width |
| if usedwidth == 0 or ((framewidth) + usedwidth > width) or child.width == "fill" then |
| if isfullheight then |
| -- a previous row has already filled the entire height, there's nothing we can usefully do anymore |
| -- (maybe error/warn about this?) |
| break |
| end |
| --anchor the previous row, we will now know its height and offset |
| rowstart:SetPoint("TOPLEFT", content, "TOPLEFT", 0, -(height + (rowoffset - rowstartoffset) + 3)) |
| height = height + rowheight + 3 |
| --save this as the rowstart so we can anchor it after the row is complete and we have the max height and offset of controls in it |
| rowstart = frame |
| rowstartoffset = frameoffset |
| rowheight = frameheight |
| rowoffset = frameoffset |
| usedwidth = framewidth |
| if usedwidth > width then |
| oversize = true |
| end |
| -- put the control on the current row, adding it to the width and checking if the height needs to be increased |
| else |
| --handles cases where the new height is higher than either control because of the offsets |
| --math.max(rowheight-rowoffset+frameoffset, frameheight-frameoffset+rowoffset) |
| --offset is always the larger of the two offsets |
| rowoffset = math_max(rowoffset, frameoffset) |
| rowheight = math_max(rowheight, rowoffset + (frameheight / 2)) |
| frame:SetPoint("TOPLEFT", children[i-1].frame, "TOPRIGHT", 0, frameoffset - lastframeoffset) |
| usedwidth = framewidth + usedwidth |
| end |
| end |
| if child.width == "fill" then |
| child:SetWidth(width) |
| frame:SetPoint("RIGHT", content) |
| usedwidth = 0 |
| rowstart = frame |
| rowstartoffset = frameoffset |
| if child.DoLayout then |
| child:DoLayout() |
| end |
| rowheight = frame.height or frame:GetHeight() or 0 |
| rowoffset = child.alignoffset or (rowheight / 2) |
| rowstartoffset = rowoffset |
| elseif child.width == "relative" then |
| child:SetWidth(width * child.relWidth) |
| if child.DoLayout then |
| child:DoLayout() |
| end |
| elseif oversize then |
| if width > 1 then |
| frame:SetPoint("RIGHT", content) |
| end |
| end |
| if child.height == "fill" then |
| frame:SetPoint("BOTTOM", content) |
| isfullheight = true |
| end |
| end |
| --anchor the last row, if its full height needs a special case since its height has just been changed by the anchor |
| if isfullheight then |
| rowstart:SetPoint("TOPLEFT", content, "TOPLEFT", 0, -height) |
| elseif rowstart then |
| rowstart:SetPoint("TOPLEFT", content, "TOPLEFT", 0, -(height + (rowoffset - rowstartoffset) + 3)) |
| end |
| height = height + rowheight + 3 |
| safecall(content.obj.LayoutFinished, content.obj, nil, height) |
| end) |
mRunes/Libs/AceGUI-3.0-SharedMediaWidgets/Libs/LibStub/LibStub.lua
New file
0,0 → 1,30
| -- LibStub is a simple versioning stub meant for use in Libraries. http://www.wowace.com/wiki/LibStub for more info |
| -- LibStub is hereby placed in the Public Domain Credits: Kaelten, Cladhaire, ckknight, Mikk, Ammo, Nevcairiel, joshborke |
| local LIBSTUB_MAJOR, LIBSTUB_MINOR = "LibStub", 2 -- NEVER MAKE THIS AN SVN REVISION! IT NEEDS TO BE USABLE IN ALL REPOS! |
| local LibStub = _G[LIBSTUB_MAJOR] |
| if not LibStub or LibStub.minor < LIBSTUB_MINOR then |
| LibStub = LibStub or {libs = {}, minors = {} } |
| _G[LIBSTUB_MAJOR] = LibStub |
| LibStub.minor = LIBSTUB_MINOR |
| function LibStub:NewLibrary(major, minor) |
| assert(type(major) == "string", "Bad argument #2 to `NewLibrary' (string expected)") |
| minor = assert(tonumber(strmatch(minor, "%d+")), "Minor version must either be a number or contain a number.") |
| local oldminor = self.minors[major] |
| if oldminor and oldminor >= minor then return nil end |
| self.minors[major], self.libs[major] = minor, self.libs[major] or {} |
| return self.libs[major], oldminor |
| end |
| function LibStub:GetLibrary(major, silent) |
| if not self.libs[major] and not silent then |
| error(("Cannot find a library instance of %q."):format(tostring(major)), 2) |
| end |
| return self.libs[major], self.minors[major] |
| end |
| function LibStub:IterateLibraries() return pairs(self.libs) end |
| setmetatable(LibStub, { __call = LibStub.GetLibrary }) |
| end |
mRunes/Libs/AceGUI-3.0-SharedMediaWidgets/Libs/LibStub/LibStub.toc
New file
0,0 → 1,13
| ## Interface: 20400 |
| ## Title: Lib: LibStub |
| ## Notes: Universal Library Stub |
| ## Credits: Kaelten, Cladhaire, ckknight, Mikk, Ammo, Nevcairiel |
| ## X-Website: http://jira.wowace.com/browse/LS |
| ## X-Category: Library |
| ## X-License: Public Domain |
| ## X-Curse-Packaged-Version: 1.0 |
| ## X-Curse-Project-Name: LibStub |
| ## X-Curse-Project-ID: libstub |
| ## X-Curse-Repository-ID: wow/libstub/mainline |
| LibStub.lua |
mRunes/Libs/AceGUI-3.0-SharedMediaWidgets/FontWidget.lua
New file
0,0 → 1,214
| -- Widget is based on the AceGUIWidget-DropDown.lua supplied with AceGUI-3.0 |
| -- Widget created by Yssaril |
| local AceGUI = LibStub("AceGUI-3.0") |
| local Media = LibStub("LibSharedMedia-3.0") |
| local AGSMW = LibStub("AceGUISharedMediaWidgets-1.0") |
| do |
| local widgetType = "LSM30_Font" |
| local widgetVersion = 9 |
| local contentFrameCache = {} |
| local function ReturnSelf(self) |
| self:ClearAllPoints() |
| self:Hide() |
| self.check:Hide() |
| table.insert(contentFrameCache, self) |
| end |
| local function ContentOnClick(this, button) |
| local self = this.obj |
| self:Fire("OnValueChanged", this.text:GetText()) |
| if self.dropdown then |
| self.dropdown = AGSMW:ReturnDropDownFrame(self.dropdown) |
| end |
| end |
| local function GetContentLine() |
| local frame |
| if next(contentFrameCache) then |
| frame = table.remove(contentFrameCache) |
| else |
| frame = CreateFrame("Button", nil, UIParent) |
| --frame:SetWidth(200) |
| frame:SetHeight(18) |
| frame:SetHighlightTexture([[Interface\QuestFrame\UI-QuestTitleHighlight]], "ADD") |
| frame:SetScript("OnClick", ContentOnClick) |
| local check = frame:CreateTexture("OVERLAY") |
| check:SetWidth(16) |
| check:SetHeight(16) |
| check:SetPoint("LEFT",frame,"LEFT",1,-1) |
| check:SetTexture("Interface\\Buttons\\UI-CheckBox-Check") |
| check:Hide() |
| frame.check = check |
| local text = frame:CreateFontString(nil,"OVERLAY","GameFontWhite") |
| text:SetPoint("LEFT", check, "RIGHT", 1, 0) |
| text:SetPoint("RIGHT", frame, "RIGHT", -2, 0) |
| text:SetJustifyH("LEFT") |
| text:SetText("Test Test Test Test Test Test Test") |
| frame.text = text |
| frame.ReturnSelf = ReturnSelf |
| end |
| frame:Show() |
| return frame |
| end |
| local function OnAcquire(self) |
| self:SetHeight(44) |
| self:SetWidth(200) |
| end |
| local function OnRelease(self) |
| self:SetText("") |
| self:SetLabel("") |
| self:SetDisabled(false) |
| self.value = nil |
| self.list = nil |
| self.open = nil |
| self.hasClose = nil |
| self.frame:ClearAllPoints() |
| self.frame:Hide() |
| end |
| local function SetValue(self, value) -- Set the value to an item in the List. |
| if self.list then |
| self:SetText(value or "") |
| end |
| self.value = value |
| end |
| local function GetValue(self) |
| return self.value |
| end |
| local function SetList(self, list) -- Set the list of values for the dropdown (key => value pairs) |
| self.list = list or Media:HashTable("font") |
| end |
| local function SetText(self, text) -- Set the text displayed in the box. |
| self.frame.text:SetText(text or "") |
| local font = self.list[text] ~= text and self.list[text] or Media:Fetch('font',text) |
| local _, size, outline= self.frame.text:GetFont() |
| self.frame.text:SetFont(font,size,outline) |
| end |
| local function SetLabel(self, text) -- Set the text for the label. |
| self.frame.label:SetText(text or "") |
| end |
| local function AddItem(self, key, value) -- Add an item to the list. |
| self.list = self.list or {} |
| self.list[key] = value |
| end |
| local SetItemValue = AddItem -- Set the value of a item in the list. <<same as adding a new item>> |
| local function SetMultiselect(self, flag) end -- Toggle multi-selecting. <<Dummy function to stay inline with the dropdown API>> |
| local function GetMultiselect() return false end-- Query the multi-select flag. <<Dummy function to stay inline with the dropdown API>> |
| local function SetItemDisabled(self, key) end-- Disable one item in the list. <<Dummy function to stay inline with the dropdown API>> |
| local function SetDisabled(self, disabled) -- Disable the widget. |
| self.disabled = disabled |
| if disabled then |
| self.frame:Disable() |
| else |
| self.frame:Enable() |
| end |
| end |
| local function textSort(a,b) |
| return string.upper(a) < string.upper(b) |
| end |
| local sortedlist = {} |
| local function ToggleDrop(this) |
| local self = this.obj |
| if self.dropdown then |
| self.dropdown = AGSMW:ReturnDropDownFrame(self.dropdown) |
| AceGUI:ClearFocus() |
| else |
| AceGUI:SetFocus(self) |
| self.dropdown = AGSMW:GetDropDownFrame() |
| self.dropdown:SetPoint("TOPLEFT", self.frame, "BOTTOMLEFT") |
| for k, v in pairs(self.list) do |
| sortedlist[#sortedlist+1] = k |
| end |
| table.sort(sortedlist, textSort) |
| for i, k in ipairs(sortedlist) do |
| local f = GetContentLine() |
| local _, size, outline= f.text:GetFont() |
| local font = self.list[k] ~= k and self.list[k] or Media:Fetch('font',k) |
| f.text:SetFont(font,size,outline) |
| f.text:SetText(k) |
| if k == self.value then |
| f.check:Show() |
| end |
| f.obj = self |
| self.dropdown:AddFrame(f) |
| end |
| wipe(sortedlist) |
| end |
| end |
| local function ClearFocus(self) |
| if self.dropdown then |
| self.dropdown = AGSMW:ReturnDropDownFrame(self.dropdown) |
| end |
| end |
| local function OnHide(this) |
| local self = this.obj |
| if self.dropdown then |
| self.dropdown = AGSMW:ReturnDropDownFrame(self.dropdown) |
| end |
| end |
| local function Drop_OnEnter(this) |
| this.obj:Fire("OnEnter") |
| end |
| local function Drop_OnLeave(this) |
| this.obj:Fire("OnLeave") |
| end |
| local function Constructor() |
| local frame = AGSMW:GetBaseFrame() |
| local self = {} |
| self.type = widgetType |
| self.frame = frame |
| frame.obj = self |
| frame.dropButton.obj = self |
| frame.dropButton:SetScript("OnEnter", Drop_OnEnter) |
| frame.dropButton:SetScript("OnLeave", Drop_OnLeave) |
| frame.dropButton:SetScript("OnClick",ToggleDrop) |
| frame:SetScript("OnHide", OnHide) |
| self.alignoffset = 31 |
| self.OnRelease = OnRelease |
| self.OnAcquire = OnAcquire |
| self.ClearFocus = ClearFocus |
| self.SetText = SetText |
| self.SetValue = SetValue |
| self.GetValue = GetValue |
| self.SetList = SetList |
| self.SetLabel = SetLabel |
| self.SetDisabled = SetDisabled |
| self.AddItem = AddItem |
| self.SetMultiselect = SetMultiselect |
| self.GetMultiselect = GetMultiselect |
| self.SetItemValue = SetItemValue |
| self.SetItemDisabled = SetItemDisabled |
| self.ToggleDrop = ToggleDrop |
| AceGUI:RegisterAsWidget(self) |
| return self |
| end |
| AceGUI:RegisterWidgetType(widgetType, Constructor, widgetVersion) |
| end |
mRunes/Libs/AceGUI-3.0-SharedMediaWidgets/SoundWidget.lua
New file
0,0 → 1,262
| -- Widget is based on the AceGUIWidget-DropDown.lua supplied with AceGUI-3.0 |
| -- Widget created by Yssaril |
| local AceGUI = LibStub("AceGUI-3.0") |
| local Media = LibStub("LibSharedMedia-3.0") |
| local AGSMW = LibStub("AceGUISharedMediaWidgets-1.0") |
| do |
| local widgetType = "LSM30_Sound" |
| local widgetVersion = 9 |
| local contentFrameCache = {} |
| local function ReturnSelf(self) |
| self:ClearAllPoints() |
| self:Hide() |
| self.check:Hide() |
| table.insert(contentFrameCache, self) |
| end |
| local function ContentOnClick(this, button) |
| local self = this.obj |
| self:Fire("OnValueChanged", this.text:GetText()) |
| if self.dropdown then |
| self.dropdown = AGSMW:ReturnDropDownFrame(self.dropdown) |
| end |
| end |
| local function ContentSpeakerOnClick(this, button) |
| local self = this.frame.obj |
| local sound = this.frame.text:GetText() |
| PlaySoundFile(self.list[sound] ~= sound and self.list[sound] or Media:Fetch('sound',sound)) |
| end |
| local function GetContentLine() |
| local frame |
| if next(contentFrameCache) then |
| frame = table.remove(contentFrameCache) |
| else |
| frame = CreateFrame("Button", nil, UIParent) |
| --frame:SetWidth(200) |
| frame:SetHeight(18) |
| frame:SetHighlightTexture([[Interface\QuestFrame\UI-QuestTitleHighlight]], "ADD") |
| frame:SetScript("OnClick", ContentOnClick) |
| local check = frame:CreateTexture("OVERLAY") |
| check:SetWidth(16) |
| check:SetHeight(16) |
| check:SetPoint("LEFT",frame,"LEFT",1,-1) |
| check:SetTexture("Interface\\Buttons\\UI-CheckBox-Check") |
| check:Hide() |
| frame.check = check |
| local soundbutton = CreateFrame("Button", nil, frame) |
| soundbutton:SetWidth(16) |
| soundbutton:SetHeight(16) |
| soundbutton:SetPoint("RIGHT",frame,"RIGHT",-1,0) |
| soundbutton.frame = frame |
| soundbutton:SetScript("OnClick", ContentSpeakerOnClick) |
| frame.soundbutton = soundbutton |
| local speaker = soundbutton:CreateTexture(nil, "BACKGROUND") |
| speaker:SetTexture("Interface\\Common\\VoiceChat-Speaker") |
| speaker:SetAllPoints(soundbutton) |
| frame.speaker = speaker |
| local speakeron = soundbutton:CreateTexture(nil, "HIGHLIGHT") |
| speakeron:SetTexture("Interface\\Common\\VoiceChat-On") |
| speakeron:SetAllPoints(soundbutton) |
| frame.speakeron = speakeron |
| local text = frame:CreateFontString(nil,"OVERLAY","GameFontWhite") |
| text:SetPoint("LEFT", check, "RIGHT", 1, 0) |
| text:SetPoint("RIGHT", soundbutton, "LEFT", -2, 0) |
| text:SetJustifyH("LEFT") |
| text:SetText("Test Test Test Test Test Test Test") |
| frame.text = text |
| frame.ReturnSelf = ReturnSelf |
| end |
| frame:Show() |
| return frame |
| end |
| local function OnAcquire(self) |
| self:SetHeight(44) |
| self:SetWidth(200) |
| end |
| local function OnRelease(self) |
| self:SetText("") |
| self:SetLabel("") |
| self:SetDisabled(false) |
| self.value = nil |
| self.list = nil |
| self.open = nil |
| self.hasClose = nil |
| self.frame:ClearAllPoints() |
| self.frame:Hide() |
| end |
| local function SetValue(self, value) -- Set the value to an item in the List. |
| if self.list then |
| self:SetText(value or "") |
| end |
| self.value = value |
| end |
| local function GetValue(self) |
| return self.value |
| end |
| local function SetList(self, list) -- Set the list of values for the dropdown (key => value pairs) |
| self.list = list or Media:HashTable("sound") |
| end |
| local function SetText(self, text) -- Set the text displayed in the box. |
| self.frame.text:SetText(text or "") |
| end |
| local function SetLabel(self, text) -- Set the text for the label. |
| self.frame.label:SetText(text or "") |
| end |
| local function AddItem(self, key, value) -- Add an item to the list. |
| self.list = self.list or {} |
| self.list[key] = value |
| end |
| local SetItemValue = AddItem -- Set the value of a item in the list. <<same as adding a new item>> |
| local function SetMultiselect(self, flag) end -- Toggle multi-selecting. <<Dummy function to stay inline with the dropdown API>> |
| local function GetMultiselect() return false end-- Query the multi-select flag. <<Dummy function to stay inline with the dropdown API>> |
| local function SetItemDisabled(self, key) end-- Disable one item in the list. <<Dummy function to stay inline with the dropdown API>> |
| local function SetDisabled(self, disabled) -- Disable the widget. |
| self.disabled = disabled |
| if disabled then |
| self.frame:Disable() |
| self.speaker:SetDesaturated(true) |
| self.speakeron:SetDesaturated(true) |
| else |
| self.frame:Enable() |
| self.speaker:SetDesaturated(false) |
| self.speakeron:SetDesaturated(false) |
| end |
| end |
| local function textSort(a,b) |
| return string.upper(a) < string.upper(b) |
| end |
| local sortedlist = {} |
| local function ToggleDrop(this) |
| local self = this.obj |
| if self.dropdown then |
| self.dropdown = AGSMW:ReturnDropDownFrame(self.dropdown) |
| AceGUI:ClearFocus() |
| else |
| AceGUI:SetFocus(self) |
| self.dropdown = AGSMW:GetDropDownFrame() |
| self.dropdown:SetPoint("TOPLEFT", self.frame, "BOTTOMLEFT") |
| for k, v in pairs(self.list) do |
| sortedlist[#sortedlist+1] = k |
| end |
| table.sort(sortedlist, textSort) |
| for i, k in ipairs(sortedlist) do |
| local f = GetContentLine() |
| f.text:SetText(k) |
| if k == self.value then |
| f.check:Show() |
| end |
| f.obj = self |
| self.dropdown:AddFrame(f) |
| end |
| wipe(sortedlist) |
| end |
| end |
| local function ClearFocus(self) |
| if self.dropdown then |
| self.dropdown = AGSMW:ReturnDropDownFrame(self.dropdown) |
| end |
| end |
| local function OnHide(this) |
| local self = this.obj |
| if self.dropdown then |
| self.dropdown = AGSMW:ReturnDropDownFrame(self.dropdown) |
| end |
| end |
| local function Drop_OnEnter(this) |
| this.obj:Fire("OnEnter") |
| end |
| local function Drop_OnLeave(this) |
| this.obj:Fire("OnLeave") |
| end |
| local function WidgetPlaySound(this) |
| local self = this.obj |
| local sound = self.frame.text:GetText() |
| PlaySoundFile(self.list[sound] ~= sound and self.list[sound] or Media:Fetch('sound',sound)) |
| end |
| local function Constructor() |
| local frame = AGSMW:GetBaseFrame() |
| local self = {} |
| self.type = widgetType |
| self.frame = frame |
| frame.obj = self |
| frame.dropButton.obj = self |
| frame.dropButton:SetScript("OnEnter", Drop_OnEnter) |
| frame.dropButton:SetScript("OnLeave", Drop_OnLeave) |
| frame.dropButton:SetScript("OnClick",ToggleDrop) |
| frame:SetScript("OnHide", OnHide) |
| local soundbutton = CreateFrame("Button", nil, frame) |
| soundbutton:SetWidth(16) |
| soundbutton:SetHeight(16) |
| soundbutton:SetPoint("LEFT",frame.DLeft,"LEFT",26,1) |
| soundbutton:SetScript("OnClick", WidgetPlaySound) |
| soundbutton.obj = self |
| self.soundbutton = soundbutton |
| frame.text:SetPoint("LEFT",soundbutton,"RIGHT",2,0) |
| local speaker = soundbutton:CreateTexture(nil, "BACKGROUND") |
| speaker:SetTexture("Interface\\Common\\VoiceChat-Speaker") |
| speaker:SetAllPoints(soundbutton) |
| self.speaker = speaker |
| local speakeron = soundbutton:CreateTexture(nil, "HIGHLIGHT") |
| speakeron:SetTexture("Interface\\Common\\VoiceChat-On") |
| speakeron:SetAllPoints(soundbutton) |
| self.speakeron = speakeron |
| self.alignoffset = 31 |
| self.OnRelease = OnRelease |
| self.OnAcquire = OnAcquire |
| self.ClearFocus = ClearFocus |
| self.SetText = SetText |
| self.SetValue = SetValue |
| self.GetValue = GetValue |
| self.SetList = SetList |
| self.SetLabel = SetLabel |
| self.SetDisabled = SetDisabled |
| self.AddItem = AddItem |
| self.SetMultiselect = SetMultiselect |
| self.GetMultiselect = GetMultiselect |
| self.SetItemValue = SetItemValue |
| self.SetItemDisabled = SetItemDisabled |
| self.ToggleDrop = ToggleDrop |
| AceGUI:RegisterAsWidget(self) |
| return self |
| end |
| AceGUI:RegisterWidgetType(widgetType, Constructor, widgetVersion) |
| end |
mRunes/Libs/AceGUI-3.0-SharedMediaWidgets/StatusbarWidget.lua
New file
0,0 → 1,230
| -- Widget is based on the AceGUIWidget-DropDown.lua supplied with AceGUI-3.0 |
| -- Widget created by Yssaril |
| local AceGUI = LibStub("AceGUI-3.0") |
| local Media = LibStub("LibSharedMedia-3.0") |
| local AGSMW = LibStub("AceGUISharedMediaWidgets-1.0") |
| do |
| local widgetType = "LSM30_Statusbar" |
| local widgetVersion = 9 |
| local contentFrameCache = {} |
| local function ReturnSelf(self) |
| self:ClearAllPoints() |
| self:Hide() |
| self.check:Hide() |
| table.insert(contentFrameCache, self) |
| end |
| local function ContentOnClick(this, button) |
| local self = this.obj |
| self:Fire("OnValueChanged", this.text:GetText()) |
| if self.dropdown then |
| self.dropdown = AGSMW:ReturnDropDownFrame(self.dropdown) |
| end |
| end |
| local function GetContentLine() |
| local frame |
| if next(contentFrameCache) then |
| frame = table.remove(contentFrameCache) |
| else |
| frame = CreateFrame("Button", nil, UIParent) |
| --frame:SetWidth(200) |
| frame:SetHeight(18) |
| frame:SetHighlightTexture([[Interface\QuestFrame\UI-QuestTitleHighlight]], "ADD") |
| frame:SetScript("OnClick", ContentOnClick) |
| local check = frame:CreateTexture("OVERLAY") |
| check:SetWidth(16) |
| check:SetHeight(16) |
| check:SetPoint("LEFT",frame,"LEFT",1,-1) |
| check:SetTexture("Interface\\Buttons\\UI-CheckBox-Check") |
| check:Hide() |
| frame.check = check |
| local bar = frame:CreateTexture("ARTWORK") |
| bar:SetHeight(16) |
| bar:SetPoint("LEFT",check,"RIGHT",1,0) |
| bar:SetPoint("RIGHT",frame,"RIGHT",-1,0) |
| frame.bar = bar |
| local text = frame:CreateFontString(nil,"OVERLAY","GameFontWhite") |
| local font, size = text:GetFont() |
| text:SetFont(font,size,"OUTLINE") |
| text:SetPoint("LEFT", check, "RIGHT", 3, 0) |
| text:SetPoint("RIGHT", frame, "RIGHT", -2, 0) |
| text:SetJustifyH("LEFT") |
| text:SetText("Test Test Test Test Test Test Test") |
| frame.text = text |
| frame.ReturnSelf = ReturnSelf |
| end |
| frame:Show() |
| return frame |
| end |
| local function OnAcquire(self) |
| self:SetHeight(44) |
| self:SetWidth(200) |
| end |
| local function OnRelease(self) |
| self:SetText("") |
| self:SetLabel("") |
| self:SetDisabled(false) |
| self.value = nil |
| self.list = nil |
| self.open = nil |
| self.hasClose = nil |
| self.frame:ClearAllPoints() |
| self.frame:Hide() |
| end |
| local function SetValue(self, value) -- Set the value to an item in the List. |
| if self.list then |
| self:SetText(value or "") |
| end |
| self.value = value |
| end |
| local function GetValue(self) |
| return self.value |
| end |
| local function SetList(self, list) -- Set the list of values for the dropdown (key => value pairs) |
| self.list = list or Media:HashTable("statusbar") |
| end |
| local function SetText(self, text) -- Set the text displayed in the box. |
| self.frame.text:SetText(text or "") |
| local statusbar = self.list[text] ~= text and self.list[text] or Media:Fetch('statusbar',text) |
| self.bar:SetTexture(statusbar) |
| end |
| local function SetLabel(self, text) -- Set the text for the label. |
| self.frame.label:SetText(text or "") |
| end |
| local function AddItem(self, key, value) -- Add an item to the list. |
| self.list = self.list or {} |
| self.list[key] = value |
| end |
| local SetItemValue = AddItem -- Set the value of a item in the list. <<same as adding a new item>> |
| local function SetMultiselect(self, flag) end -- Toggle multi-selecting. <<Dummy function to stay inline with the dropdown API>> |
| local function GetMultiselect() return false end-- Query the multi-select flag. <<Dummy function to stay inline with the dropdown API>> |
| local function SetItemDisabled(self, key) end-- Disable one item in the list. <<Dummy function to stay inline with the dropdown API>> |
| local function SetDisabled(self, disabled) -- Disable the widget. |
| self.disabled = disabled |
| if disabled then |
| self.frame:Disable() |
| else |
| self.frame:Enable() |
| end |
| end |
| local function textSort(a,b) |
| return string.upper(a) < string.upper(b) |
| end |
| local sortedlist = {} |
| local function ToggleDrop(this) |
| local self = this.obj |
| if self.dropdown then |
| self.dropdown = AGSMW:ReturnDropDownFrame(self.dropdown) |
| AceGUI:ClearFocus() |
| else |
| AceGUI:SetFocus(self) |
| self.dropdown = AGSMW:GetDropDownFrame() |
| self.dropdown:SetPoint("TOPLEFT", self.frame, "BOTTOMLEFT") |
| for k, v in pairs(self.list) do |
| sortedlist[#sortedlist+1] = k |
| end |
| table.sort(sortedlist, textSort) |
| for i, k in ipairs(sortedlist) do |
| local f = GetContentLine() |
| f.text:SetText(k) |
| --print(k) |
| if k == self.value then |
| f.check:Show() |
| end |
| local statusbar = self.list[k] ~= k and self.list[k] or Media:Fetch('statusbar',k) |
| f.bar:SetTexture(statusbar) |
| f.obj = self |
| f.dropdown = self.dropdown |
| self.dropdown:AddFrame(f) |
| end |
| wipe(sortedlist) |
| end |
| end |
| local function ClearFocus(self) |
| if self.dropdown then |
| self.dropdown = AGSMW:ReturnDropDownFrame(self.dropdown) |
| end |
| end |
| local function OnHide(this) |
| local self = this.obj |
| if self.dropdown then |
| self.dropdown = AGSMW:ReturnDropDownFrame(self.dropdown) |
| end |
| end |
| local function Drop_OnEnter(this) |
| this.obj:Fire("OnEnter") |
| end |
| local function Drop_OnLeave(this) |
| this.obj:Fire("OnLeave") |
| end |
| local function Constructor() |
| local frame = AGSMW:GetBaseFrame() |
| local self = {} |
| self.type = widgetType |
| self.frame = frame |
| frame.obj = self |
| frame.dropButton.obj = self |
| frame.dropButton:SetScript("OnEnter", Drop_OnEnter) |
| frame.dropButton:SetScript("OnLeave", Drop_OnLeave) |
| frame.dropButton:SetScript("OnClick",ToggleDrop) |
| frame:SetScript("OnHide", OnHide) |
| local bar = frame:CreateTexture(nil, "ARTWORK") |
| bar:SetPoint("TOPLEFT", frame,"TOPLEFT",6,-25) |
| bar:SetPoint("BOTTOMRIGHT", frame,"BOTTOMRIGHT", -21, 5) |
| self.bar = bar |
| self.alignoffset = 31 |
| self.OnRelease = OnRelease |
| self.OnAcquire = OnAcquire |
| self.ClearFocus = ClearFocus |
| self.SetText = SetText |
| self.SetValue = SetValue |
| self.GetValue = GetValue |
| self.SetList = SetList |
| self.SetLabel = SetLabel |
| self.SetDisabled = SetDisabled |
| self.AddItem = AddItem |
| self.SetMultiselect = SetMultiselect |
| self.GetMultiselect = GetMultiselect |
| self.SetItemValue = SetItemValue |
| self.SetItemDisabled = SetItemDisabled |
| self.ToggleDrop = ToggleDrop |
| AceGUI:RegisterAsWidget(self) |
| return self |
| end |
| AceGUI:RegisterWidgetType(widgetType, Constructor, widgetVersion) |
| end |
mRunes/Libs/AceGUI-3.0-SharedMediaWidgets/BorderWidget.lua
New file
0,0 → 1,228
| -- Widget is based on the AceGUIWidget-DropDown.lua supplied with AceGUI-3.0 |
| -- Widget created by Yssaril |
| local AceGUI = LibStub("AceGUI-3.0") |
| local Media = LibStub("LibSharedMedia-3.0") |
| local AGSMW = LibStub("AceGUISharedMediaWidgets-1.0") |
| do |
| local widgetType = "LSM30_Border" |
| local widgetVersion = 9 |
| local contentFrameCache = {} |
| local function ReturnSelf(self) |
| self:ClearAllPoints() |
| self:Hide() |
| self.check:Hide() |
| table.insert(contentFrameCache, self) |
| end |
| local function ContentOnClick(this, button) |
| local self = this.obj |
| self:Fire("OnValueChanged", this.text:GetText()) |
| if self.dropdown then |
| self.dropdown = AGSMW:ReturnDropDownFrame(self.dropdown) |
| end |
| end |
| local function ContentOnEnter(this, button) |
| local self = this.obj |
| local text = this.text:GetText() |
| local border = self.list[text] ~= text and self.list[text] or Media:Fetch('border',text) |
| this.dropdown:SetBackdrop({edgeFile = border, |
| bgFile=[[Interface\DialogFrame\UI-DialogBox-Background-Dark]], |
| tile = true, tileSize = 16, edgeSize = 16, |
| insets = { left = 4, right = 4, top = 4, bottom = 4 }}) |
| end |
| local function GetContentLine() |
| local frame |
| if next(contentFrameCache) then |
| frame = table.remove(contentFrameCache) |
| else |
| frame = CreateFrame("Button", nil, UIParent) |
| --frame:SetWidth(200) |
| frame:SetHeight(18) |
| frame:SetHighlightTexture([[Interface\QuestFrame\UI-QuestTitleHighlight]], "ADD") |
| frame:SetScript("OnClick", ContentOnClick) |
| frame:SetScript("OnEnter", ContentOnEnter) |
| local check = frame:CreateTexture("OVERLAY") |
| check:SetWidth(16) |
| check:SetHeight(16) |
| check:SetPoint("LEFT",frame,"LEFT",1,-1) |
| check:SetTexture("Interface\\Buttons\\UI-CheckBox-Check") |
| check:Hide() |
| frame.check = check |
| local text = frame:CreateFontString(nil,"OVERLAY","GameFontWhite") |
| text:SetPoint("LEFT", check, "RIGHT", 1, 0) |
| text:SetPoint("RIGHT", frame, "RIGHT", -2, 0) |
| text:SetJustifyH("LEFT") |
| text:SetText("Test Test Test Test Test Test Test") |
| frame.text = text |
| frame.ReturnSelf = ReturnSelf |
| end |
| frame:Show() |
| return frame |
| end |
| local function OnAcquire(self) |
| self:SetHeight(44) |
| self:SetWidth(200) |
| end |
| local function OnRelease(self) |
| self:SetText("") |
| self:SetLabel("") |
| self:SetDisabled(false) |
| self.value = nil |
| self.list = nil |
| self.open = nil |
| self.hasClose = nil |
| self.frame:ClearAllPoints() |
| self.frame:Hide() |
| end |
| local function SetValue(self, value) -- Set the value to an item in the List. |
| if self.list then |
| self:SetText(value or "") |
| end |
| self.value = value |
| end |
| local function GetValue(self) |
| return self.value |
| end |
| local function SetList(self, list) -- Set the list of values for the dropdown (key => value pairs) |
| self.list = list or Media:HashTable("border") |
| end |
| local function SetText(self, text) -- Set the text displayed in the box. |
| self.frame.text:SetText(text or "") |
| local border = self.list[text] ~= text and self.list[text] or Media:Fetch('border',text) |
| self.frame.displayButton:SetBackdrop({edgeFile = border, |
| bgFile=[[Interface\DialogFrame\UI-DialogBox-Background-Dark]], |
| tile = true, tileSize = 16, edgeSize = 16, |
| insets = { left = 4, right = 4, top = 4, bottom = 4 }}) |
| end |
| local function SetLabel(self, text) -- Set the text for the label. |
| self.frame.label:SetText(text or "") |
| end |
| local function AddItem(self, key, value) -- Add an item to the list. |
| self.list = self.list or {} |
| self.list[key] = value |
| end |
| local SetItemValue = AddItem -- Set the value of a item in the list. <<same as adding a new item>> |
| local function SetMultiselect(self, flag) end -- Toggle multi-selecting. <<Dummy function to stay inline with the dropdown API>> |
| local function GetMultiselect() return false end-- Query the multi-select flag. <<Dummy function to stay inline with the dropdown API>> |
| local function SetItemDisabled(self, key) end-- Disable one item in the list. <<Dummy function to stay inline with the dropdown API>> |
| local function SetDisabled(self, disabled) -- Disable the widget. |
| self.disabled = disabled |
| if disabled then |
| self.frame:Disable() |
| else |
| self.frame:Enable() |
| end |
| end |
| local function textSort(a,b) |
| return string.upper(a) < string.upper(b) |
| end |
| local sortedlist = {} |
| local function ToggleDrop(this) |
| local self = this.obj |
| if self.dropdown then |
| self.dropdown = AGSMW:ReturnDropDownFrame(self.dropdown) |
| AceGUI:ClearFocus() |
| else |
| AceGUI:SetFocus(self) |
| self.dropdown = AGSMW:GetDropDownFrame() |
| self.dropdown:SetPoint("TOPLEFT", self.frame, "BOTTOMLEFT") |
| for k, v in pairs(self.list) do |
| sortedlist[#sortedlist+1] = k |
| end |
| table.sort(sortedlist, textSort) |
| for i, k in ipairs(sortedlist) do |
| local f = GetContentLine() |
| f.text:SetText(k) |
| --print(k) |
| if k == self.value then |
| f.check:Show() |
| end |
| f.obj = self |
| f.dropdown = self.dropdown |
| self.dropdown:AddFrame(f) |
| end |
| wipe(sortedlist) |
| end |
| end |
| local function ClearFocus(self) |
| if self.dropdown then |
| self.dropdown = AGSMW:ReturnDropDownFrame(self.dropdown) |
| end |
| end |
| local function OnHide(this) |
| local self = this.obj |
| if self.dropdown then |
| self.dropdown = AGSMW:ReturnDropDownFrame(self.dropdown) |
| end |
| end |
| local function Drop_OnEnter(this) |
| this.obj:Fire("OnEnter") |
| end |
| local function Drop_OnLeave(this) |
| this.obj:Fire("OnLeave") |
| end |
| local function Constructor() |
| local frame = AGSMW:GetBaseFrameWithWindow() |
| local self = {} |
| self.type = widgetType |
| self.frame = frame |
| frame.obj = self |
| frame.dropButton.obj = self |
| frame.dropButton:SetScript("OnEnter", Drop_OnEnter) |
| frame.dropButton:SetScript("OnLeave", Drop_OnLeave) |
| frame.dropButton:SetScript("OnClick",ToggleDrop) |
| frame:SetScript("OnHide", OnHide) |
| self.alignoffset = 31 |
| self.OnRelease = OnRelease |
| self.OnAcquire = OnAcquire |
| self.ClearFocus = ClearFocus |
| self.SetText = SetText |
| self.SetValue = SetValue |
| self.GetValue = GetValue |
| self.SetList = SetList |
| self.SetLabel = SetLabel |
| self.SetDisabled = SetDisabled |
| self.AddItem = AddItem |
| self.SetMultiselect = SetMultiselect |
| self.GetMultiselect = GetMultiselect |
| self.SetItemValue = SetItemValue |
| self.SetItemDisabled = SetItemDisabled |
| self.ToggleDrop = ToggleDrop |
| AceGUI:RegisterAsWidget(self) |
| return self |
| end |
| AceGUI:RegisterWidgetType(widgetType, Constructor, widgetVersion) |
| end |
mRunes/Libs/AceGUI-3.0-SharedMediaWidgets/widget.xml
New file
0,0 → 1,9
\ No newline at end of file
| <Ui xmlns="http://www.blizzard.com/wow/ui/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.blizzard.com/wow/ui/ |
| ..\FrameXML\UI.xsd"> |
| <Script file="prototypes.lua" /> |
| <Script file="FontWidget.lua" /> |
| <Script file="SoundWidget.lua" /> |
| <Script file="StatusbarWidget.lua" /> |
| <Script file="BorderWidget.lua" /> |
| <Script file="BackgroundWidget.lua" /> |
| </Ui> |
mRunes/Libs/CallbackHandler-1.0/CallbackHandler-1.0.xml
New file
0,0 → 1,4
\ No newline at end of file
| <Ui xmlns="http://www.blizzard.com/wow/ui/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.blizzard.com/wow/ui/ |
| ..\FrameXML\UI.xsd"> |
| <Script file="CallbackHandler-1.0.lua"/> |
| </Ui> |
mRunes/Libs/CallbackHandler-1.0/CallbackHandler-1.0.lua
New file
0,0 → 1,239
| --[[ $Id: CallbackHandler-1.0.lua 3 2008-09-29 16:54:20Z nevcairiel $ ]] |
| local MAJOR, MINOR = "CallbackHandler-1.0", 3 |
| local CallbackHandler = LibStub:NewLibrary(MAJOR, MINOR) |
| if not CallbackHandler then return end -- No upgrade needed |
| local meta = {__index = function(tbl, key) tbl[key] = {} return tbl[key] end} |
| local type = type |
| local pcall = pcall |
| local pairs = pairs |
| local assert = assert |
| local concat = table.concat |
| local loadstring = loadstring |
| local next = next |
| local select = select |
| local type = type |
| local xpcall = xpcall |
| local function errorhandler(err) |
| return geterrorhandler()(err) |
| end |
| local function CreateDispatcher(argCount) |
| local code = [[ |
| local next, xpcall, eh = ... |
| local method, ARGS |
| local function call() method(ARGS) end |
| local function dispatch(handlers, ...) |
| local index |
| index, method = next(handlers) |
| if not method then return end |
| local OLD_ARGS = ARGS |
| ARGS = ... |
| repeat |
| xpcall(call, eh) |
| index, method = next(handlers, index) |
| until not method |
| ARGS = OLD_ARGS |
| end |
| return dispatch |
| ]] |
| local ARGS, OLD_ARGS = {}, {} |
| for i = 1, argCount do ARGS[i], OLD_ARGS[i] = "arg"..i, "old_arg"..i end |
| code = code:gsub("OLD_ARGS", concat(OLD_ARGS, ", ")):gsub("ARGS", concat(ARGS, ", ")) |
| return assert(loadstring(code, "safecall Dispatcher["..argCount.."]"))(next, xpcall, errorhandler) |
| end |
| local Dispatchers = setmetatable({}, {__index=function(self, argCount) |
| local dispatcher = CreateDispatcher(argCount) |
| rawset(self, argCount, dispatcher) |
| return dispatcher |
| end}) |
| -------------------------------------------------------------------------- |
| -- CallbackHandler:New |
| -- |
| -- target - target object to embed public APIs in |
| -- RegisterName - name of the callback registration API, default "RegisterCallback" |
| -- UnregisterName - name of the callback unregistration API, default "UnregisterCallback" |
| -- UnregisterAllName - name of the API to unregister all callbacks, default "UnregisterAllCallbacks". false == don't publish this API. |
| function CallbackHandler:New(target, RegisterName, UnregisterName, UnregisterAllName, OnUsed, OnUnused) |
| -- TODO: Remove this after beta has gone out |
| assert(not OnUsed and not OnUnused, "ACE-80: OnUsed/OnUnused are deprecated. Callbacks are now done to registry.OnUsed and registry.OnUnused") |
| RegisterName = RegisterName or "RegisterCallback" |
| UnregisterName = UnregisterName or "UnregisterCallback" |
| if UnregisterAllName==nil then -- false is used to indicate "don't want this method" |
| UnregisterAllName = "UnregisterAllCallbacks" |
| end |
| -- we declare all objects and exported APIs inside this closure to quickly gain access |
| -- to e.g. function names, the "target" parameter, etc |
| -- Create the registry object |
| local events = setmetatable({}, meta) |
| local registry = { recurse=0, events=events } |
| -- registry:Fire() - fires the given event/message into the registry |
| function registry:Fire(eventname, ...) |
| if not rawget(events, eventname) or not next(events[eventname]) then return end |
| local oldrecurse = registry.recurse |
| registry.recurse = oldrecurse + 1 |
| Dispatchers[select('#', ...) + 1](events[eventname], eventname, ...) |
| registry.recurse = oldrecurse |
| if registry.insertQueue and oldrecurse==0 then |
| -- Something in one of our callbacks wanted to register more callbacks; they got queued |
| for eventname,callbacks in pairs(registry.insertQueue) do |
| local first = not rawget(events, eventname) or not next(events[eventname]) -- test for empty before. not test for one member after. that one member may have been overwritten. |
| for self,func in pairs(callbacks) do |
| events[eventname][self] = func |
| -- fire OnUsed callback? |
| if first and registry.OnUsed then |
| registry.OnUsed(registry, target, eventname) |
| first = nil |
| end |
| end |
| end |
| registry.insertQueue = nil |
| end |
| end |
| -- Registration of a callback, handles: |
| -- self["method"], leads to self["method"](self, ...) |
| -- self with function ref, leads to functionref(...) |
| -- "addonId" (instead of self) with function ref, leads to functionref(...) |
| -- all with an optional arg, which, if present, gets passed as first argument (after self if present) |
| target[RegisterName] = function(self, eventname, method, ... --[[actually just a single arg]]) |
| if type(eventname) ~= "string" then |
| error("Usage: "..RegisterName.."(eventname, method[, arg]): 'eventname' - string expected.", 2) |
| end |
| method = method or eventname |
| local first = not rawget(events, eventname) or not next(events[eventname]) -- test for empty before. not test for one member after. that one member may have been overwritten. |
| if type(method) ~= "string" and type(method) ~= "function" then |
| error("Usage: "..RegisterName.."(\"eventname\", \"methodname\"): 'methodname' - string or function expected.", 2) |
| end |
| local regfunc |
| if type(method) == "string" then |
| -- self["method"] calling style |
| if type(self) ~= "table" then |
| error("Usage: "..RegisterName.."(\"eventname\", \"methodname\"): self was not a table?", 2) |
| elseif self==target then |
| error("Usage: "..RegisterName.."(\"eventname\", \"methodname\"): do not use Library:"..RegisterName.."(), use your own 'self'", 2) |
| elseif type(self[method]) ~= "function" then |
| error("Usage: "..RegisterName.."(\"eventname\", \"methodname\"): 'methodname' - method '"..tostring(method).."' not found on self.", 2) |
| end |
| if select("#",...)>=1 then -- this is not the same as testing for arg==nil! |
| local arg=select(1,...) |
| regfunc = function(...) self[method](self,arg,...) end |
| else |
| regfunc = function(...) self[method](self,...) end |
| end |
| else |
| -- function ref with self=object or self="addonId" |
| if type(self)~="table" and type(self)~="string" then |
| error("Usage: "..RegisterName.."(self or \"addonId\", eventname, method): 'self or addonId': table or string expected.", 2) |
| end |
| if select("#",...)>=1 then -- this is not the same as testing for arg==nil! |
| local arg=select(1,...) |
| regfunc = function(...) method(arg,...) end |
| else |
| regfunc = method |
| end |
| end |
| if events[eventname][self] or registry.recurse<1 then |
| -- if registry.recurse<1 then |
| -- we're overwriting an existing entry, or not currently recursing. just set it. |
| events[eventname][self] = regfunc |
| -- fire OnUsed callback? |
| if registry.OnUsed and first then |
| registry.OnUsed(registry, target, eventname) |
| end |
| else |
| -- we're currently processing a callback in this registry, so delay the registration of this new entry! |
| -- yes, we're a bit wasteful on garbage, but this is a fringe case, so we're picking low implementation overhead over garbage efficiency |
| registry.insertQueue = registry.insertQueue or setmetatable({},meta) |
| registry.insertQueue[eventname][self] = regfunc |
| end |
| end |
| -- Unregister a callback |
| target[UnregisterName] = function(self, eventname) |
| if not self or self==target then |
| error("Usage: "..UnregisterName.."(eventname): bad 'self'", 2) |
| end |
| if type(eventname) ~= "string" then |
| error("Usage: "..UnregisterName.."(eventname): 'eventname' - string expected.", 2) |
| end |
| if rawget(events, eventname) and events[eventname][self] then |
| events[eventname][self] = nil |
| -- Fire OnUnused callback? |
| if registry.OnUnused and not next(events[eventname]) then |
| registry.OnUnused(registry, target, eventname) |
| end |
| end |
| if registry.insertQueue and rawget(registry.insertQueue, eventname) and registry.insertQueue[eventname][self] then |
| registry.insertQueue[eventname][self] = nil |
| end |
| end |
| -- OPTIONAL: Unregister all callbacks for given selfs/addonIds |
| if UnregisterAllName then |
| target[UnregisterAllName] = function(...) |
| if select("#",...)<1 then |
| error("Usage: "..UnregisterAllName.."([whatFor]): missing 'self' or \"addonId\" to unregister events for.", 2) |
| end |
| if select("#",...)==1 and ...==target then |
| error("Usage: "..UnregisterAllName.."([whatFor]): supply a meaningful 'self' or \"addonId\"", 2) |
| end |
| for i=1,select("#",...) do |
| local self = select(i,...) |
| if registry.insertQueue then |
| for eventname, callbacks in pairs(registry.insertQueue) do |
| if callbacks[self] then |
| callbacks[self] = nil |
| end |
| end |
| end |
| for eventname, callbacks in pairs(events) do |
| if callbacks[self] then |
| callbacks[self] = nil |
| -- Fire OnUnused callback? |
| if registry.OnUnused and not next(callbacks) then |
| registry.OnUnused(registry, target, eventname) |
| end |
| end |
| end |
| end |
| end |
| end |
| return registry |
| end |
| -- CallbackHandler purposefully does NOT do explicit embedding. Nor does it |
| -- try to upgrade old implicit embeds since the system is selfcontained and |
| -- relies on closures to work. |
mRunes/Libs/modules.xml
New file
0,0 → 1,16
\ No newline at end of file
| <Ui xmlns="http://www.blizzard.com/wow/ui/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.blizzard.com/wow/ui/ |
| ..\FrameXML\UI.xsd"> |
| <Script file="LibStub\LibStub.lua"/> |
| <Include file="CallbackHandler-1.0\CallbackHandler-1.0.xml"/> |
| <Include file="AceAddon-3.0\AceAddon-3.0.xml"/> |
| <Include file="AceEvent-3.0\AceEvent-3.0.xml"/> |
| <Include file="AceDB-3.0\AceDB-3.0.xml"/> |
| <Include file="AceConsole-3.0\AceConsole-3.0.xml"/> |
| <Include file="AceGUI-3.0\AceGUI-3.0.xml"/> |
| <Include file="LibSharedMedia-3.0\lib.xml"/> |
| <Include file="AceGUI-3.0-SharedMediaWidgets\widget.xml"/> |
| <Script file="LibBackdrop-1.0\LibBackdrop-1.0.lua"/> |
| <Include file="LibFrameAnchorRegistry-1.0\lib.xml"/> |
| <Include file="LibGUIFactory-1.0\lib.xml"/> |
| </Ui> |
mRunes/Libs/AceEvent-3.0/AceEvent-3.0.xml
New file
0,0 → 1,4
\ No newline at end of file
| <Ui xmlns="http://www.blizzard.com/wow/ui/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.blizzard.com/wow/ui/ |
| ..\FrameXML\UI.xsd"> |
| <Script file="AceEvent-3.0.lua"/> |
| </Ui> |
mRunes/Libs/AceEvent-3.0/AceEvent-3.0.lua
New file
0,0 → 1,126
| --- AceEvent-3.0 provides event registration and secure dispatching. |
| -- All dispatching is done using **CallbackHandler-1.0**. AceEvent is a simple wrapper around |
| -- CallbackHandler, and dispatches all game events or addon message to the registrees. |
| -- |
| -- **AceEvent-3.0** can be embeded into your addon, either explicitly by calling AceEvent:Embed(MyAddon) or by |
| -- specifying it as an embeded library in your AceAddon. All functions will be available on your addon object |
| -- and can be accessed directly, without having to explicitly call AceEvent itself.\\ |
| -- It is recommended to embed AceEvent, otherwise you'll have to specify a custom `self` on all calls you |
| -- make into AceEvent. |
| -- @class file |
| -- @name AceEvent-3.0 |
| -- @release $Id: AceEvent-3.0.lua 975 2010-10-23 11:26:18Z nevcairiel $ |
| local MAJOR, MINOR = "AceEvent-3.0", 3 |
| local AceEvent = LibStub:NewLibrary(MAJOR, MINOR) |
| if not AceEvent then return end |
| -- Lua APIs |
| local pairs = pairs |
| local CallbackHandler = LibStub:GetLibrary("CallbackHandler-1.0") |
| AceEvent.frame = AceEvent.frame or CreateFrame("Frame", "AceEvent30Frame") -- our event frame |
| AceEvent.embeds = AceEvent.embeds or {} -- what objects embed this lib |
| -- APIs and registry for blizzard events, using CallbackHandler lib |
| if not AceEvent.events then |
| AceEvent.events = CallbackHandler:New(AceEvent, |
| "RegisterEvent", "UnregisterEvent", "UnregisterAllEvents") |
| end |
| function AceEvent.events:OnUsed(target, eventname) |
| AceEvent.frame:RegisterEvent(eventname) |
| end |
| function AceEvent.events:OnUnused(target, eventname) |
| AceEvent.frame:UnregisterEvent(eventname) |
| end |
| -- APIs and registry for IPC messages, using CallbackHandler lib |
| if not AceEvent.messages then |
| AceEvent.messages = CallbackHandler:New(AceEvent, |
| "RegisterMessage", "UnregisterMessage", "UnregisterAllMessages" |
| ) |
| AceEvent.SendMessage = AceEvent.messages.Fire |
| end |
| --- embedding and embed handling |
| local mixins = { |
| "RegisterEvent", "UnregisterEvent", |
| "RegisterMessage", "UnregisterMessage", |
| "SendMessage", |
| "UnregisterAllEvents", "UnregisterAllMessages", |
| } |
| --- Register for a Blizzard Event. |
| -- The callback will be called with the optional `arg` as the first argument (if supplied), and the event name as the second (or first, if no arg was supplied) |
| -- Any arguments to the event will be passed on after that. |
| -- @name AceEvent:RegisterEvent |
| -- @class function |
| -- @paramsig event[, callback [, arg]] |
| -- @param event The event to register for |
| -- @param callback The callback function to call when the event is triggered (funcref or method, defaults to a method with the event name) |
| -- @param arg An optional argument to pass to the callback function |
| --- Unregister an event. |
| -- @name AceEvent:UnregisterEvent |
| -- @class function |
| -- @paramsig event |
| -- @param event The event to unregister |
| --- Register for a custom AceEvent-internal message. |
| -- The callback will be called with the optional `arg` as the first argument (if supplied), and the event name as the second (or first, if no arg was supplied) |
| -- Any arguments to the event will be passed on after that. |
| -- @name AceEvent:RegisterMessage |
| -- @class function |
| -- @paramsig message[, callback [, arg]] |
| -- @param message The message to register for |
| -- @param callback The callback function to call when the message is triggered (funcref or method, defaults to a method with the event name) |
| -- @param arg An optional argument to pass to the callback function |
| --- Unregister a message |
| -- @name AceEvent:UnregisterMessage |
| -- @class function |
| -- @paramsig message |
| -- @param message The message to unregister |
| --- Send a message over the AceEvent-3.0 internal message system to other addons registered for this message. |
| -- @name AceEvent:SendMessage |
| -- @class function |
| -- @paramsig message, ... |
| -- @param message The message to send |
| -- @param ... Any arguments to the message |
| -- Embeds AceEvent into the target object making the functions from the mixins list available on target:.. |
| -- @param target target object to embed AceEvent in |
| function AceEvent:Embed(target) |
| for k, v in pairs(mixins) do |
| target[v] = self[v] |
| end |
| self.embeds[target] = true |
| return target |
| end |
| -- AceEvent:OnEmbedDisable( target ) |
| -- target (object) - target object that is being disabled |
| -- |
| -- Unregister all events messages etc when the target disables. |
| -- this method should be called by the target manually or by an addon framework |
| function AceEvent:OnEmbedDisable(target) |
| target:UnregisterAllEvents() |
| target:UnregisterAllMessages() |
| end |
| -- Script to fire blizzard events into the event listeners |
| local events = AceEvent.events |
| AceEvent.frame:SetScript("OnEvent", function(this, event, ...) |
| events:Fire(event, ...) |
| end) |
| --- Finally: upgrade our old embeds |
| for target, v in pairs(AceEvent.embeds) do |
| AceEvent:Embed(target) |
| end |
mRunes/Libs/LibBackdrop-1.0/LibBackdrop-1.0.toc
New file
0,0 → 1,15
\ No newline at end of file
| ## Interface: 40000 |
| ## X-Compatible-With: 30300 |
| ## Title: Lib: Backdrop-1.0 |
| ## Notes: Dropin replacement library for SetBackDrop |
| ## Author: kagaro, lilsparky |
| ## X-Website: http://www.wowace.com |
| ## X-Category: Library |
| ## X-License: All Rights Reserved |
| ## X-Curse-Packaged-Version: 1.0.7-4-gc67fc1c |
| ## X-Curse-Project-Name: LibBackdrop-1.0 |
| ## X-Curse-Project-ID: libbackdrop-1-0 |
| ## X-Curse-Repository-ID: wow/libbackdrop-1-0/mainline |
| LibStub\LibStub.lua |
| LibBackdrop-1.0.lua |
mRunes/Libs/LibBackdrop-1.0/LibStub/LibStub.lua
New file
0,0 → 1,30
| -- LibStub is a simple versioning stub meant for use in Libraries. http://www.wowace.com/wiki/LibStub for more info |
| -- LibStub is hereby placed in the Public Domain Credits: Kaelten, Cladhaire, ckknight, Mikk, Ammo, Nevcairiel, joshborke |
| local LIBSTUB_MAJOR, LIBSTUB_MINOR = "LibStub", 2 -- NEVER MAKE THIS AN SVN REVISION! IT NEEDS TO BE USABLE IN ALL REPOS! |
| local LibStub = _G[LIBSTUB_MAJOR] |
| if not LibStub or LibStub.minor < LIBSTUB_MINOR then |
| LibStub = LibStub or {libs = {}, minors = {} } |
| _G[LIBSTUB_MAJOR] = LibStub |
| LibStub.minor = LIBSTUB_MINOR |
| function LibStub:NewLibrary(major, minor) |
| assert(type(major) == "string", "Bad argument #2 to `NewLibrary' (string expected)") |
| minor = assert(tonumber(strmatch(minor, "%d+")), "Minor version must either be a number or contain a number.") |
| local oldminor = self.minors[major] |
| if oldminor and oldminor >= minor then return nil end |
| self.minors[major], self.libs[major] = minor, self.libs[major] or {} |
| return self.libs[major], oldminor |
| end |
| function LibStub:GetLibrary(major, silent) |
| if not self.libs[major] and not silent then |
| error(("Cannot find a library instance of %q."):format(tostring(major)), 2) |
| end |
| return self.libs[major], self.minors[major] |
| end |
| function LibStub:IterateLibraries() return pairs(self.libs) end |
| setmetatable(LibStub, { __call = LibStub.GetLibrary }) |
| end |
mRunes/Libs/LibBackdrop-1.0/LibStub/LibStub.toc
New file
0,0 → 1,13
| ## Interface: 20400 |
| ## Title: Lib: LibStub |
| ## Notes: Universal Library Stub |
| ## Credits: Kaelten, Cladhaire, ckknight, Mikk, Ammo, Nevcairiel |
| ## X-Website: http://jira.wowace.com/browse/LS |
| ## X-Category: Library |
| ## X-License: Public Domain |
| ## X-Curse-Packaged-Version: 1.0 |
| ## X-Curse-Project-Name: LibStub |
| ## X-Curse-Project-ID: libstub |
| ## X-Curse-Repository-ID: wow/libstub/mainline |
| LibStub.lua |
mRunes/Libs/LibBackdrop-1.0/LibBackdrop-1.0.lua
New file
0,0 → 1,525
\ No newline at end of file
| --[[ |
| Replacement library for SetBackDrop |
| Blizzard decided they want to deprecate SetBackDrop, so this library is intended as a replacement for simple table drop |
| and decorate a given frame with a backdrop. |
| Credits to Lilsparky for doing the math for cutting up the quadrants |
| --]] |
| local MAJOR, MINOR = "LibBackdrop-1.0", 2 |
| local Backdrop, oldminor = LibStub:NewLibrary(MAJOR, MINOR) |
| if not Backdrop then return end -- No upgrade needed |
| local MakeFrame = CreateFrame |
| local edgePoints = { |
| TOPLEFTCORNER = "TOPLEFT", |
| TOP = "TOP", |
| TOPRIGHTCORNER = "TOPRIGHT", |
| LEFT = "LEFT", |
| RIGHT = "RIGHT", |
| BOTLEFTCORNER = "BOTTOMLEFT", |
| BOT = "BOTTOM", |
| BOTRIGHTCORNER = "BOTTOMRIGHT" |
| } |
| function Backdrop:Embed(frame) |
| print("Embed is now deprecated, use :EnhanceBackdrop instead") |
| self:EnhanceBackdrop(frame) |
| end |
| --- API |
| -- This method will embed the new backdrop functionality onto your frame |
| -- This will replace the standard SetBackdropxxx functions and will add |
| -- the following functions to your frame. |
| -- SetBackdropGradient(orientation,minR,minG,minB,maxR,maxG,maxB) setup a gradient on the bg texture |
| -- SetBackdropGradientAlpha(orientation,minR,minG,minB,minA,maxR,maxG,maxB,maxA) setup a gradient on the bg texture |
| -- SetBackdropBorderGradient(orientation,minR,minG,minB,maxR,maxG,maxB) setup a gradient on the border texture |
| -- SetBackdropBorderGradientAlpha(orientation,minR,minG,minB,minA,maxR,maxG,maxB,maxA) setup a gradient on the border texture |
| -- @param frame to enhance |
| function Backdrop:EnhanceBackdrop(frame) |
| if frame._backdrop then return end |
| -- Create our enhancement frame we will use to create the backdrop |
| frame._backdrop = MakeFrame("Frame",nil,frame) |
| for k,v in pairs(edgePoints) do |
| local texture = frame:CreateTexture(nil,"BORDER") |
| frame._backdrop["Edge"..k] = texture |
| end |
| frame._backdrop["bgTexture"] = frame:CreateTexture(nil,"BACKGROUND") |
| frame.SetBackdrop = Backdrop.SetBackdrop -- Set the backdrop of the frame according to the specification provided. |
| frame.GetBackdrop = Backdrop.GetBackdrop -- Get the backdrop of the frame for use in SetBackdrop |
| frame.SetBackdropBorderColor = Backdrop.SetBackdropBorderColor --(r, g, b[, a]) - Set the frame's backdrop's border's color. |
| frame.GetBackdropBorderColor = Backdrop.GetBackdropBorderColor -- Get the frame's backdrop's border's color. |
| frame.SetBackdropColor = Backdrop.SetBackdropColor --(r, g, b[, a]) - Set the frame's backdrop color. |
| frame.GetBackdropColor = Backdrop.GetBackdropColor -- Get the backdrop color |
| frame.SetBackdropGradient = Backdrop.SetBackdropGradient -- New API |
| frame.SetBackdropGradientAlpha = Backdrop.SetBackdropGradientAlpha -- New API |
| frame.SetBackdropBorderGradient = Backdrop.SetBackdropBorderGradient -- New API |
| frame.SetBackdropBorderGradientAlpha = Backdrop.SetBackdropBorderGradientAlpha -- New API |
| frame.GetBackdropBorderSection = Backdrop.GetBackdropBorderSection -- New API |
| frame.GetBackdropBackground = Backdrop.GetBackdropBackground -- New API |
| frame.BorderTextureFunction = Backdrop.BorderTextureFunction |
| end |
| --- API |
| -- this method will let you test to see if a frame has been embedded with enchanced backdrop |
| -- @param frame to check |
| -- @return true if embedded already |
| function Backdrop:IsEmbedded(frame) |
| print("IsEmbedded is now deprecate use :IsEnhanced") |
| return self:IsEnhanced(frame) |
| end |
| function Backdrop:IsEnhanced(frame) |
| return frame._backdrop ~= nil |
| end |
| --- API |
| -- Convience method to mass execute a given function and params across |
| -- all border segments |
| function Backdrop:BorderTextureFunction(func,...) |
| -- check to see the function exists for a texture object |
| if not self._backdrop.bgTexture[func] then return end |
| for k,v in pairs(edgePoints) do |
| local texture = self._backdrop["Edge"..k] |
| texture[func](texture,...) |
| end |
| end |
| --- API |
| -- This method allows you to get a reference to the backdrop itself |
| -- @return a reference to the backdrop background texture |
| function Backdrop:GetBackdropBackground() |
| return self._backdrop["bgTexture"] |
| end |
| --- API |
| -- this method allows you to get a reference to given border section |
| -- @param section [Valid values are: TOPLEFTCORNER,TOP,TOPRIGHTCORNER,LEFT,RIGHT,BOTLEFTCORNER,BOT,BOTRIGHTCORNER] |
| -- @return the section texture or nil |
| function Backdrop:GetBackdropBorderSection(section) |
| section = strupper(section) |
| return self._backdrop["Edge"..section] |
| end |
| --[[ |
| FUTURE, once blizz removes SetBackdrop, we should hook CreateFrame and automatically embed ourselves |
| to allow for backwards compat |
| --]] |
| --[[ |
| { |
| bgFile = "bgFile", |
| edgeFile = "edgeFile", tile = false, tileSize = 0, edgeSize = 32, |
| insets = { left = 0, right = 0, top = 0, bottom = 0 |
| } |
| Alternatily you can use the new blizz style of borders |
| where you have a corner file and 1 file for each side. To build those style of borders |
| be sure each quadrant is 32x32 blocks. See Interface\DialogFrame\DialogFrame-Corners and Interface\DialogFrame\DialogFrame-Top |
| for examples. To pass those style borders in, setup the edge file as follows |
| edgeFile = { |
| ["TOPLEFTCORNER"] = "Interface/DialogFrame/DialogFrame-Corners", |
| ["TOPRIGHTCORNER"] = "Interface/DialogFrame/DialogFrame-Corners", |
| ["BOTLEFTCORNER"] = "Interface/DialogFrame/DialogFrame-Corners", |
| ["BOTRIGHTCORNER"] = "Interface/DialogFrame/DialogFrame-Corners", |
| ["LEFT"] = "Interface/DialogFrame/DialogFrame-Left", |
| ["TOP"] = "Interface/DialogFrame/DialogFrame-Top", |
| ["BOT"] = "Interface/DialogFrame/DialogFrame-Bot", |
| ["RIGHT"] = "Interface/DialogFrame/DialogFrame-Right", |
| } |
| --]] |
| local tilingOptions = { |
| ["LEFT"] = true, |
| ["RIGHT"] = true, |
| ["TOP"] = true, |
| ["BOTTOM"] = true, |
| ["TOPLEFTCORNER"] = false, |
| ["TOPRIGHTCORNER"] = false, |
| ["BOTLEFTCORNER"] = false, |
| ["BOTRIGHTCORNER"] = false, |
| } |
| -- Corners and their quadrant positions |
| local corners = { |
| TOPLEFTCORNER = 4, |
| TOPRIGHTCORNER = 5, |
| BOTLEFTCORNER = 6, |
| BOTRIGHTCORNER = 7, |
| } |
| -- Sides and their quadrant positions |
| local vSides = { |
| LEFT = 0, |
| RIGHT = 1, |
| } |
| local hSides = { |
| TOP = 2, |
| BOT = 3, |
| } |
| local NaN = { |
| ["nan"] = true, |
| ["-1.#IND"] = true, |
| ["-1.#INF"] = true, |
| ["nil"] = true, |
| } |
| -- Resizing hook to keep them aligned |
| local function Resize(frame) |
| if not frame then |
| return |
| end |
| local w,h = frame:GetWidth()-frame.bgEdgeSize*2, frame:GetHeight()-frame.bgEdgeSize*2 |
| if NaN[tostring(w)] or NaN[tostring(h)] then |
| -- frame was resized to nothing. |
| return |
| end |
| for k,v in pairs(vSides) do |
| local t = frame["Edge"..k] |
| local y = h/frame.bgEdgeSize |
| t:SetTexCoord(v*.125, v*.125+.125, 0, y) |
| end |
| for k,v in pairs(hSides) do |
| local t = frame["Edge"..k] |
| local y = w/frame.bgEdgeSize |
| local x1 = v*.125 |
| local x2 = v*.125+.125 |
| t:SetTexCoord(x1,0, x2,0, x1,y, x2, y) |
| end |
| if frame.tile then |
| frame.bgTexture:SetTexCoord(0,w/frame.tileSize, 0,h/frame.tileSize) |
| end |
| end |
| -- Attach the corner textures |
| local function AttachCorners(frame,options) |
| local nudge = 0 |
| if options.edgeSize >= 32 then |
| nudge = options.edgeSize/32 |
| end |
| if options.edgeSize <= 16 then |
| nudge = options.edgeSize/16 |
| end |
| for k,v in pairs(corners) do |
| local texture = frame["Edge"..k] |
| texture:ClearAllPoints() |
| texture:SetWidth(options.edgeSize) |
| texture:SetHeight(options.edgeSize) |
| texture:SetTexCoord(v*.125,v*.125+.125, 0,1) |
| end |
| frame["EdgeTOPLEFTCORNER"]:SetPoint(edgePoints["TOPLEFTCORNER"],frame,0,nudge) |
| frame["EdgeBOTLEFTCORNER"]:SetPoint(edgePoints["BOTLEFTCORNER"],frame,0,-nudge) |
| frame["EdgeTOPRIGHTCORNER"]:SetPoint(edgePoints["TOPRIGHTCORNER"],frame,0,nudge) |
| frame["EdgeBOTRIGHTCORNER"]:SetPoint(edgePoints["BOTRIGHTCORNER"],frame,0,-nudge) |
| end |
| local nk = { |
| ["TOPLEFTCORNER"] = { l = 0, r = 0.5, t= 0, b=0.5}, |
| ["TOPRIGHTCORNER"] = { l = 0.5, r = 1, t= 0, b=0.5}, |
| ["BOTLEFTCORNER"] = { l = 0, r = 0.5, t= 0.5, b=1}, |
| ["BOTRIGHTCORNER"] = { l = 0.5, r = 1, t= 0.5, b=1}, |
| } |
| -- Attach new style corners |
| local function AttachNewCorners(frame) |
| for k,v in pairs(corners) do |
| local texture = frame["Edge"..k] |
| texture:SetPoint(edgePoints[k], frame) |
| texture:SetWidth(frame.bgEdgeSize) |
| texture:SetHeight(frame.bgEdgeSize) |
| texture:SetTexCoord(nk[k].l,nk[k].r,nk[k].t,nk[k].b) |
| end |
| end |
| -- Attach new style sdes |
| local function AttachNewSides(frame,w,h) |
| local offset = 1 |
| offset = frame.bgEdgeSize /32 |
| -- Left and Right |
| frame["EdgeLEFT"]:SetPoint("TOPLEFT",frame["EdgeTOPLEFTCORNER"],"BOTTOMLEFT",offset,0) |
| frame["EdgeLEFT"]:SetPoint("BOTTOMLEFT",frame["EdgeBOTLEFTCORNER"],"TOPLEFT",offset,0) |
| frame["EdgeLEFT"]:SetWidth(frame.bgEdgeSize/2) |
| frame["EdgeLEFT"]:SetVertTile(true) |
| frame["EdgeLEFT"]:SetHorizTile(false) |
| frame["EdgeRIGHT"]:SetPoint("TOPRIGHT",frame["EdgeTOPRIGHTCORNER"],"BOTTOMRIGHT") |
| frame["EdgeRIGHT"]:SetPoint("BOTTOMRIGHT",frame["EdgeBOTRIGHTCORNER"],"TOPRIGHT") |
| frame["EdgeRIGHT"]:SetWidth(frame.bgEdgeSize/2) |
| frame["EdgeRIGHT"]:SetVertTile(true) |
| frame["EdgeRIGHT"]:SetHorizTile(false) |
| -- Top and Bottom |
| frame["EdgeTOP"]:SetPoint("TOPLEFT",frame["EdgeTOPLEFTCORNER"],"TOPRIGHT",0,-offset) |
| frame["EdgeTOP"]:SetPoint("TOPRIGHT",frame["EdgeTOPRIGHTCORNER"],"TOPLEFT",0,-offset) |
| frame["EdgeTOP"]:SetHeight(frame.bgEdgeSize/2) |
| frame["EdgeTOP"]:SetVertTile(false) |
| frame["EdgeTOP"]:SetHorizTile(true) |
| frame["EdgeBOT"]:SetPoint("BOTTOMLEFT",frame["EdgeBOTLEFTCORNER"],"BOTTOMRIGHT") |
| frame["EdgeBOT"]:SetPoint("BOTTOMRIGHT",frame["EdgeBOTRIGHTCORNER"],"BOTTOMLEFT") |
| frame["EdgeBOT"]:SetHeight(frame.bgEdgeSize/2) |
| frame["EdgeBOT"]:SetVertTile(false) |
| frame["EdgeBOT"]:SetHorizTile(true) |
| end |
| -- Attach the side textures |
| local function AttachSides(frame,w,h,options) |
| local nudge = 0.125 |
| if options.edgeSize >= 32 then |
| nudge = nudge * (options.edgeSize/32) |
| end |
| if options.edgeSize <= 16 then |
| nudge = nudge / (16/options.edgeSize) |
| end |
| local offset = 0 |
| if options.edgeSize >= 32 then |
| offset = options.edgeSize/32 |
| end |
| if options.edgeSize <= 16 then |
| offset = options.edgeSize/16 |
| end |
| -- SOOOO Issue here is when resetting an existing border the top area gets jacked up |
| -- Left and Right |
| for k,v in pairs(vSides) do |
| local texture = frame["Edge"..k] |
| texture:ClearAllPoints() |
| if k == "RIGHT" then |
| texture:SetPoint(edgePoints[k], frame, nudge,0) |
| texture:SetPoint("BOTTOM", frame, "BOTTOM", 0, options.edgeSize-offset) |
| texture:SetPoint("TOP", frame, "TOP", 0, -options.edgeSize+offset) |
| else |
| texture:SetPoint(edgePoints[k], frame, nudge,0) |
| texture:SetPoint("BOTTOM", frame, "BOTTOM", 0, options.edgeSize-offset) |
| texture:SetPoint("TOP", frame, "TOP", 0, -options.edgeSize+offset) |
| end |
| texture:SetWidth(options.edgeSize) |
| local y = h/options.edgeSize |
| texture:SetTexCoord(v*.125, v*.125+.125, 0, y) |
| end |
| -- Top and Bottom |
| for k,v in pairs(hSides) do |
| local texture = frame["Edge"..k] |
| texture:ClearAllPoints() |
| -- Adjusments for placement |
| if k == "TOP" then |
| texture:SetPoint(edgePoints[k], frame, nudge, offset) |
| texture:SetPoint("LEFT", frame, "LEFT", options.edgeSize, 0) |
| texture:SetPoint("RIGHT", frame, "RIGHT", -options.edgeSize, 0) |
| else |
| texture:SetPoint(edgePoints[k], frame,-nudge,-offset) |
| texture:SetPoint("LEFT", frame, "LEFT", options.edgeSize, 1) |
| texture:SetPoint("RIGHT", frame, "RIGHT", -options.edgeSize, 1) |
| end |
| texture:SetHeight(options.edgeSize) |
| local y = w/options.edgeSize |
| local x1 = v*.125 |
| local x2 = v*.125+.125 |
| if k == "TOP" then -- Flip |
| x1,x2 = x2, x1 |
| end |
| texture:SetTexCoord(x1,0, x2,0, x1,y, x2, y) |
| end |
| end |
| --- API |
| -- Setup the backdrop see normal wow api for table options |
| function Backdrop:SetBackdrop(options) |
| if not options then return end |
| -- Set textures |
| local vTile = false |
| local hTile = false |
| if options.tile then |
| hTile = true |
| end |
| local reset = false |
| if self._backdrop_options then |
| table.wipe(self._backdrop_options) |
| reset = true |
| else |
| self._backdrop_options = {} |
| end |
| -- Copy backdrop options |
| self._backdrop_options.bgFile = options.bgFile |
| self._backdrop_options.edgeFile = options.edgeFile |
| self._backdrop_options.tile = options.tile |
| self._backdrop_options.tileSize = options.tileSize |
| self._backdrop_options.edgeSize = options.edgeSize |
| self._backdrop_options.insets = {} |
| self._backdrop_options.insets.left = options.insets.left |
| self._backdrop_options.insets.right = options.insets.right |
| self._backdrop_options.insets.top = options.insets.top |
| self._backdrop_options.insets.bottom = options.insets.bottom |
| if type(options.edgeFile) == "table" then |
| Backdrop.SetNewBackdrop(self,options) |
| else |
| self._backdrop["bgTexture"]:SetTexture(options.bgFile,hTile,vTile) |
| for k,v in pairs(edgePoints) do |
| self._backdrop["Edge"..k]:SetTexture(options.edgeFile,tilingOptions[k]) |
| end |
| -- Copy options |
| self._backdrop.tileSize = options.tileSize |
| self._backdrop.tile = options.tile |
| self._backdrop.bgEdgeSize = options.edgeSize |
| -- Setup insets |
| self._backdrop:ClearAllPoints() |
| self._backdrop:SetAllPoints(self) |
| local w,h = self:GetWidth()-(options.edgeSize*2), self:GetHeight()-(options.edgeSize*2) |
| if options.edgeSize > 0 then |
| -- Attach croners |
| AttachCorners(self._backdrop, self._backdrop_options) |
| -- Attach sides |
| AttachSides(self._backdrop,w,h, self._backdrop_options) |
| end |
| -- Attach Background |
| self._backdrop.bgTexture:ClearAllPoints() |
| self._backdrop.bgTexture:SetPoint("TOPLEFT", self._backdrop, "TOPLEFT", options.insets.left, -options.insets.top) |
| self._backdrop.bgTexture:SetPoint("BOTTOMRIGHT", self._backdrop, "BOTTOMRIGHT", -options.insets.right, options.insets.bottom) |
| if options.tile then |
| self._backdrop.bgTexture:SetTexCoord(0,w/options.tileSize, 0,h/options.tileSize) |
| end |
| self._backdrop:SetScript("OnSizeChanged", Resize) |
| end |
| if reset then |
| Resize(self._backdrop) |
| end |
| end |
| -- replace std api call |
| function Backdrop:GetBackdrop() |
| return self._backdrop_options |
| end |
| -- replace std api call |
| function Backdrop:GetBackdropColor() |
| return self._backdrop.bgTexture:GetVertexColor() |
| end |
| -- repalce std api call |
| function Backdrop:GetBackdropBorderColor() |
| return self._backdrop["EdgeTOP"]:GetVertexColor() |
| end |
| --- API |
| -- change the backdrop border color |
| -- @params r,g,b[,a] |
| function Backdrop:SetBackdropBorderColor(...) |
| for k,v in pairs(edgePoints) do |
| self._backdrop["Edge"..k]:SetVertexColor(...) |
| end |
| end |
| --- API |
| -- set the backdrop color |
| -- @params r,g,b[,a] |
| function Backdrop:SetBackdropColor(...) |
| self._backdrop["bgTexture"]:SetVertexColor(...) |
| end |
| --- API |
| -- set the backdrop gradient color |
| -- @params "orientation", minR, minG, minB, maxR, maxG, maxB |
| function Backdrop:SetBackdropGradient(...) |
| self._backdrop["bgTexture"]:SetGradient(...) |
| end |
| --- API |
| -- set the backdrop gradient with alpha |
| -- @params "orientation", minR, minG, minB, minA, maxR, maxG, maxB, maxA |
| function Backdrop:SetBackdropGradientAlpha(...) |
| self._backdrop["bgTexture"]:SetGradientAlpha(...) |
| end |
| --- API |
| -- set the border gradient color |
| -- @params "orientation", minR, minG, minB, maxR, maxG, maxB |
| function Backdrop:SetBackdropBorderGradient(orientation,minR,minG,minB,maxR,maxG,maxB) |
| orientation = strupper(orientation) |
| if orientation == "HORIZONTAL" then |
| self._backdrop["EdgeTOPLEFTCORNER"]:SetGradient(orientation,minR,minG,minB,minR,minG,minB) |
| self._backdrop["EdgeBOTLEFTCORNER"]:SetGradient(orientation,minR,minG,minB,minR,minG,minB) |
| self._backdrop["EdgeLEFT"]:SetGradient(orientation,minR,minG,minB,minR,minG,minB) |
| self._backdrop["EdgeBOT"]:SetGradient(orientation,minR,minG,minB,maxR,maxG,maxB) |
| self._backdrop["EdgeTOP"]:SetGradient(orientation,minR,minG,minB,maxR,maxG,maxB) |
| self._backdrop["EdgeTOPRIGHTCORNER"]:SetGradient(orientation,maxR,maxG,maxB,maxR,maxG,maxB) |
| self._backdrop["EdgeBOTRIGHTCORNER"]:SetGradient(orientation,maxR,maxG,maxB,maxR,maxG,maxB) |
| self._backdrop["EdgeRIGHT"]:SetGradient(orientation,maxR,maxG,maxB,maxR,maxG,maxB) |
| else |
| self._backdrop["EdgeTOPLEFTCORNER"]:SetGradient(orientation,maxR,maxG,maxB,maxR,maxG,maxB) |
| self._backdrop["EdgeBOTLEFTCORNER"]:SetGradient(orientation,minR,minG,minB,minR,minG,minB) |
| self._backdrop["EdgeLEFT"]:SetGradient(orientation,minR,minG,minB,maxR,maxG,maxB) |
| self._backdrop["EdgeBOT"]:SetGradient(orientation,minR,minG,minB,minR,minG,minB) |
| self._backdrop["EdgeTOP"]:SetGradient(orientation,maxR,maxG,maxB,maxR,maxG,maxB) |
| self._backdrop["EdgeTOPRIGHTCORNER"]:SetGradient(orientation,maxR,maxG,maxB,maxR,maxG,maxB) |
| self._backdrop["EdgeBOTRIGHTCORNER"]:SetGradient(orientation,minR,minG,minB,minR,minG,minB) |
| self._backdrop["EdgeRIGHT"]:SetGradient(orientation,minR,minG,minB,maxR,maxG,maxB) |
| end |
| end |
| --- API |
| -- set the border gradient alpha color |
| -- @params "orientation", minR, minG, minB, minA, maxR, maxG, maxB, maxA |
| function Backdrop:SetBackdropBorderGradientAlpha(orientation,minR,minG,minB,minA,maxR,maxG,maxB,maxA) |
| orientation = strupper(orientation) |
| if orientation == "HORIZONTAL" then |
| self._backdrop["EdgeTOPLEFTCORNER"]:SetGradientAlpa(orientation,minR,minG,minB,minA,minR,minG,minB,minA) |
| self._backdrop["EdgeBOTLEFTCORNER"]:SetGradientAlpha(orientation,minR,minG,minB,minA,minR,minG,minB,minA) |
| self._backdrop["EdgeLEFT"]:SetGradientAlpha(orientation,minR,minG,minB,minA,minR,minG,minB,minA) |
| self._backdrop["EdgeBOT"]:SetGradientAlpha(orientation,minR,minG,minB,minA,maxR,maxG,maxB,maxA) |
| self._backdrop["EdgeTOP"]:SetGradientAlpha(orientation,minR,minG,minB,minA,maxR,maxG,maxB,maxA) |
| self._backdrop["EdgeTOPRIGHTCORNER"]:SetGradientAlpha(orientation,maxR,maxG,maxB,maxA,maxR,maxG,maxB,maxA) |
| self._backdrop["EdgeBOTRIGHTCORNER"]:SetGradientAlpha(orientation,maxR,maxG,maxB,maxA,maxR,maxG,maxB,maxA) |
| self._backdrop["EdgeRIGHT"]:SetGradientAlpha(orientation,maxR,maxG,maxB,maxA,maxR,maxG,maxB,maxA) |
| else |
| self._backdrop["EdgeTOPLEFTCORNER"]:SetGradientAlpha(orientation,maxR,maxG,maxB,maxA,maxR,maxG,maxB,maxA) |
| self._backdrop["EdgeBOTLEFTCORNER"]:SetGradientAlpha(orientation,minR,minG,minB,minA,minR,minG,minB,minA) |
| self._backdrop["EdgeLEFT"]:SetGradientAlpha(orientation,minR,minG,minB,minA,maxR,maxG,maxB,maxA) |
| self._backdrop["EdgeBOT"]:SetGradientAlpha(orientation,minR,minG,minB,minA,minR,minG,minB,minA) |
| self._backdrop["EdgeTOP"]:SetGradientAlpha(orientation,maxR,maxG,maxB,maxA,maxR,maxG,maxB,maxA) |
| self._backdrop["EdgeTOPRIGHTCORNER"]:SetGradientAlpha(orientation,maxR,maxG,maxB,maxA,maxR,maxG,maxB,maxA) |
| self._backdrop["EdgeBOTRIGHTCORNER"]:SetGradientAlpha(orientation,minR,minG,minB,minA,minR,minG,minB,minA) |
| self._backdrop["EdgeRIGHT"]:SetGradientAlpha(orientation,minR,minG,minB,minA,maxR,maxG,maxB,maxA) |
| end |
| end |
| --- API |
| -- New Backdrop function, for use with the new table layout defined above. |
| -- called when you pass a new table layout to SetBackdrop |
| function Backdrop:SetNewBackdrop(options) |
| self._backdrop["bgTexture"]:SetTexture(options.bgFile,hTile,vTile) |
| for k,v in pairs(edgePoints) do |
| self._backdrop["Edge"..k]:SetTexture(options.edgeFile[k],tilingOptions[k]) |
| end |
| -- Copy options |
| self._backdrop.tileSize = options.tileSize |
| self._backdrop.tile = options.tile |
| self._backdrop.bgEdgeSize = options.edgeSize |
| -- Setup insets |
| self._backdrop:SetPoint("TOPLEFT",self,"TOPLEFT",-options.insets.left, options.insets.top) |
| self._backdrop:SetPoint("BOTTOMRIGHT",self,"BOTTOMRIGHT", options.insets.right, -options.insets.bottom) |
| local w,h = self:GetWidth()-options.edgeSize*2, self:GetHeight()-options.edgeSize*2 |
| if options.edgeSize > 0 then |
| -- Attach croners |
| AttachNewCorners(self._backdrop) |
| -- Attach sides |
| AttachNewSides(self._backdrop,w,h) |
| end |
| -- Attach Background |
| self._backdrop.bgTexture:SetPoint("TOPLEFT", self._backdrop, "TOPLEFT", options.insets.left, -options.insets.top) |
| self._backdrop.bgTexture:SetPoint("BOTTOMRIGHT", self._backdrop, "BOTTOMRIGHT", -options.insets.right, options.insets.bottom) |
| if options.tile then |
| self._backdrop.bgTexture:SetTexCoord(0,w/options.tileSize, 0,h/options.tileSize) |
| end |
| end |
| --[[ |
| local debug = false |
| if debug then |
| for k,v in pairs(_G) do |
| -- Reset any existing frames |
| if type(v) == "table" and v.GetObjectype and v:GetObjectType() == "Frame" then |
| local ob = v:GetBackdrop() |
| Backdrop:EhanceBackdrop(v) |
| v:SetBackdrop(ob) |
| end |
| end |
| CreateFrame = function(...) |
| local f = MakeFrame(...) |
| Backdrop:EnhanceBackdrop(f) |
| return f |
| end |
| end |
| --]] |
mRunes/Libs/AceConsole-3.0/AceConsole-3.0.xml
New file
0,0 → 1,4
\ No newline at end of file
| <Ui xmlns="http://www.blizzard.com/wow/ui/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.blizzard.com/wow/ui/ |
| ..\FrameXML\UI.xsd"> |
| <Script file="AceConsole-3.0.lua"/> |
| </Ui> |
mRunes/Libs/AceConsole-3.0/AceConsole-3.0.lua
New file
0,0 → 1,250
| --- **AceConsole-3.0** provides registration facilities for slash commands. |
| -- You can register slash commands to your custom functions and use the `GetArgs` function to parse them |
| -- to your addons individual needs. |
| -- |
| -- **AceConsole-3.0** can be embeded into your addon, either explicitly by calling AceConsole:Embed(MyAddon) or by |
| -- specifying it as an embeded library in your AceAddon. All functions will be available on your addon object |
| -- and can be accessed directly, without having to explicitly call AceConsole itself.\\ |
| -- It is recommended to embed AceConsole, otherwise you'll have to specify a custom `self` on all calls you |
| -- make into AceConsole. |
| -- @class file |
| -- @name AceConsole-3.0 |
| -- @release $Id: AceConsole-3.0.lua 878 2009-11-02 18:51:58Z nevcairiel $ |
| local MAJOR,MINOR = "AceConsole-3.0", 7 |
| local AceConsole, oldminor = LibStub:NewLibrary(MAJOR, MINOR) |
| if not AceConsole then return end -- No upgrade needed |
| AceConsole.embeds = AceConsole.embeds or {} -- table containing objects AceConsole is embedded in. |
| AceConsole.commands = AceConsole.commands or {} -- table containing commands registered |
| AceConsole.weakcommands = AceConsole.weakcommands or {} -- table containing self, command => func references for weak commands that don't persist through enable/disable |
| -- Lua APIs |
| local tconcat, tostring, select = table.concat, tostring, select |
| local type, pairs, error = type, pairs, error |
| local format, strfind, strsub = string.format, string.find, string.sub |
| local max = math.max |
| -- WoW APIs |
| local _G = _G |
| -- Global vars/functions that we don't upvalue since they might get hooked, or upgraded |
| -- List them here for Mikk's FindGlobals script |
| -- GLOBALS: DEFAULT_CHAT_FRAME, SlashCmdList, hash_SlashCmdList |
| local tmp={} |
| local function Print(self,frame,...) |
| local n=0 |
| if self ~= AceConsole then |
| n=n+1 |
| tmp[n] = "|cff33ff99"..tostring( self ).."|r:" |
| end |
| for i=1, select("#", ...) do |
| n=n+1 |
| tmp[n] = tostring(select(i, ...)) |
| end |
| frame:AddMessage( tconcat(tmp," ",1,n) ) |
| end |
| --- Print to DEFAULT_CHAT_FRAME or given ChatFrame (anything with an .AddMessage function) |
| -- @paramsig [chatframe ,] ... |
| -- @param chatframe Custom ChatFrame to print to (or any frame with an .AddMessage function) |
| -- @param ... List of any values to be printed |
| function AceConsole:Print(...) |
| local frame = ... |
| if type(frame) == "table" and frame.AddMessage then -- Is first argument something with an .AddMessage member? |
| return Print(self, frame, select(2,...)) |
| else |
| return Print(self, DEFAULT_CHAT_FRAME, ...) |
| end |
| end |
| --- Formatted (using format()) print to DEFAULT_CHAT_FRAME or given ChatFrame (anything with an .AddMessage function) |
| -- @paramsig [chatframe ,] "format"[, ...] |
| -- @param chatframe Custom ChatFrame to print to (or any frame with an .AddMessage function) |
| -- @param format Format string - same syntax as standard Lua format() |
| -- @param ... Arguments to the format string |
| function AceConsole:Printf(...) |
| local frame = ... |
| if type(frame) == "table" and frame.AddMessage then -- Is first argument something with an .AddMessage member? |
| return Print(self, frame, format(select(2,...))) |
| else |
| return Print(self, DEFAULT_CHAT_FRAME, format(...)) |
| end |
| end |
| --- Register a simple chat command |
| -- @param command Chat command to be registered WITHOUT leading "/" |
| -- @param func Function to call when the slash command is being used (funcref or methodname) |
| -- @param persist if false, the command will be soft disabled/enabled when aceconsole is used as a mixin (default: true) |
| function AceConsole:RegisterChatCommand( command, func, persist ) |
| if type(command)~="string" then error([[Usage: AceConsole:RegisterChatCommand( "command", func[, persist ]): 'command' - expected a string]], 2) end |
| if persist==nil then persist=true end -- I'd rather have my addon's "/addon enable" around if the author screws up. Having some extra slash regged when it shouldnt be isn't as destructive. True is a better default. /Mikk |
| local name = "ACECONSOLE_"..command:upper() |
| if type( func ) == "string" then |
| SlashCmdList[name] = function(input, editBox) |
| self[func](self, input, editBox) |
| end |
| else |
| SlashCmdList[name] = func |
| end |
| _G["SLASH_"..name.."1"] = "/"..command:lower() |
| AceConsole.commands[command] = name |
| -- non-persisting commands are registered for enabling disabling |
| if not persist then |
| if not AceConsole.weakcommands[self] then AceConsole.weakcommands[self] = {} end |
| AceConsole.weakcommands[self][command] = func |
| end |
| return true |
| end |
| --- Unregister a chatcommand |
| -- @param command Chat command to be unregistered WITHOUT leading "/" |
| function AceConsole:UnregisterChatCommand( command ) |
| local name = AceConsole.commands[command] |
| if name then |
| SlashCmdList[name] = nil |
| _G["SLASH_" .. name .. "1"] = nil |
| hash_SlashCmdList["/" .. command:upper()] = nil |
| AceConsole.commands[command] = nil |
| end |
| end |
| --- Get an iterator over all Chat Commands registered with AceConsole |
| -- @return Iterator (pairs) over all commands |
| function AceConsole:IterateChatCommands() return pairs(AceConsole.commands) end |
| local function nils(n, ...) |
| if n>1 then |
| return nil, nils(n-1, ...) |
| elseif n==1 then |
| return nil, ... |
| else |
| return ... |
| end |
| end |
| --- Retreive one or more space-separated arguments from a string. |
| -- Treats quoted strings and itemlinks as non-spaced. |
| -- @param string The raw argument string |
| -- @param numargs How many arguments to get (default 1) |
| -- @param startpos Where in the string to start scanning (default 1) |
| -- @return Returns arg1, arg2, ..., nextposition\\ |
| -- Missing arguments will be returned as nils. 'nextposition' is returned as 1e9 at the end of the string. |
| function AceConsole:GetArgs(str, numargs, startpos) |
| numargs = numargs or 1 |
| startpos = max(startpos or 1, 1) |
| local pos=startpos |
| -- find start of new arg |
| pos = strfind(str, "[^ ]", pos) |
| if not pos then -- whoops, end of string |
| return nils(numargs, 1e9) |
| end |
| if numargs<1 then |
| return pos |
| end |
| -- quoted or space separated? find out which pattern to use |
| local delim_or_pipe |
| local ch = strsub(str, pos, pos) |
| if ch=='"' then |
| pos = pos + 1 |
| delim_or_pipe='([|"])' |
| elseif ch=="'" then |
| pos = pos + 1 |
| delim_or_pipe="([|'])" |
| else |
| delim_or_pipe="([| ])" |
| end |
| startpos = pos |
| while true do |
| -- find delimiter or hyperlink |
| local ch,_ |
| pos,_,ch = strfind(str, delim_or_pipe, pos) |
| if not pos then break end |
| if ch=="|" then |
| -- some kind of escape |
| if strsub(str,pos,pos+1)=="|H" then |
| -- It's a |H....|hhyper link!|h |
| pos=strfind(str, "|h", pos+2) -- first |h |
| if not pos then break end |
| pos=strfind(str, "|h", pos+2) -- second |h |
| if not pos then break end |
| elseif strsub(str,pos, pos+1) == "|T" then |
| -- It's a |T....|t texture |
| pos=strfind(str, "|t", pos+2) |
| if not pos then break end |
| end |
| pos=pos+2 -- skip past this escape (last |h if it was a hyperlink) |
| else |
| -- found delimiter, done with this arg |
| return strsub(str, startpos, pos-1), AceConsole:GetArgs(str, numargs-1, pos+1) |
| end |
| end |
| -- search aborted, we hit end of string. return it all as one argument. (yes, even if it's an unterminated quote or hyperlink) |
| return strsub(str, startpos), nils(numargs-1, 1e9) |
| end |
| --- embedding and embed handling |
| local mixins = { |
| "Print", |
| "Printf", |
| "RegisterChatCommand", |
| "UnregisterChatCommand", |
| "GetArgs", |
| } |
| -- Embeds AceConsole into the target object making the functions from the mixins list available on target:.. |
| -- @param target target object to embed AceBucket in |
| function AceConsole:Embed( target ) |
| for k, v in pairs( mixins ) do |
| target[v] = self[v] |
| end |
| self.embeds[target] = true |
| return target |
| end |
| function AceConsole:OnEmbedEnable( target ) |
| if AceConsole.weakcommands[target] then |
| for command, func in pairs( AceConsole.weakcommands[target] ) do |
| target:RegisterChatCommand( command, func, false, true ) -- nonpersisting and silent registry |
| end |
| end |
| end |
| function AceConsole:OnEmbedDisable( target ) |
| if AceConsole.weakcommands[target] then |
| for command, func in pairs( AceConsole.weakcommands[target] ) do |
| target:UnregisterChatCommand( command ) -- TODO: this could potentially unregister a command from another application in case of command conflicts. Do we care? |
| end |
| end |
| end |
| for addon in pairs(AceConsole.embeds) do |
| AceConsole:Embed(addon) |
| end |
mRunes/Libs/AceGUI-3.0/widgets/AceGUIContainer-SimpleGroup.lua
New file
0,0 → 1,69
| --[[----------------------------------------------------------------------------- |
| SimpleGroup Container |
| Simple container widget that just groups widgets. |
| -------------------------------------------------------------------------------]] |
| local Type, Version = "SimpleGroup", 20 |
| local AceGUI = LibStub and LibStub("AceGUI-3.0", true) |
| if not AceGUI or (AceGUI:GetWidgetVersion(Type) or 0) >= Version then return end |
| -- Lua APIs |
| local pairs = pairs |
| -- WoW APIs |
| local CreateFrame, UIParent = CreateFrame, UIParent |
| --[[----------------------------------------------------------------------------- |
| Methods |
| -------------------------------------------------------------------------------]] |
| local methods = { |
| ["OnAcquire"] = function(self) |
| self:SetWidth(300) |
| self:SetHeight(100) |
| end, |
| -- ["OnRelease"] = nil, |
| ["LayoutFinished"] = function(self, width, height) |
| if self.noAutoHeight then return end |
| self:SetHeight(height or 0) |
| end, |
| ["OnWidthSet"] = function(self, width) |
| local content = self.content |
| content:SetWidth(width) |
| content.width = width |
| end, |
| ["OnHeightSet"] = function(self, height) |
| local content = self.content |
| content:SetHeight(height) |
| content.height = height |
| end |
| } |
| --[[----------------------------------------------------------------------------- |
| Constructor |
| -------------------------------------------------------------------------------]] |
| local function Constructor() |
| local frame = CreateFrame("Frame", nil, UIParent) |
| frame:SetFrameStrata("FULLSCREEN_DIALOG") |
| --Container Support |
| local content = CreateFrame("Frame", nil, frame) |
| content:SetPoint("TOPLEFT") |
| content:SetPoint("BOTTOMRIGHT") |
| local widget = { |
| frame = frame, |
| content = content, |
| type = Type |
| } |
| for method, func in pairs(methods) do |
| widget[method] = func |
| end |
| return AceGUI:RegisterAsContainer(widget) |
| end |
| AceGUI:RegisterWidgetType(Type, Constructor, Version) |
mRunes/Libs/AceGUI-3.0/widgets/AceGUIContainer-Window.lua
New file
0,0 → 1,331
| local AceGUI = LibStub("AceGUI-3.0") |
| -- Lua APIs |
| local pairs, assert, type = pairs, assert, type |
| -- WoW APIs |
| local PlaySound = PlaySound |
| local CreateFrame, UIParent = CreateFrame, UIParent |
| -- Global vars/functions that we don't upvalue since they might get hooked, or upgraded |
| -- List them here for Mikk's FindGlobals script |
| -- GLOBALS: GameFontNormal |
| ---------------- |
| -- Main Frame -- |
| ---------------- |
| --[[ |
| Events : |
| OnClose |
| ]] |
| do |
| local Type = "Window" |
| local Version = 4 |
| local function frameOnClose(this) |
| this.obj:Fire("OnClose") |
| end |
| local function closeOnClick(this) |
| PlaySound("gsTitleOptionExit") |
| this.obj:Hide() |
| end |
| local function frameOnMouseDown(this) |
| AceGUI:ClearFocus() |
| end |
| local function titleOnMouseDown(this) |
| this:GetParent():StartMoving() |
| AceGUI:ClearFocus() |
| end |
| local function frameOnMouseUp(this) |
| local frame = this:GetParent() |
| frame:StopMovingOrSizing() |
| local self = frame.obj |
| local status = self.status or self.localstatus |
| status.width = frame:GetWidth() |
| status.height = frame:GetHeight() |
| status.top = frame:GetTop() |
| status.left = frame:GetLeft() |
| end |
| local function sizerseOnMouseDown(this) |
| this:GetParent():StartSizing("BOTTOMRIGHT") |
| AceGUI:ClearFocus() |
| end |
| local function sizersOnMouseDown(this) |
| this:GetParent():StartSizing("BOTTOM") |
| AceGUI:ClearFocus() |
| end |
| local function sizereOnMouseDown(this) |
| this:GetParent():StartSizing("RIGHT") |
| AceGUI:ClearFocus() |
| end |
| local function sizerOnMouseUp(this) |
| this:GetParent():StopMovingOrSizing() |
| end |
| local function SetTitle(self,title) |
| self.titletext:SetText(title) |
| end |
| local function SetStatusText(self,text) |
| -- self.statustext:SetText(text) |
| end |
| local function Hide(self) |
| self.frame:Hide() |
| end |
| local function Show(self) |
| self.frame:Show() |
| end |
| local function OnAcquire(self) |
| self.frame:SetParent(UIParent) |
| self.frame:SetFrameStrata("FULLSCREEN_DIALOG") |
| self:ApplyStatus() |
| self:EnableResize(true) |
| self:Show() |
| end |
| local function OnRelease(self) |
| self.status = nil |
| for k in pairs(self.localstatus) do |
| self.localstatus[k] = nil |
| end |
| end |
| -- called to set an external table to store status in |
| local function SetStatusTable(self, status) |
| assert(type(status) == "table") |
| self.status = status |
| self:ApplyStatus() |
| end |
| local function ApplyStatus(self) |
| local status = self.status or self.localstatus |
| local frame = self.frame |
| self:SetWidth(status.width or 700) |
| self:SetHeight(status.height or 500) |
| if status.top and status.left then |
| frame:SetPoint("TOP",UIParent,"BOTTOM",0,status.top) |
| frame:SetPoint("LEFT",UIParent,"LEFT",status.left,0) |
| else |
| frame:SetPoint("CENTER",UIParent,"CENTER") |
| end |
| end |
| local function OnWidthSet(self, width) |
| local content = self.content |
| local contentwidth = width - 34 |
| if contentwidth < 0 then |
| contentwidth = 0 |
| end |
| content:SetWidth(contentwidth) |
| content.width = contentwidth |
| end |
| local function OnHeightSet(self, height) |
| local content = self.content |
| local contentheight = height - 57 |
| if contentheight < 0 then |
| contentheight = 0 |
| end |
| content:SetHeight(contentheight) |
| content.height = contentheight |
| end |
| local function EnableResize(self, state) |
| local func = state and "Show" or "Hide" |
| self.sizer_se[func](self.sizer_se) |
| self.sizer_s[func](self.sizer_s) |
| self.sizer_e[func](self.sizer_e) |
| end |
| local function Constructor() |
| local frame = CreateFrame("Frame",nil,UIParent) |
| local self = {} |
| self.type = "Window" |
| self.Hide = Hide |
| self.Show = Show |
| self.SetTitle = SetTitle |
| self.OnRelease = OnRelease |
| self.OnAcquire = OnAcquire |
| self.SetStatusText = SetStatusText |
| self.SetStatusTable = SetStatusTable |
| self.ApplyStatus = ApplyStatus |
| self.OnWidthSet = OnWidthSet |
| self.OnHeightSet = OnHeightSet |
| self.EnableResize = EnableResize |
| self.localstatus = {} |
| self.frame = frame |
| frame.obj = self |
| frame:SetWidth(700) |
| frame:SetHeight(500) |
| frame:SetPoint("CENTER",UIParent,"CENTER",0,0) |
| frame:EnableMouse() |
| frame:SetMovable(true) |
| frame:SetResizable(true) |
| frame:SetFrameStrata("FULLSCREEN_DIALOG") |
| frame:SetScript("OnMouseDown", frameOnMouseDown) |
| frame:SetScript("OnHide",frameOnClose) |
| frame:SetMinResize(240,240) |
| frame:SetToplevel(true) |
| local titlebg = frame:CreateTexture(nil, "BACKGROUND") |
| titlebg:SetTexture([[Interface\PaperDollInfoFrame\UI-GearManager-Title-Background]]) |
| titlebg:SetPoint("TOPLEFT", 9, -6) |
| titlebg:SetPoint("BOTTOMRIGHT", frame, "TOPRIGHT", -28, -24) |
| local dialogbg = frame:CreateTexture(nil, "BACKGROUND") |
| dialogbg:SetTexture([[Interface\Tooltips\UI-Tooltip-Background]]) |
| dialogbg:SetPoint("TOPLEFT", 8, -24) |
| dialogbg:SetPoint("BOTTOMRIGHT", -6, 8) |
| dialogbg:SetVertexColor(0, 0, 0, .75) |
| local topleft = frame:CreateTexture(nil, "BORDER") |
| topleft:SetTexture([[Interface\PaperDollInfoFrame\UI-GearManager-Border]]) |
| topleft:SetWidth(64) |
| topleft:SetHeight(64) |
| topleft:SetPoint("TOPLEFT") |
| topleft:SetTexCoord(0.501953125, 0.625, 0, 1) |
| local topright = frame:CreateTexture(nil, "BORDER") |
| topright:SetTexture([[Interface\PaperDollInfoFrame\UI-GearManager-Border]]) |
| topright:SetWidth(64) |
| topright:SetHeight(64) |
| topright:SetPoint("TOPRIGHT") |
| topright:SetTexCoord(0.625, 0.75, 0, 1) |
| local top = frame:CreateTexture(nil, "BORDER") |
| top:SetTexture([[Interface\PaperDollInfoFrame\UI-GearManager-Border]]) |
| top:SetHeight(64) |
| top:SetPoint("TOPLEFT", topleft, "TOPRIGHT") |
| top:SetPoint("TOPRIGHT", topright, "TOPLEFT") |
| top:SetTexCoord(0.25, 0.369140625, 0, 1) |
| local bottomleft = frame:CreateTexture(nil, "BORDER") |
| bottomleft:SetTexture([[Interface\PaperDollInfoFrame\UI-GearManager-Border]]) |
| bottomleft:SetWidth(64) |
| bottomleft:SetHeight(64) |
| bottomleft:SetPoint("BOTTOMLEFT") |
| bottomleft:SetTexCoord(0.751953125, 0.875, 0, 1) |
| local bottomright = frame:CreateTexture(nil, "BORDER") |
| bottomright:SetTexture([[Interface\PaperDollInfoFrame\UI-GearManager-Border]]) |
| bottomright:SetWidth(64) |
| bottomright:SetHeight(64) |
| bottomright:SetPoint("BOTTOMRIGHT") |
| bottomright:SetTexCoord(0.875, 1, 0, 1) |
| local bottom = frame:CreateTexture(nil, "BORDER") |
| bottom:SetTexture([[Interface\PaperDollInfoFrame\UI-GearManager-Border]]) |
| bottom:SetHeight(64) |
| bottom:SetPoint("BOTTOMLEFT", bottomleft, "BOTTOMRIGHT") |
| bottom:SetPoint("BOTTOMRIGHT", bottomright, "BOTTOMLEFT") |
| bottom:SetTexCoord(0.376953125, 0.498046875, 0, 1) |
| local left = frame:CreateTexture(nil, "BORDER") |
| left:SetTexture([[Interface\PaperDollInfoFrame\UI-GearManager-Border]]) |
| left:SetWidth(64) |
| left:SetPoint("TOPLEFT", topleft, "BOTTOMLEFT") |
| left:SetPoint("BOTTOMLEFT", bottomleft, "TOPLEFT") |
| left:SetTexCoord(0.001953125, 0.125, 0, 1) |
| local right = frame:CreateTexture(nil, "BORDER") |
| right:SetTexture([[Interface\PaperDollInfoFrame\UI-GearManager-Border]]) |
| right:SetWidth(64) |
| right:SetPoint("TOPRIGHT", topright, "BOTTOMRIGHT") |
| right:SetPoint("BOTTOMRIGHT", bottomright, "TOPRIGHT") |
| right:SetTexCoord(0.1171875, 0.2421875, 0, 1) |
| local close = CreateFrame("Button", nil, frame, "UIPanelCloseButton") |
| close:SetPoint("TOPRIGHT", 2, 1) |
| close:SetScript("OnClick", closeOnClick) |
| self.closebutton = close |
| close.obj = self |
| local titletext = frame:CreateFontString(nil, "ARTWORK") |
| titletext:SetFontObject(GameFontNormal) |
| titletext:SetPoint("TOPLEFT", 12, -8) |
| titletext:SetPoint("TOPRIGHT", -32, -8) |
| self.titletext = titletext |
| local title = CreateFrame("Button", nil, frame) |
| title:SetPoint("TOPLEFT", titlebg) |
| title:SetPoint("BOTTOMRIGHT", titlebg) |
| title:EnableMouse() |
| title:SetScript("OnMouseDown",titleOnMouseDown) |
| title:SetScript("OnMouseUp", frameOnMouseUp) |
| self.title = title |
| local sizer_se = CreateFrame("Frame",nil,frame) |
| sizer_se:SetPoint("BOTTOMRIGHT",frame,"BOTTOMRIGHT",0,0) |
| sizer_se:SetWidth(25) |
| sizer_se:SetHeight(25) |
| sizer_se:EnableMouse() |
| sizer_se:SetScript("OnMouseDown",sizerseOnMouseDown) |
| sizer_se:SetScript("OnMouseUp", sizerOnMouseUp) |
| self.sizer_se = sizer_se |
| local line1 = sizer_se:CreateTexture(nil, "BACKGROUND") |
| self.line1 = line1 |
| line1:SetWidth(14) |
| line1:SetHeight(14) |
| line1:SetPoint("BOTTOMRIGHT", -8, 8) |
| line1:SetTexture("Interface\\Tooltips\\UI-Tooltip-Border") |
| local x = 0.1 * 14/17 |
| line1:SetTexCoord(0.05 - x, 0.5, 0.05, 0.5 + x, 0.05, 0.5 - x, 0.5 + x, 0.5) |
| local line2 = sizer_se:CreateTexture(nil, "BACKGROUND") |
| self.line2 = line2 |
| line2:SetWidth(8) |
| line2:SetHeight(8) |
| line2:SetPoint("BOTTOMRIGHT", -8, 8) |
| line2:SetTexture("Interface\\Tooltips\\UI-Tooltip-Border") |
| local x = 0.1 * 8/17 |
| line2:SetTexCoord(0.05 - x, 0.5, 0.05, 0.5 + x, 0.05, 0.5 - x, 0.5 + x, 0.5) |
| local sizer_s = CreateFrame("Frame",nil,frame) |
| sizer_s:SetPoint("BOTTOMRIGHT",frame,"BOTTOMRIGHT",-25,0) |
| sizer_s:SetPoint("BOTTOMLEFT",frame,"BOTTOMLEFT",0,0) |
| sizer_s:SetHeight(25) |
| sizer_s:EnableMouse() |
| sizer_s:SetScript("OnMouseDown",sizersOnMouseDown) |
| sizer_s:SetScript("OnMouseUp", sizerOnMouseUp) |
| self.sizer_s = sizer_s |
| local sizer_e = CreateFrame("Frame",nil,frame) |
| sizer_e:SetPoint("BOTTOMRIGHT",frame,"BOTTOMRIGHT",0,25) |
| sizer_e:SetPoint("TOPRIGHT",frame,"TOPRIGHT",0,0) |
| sizer_e:SetWidth(25) |
| sizer_e:EnableMouse() |
| sizer_e:SetScript("OnMouseDown",sizereOnMouseDown) |
| sizer_e:SetScript("OnMouseUp", sizerOnMouseUp) |
| self.sizer_e = sizer_e |
| --Container Support |
| local content = CreateFrame("Frame",nil,frame) |
| self.content = content |
| content.obj = self |
| content:SetPoint("TOPLEFT",frame,"TOPLEFT",12,-32) |
| content:SetPoint("BOTTOMRIGHT",frame,"BOTTOMRIGHT",-12,13) |
| AceGUI:RegisterAsContainer(self) |
| return self |
| end |
| AceGUI:RegisterWidgetType(Type,Constructor,Version) |
| end |
mRunes/Libs/AceGUI-3.0/widgets/AceGUIContainer-DropDownGroup.lua
New file
0,0 → 1,157
| --[[----------------------------------------------------------------------------- |
| DropdownGroup Container |
| Container controlled by a dropdown on the top. |
| -------------------------------------------------------------------------------]] |
| local Type, Version = "DropdownGroup", 20 |
| local AceGUI = LibStub and LibStub("AceGUI-3.0", true) |
| if not AceGUI or (AceGUI:GetWidgetVersion(Type) or 0) >= Version then return end |
| -- Lua APIs |
| local assert, pairs, type = assert, pairs, type |
| -- WoW APIs |
| local CreateFrame = CreateFrame |
| --[[----------------------------------------------------------------------------- |
| Scripts |
| -------------------------------------------------------------------------------]] |
| local function SelectedGroup(self, event, value) |
| local group = self.parentgroup |
| local status = group.status or group.localstatus |
| status.selected = value |
| self.parentgroup:Fire("OnGroupSelected", value) |
| end |
| --[[----------------------------------------------------------------------------- |
| Methods |
| -------------------------------------------------------------------------------]] |
| local methods = { |
| ["OnAcquire"] = function(self) |
| self.dropdown:SetText("") |
| self:SetDropdownWidth(200) |
| self:SetTitle("") |
| end, |
| ["OnRelease"] = function(self) |
| self.dropdown.list = nil |
| self.status = nil |
| for k in pairs(self.localstatus) do |
| self.localstatus[k] = nil |
| end |
| end, |
| ["SetTitle"] = function(self, title) |
| self.titletext:SetText(title) |
| self.dropdown.frame:ClearAllPoints() |
| if title and title ~= "" then |
| self.dropdown.frame:SetPoint("TOPRIGHT", -2, 0) |
| else |
| self.dropdown.frame:SetPoint("TOPLEFT", -1, 0) |
| end |
| end, |
| ["SetGroupList"] = function(self,list) |
| self.dropdown:SetList(list) |
| end, |
| ["SetStatusTable"] = function(self, status) |
| assert(type(status) == "table") |
| self.status = status |
| end, |
| ["SetGroup"] = function(self,group) |
| self.dropdown:SetValue(group) |
| local status = self.status or self.localstatus |
| status.selected = group |
| self:Fire("OnGroupSelected", group) |
| end, |
| ["OnWidthSet"] = function(self, width) |
| local content = self.content |
| local contentwidth = width - 26 |
| if contentwidth < 0 then |
| contentwidth = 0 |
| end |
| content:SetWidth(contentwidth) |
| content.width = contentwidth |
| end, |
| ["OnHeightSet"] = function(self, height) |
| local content = self.content |
| local contentheight = height - 63 |
| if contentheight < 0 then |
| contentheight = 0 |
| end |
| content:SetHeight(contentheight) |
| content.height = contentheight |
| end, |
| ["LayoutFinished"] = function(self, width, height) |
| self:SetHeight((height or 0) + 63) |
| end, |
| ["SetDropdownWidth"] = function(self, width) |
| self.dropdown:SetWidth(width) |
| end |
| } |
| --[[----------------------------------------------------------------------------- |
| Constructor |
| -------------------------------------------------------------------------------]] |
| local PaneBackdrop = { |
| bgFile = "Interface\\ChatFrame\\ChatFrameBackground", |
| edgeFile = "Interface\\Tooltips\\UI-Tooltip-Border", |
| tile = true, tileSize = 16, edgeSize = 16, |
| insets = { left = 3, right = 3, top = 5, bottom = 3 } |
| } |
| local function Constructor() |
| local frame = CreateFrame("Frame") |
| frame:SetHeight(100) |
| frame:SetWidth(100) |
| frame:SetFrameStrata("FULLSCREEN_DIALOG") |
| local titletext = frame:CreateFontString(nil, "OVERLAY", "GameFontNormal") |
| titletext:SetPoint("TOPLEFT", 4, -5) |
| titletext:SetPoint("TOPRIGHT", -4, -5) |
| titletext:SetJustifyH("LEFT") |
| titletext:SetHeight(18) |
| local dropdown = AceGUI:Create("Dropdown") |
| dropdown.frame:SetParent(frame) |
| dropdown.frame:SetFrameLevel(dropdown.frame:GetFrameLevel() + 2) |
| dropdown:SetCallback("OnValueChanged", SelectedGroup) |
| dropdown.frame:SetPoint("TOPLEFT", -1, 0) |
| dropdown.frame:Show() |
| dropdown:SetLabel("") |
| local border = CreateFrame("Frame", nil, frame) |
| border:SetPoint("TOPLEFT", 0, -26) |
| border:SetPoint("BOTTOMRIGHT", 0, 3) |
| border:SetBackdrop(PaneBackdrop) |
| border:SetBackdropColor(0.1,0.1,0.1,0.5) |
| border:SetBackdropBorderColor(0.4,0.4,0.4) |
| --Container Support |
| local content = CreateFrame("Frame", nil, border) |
| content:SetPoint("TOPLEFT", 10, -10) |
| content:SetPoint("BOTTOMRIGHT", -10, 10) |
| local widget = { |
| frame = frame, |
| localstatus = {}, |
| titletext = titletext, |
| dropdown = dropdown, |
| border = border, |
| content = content, |
| type = Type |
| } |
| for method, func in pairs(methods) do |
| widget[method] = func |
| end |
| dropdown.parentgroup = widget |
| return AceGUI:RegisterAsContainer(widget) |
| end |
| AceGUI:RegisterWidgetType(Type, Constructor, Version) |
mRunes/Libs/AceGUI-3.0/widgets/AceGUIContainer-ScrollFrame.lua
New file
0,0 → 1,203
| --[[----------------------------------------------------------------------------- |
| ScrollFrame Container |
| Plain container that scrolls its content and doesn't grow in height. |
| -------------------------------------------------------------------------------]] |
| local Type, Version = "ScrollFrame", 21 |
| local AceGUI = LibStub and LibStub("AceGUI-3.0", true) |
| if not AceGUI or (AceGUI:GetWidgetVersion(Type) or 0) >= Version then return end |
| -- Lua APIs |
| local pairs, assert, type = pairs, assert, type |
| local min, max, floor, abs = math.min, math.max, math.floor, math.abs |
| -- WoW APIs |
| local CreateFrame, UIParent = CreateFrame, UIParent |
| --[[----------------------------------------------------------------------------- |
| Support functions |
| -------------------------------------------------------------------------------]] |
| local function FixScrollOnUpdate(frame) |
| frame:SetScript("OnUpdate", nil) |
| frame.obj:FixScroll() |
| end |
| --[[----------------------------------------------------------------------------- |
| Scripts |
| -------------------------------------------------------------------------------]] |
| local function ScrollFrame_OnMouseWheel(frame, value) |
| frame.obj:MoveScroll(value) |
| end |
| local function ScrollFrame_OnSizeChanged(frame) |
| frame:SetScript("OnUpdate", FixScrollOnUpdate) |
| end |
| local function ScrollBar_OnScrollValueChanged(frame, value) |
| frame.obj:SetScroll(value) |
| end |
| --[[----------------------------------------------------------------------------- |
| Methods |
| -------------------------------------------------------------------------------]] |
| local methods = { |
| ["OnAcquire"] = function(self) |
| self:SetScroll(0) |
| end, |
| ["OnRelease"] = function(self) |
| self.status = nil |
| for k in pairs(self.localstatus) do |
| self.localstatus[k] = nil |
| end |
| self.scrollframe:SetPoint("BOTTOMRIGHT") |
| self.scrollbar:Hide() |
| self.scrollBarShown = nil |
| self.content.height, self.content.width = nil, nil |
| end, |
| ["SetScroll"] = function(self, value) |
| local status = self.status or self.localstatus |
| local viewheight = self.scrollframe:GetHeight() |
| local height = self.content:GetHeight() |
| local offset |
| if viewheight > height then |
| offset = 0 |
| else |
| offset = floor((height - viewheight) / 1000.0 * value) |
| end |
| self.content:ClearAllPoints() |
| self.content:SetPoint("TOPLEFT", 0, offset) |
| self.content:SetPoint("TOPRIGHT", 0, offset) |
| status.offset = offset |
| status.scrollvalue = value |
| end, |
| ["MoveScroll"] = function(self, value) |
| local status = self.status or self.localstatus |
| local height, viewheight = self.scrollframe:GetHeight(), self.content:GetHeight() |
| if self.scrollBarShown then |
| local diff = height - viewheight |
| local delta = 1 |
| if value < 0 then |
| delta = -1 |
| end |
| self.scrollbar:SetValue(min(max(status.scrollvalue + delta*(1000/(diff/45)),0), 1000)) |
| end |
| end, |
| ["FixScroll"] = function(self) |
| if self.updateLock then return end |
| self.updateLock = true |
| local status = self.status or self.localstatus |
| local height, viewheight = self.scrollframe:GetHeight(), self.content:GetHeight() |
| local offset = status.offset or 0 |
| local curvalue = self.scrollbar:GetValue() |
| -- Give us a margin of error of 2 pixels to stop some conditions that i would blame on floating point inaccuracys |
| -- No-one is going to miss 2 pixels at the bottom of the frame, anyhow! |
| if viewheight < height + 2 then |
| if self.scrollBarShown then |
| self.scrollBarShown = nil |
| self.scrollbar:Hide() |
| self.scrollbar:SetValue(0) |
| self.scrollframe:SetPoint("BOTTOMRIGHT") |
| self:DoLayout() |
| end |
| else |
| if not self.scrollBarShown then |
| self.scrollBarShown = true |
| self.scrollbar:Show() |
| self.scrollframe:SetPoint("BOTTOMRIGHT", -20, 0) |
| self:DoLayout() |
| end |
| local value = (offset / (viewheight - height) * 1000) |
| if value > 1000 then value = 1000 end |
| self.scrollbar:SetValue(value) |
| self:SetScroll(value) |
| if value < 1000 then |
| self.content:ClearAllPoints() |
| self.content:SetPoint("TOPLEFT", 0, offset) |
| self.content:SetPoint("TOPRIGHT", 0, offset) |
| status.offset = offset |
| end |
| end |
| self.updateLock = nil |
| end, |
| ["LayoutFinished"] = function(self, width, height) |
| self.content:SetHeight(height or 0 + 20) |
| self.scrollframe:SetScript("OnUpdate", FixScrollOnUpdate) |
| end, |
| ["SetStatusTable"] = function(self, status) |
| assert(type(status) == "table") |
| self.status = status |
| if not status.scrollvalue then |
| status.scrollvalue = 0 |
| end |
| end, |
| ["OnWidthSet"] = function(self, width) |
| local content = self.content |
| content.width = width |
| end, |
| ["OnHeightSet"] = function(self, height) |
| local content = self.content |
| content.height = height |
| end |
| } |
| --[[----------------------------------------------------------------------------- |
| Constructor |
| -------------------------------------------------------------------------------]] |
| local function Constructor() |
| local frame = CreateFrame("Frame", nil, UIParent) |
| local num = AceGUI:GetNextWidgetNum(Type) |
| local scrollframe = CreateFrame("ScrollFrame", nil, frame) |
| scrollframe:SetPoint("TOPLEFT") |
| scrollframe:SetPoint("BOTTOMRIGHT") |
| scrollframe:EnableMouseWheel(true) |
| scrollframe:SetScript("OnMouseWheel", ScrollFrame_OnMouseWheel) |
| scrollframe:SetScript("OnSizeChanged", ScrollFrame_OnSizeChanged) |
| local scrollbar = CreateFrame("Slider", ("AceConfigDialogScrollFrame%dScrollBar"):format(num), scrollframe, "UIPanelScrollBarTemplate") |
| scrollbar:SetPoint("TOPLEFT", scrollframe, "TOPRIGHT", 4, -16) |
| scrollbar:SetPoint("BOTTOMLEFT", scrollframe, "BOTTOMRIGHT", 4, 16) |
| scrollbar:SetMinMaxValues(0, 1000) |
| scrollbar:SetValueStep(1) |
| scrollbar:SetValue(0) |
| scrollbar:SetWidth(16) |
| scrollbar:Hide() |
| -- set the script as the last step, so it doesn't fire yet |
| scrollbar:SetScript("OnValueChanged", ScrollBar_OnScrollValueChanged) |
| local scrollbg = scrollbar:CreateTexture(nil, "BACKGROUND") |
| scrollbg:SetAllPoints(scrollbar) |
| scrollbg:SetTexture(0, 0, 0, 0.4) |
| --Container Support |
| local content = CreateFrame("Frame", nil, scrollframe) |
| content:SetPoint("TOPLEFT") |
| content:SetPoint("TOPRIGHT") |
| content:SetHeight(400) |
| scrollframe:SetScrollChild(content) |
| local widget = { |
| localstatus = { scrollvalue = 0 }, |
| scrollframe = scrollframe, |
| scrollbar = scrollbar, |
| content = content, |
| frame = frame, |
| type = Type |
| } |
| for method, func in pairs(methods) do |
| widget[method] = func |
| end |
| scrollframe.obj, scrollbar.obj = widget, widget |
| return AceGUI:RegisterAsContainer(widget) |
| end |
| AceGUI:RegisterWidgetType(Type, Constructor, Version) |
mRunes/Libs/AceGUI-3.0/widgets/AceGUIContainer-TreeGroup.lua
New file
0,0 → 1,670
| --[[----------------------------------------------------------------------------- |
| TreeGroup Container |
| Container that uses a tree control to switch between groups. |
| -------------------------------------------------------------------------------]] |
| local Type, Version = "TreeGroup", 30 |
| local AceGUI = LibStub and LibStub("AceGUI-3.0", true) |
| if not AceGUI or (AceGUI:GetWidgetVersion(Type) or 0) >= Version then return end |
| -- Lua APIs |
| local next, pairs, ipairs, assert, type = next, pairs, ipairs, assert, type |
| local math_min, math_max, floor = math.min, math.max, floor |
| local select, tremove, unpack = select, table.remove, unpack |
| -- WoW APIs |
| local CreateFrame, UIParent = CreateFrame, UIParent |
| -- Global vars/functions that we don't upvalue since they might get hooked, or upgraded |
| -- List them here for Mikk's FindGlobals script |
| -- GLOBALS: GameTooltip, FONT_COLOR_CODE_CLOSE |
| -- Recycling functions |
| local new, del |
| do |
| local pool = setmetatable({},{__mode='k'}) |
| function new() |
| local t = next(pool) |
| if t then |
| pool[t] = nil |
| return t |
| else |
| return {} |
| end |
| end |
| function del(t) |
| for k in pairs(t) do |
| t[k] = nil |
| end |
| pool[t] = true |
| end |
| end |
| local DEFAULT_TREE_WIDTH = 175 |
| local DEFAULT_TREE_SIZABLE = true |
| --[[----------------------------------------------------------------------------- |
| Support functions |
| -------------------------------------------------------------------------------]] |
| local function GetButtonUniqueValue(line) |
| local parent = line.parent |
| if parent and parent.value then |
| return GetButtonUniqueValue(parent).."\001"..line.value |
| else |
| return line.value |
| end |
| end |
| local function UpdateButton(button, treeline, selected, canExpand, isExpanded) |
| local self = button.obj |
| local toggle = button.toggle |
| local frame = self.frame |
| local text = treeline.text or "" |
| local icon = treeline.icon |
| local iconCoords = treeline.iconCoords |
| local level = treeline.level |
| local value = treeline.value |
| local uniquevalue = treeline.uniquevalue |
| local disabled = treeline.disabled |
| button.treeline = treeline |
| button.value = value |
| button.uniquevalue = uniquevalue |
| if selected then |
| button:LockHighlight() |
| button.selected = true |
| else |
| button:UnlockHighlight() |
| button.selected = false |
| end |
| local normalTexture = button:GetNormalTexture() |
| local line = button.line |
| button.level = level |
| if ( level == 1 ) then |
| button:SetNormalFontObject("GameFontNormal") |
| button:SetHighlightFontObject("GameFontHighlight") |
| button.text:SetPoint("LEFT", (icon and 16 or 0) + 8, 2) |
| else |
| button:SetNormalFontObject("GameFontHighlightSmall") |
| button:SetHighlightFontObject("GameFontHighlightSmall") |
| button.text:SetPoint("LEFT", (icon and 16 or 0) + 8 * level, 2) |
| end |
| if disabled then |
| button:EnableMouse(false) |
| button.text:SetText("|cff808080"..text..FONT_COLOR_CODE_CLOSE) |
| else |
| button.text:SetText(text) |
| button:EnableMouse(true) |
| end |
| if icon then |
| button.icon:SetTexture(icon) |
| button.icon:SetPoint("LEFT", 8 * level, (level == 1) and 0 or 1) |
| else |
| button.icon:SetTexture(nil) |
| end |
| if iconCoords then |
| button.icon:SetTexCoord(unpack(iconCoords)) |
| else |
| button.icon:SetTexCoord(0, 1, 0, 1) |
| end |
| if canExpand then |
| if not isExpanded then |
| toggle:SetNormalTexture("Interface\\Buttons\\UI-PlusButton-UP") |
| toggle:SetPushedTexture("Interface\\Buttons\\UI-PlusButton-DOWN") |
| else |
| toggle:SetNormalTexture("Interface\\Buttons\\UI-MinusButton-UP") |
| toggle:SetPushedTexture("Interface\\Buttons\\UI-MinusButton-DOWN") |
| end |
| toggle:Show() |
| else |
| toggle:Hide() |
| end |
| end |
| local function ShouldDisplayLevel(tree) |
| local result = false |
| for k, v in ipairs(tree) do |
| if v.children == nil and v.visible ~= false then |
| result = true |
| elseif v.children then |
| result = result or ShouldDisplayLevel(v.children) |
| end |
| if result then return result end |
| end |
| return false |
| end |
| local function addLine(self, v, tree, level, parent) |
| local line = new() |
| line.value = v.value |
| line.text = v.text |
| line.icon = v.icon |
| line.iconCoords = v.iconCoords |
| line.disabled = v.disabled |
| line.tree = tree |
| line.level = level |
| line.parent = parent |
| line.visible = v.visible |
| line.uniquevalue = GetButtonUniqueValue(line) |
| if v.children then |
| line.hasChildren = true |
| else |
| line.hasChildren = nil |
| end |
| self.lines[#self.lines+1] = line |
| return line |
| end |
| --fire an update after one frame to catch the treeframes height |
| local function FirstFrameUpdate(frame) |
| local self = frame.obj |
| frame:SetScript("OnUpdate", nil) |
| self:RefreshTree() |
| end |
| local function BuildUniqueValue(...) |
| local n = select('#', ...) |
| if n == 1 then |
| return ... |
| else |
| return (...).."\001"..BuildUniqueValue(select(2,...)) |
| end |
| end |
| --[[----------------------------------------------------------------------------- |
| Scripts |
| -------------------------------------------------------------------------------]] |
| local function Expand_OnClick(frame) |
| local button = frame.button |
| local self = button.obj |
| local status = (self.status or self.localstatus).groups |
| status[button.uniquevalue] = not status[button.uniquevalue] |
| self:RefreshTree() |
| end |
| local function Button_OnClick(frame) |
| local self = frame.obj |
| self:Fire("OnClick", frame.uniquevalue, frame.selected) |
| if not frame.selected then |
| self:SetSelected(frame.uniquevalue) |
| frame.selected = true |
| frame:LockHighlight() |
| self:RefreshTree() |
| end |
| AceGUI:ClearFocus() |
| end |
| local function Button_OnDoubleClick(button) |
| local self = button.obj |
| local status = self.status or self.localstatus |
| local status = (self.status or self.localstatus).groups |
| status[button.uniquevalue] = not status[button.uniquevalue] |
| self:RefreshTree() |
| end |
| local function Button_OnEnter(frame) |
| local self = frame.obj |
| self:Fire("OnButtonEnter", frame.uniquevalue, frame) |
| if self.enabletooltips then |
| GameTooltip:SetOwner(frame, "ANCHOR_NONE") |
| GameTooltip:SetPoint("LEFT",frame,"RIGHT") |
| GameTooltip:SetText(frame.text:GetText() or "", 1, .82, 0, 1) |
| GameTooltip:Show() |
| end |
| end |
| local function Button_OnLeave(frame) |
| local self = frame.obj |
| self:Fire("OnButtonLeave", frame.uniquevalue, frame) |
| if self.enabletooltips then |
| GameTooltip:Hide() |
| end |
| end |
| local function OnScrollValueChanged(frame, value) |
| if frame.obj.noupdate then return end |
| local self = frame.obj |
| local status = self.status or self.localstatus |
| status.scrollvalue = value |
| self:RefreshTree() |
| AceGUI:ClearFocus() |
| end |
| local function Tree_OnSizeChanged(frame) |
| frame.obj:RefreshTree() |
| end |
| local function Tree_OnMouseWheel(frame, delta) |
| local self = frame.obj |
| if self.showscroll then |
| local scrollbar = self.scrollbar |
| local min, max = scrollbar:GetMinMaxValues() |
| local value = scrollbar:GetValue() |
| local newvalue = math_min(max,math_max(min,value - delta)) |
| if value ~= newvalue then |
| scrollbar:SetValue(newvalue) |
| end |
| end |
| end |
| local function Dragger_OnLeave(frame) |
| frame:SetBackdropColor(1, 1, 1, 0) |
| end |
| local function Dragger_OnEnter(frame) |
| frame:SetBackdropColor(1, 1, 1, 0.8) |
| end |
| local function Dragger_OnMouseDown(frame) |
| local treeframe = frame:GetParent() |
| treeframe:StartSizing("RIGHT") |
| end |
| local function Dragger_OnMouseUp(frame) |
| local treeframe = frame:GetParent() |
| local self = treeframe.obj |
| local frame = treeframe:GetParent() |
| treeframe:StopMovingOrSizing() |
| --treeframe:SetScript("OnUpdate", nil) |
| treeframe:SetUserPlaced(false) |
| --Without this :GetHeight will get stuck on the current height, causing the tree contents to not resize |
| treeframe:SetHeight(0) |
| treeframe:SetPoint("TOPLEFT", frame, "TOPLEFT",0,0) |
| treeframe:SetPoint("BOTTOMLEFT", frame, "BOTTOMLEFT",0,0) |
| local status = self.status or self.localstatus |
| status.treewidth = treeframe:GetWidth() |
| treeframe.obj:Fire("OnTreeResize",treeframe:GetWidth()) |
| -- recalculate the content width |
| treeframe.obj:OnWidthSet(status.fullwidth) |
| -- update the layout of the content |
| treeframe.obj:DoLayout() |
| end |
| --[[----------------------------------------------------------------------------- |
| Methods |
| -------------------------------------------------------------------------------]] |
| local methods = { |
| ["OnAcquire"] = function(self) |
| self:SetTreeWidth(DEFAULT_TREE_WIDTH, DEFAULT_TREE_SIZABLE) |
| self:EnableButtonTooltips(true) |
| end, |
| ["OnRelease"] = function(self) |
| self.status = nil |
| for k, v in pairs(self.localstatus) do |
| if k == "groups" then |
| for k2 in pairs(v) do |
| v[k2] = nil |
| end |
| else |
| self.localstatus[k] = nil |
| end |
| end |
| self.localstatus.scrollvalue = 0 |
| self.localstatus.treewidth = DEFAULT_TREE_WIDTH |
| self.localstatus.treesizable = DEFAULT_TREE_SIZABLE |
| end, |
| ["EnableButtonTooltips"] = function(self, enable) |
| self.enabletooltips = enable |
| end, |
| ["CreateButton"] = function(self) |
| local num = AceGUI:GetNextWidgetNum("TreeGroupButton") |
| local button = CreateFrame("Button", ("AceGUI30TreeButton%d"):format(num), self.treeframe, "OptionsListButtonTemplate") |
| button.obj = self |
| local icon = button:CreateTexture(nil, "OVERLAY") |
| icon:SetWidth(14) |
| icon:SetHeight(14) |
| button.icon = icon |
| button:SetScript("OnClick",Button_OnClick) |
| button:SetScript("OnDoubleClick", Button_OnDoubleClick) |
| button:SetScript("OnEnter",Button_OnEnter) |
| button:SetScript("OnLeave",Button_OnLeave) |
| button.toggle.button = button |
| button.toggle:SetScript("OnClick",Expand_OnClick) |
| return button |
| end, |
| ["SetStatusTable"] = function(self, status) |
| assert(type(status) == "table") |
| self.status = status |
| if not status.groups then |
| status.groups = {} |
| end |
| if not status.scrollvalue then |
| status.scrollvalue = 0 |
| end |
| if not status.treewidth then |
| status.treewidth = DEFAULT_TREE_WIDTH |
| end |
| if not status.treesizable then |
| status.treesizable = DEFAULT_TREE_SIZABLE |
| end |
| self:SetTreeWidth(status.treewidth,status.treesizable) |
| self:RefreshTree() |
| end, |
| --sets the tree to be displayed |
| ["SetTree"] = function(self, tree, filter) |
| self.filter = filter |
| if tree then |
| assert(type(tree) == "table") |
| end |
| self.tree = tree |
| self:RefreshTree() |
| end, |
| ["BuildLevel"] = function(self, tree, level, parent) |
| local groups = (self.status or self.localstatus).groups |
| local hasChildren = self.hasChildren |
| for i, v in ipairs(tree) do |
| if v.children then |
| if not self.filter or ShouldDisplayLevel(v.children) then |
| local line = addLine(self, v, tree, level, parent) |
| if groups[line.uniquevalue] then |
| self:BuildLevel(v.children, level+1, line) |
| end |
| end |
| elseif v.visible ~= false or not self.filter then |
| addLine(self, v, tree, level, parent) |
| end |
| end |
| end, |
| ["RefreshTree"] = function(self) |
| local buttons = self.buttons |
| local lines = self.lines |
| for i, v in ipairs(buttons) do |
| v:Hide() |
| end |
| while lines[1] do |
| local t = tremove(lines) |
| for k in pairs(t) do |
| t[k] = nil |
| end |
| del(t) |
| end |
| if not self.tree then return end |
| --Build the list of visible entries from the tree and status tables |
| local status = self.status or self.localstatus |
| local groupstatus = status.groups |
| local tree = self.tree |
| local treeframe = self.treeframe |
| self:BuildLevel(tree, 1) |
| local numlines = #lines |
| local maxlines = (floor(((self.treeframe:GetHeight()or 0) - 20 ) / 18)) |
| local first, last |
| if numlines <= maxlines then |
| --the whole tree fits in the frame |
| status.scrollvalue = 0 |
| self:ShowScroll(false) |
| first, last = 1, numlines |
| else |
| self:ShowScroll(true) |
| --scrolling will be needed |
| self.noupdate = true |
| self.scrollbar:SetMinMaxValues(0, numlines - maxlines) |
| --check if we are scrolled down too far |
| if numlines - status.scrollvalue < maxlines then |
| status.scrollvalue = numlines - maxlines |
| self.scrollbar:SetValue(status.scrollvalue) |
| end |
| self.noupdate = nil |
| first, last = status.scrollvalue+1, status.scrollvalue + maxlines |
| end |
| local buttonnum = 1 |
| for i = first, last do |
| local line = lines[i] |
| local button = buttons[buttonnum] |
| if not button then |
| button = self:CreateButton() |
| buttons[buttonnum] = button |
| button:SetParent(treeframe) |
| button:SetFrameLevel(treeframe:GetFrameLevel()+1) |
| button:ClearAllPoints() |
| if i == 1 then |
| if self.showscroll then |
| button:SetPoint("TOPRIGHT", self.treeframe,"TOPRIGHT",-22,-10) |
| button:SetPoint("TOPLEFT", self.treeframe, "TOPLEFT", 0, -10) |
| else |
| button:SetPoint("TOPRIGHT", self.treeframe,"TOPRIGHT",0,-10) |
| button:SetPoint("TOPLEFT", self.treeframe, "TOPLEFT", 0, -10) |
| end |
| else |
| button:SetPoint("TOPRIGHT", buttons[buttonnum-1], "BOTTOMRIGHT",0,0) |
| button:SetPoint("TOPLEFT", buttons[buttonnum-1], "BOTTOMLEFT",0,0) |
| end |
| end |
| UpdateButton(button, line, status.selected == line.uniquevalue, line.hasChildren, groupstatus[line.uniquevalue] ) |
| button:Show() |
| buttonnum = buttonnum + 1 |
| end |
| end, |
| ["SetSelected"] = function(self, value) |
| local status = self.status or self.localstatus |
| if status.selected ~= value then |
| status.selected = value |
| self:Fire("OnGroupSelected", value) |
| end |
| end, |
| ["Select"] = function(self, uniquevalue, ...) |
| self.filter = false |
| local status = self.status or self.localstatus |
| local groups = status.groups |
| for i = 1, select('#', ...) do |
| groups[BuildUniqueValue(select(i, ...))] = true |
| end |
| status.selected = uniquevalue |
| self:RefreshTree() |
| self:Fire("OnGroupSelected", uniquevalue) |
| end, |
| ["SelectByPath"] = function(self, ...) |
| self:Select(BuildUniqueValue(...), ...) |
| end, |
| ["SelectByValue"] = function(self, uniquevalue) |
| self:Select(uniquevalue, ("\001"):split(uniquevalue)) |
| end, |
| ["ShowScroll"] = function(self, show) |
| self.showscroll = show |
| if show then |
| self.scrollbar:Show() |
| if self.buttons[1] then |
| self.buttons[1]:SetPoint("TOPRIGHT", self.treeframe,"TOPRIGHT",-22,-10) |
| end |
| else |
| self.scrollbar:Hide() |
| if self.buttons[1] then |
| self.buttons[1]:SetPoint("TOPRIGHT", self.treeframe,"TOPRIGHT",0,-10) |
| end |
| end |
| end, |
| ["OnWidthSet"] = function(self, width) |
| local content = self.content |
| local treeframe = self.treeframe |
| local status = self.status or self.localstatus |
| status.fullwidth = width |
| local contentwidth = width - status.treewidth - 20 |
| if contentwidth < 0 then |
| contentwidth = 0 |
| end |
| content:SetWidth(contentwidth) |
| content.width = contentwidth |
| local maxtreewidth = math_min(400, width - 50) |
| if maxtreewidth > 100 and status.treewidth > maxtreewidth then |
| self:SetTreeWidth(maxtreewidth, status.treesizable) |
| end |
| treeframe:SetMaxResize(maxtreewidth, 1600) |
| end, |
| ["OnHeightSet"] = function(self, height) |
| local content = self.content |
| local contentheight = height - 20 |
| if contentheight < 0 then |
| contentheight = 0 |
| end |
| content:SetHeight(contentheight) |
| content.height = contentheight |
| end, |
| ["SetTreeWidth"] = function(self, treewidth, resizable) |
| if not resizable then |
| if type(treewidth) == 'number' then |
| resizable = false |
| elseif type(treewidth) == 'boolean' then |
| resizable = treewidth |
| treewidth = DEFAULT_TREE_WIDTH |
| else |
| resizable = false |
| treewidth = DEFAULT_TREE_WIDTH |
| end |
| end |
| self.treeframe:SetWidth(treewidth) |
| self.dragger:EnableMouse(resizable) |
| local status = self.status or self.localstatus |
| status.treewidth = treewidth |
| status.treesizable = resizable |
| -- recalculate the content width |
| if status.fullwidth then |
| self:OnWidthSet(status.fullwidth) |
| end |
| end, |
| ["LayoutFinished"] = function(self, width, height) |
| if self.noAutoHeight then return end |
| self:SetHeight((height or 0) + 20) |
| end |
| } |
| --[[----------------------------------------------------------------------------- |
| Constructor |
| -------------------------------------------------------------------------------]] |
| local PaneBackdrop = { |
| bgFile = "Interface\\ChatFrame\\ChatFrameBackground", |
| edgeFile = "Interface\\Tooltips\\UI-Tooltip-Border", |
| tile = true, tileSize = 16, edgeSize = 16, |
| insets = { left = 3, right = 3, top = 5, bottom = 3 } |
| } |
| local DraggerBackdrop = { |
| bgFile = "Interface\\Tooltips\\UI-Tooltip-Background", |
| edgeFile = nil, |
| tile = true, tileSize = 16, edgeSize = 0, |
| insets = { left = 3, right = 3, top = 7, bottom = 7 } |
| } |
| local function Constructor() |
| local num = AceGUI:GetNextWidgetNum(Type) |
| local frame = CreateFrame("Frame", nil, UIParent) |
| local treeframe = CreateFrame("Frame", nil, frame) |
| treeframe:SetPoint("TOPLEFT") |
| treeframe:SetPoint("BOTTOMLEFT") |
| treeframe:SetWidth(DEFAULT_TREE_WIDTH) |
| treeframe:EnableMouseWheel(true) |
| treeframe:SetBackdrop(PaneBackdrop) |
| treeframe:SetBackdropColor(0.1, 0.1, 0.1, 0.5) |
| treeframe:SetBackdropBorderColor(0.4, 0.4, 0.4) |
| treeframe:SetResizable(true) |
| treeframe:SetMinResize(100, 1) |
| treeframe:SetMaxResize(400, 1600) |
| treeframe:SetScript("OnUpdate", FirstFrameUpdate) |
| treeframe:SetScript("OnSizeChanged", Tree_OnSizeChanged) |
| treeframe:SetScript("OnMouseWheel", Tree_OnMouseWheel) |
| local dragger = CreateFrame("Frame", nil, treeframe) |
| dragger:SetWidth(8) |
| dragger:SetPoint("TOP", treeframe, "TOPRIGHT") |
| dragger:SetPoint("BOTTOM", treeframe, "BOTTOMRIGHT") |
| dragger:SetBackdrop(DraggerBackdrop) |
| dragger:SetBackdropColor(1, 1, 1, 0) |
| dragger:SetScript("OnEnter", Dragger_OnEnter) |
| dragger:SetScript("OnLeave", Dragger_OnLeave) |
| dragger:SetScript("OnMouseDown", Dragger_OnMouseDown) |
| dragger:SetScript("OnMouseUp", Dragger_OnMouseUp) |
| local scrollbar = CreateFrame("Slider", ("AceConfigDialogTreeGroup%dScrollBar"):format(num), treeframe, "UIPanelScrollBarTemplate") |
| scrollbar:SetScript("OnValueChanged", nil) |
| scrollbar:SetPoint("TOPRIGHT", -10, -26) |
| scrollbar:SetPoint("BOTTOMRIGHT", -10, 26) |
| scrollbar:SetMinMaxValues(0,0) |
| scrollbar:SetValueStep(1) |
| scrollbar:SetValue(0) |
| scrollbar:SetWidth(16) |
| scrollbar:SetScript("OnValueChanged", OnScrollValueChanged) |
| local scrollbg = scrollbar:CreateTexture(nil, "BACKGROUND") |
| scrollbg:SetAllPoints(scrollbar) |
| scrollbg:SetTexture(0,0,0,0.4) |
| local border = CreateFrame("Frame",nil,frame) |
| border:SetPoint("TOPLEFT", treeframe, "TOPRIGHT") |
| border:SetPoint("BOTTOMRIGHT") |
| border:SetBackdrop(PaneBackdrop) |
| border:SetBackdropColor(0.1, 0.1, 0.1, 0.5) |
| border:SetBackdropBorderColor(0.4, 0.4, 0.4) |
| --Container Support |
| local content = CreateFrame("Frame", nil, border) |
| content:SetPoint("TOPLEFT", 10, -10) |
| content:SetPoint("BOTTOMRIGHT", -10, 10) |
| local widget = { |
| frame = frame, |
| lines = {}, |
| levels = {}, |
| buttons = {}, |
| hasChildren = {}, |
| localstatus = { groups = {}, scrollvalue = 0 }, |
| filter = false, |
| treeframe = treeframe, |
| dragger = dragger, |
| scrollbar = scrollbar, |
| border = border, |
| content = content, |
| type = Type |
| } |
| for method, func in pairs(methods) do |
| widget[method] = func |
| end |
| treeframe.obj, dragger.obj, scrollbar.obj = widget, widget, widget |
| return AceGUI:RegisterAsContainer(widget) |
| end |
| AceGUI:RegisterWidgetType(Type, Constructor, Version) |
mRunes/Libs/AceGUI-3.0/widgets/AceGUIWidget-Button.lua
New file
0,0 → 1,92
| --[[----------------------------------------------------------------------------- |
| Button Widget |
| Graphical Button. |
| -------------------------------------------------------------------------------]] |
| local Type, Version = "Button", 20 |
| local AceGUI = LibStub and LibStub("AceGUI-3.0", true) |
| if not AceGUI or (AceGUI:GetWidgetVersion(Type) or 0) >= Version then return end |
| -- Lua APIs |
| local pairs = pairs |
| -- WoW APIs |
| local _G = _G |
| local PlaySound, CreateFrame, UIParent = PlaySound, CreateFrame, UIParent |
| --[[----------------------------------------------------------------------------- |
| Scripts |
| -------------------------------------------------------------------------------]] |
| local function Button_OnClick(frame, ...) |
| PlaySound("igMainMenuOption") |
| frame.obj:Fire("OnClick", ...) |
| AceGUI:ClearFocus() |
| end |
| local function Control_OnEnter(frame) |
| frame.obj:Fire("OnEnter") |
| end |
| local function Control_OnLeave(frame) |
| frame.obj:Fire("OnLeave") |
| end |
| --[[----------------------------------------------------------------------------- |
| Methods |
| -------------------------------------------------------------------------------]] |
| local methods = { |
| ["OnAcquire"] = function(self) |
| -- restore default values |
| self:SetHeight(24) |
| self:SetWidth(200) |
| self:SetDisabled(false) |
| self:SetText() |
| end, |
| -- ["OnRelease"] = nil, |
| ["SetText"] = function(self, text) |
| self.text:SetText(text) |
| end, |
| ["SetDisabled"] = function(self, disabled) |
| self.disabled = disabled |
| if disabled then |
| self.frame:Disable() |
| else |
| self.frame:Enable() |
| end |
| end |
| } |
| --[[----------------------------------------------------------------------------- |
| Constructor |
| -------------------------------------------------------------------------------]] |
| local function Constructor() |
| local name = "AceGUI30Button" .. AceGUI:GetNextWidgetNum(Type) |
| local frame = CreateFrame("Button", name, UIParent, "UIPanelButtonTemplate2") |
| frame:Hide() |
| frame:EnableMouse(true) |
| frame:SetScript("OnClick", Button_OnClick) |
| frame:SetScript("OnEnter", Control_OnEnter) |
| frame:SetScript("OnLeave", Control_OnLeave) |
| local text = frame:GetFontString() |
| text:ClearAllPoints() |
| text:SetPoint("TOPLEFT", 15, -1) |
| text:SetPoint("BOTTOMRIGHT", -15, 1) |
| text:SetJustifyV("MIDDLE") |
| local widget = { |
| text = text, |
| frame = frame, |
| type = Type |
| } |
| for method, func in pairs(methods) do |
| widget[method] = func |
| end |
| return AceGUI:RegisterAsWidget(widget) |
| end |
| AceGUI:RegisterWidgetType(Type, Constructor, Version) |
mRunes/Libs/AceGUI-3.0/widgets/AceGUIWidget-DropDown-Items.lua
New file
0,0 → 1,465
| --[[ $Id: AceGUIWidget-DropDown-Items.lua 916 2010-03-15 12:24:36Z nevcairiel $ ]]-- |
| local AceGUI = LibStub("AceGUI-3.0") |
| -- Lua APIs |
| local select, assert = select, assert |
| -- WoW APIs |
| local PlaySound = PlaySound |
| local CreateFrame = CreateFrame |
| local function fixlevels(parent,...) |
| local i = 1 |
| local child = select(i, ...) |
| while child do |
| child:SetFrameLevel(parent:GetFrameLevel()+1) |
| fixlevels(child, child:GetChildren()) |
| i = i + 1 |
| child = select(i, ...) |
| end |
| end |
| local function fixstrata(strata, parent, ...) |
| local i = 1 |
| local child = select(i, ...) |
| parent:SetFrameStrata(strata) |
| while child do |
| fixstrata(strata, child, child:GetChildren()) |
| i = i + 1 |
| child = select(i, ...) |
| end |
| end |
| -- ItemBase is the base "class" for all dropdown items. |
| -- Each item has to use ItemBase.Create(widgetType) to |
| -- create an initial 'self' value. |
| -- ItemBase will add common functions and ui event handlers. |
| -- Be sure to keep basic usage when you override functions. |
| local ItemBase = { |
| -- NOTE: The ItemBase version is added to each item's version number |
| -- to ensure proper updates on ItemBase changes. |
| -- Use at least 1000er steps. |
| version = 1000, |
| counter = 0, |
| } |
| function ItemBase.Frame_OnEnter(this) |
| local self = this.obj |
| if self.useHighlight then |
| self.highlight:Show() |
| end |
| self:Fire("OnEnter") |
| if self.specialOnEnter then |
| self.specialOnEnter(self) |
| end |
| end |
| function ItemBase.Frame_OnLeave(this) |
| local self = this.obj |
| self.highlight:Hide() |
| self:Fire("OnLeave") |
| if self.specialOnLeave then |
| self.specialOnLeave(self) |
| end |
| end |
| -- exported, AceGUI callback |
| function ItemBase.OnAcquire(self) |
| self.frame:SetToplevel(true) |
| self.frame:SetFrameStrata("FULLSCREEN_DIALOG") |
| end |
| -- exported, AceGUI callback |
| function ItemBase.OnRelease(self) |
| self:SetDisabled(false) |
| self.pullout = nil |
| self.frame:SetParent(nil) |
| self.frame:ClearAllPoints() |
| self.frame:Hide() |
| end |
| -- exported |
| -- NOTE: this is called by a Dropdown-Pullout. |
| -- Do not call this method directly |
| function ItemBase.SetPullout(self, pullout) |
| self.pullout = pullout |
| self.frame:SetParent(nil) |
| self.frame:SetParent(pullout.itemFrame) |
| self.parent = pullout.itemFrame |
| fixlevels(pullout.itemFrame, pullout.itemFrame:GetChildren()) |
| end |
| -- exported |
| function ItemBase.SetText(self, text) |
| self.text:SetText(text or "") |
| end |
| -- exported |
| function ItemBase.GetText(self) |
| return self.text:GetText() |
| end |
| -- exported |
| function ItemBase.SetPoint(self, ...) |
| self.frame:SetPoint(...) |
| end |
| -- exported |
| function ItemBase.Show(self) |
| self.frame:Show() |
| end |
| -- exported |
| function ItemBase.Hide(self) |
| self.frame:Hide() |
| end |
| -- exported |
| function ItemBase.SetDisabled(self, disabled) |
| self.disabled = disabled |
| if disabled then |
| self.useHighlight = false |
| self.text:SetTextColor(.5, .5, .5) |
| else |
| self.useHighlight = true |
| self.text:SetTextColor(1, 1, 1) |
| end |
| end |
| -- exported |
| -- NOTE: this is called by a Dropdown-Pullout. |
| -- Do not call this method directly |
| function ItemBase.SetOnLeave(self, func) |
| self.specialOnLeave = func |
| end |
| -- exported |
| -- NOTE: this is called by a Dropdown-Pullout. |
| -- Do not call this method directly |
| function ItemBase.SetOnEnter(self, func) |
| self.specialOnEnter = func |
| end |
| function ItemBase.Create(type) |
| -- NOTE: Most of the following code is copied from AceGUI-3.0/Dropdown widget |
| local count = AceGUI:GetNextWidgetNum(type) |
| local frame = CreateFrame("Button", "AceGUI30DropDownItem"..count) |
| local self = {} |
| self.frame = frame |
| frame.obj = self |
| self.type = type |
| self.useHighlight = true |
| frame:SetHeight(17) |
| frame:SetFrameStrata("FULLSCREEN_DIALOG") |
| local text = frame:CreateFontString(nil,"OVERLAY","GameFontNormalSmall") |
| text:SetTextColor(1,1,1) |
| text:SetJustifyH("LEFT") |
| text:SetPoint("TOPLEFT",frame,"TOPLEFT",18,0) |
| text:SetPoint("BOTTOMRIGHT",frame,"BOTTOMRIGHT",-8,0) |
| self.text = text |
| local highlight = frame:CreateTexture(nil, "OVERLAY") |
| highlight:SetTexture("Interface\\QuestFrame\\UI-QuestTitleHighlight") |
| highlight:SetBlendMode("ADD") |
| highlight:SetHeight(14) |
| highlight:ClearAllPoints() |
| highlight:SetPoint("RIGHT",frame,"RIGHT",-3,0) |
| highlight:SetPoint("LEFT",frame,"LEFT",5,0) |
| highlight:Hide() |
| self.highlight = highlight |
| local check = frame:CreateTexture("OVERLAY") |
| check:SetWidth(16) |
| check:SetHeight(16) |
| check:SetPoint("LEFT",frame,"LEFT",3,-1) |
| check:SetTexture("Interface\\Buttons\\UI-CheckBox-Check") |
| check:Hide() |
| self.check = check |
| local sub = frame:CreateTexture("OVERLAY") |
| sub:SetWidth(16) |
| sub:SetHeight(16) |
| sub:SetPoint("RIGHT",frame,"RIGHT",-3,-1) |
| sub:SetTexture("Interface\\ChatFrame\\ChatFrameExpandArrow") |
| sub:Hide() |
| self.sub = sub |
| frame:SetScript("OnEnter", ItemBase.Frame_OnEnter) |
| frame:SetScript("OnLeave", ItemBase.Frame_OnLeave) |
| self.OnAcquire = ItemBase.OnAcquire |
| self.OnRelease = ItemBase.OnRelease |
| self.SetPullout = ItemBase.SetPullout |
| self.GetText = ItemBase.GetText |
| self.SetText = ItemBase.SetText |
| self.SetDisabled = ItemBase.SetDisabled |
| self.SetPoint = ItemBase.SetPoint |
| self.Show = ItemBase.Show |
| self.Hide = ItemBase.Hide |
| self.SetOnLeave = ItemBase.SetOnLeave |
| self.SetOnEnter = ItemBase.SetOnEnter |
| return self |
| end |
| --[[ |
| Template for items: |
| -- Item: |
| -- |
| do |
| local widgetType = "Dropdown-Item-" |
| local widgetVersion = 1 |
| local function Constructor() |
| local self = ItemBase.Create(widgetType) |
| AceGUI:RegisterAsWidget(self) |
| return self |
| end |
| AceGUI:RegisterWidgetType(widgetType, Constructor, widgetVersion + ItemBase.version) |
| end |
| --]] |
| -- Item: Header |
| -- A single text entry. |
| -- Special: Different text color and no highlight |
| do |
| local widgetType = "Dropdown-Item-Header" |
| local widgetVersion = 1 |
| local function OnEnter(this) |
| local self = this.obj |
| self:Fire("OnEnter") |
| if self.specialOnEnter then |
| self.specialOnEnter(self) |
| end |
| end |
| local function OnLeave(this) |
| local self = this.obj |
| self:Fire("OnLeave") |
| if self.specialOnLeave then |
| self.specialOnLeave(self) |
| end |
| end |
| -- exported, override |
| local function SetDisabled(self, disabled) |
| ItemBase.SetDisabled(self, disabled) |
| if not disabled then |
| self.text:SetTextColor(1, 1, 0) |
| end |
| end |
| local function Constructor() |
| local self = ItemBase.Create(widgetType) |
| self.SetDisabled = SetDisabled |
| self.frame:SetScript("OnEnter", OnEnter) |
| self.frame:SetScript("OnLeave", OnLeave) |
| self.text:SetTextColor(1, 1, 0) |
| AceGUI:RegisterAsWidget(self) |
| return self |
| end |
| AceGUI:RegisterWidgetType(widgetType, Constructor, widgetVersion + ItemBase.version) |
| end |
| -- Item: Execute |
| -- A simple button |
| do |
| local widgetType = "Dropdown-Item-Execute" |
| local widgetVersion = 1 |
| local function Frame_OnClick(this, button) |
| local self = this.obj |
| if self.disabled then return end |
| self:Fire("OnClick") |
| if self.pullout then |
| self.pullout:Close() |
| end |
| end |
| local function Constructor() |
| local self = ItemBase.Create(widgetType) |
| self.frame:SetScript("OnClick", Frame_OnClick) |
| AceGUI:RegisterAsWidget(self) |
| return self |
| end |
| AceGUI:RegisterWidgetType(widgetType, Constructor, widgetVersion + ItemBase.version) |
| end |
| -- Item: Toggle |
| -- Some sort of checkbox for dropdown menus. |
| -- Does not close the pullout on click. |
| do |
| local widgetType = "Dropdown-Item-Toggle" |
| local widgetVersion = 3 |
| local function UpdateToggle(self) |
| if self.value then |
| self.check:Show() |
| else |
| self.check:Hide() |
| end |
| end |
| local function OnRelease(self) |
| ItemBase.OnRelease(self) |
| self:SetValue(nil) |
| end |
| local function Frame_OnClick(this, button) |
| local self = this.obj |
| if self.disabled then return end |
| self.value = not self.value |
| if self.value then |
| PlaySound("igMainMenuOptionCheckBoxOn") |
| else |
| PlaySound("igMainMenuOptionCheckBoxOff") |
| end |
| UpdateToggle(self) |
| self:Fire("OnValueChanged", self.value) |
| end |
| -- exported |
| local function SetValue(self, value) |
| self.value = value |
| UpdateToggle(self) |
| end |
| -- exported |
| local function GetValue(self) |
| return self.value |
| end |
| local function Constructor() |
| local self = ItemBase.Create(widgetType) |
| self.frame:SetScript("OnClick", Frame_OnClick) |
| self.SetValue = SetValue |
| self.GetValue = GetValue |
| self.OnRelease = OnRelease |
| AceGUI:RegisterAsWidget(self) |
| return self |
| end |
| AceGUI:RegisterWidgetType(widgetType, Constructor, widgetVersion + ItemBase.version) |
| end |
| -- Item: Menu |
| -- Shows a submenu on mouse over |
| -- Does not close the pullout on click |
| do |
| local widgetType = "Dropdown-Item-Menu" |
| local widgetVersion = 2 |
| local function OnEnter(this) |
| local self = this.obj |
| self:Fire("OnEnter") |
| if self.specialOnEnter then |
| self.specialOnEnter(self) |
| end |
| self.highlight:Show() |
| if not self.disabled and self.submenu then |
| self.submenu:Open("TOPLEFT", self.frame, "TOPRIGHT", self.pullout:GetRightBorderWidth(), 0, self.frame:GetFrameLevel() + 100) |
| end |
| end |
| local function OnHide(this) |
| local self = this.obj |
| if self.submenu then |
| self.submenu:Close() |
| end |
| end |
| -- exported |
| local function SetMenu(self, menu) |
| assert(menu.type == "Dropdown-Pullout") |
| self.submenu = menu |
| end |
| -- exported |
| local function CloseMenu(self) |
| self.submenu:Close() |
| end |
| local function Constructor() |
| local self = ItemBase.Create(widgetType) |
| self.sub:Show() |
| self.frame:SetScript("OnEnter", OnEnter) |
| self.frame:SetScript("OnHide", OnHide) |
| self.SetMenu = SetMenu |
| self.CloseMenu = CloseMenu |
| AceGUI:RegisterAsWidget(self) |
| return self |
| end |
| AceGUI:RegisterWidgetType(widgetType, Constructor, widgetVersion + ItemBase.version) |
| end |
| -- Item: Separator |
| -- A single line to separate items |
| do |
| local widgetType = "Dropdown-Item-Separator" |
| local widgetVersion = 1 |
| -- exported, override |
| local function SetDisabled(self, disabled) |
| ItemBase.SetDisabled(self, disabled) |
| self.useHighlight = false |
| end |
| local function Constructor() |
| local self = ItemBase.Create(widgetType) |
| self.SetDisabled = SetDisabled |
| local line = self.frame:CreateTexture(nil, "OVERLAY") |
| line:SetHeight(1) |
| line:SetTexture(.5, .5, .5) |
| line:SetPoint("LEFT", self.frame, "LEFT", 10, 0) |
| line:SetPoint("RIGHT", self.frame, "RIGHT", -10, 0) |
| self.text:Hide() |
| self.useHighlight = false |
| AceGUI:RegisterAsWidget(self) |
| return self |
| end |
| AceGUI:RegisterWidgetType(widgetType, Constructor, widgetVersion + ItemBase.version) |
| end |
mRunes/Libs/AceGUI-3.0/widgets/AceGUIWidget-ColorPicker.lua
New file
0,0 → 1,186
| --[[----------------------------------------------------------------------------- |
| ColorPicker Widget |
| -------------------------------------------------------------------------------]] |
| local Type, Version = "ColorPicker", 20 |
| local AceGUI = LibStub and LibStub("AceGUI-3.0", true) |
| if not AceGUI or (AceGUI:GetWidgetVersion(Type) or 0) >= Version then return end |
| -- Lua APIs |
| local pairs = pairs |
| -- WoW APIs |
| local CreateFrame, UIParent = CreateFrame, UIParent |
| -- Global vars/functions that we don't upvalue since they might get hooked, or upgraded |
| -- List them here for Mikk's FindGlobals script |
| -- GLOBALS: ShowUIPanel, HideUIPanel, ColorPickerFrame, OpacitySliderFrame |
| --[[----------------------------------------------------------------------------- |
| Support functions |
| -------------------------------------------------------------------------------]] |
| local function ColorCallback(self, r, g, b, a, isAlpha) |
| if not self.HasAlpha then |
| a = 1 |
| end |
| self:SetColor(r, g, b, a) |
| if ColorPickerFrame:IsVisible() then |
| --colorpicker is still open |
| self:Fire("OnValueChanged", r, g, b, a) |
| else |
| --colorpicker is closed, color callback is first, ignore it, |
| --alpha callback is the final call after it closes so confirm now |
| if isAlpha then |
| self:Fire("OnValueConfirmed", r, g, b, a) |
| end |
| end |
| end |
| --[[----------------------------------------------------------------------------- |
| Scripts |
| -------------------------------------------------------------------------------]] |
| local function Control_OnEnter(frame) |
| frame.obj:Fire("OnEnter") |
| end |
| local function Control_OnLeave(frame) |
| frame.obj:Fire("OnLeave") |
| end |
| local function ColorSwatch_OnClick(frame) |
| HideUIPanel(ColorPickerFrame) |
| local self = frame.obj |
| if not self.disabled then |
| ColorPickerFrame:SetFrameStrata("FULLSCREEN_DIALOG") |
| ColorPickerFrame.func = function() |
| local r, g, b = ColorPickerFrame:GetColorRGB() |
| local a = 1 - OpacitySliderFrame:GetValue() |
| ColorCallback(self, r, g, b, a) |
| end |
| ColorPickerFrame.hasOpacity = self.HasAlpha |
| ColorPickerFrame.opacityFunc = function() |
| local r, g, b = ColorPickerFrame:GetColorRGB() |
| local a = 1 - OpacitySliderFrame:GetValue() |
| ColorCallback(self, r, g, b, a, true) |
| end |
| local r, g, b, a = self.r, self.g, self.b, self.a |
| if self.HasAlpha then |
| ColorPickerFrame.opacity = 1 - (a or 0) |
| end |
| ColorPickerFrame:SetColorRGB(r, g, b) |
| ColorPickerFrame.cancelFunc = function() |
| ColorCallback(self, r, g, b, a, true) |
| end |
| ShowUIPanel(ColorPickerFrame) |
| end |
| AceGUI:ClearFocus() |
| end |
| --[[----------------------------------------------------------------------------- |
| Methods |
| -------------------------------------------------------------------------------]] |
| local methods = { |
| ["OnAcquire"] = function(self) |
| self:SetHeight(24) |
| self:SetWidth(200) |
| self:SetHasAlpha(false) |
| self:SetColor(0, 0, 0, 1) |
| self:SetDisabled(nil) |
| self:SetLabel(nil) |
| end, |
| -- ["OnRelease"] = nil, |
| ["SetLabel"] = function(self, text) |
| self.text:SetText(text) |
| end, |
| ["SetColor"] = function(self, r, g, b, a) |
| self.r = r |
| self.g = g |
| self.b = b |
| self.a = a or 1 |
| self.colorSwatch:SetVertexColor(r, g, b, a) |
| end, |
| ["SetHasAlpha"] = function(self, HasAlpha) |
| self.HasAlpha = HasAlpha |
| end, |
| ["SetDisabled"] = function(self, disabled) |
| self.disabled = disabled |
| if self.disabled then |
| self.frame:Disable() |
| self.text:SetTextColor(0.5, 0.5, 0.5) |
| else |
| self.frame:Enable() |
| self.text:SetTextColor(1, 1, 1) |
| end |
| end |
| } |
| --[[----------------------------------------------------------------------------- |
| Constructor |
| -------------------------------------------------------------------------------]] |
| local function Constructor() |
| local frame = CreateFrame("Button", nil, UIParent) |
| frame:Hide() |
| frame:EnableMouse(true) |
| frame:SetScript("OnEnter", Control_OnEnter) |
| frame:SetScript("OnLeave", Control_OnLeave) |
| frame:SetScript("OnClick", ColorSwatch_OnClick) |
| local colorSwatch = frame:CreateTexture(nil, "OVERLAY") |
| colorSwatch:SetWidth(19) |
| colorSwatch:SetHeight(19) |
| colorSwatch:SetTexture("Interface\\ChatFrame\\ChatFrameColorSwatch") |
| colorSwatch:SetPoint("LEFT") |
| local texture = frame:CreateTexture(nil, "BACKGROUND") |
| texture:SetWidth(16) |
| texture:SetHeight(16) |
| texture:SetTexture(1, 1, 1) |
| texture:SetPoint("CENTER", colorSwatch) |
| texture:Show() |
| local checkers = frame:CreateTexture(nil, "BACKGROUND") |
| checkers:SetWidth(14) |
| checkers:SetHeight(14) |
| checkers:SetTexture("Tileset\\Generic\\Checkers") |
| checkers:SetTexCoord(.25, 0, 0.5, .25) |
| checkers:SetDesaturated(true) |
| checkers:SetVertexColor(1, 1, 1, 0.75) |
| checkers:SetPoint("CENTER", colorSwatch) |
| checkers:Show() |
| local text = frame:CreateFontString(nil,"OVERLAY","GameFontHighlight") |
| text:SetHeight(24) |
| text:SetJustifyH("LEFT") |
| text:SetTextColor(1, 1, 1) |
| text:SetPoint("LEFT", colorSwatch, "RIGHT", 2, 0) |
| text:SetPoint("RIGHT") |
| --local highlight = frame:CreateTexture(nil, "HIGHLIGHT") |
| --highlight:SetTexture("Interface\\QuestFrame\\UI-QuestTitleHighlight") |
| --highlight:SetBlendMode("ADD") |
| --highlight:SetAllPoints(frame) |
| local widget = { |
| colorSwatch = colorSwatch, |
| text = text, |
| frame = frame, |
| type = Type |
| } |
| for method, func in pairs(methods) do |
| widget[method] = func |
| end |
| return AceGUI:RegisterAsWidget(widget) |
| end |
| AceGUI:RegisterWidgetType(Type, Constructor, Version) |
mRunes/Libs/AceGUI-3.0/widgets/AceGUIWidget-InteractiveLabel.lua
New file
0,0 → 1,101
| --[[----------------------------------------------------------------------------- |
| InteractiveLabel Widget |
| -------------------------------------------------------------------------------]] |
| local Type, Version = "InteractiveLabel", 20 |
| local AceGUI = LibStub and LibStub("AceGUI-3.0", true) |
| if not AceGUI or (AceGUI:GetWidgetVersion(Type) or 0) >= Version then return end |
| -- Lua APIs |
| local select, pairs = select, pairs |
| -- WoW APIs |
| local CreateFrame, UIParent = CreateFrame, UIParent |
| -- Global vars/functions that we don't upvalue since they might get hooked, or upgraded |
| -- List them here for Mikk's FindGlobals script |
| -- GLOBALS: GameFontHighlightSmall |
| --[[----------------------------------------------------------------------------- |
| Scripts |
| -------------------------------------------------------------------------------]] |
| local function Control_OnEnter(frame) |
| frame.obj:Fire("OnEnter") |
| end |
| local function Control_OnLeave(frame) |
| frame.obj:Fire("OnLeave") |
| end |
| local function Label_OnClick(frame, button) |
| frame.obj:Fire("OnClick", button) |
| AceGUI:ClearFocus() |
| end |
| --[[----------------------------------------------------------------------------- |
| Methods |
| -------------------------------------------------------------------------------]] |
| local methods = { |
| ["OnAcquire"] = function(self) |
| self:LabelOnAcquire() |
| self:SetHighlight() |
| self:SetHighlightTexCoord() |
| self:SetDisabled(false) |
| end, |
| -- ["OnRelease"] = nil, |
| ["SetHighlight"] = function(self, ...) |
| self.highlight:SetTexture(...) |
| end, |
| ["SetHighlightTexCoord"] = function(self, ...) |
| local c = select("#", ...) |
| if c == 4 or c == 8 then |
| self.highlight:SetTexCoord(...) |
| else |
| self.highlight:SetTexCoord(0, 1, 0, 1) |
| end |
| end, |
| ["SetDisabled"] = function(self,disabled) |
| self.disabled = disabled |
| if disabled then |
| self.frame:EnableMouse(false) |
| self.label:SetTextColor(0.5, 0.5, 0.5) |
| else |
| self.frame:EnableMouse(true) |
| self.label:SetTextColor(1, 1, 1) |
| end |
| end |
| } |
| --[[----------------------------------------------------------------------------- |
| Constructor |
| -------------------------------------------------------------------------------]] |
| local function Constructor() |
| -- create a Label type that we will hijack |
| local label = AceGUI:Create("Label") |
| local frame = label.frame |
| frame:EnableMouse(true) |
| frame:SetScript("OnEnter", Control_OnEnter) |
| frame:SetScript("OnLeave", Control_OnLeave) |
| frame:SetScript("OnMouseDown", Label_OnClick) |
| local highlight = frame:CreateTexture(nil, "HIGHLIGHT") |
| highlight:SetTexture(nil) |
| highlight:SetAllPoints() |
| highlight:SetBlendMode("ADD") |
| label.highlight = highlight |
| label.type = Type |
| label.LabelOnAcquire = label.OnAcquire |
| for method, func in pairs(methods) do |
| label[method] = func |
| end |
| return label |
| end |
| AceGUI:RegisterWidgetType(Type, Constructor, Version) |
mRunes/Libs/AceGUI-3.0/widgets/AceGUIWidget-Label.lua
New file
0,0 → 1,162
| --[[----------------------------------------------------------------------------- |
| Label Widget |
| Displays text and optionally an icon. |
| -------------------------------------------------------------------------------]] |
| local Type, Version = "Label", 21 |
| local AceGUI = LibStub and LibStub("AceGUI-3.0", true) |
| if not AceGUI or (AceGUI:GetWidgetVersion(Type) or 0) >= Version then return end |
| -- Lua APIs |
| local max, select, pairs = math.max, select, pairs |
| -- WoW APIs |
| local CreateFrame, UIParent = CreateFrame, UIParent |
| -- Global vars/functions that we don't upvalue since they might get hooked, or upgraded |
| -- List them here for Mikk's FindGlobals script |
| -- GLOBALS: GameFontHighlightSmall |
| --[[----------------------------------------------------------------------------- |
| Support functions |
| -------------------------------------------------------------------------------]] |
| local function UpdateImageAnchor(self) |
| if self.resizing then return end |
| local frame = self.frame |
| local width = frame.width or frame:GetWidth() or 0 |
| local image = self.image |
| local label = self.label |
| local height |
| label:ClearAllPoints() |
| image:ClearAllPoints() |
| if self.imageshown then |
| local imagewidth = image:GetWidth() |
| if (width - imagewidth) < 200 or (label:GetText() or "") == "" then |
| -- image goes on top centered when less than 200 width for the text, or if there is no text |
| image:SetPoint("TOP") |
| label:SetPoint("TOP", image, "BOTTOM") |
| label:SetPoint("LEFT") |
| label:SetWidth(width) |
| height = image:GetHeight() + label:GetHeight() |
| else |
| -- image on the left |
| image:SetPoint("TOPLEFT") |
| label:SetPoint("TOPLEFT", image, "TOPRIGHT", 4, 0) |
| label:SetWidth(width - imagewidth - 4) |
| height = max(image:GetHeight(), label:GetHeight()) |
| end |
| else |
| -- no image shown |
| label:SetPoint("TOPLEFT") |
| label:SetWidth(width) |
| height = label:GetHeight() |
| end |
| self.resizing = true |
| frame:SetHeight(height) |
| frame.height = height |
| self.resizing = nil |
| end |
| --[[----------------------------------------------------------------------------- |
| Methods |
| -------------------------------------------------------------------------------]] |
| local methods = { |
| ["OnAcquire"] = function(self) |
| -- set the flag to stop constant size updates |
| self.resizing = true |
| -- height is set dynamically by the text and image size |
| self:SetWidth(200) |
| self:SetText() |
| self:SetImage(nil) |
| self:SetImageSize(16, 16) |
| self:SetColor() |
| self:SetFontObject() |
| -- reset the flag |
| self.resizing = nil |
| -- run the update explicitly |
| UpdateImageAnchor(self) |
| end, |
| -- ["OnRelease"] = nil, |
| ["OnWidthSet"] = function(self, width) |
| UpdateImageAnchor(self) |
| end, |
| ["SetText"] = function(self, text) |
| self.label:SetText(text) |
| UpdateImageAnchor(self) |
| end, |
| ["SetColor"] = function(self, r, g, b) |
| if not (r and g and b) then |
| r, g, b = 1, 1, 1 |
| end |
| self.label:SetVertexColor(r, g, b) |
| end, |
| ["SetImage"] = function(self, path, ...) |
| local image = self.image |
| image:SetTexture(path) |
| if image:GetTexture() then |
| self.imageshown = true |
| local n = select("#", ...) |
| if n == 4 or n == 8 then |
| image:SetTexCoord(...) |
| else |
| image:SetTexCoord(0, 1, 0, 1) |
| end |
| else |
| self.imageshown = nil |
| end |
| UpdateImageAnchor(self) |
| end, |
| ["SetFont"] = function(self, font, height, flags) |
| self.label:SetFont(font, height, flags) |
| end, |
| ["SetFontObject"] = function(self, font) |
| self:SetFont((font or GameFontHighlightSmall):GetFont()) |
| end, |
| ["SetImageSize"] = function(self, width, height) |
| self.image:SetWidth(width) |
| self.image:SetHeight(height) |
| UpdateImageAnchor(self) |
| end, |
| } |
| --[[----------------------------------------------------------------------------- |
| Constructor |
| -------------------------------------------------------------------------------]] |
| local function Constructor() |
| local frame = CreateFrame("Frame", nil, UIParent) |
| frame:Hide() |
| local label = frame:CreateFontString(nil, "BACKGROUND", "GameFontHighlightSmall") |
| label:SetJustifyH("LEFT") |
| label:SetJustifyV("TOP") |
| local image = frame:CreateTexture(nil, "BACKGROUND") |
| -- create widget |
| local widget = { |
| label = label, |
| image = image, |
| frame = frame, |
| type = Type |
| } |
| for method, func in pairs(methods) do |
| widget[method] = func |
| end |
| return AceGUI:RegisterAsWidget(widget) |
| end |
| AceGUI:RegisterWidgetType(Type, Constructor, Version) |
mRunes/Libs/AceGUI-3.0/widgets/AceGUIWidget-MultiLineEditBox.lua
New file
0,0 → 1,308
| local Type, Version = "MultiLineEditBox", 24 |
| local AceGUI = LibStub and LibStub("AceGUI-3.0", true) |
| if not AceGUI or (AceGUI:GetWidgetVersion(Type) or 0) >= Version then return end |
| -- Lua APIs |
| local pairs = pairs |
| -- WoW APIs |
| local GetCursorInfo, GetSpellInfo, ClearCursor = GetCursorInfo, GetSpellInfo, ClearCursor |
| local CreateFrame, UIParent = CreateFrame, UIParent |
| local _G = _G |
| -- Global vars/functions that we don't upvalue since they might get hooked, or upgraded |
| -- List them here for Mikk's FindGlobals script |
| -- GLOBALS: ACCEPT, ChatFontNormal |
| --[[----------------------------------------------------------------------------- |
| Support functions |
| -------------------------------------------------------------------------------]] |
| local function Layout(self) |
| self:SetHeight(self.numlines * 14 + (self.disablebutton and 19 or 41) + self.labelHeight) |
| if self.labelHeight == 0 then |
| self.scrollBar:SetPoint("TOP", self.frame, "TOP", 0, -23) |
| else |
| self.scrollBar:SetPoint("TOP", self.label, "BOTTOM", 0, -19) |
| end |
| if self.disablebutton then |
| self.scrollBar:SetPoint("BOTTOM", self.frame, "BOTTOM", 0, 21) |
| self.scrollBG:SetPoint("BOTTOMLEFT", 0, 4) |
| else |
| self.scrollBar:SetPoint("BOTTOM", self.button, "TOP", 0, 18) |
| self.scrollBG:SetPoint("BOTTOMLEFT", self.button, "TOPLEFT") |
| end |
| end |
| --[[----------------------------------------------------------------------------- |
| Scripts |
| -------------------------------------------------------------------------------]] |
| local function OnClick(self) -- Button |
| self = self.obj |
| self.editBox:ClearFocus() |
| if not self:Fire("OnEnterPressed", self.editBox:GetText()) then |
| self.button:Disable() |
| end |
| end |
| local function OnCursorChanged(self, _, y, _, cursorHeight) -- EditBox |
| self, y = self.obj.scrollFrame, -y |
| local offset = self:GetVerticalScroll() |
| if y < offset then |
| self:SetVerticalScroll(y) |
| else |
| y = y + cursorHeight - self:GetHeight() |
| if y > offset then |
| self:SetVerticalScroll(y) |
| end |
| end |
| end |
| local function OnEditFocusLost(self) -- EditBox |
| self:HighlightText(0, 0) |
| end |
| local function OnEnter(self) -- EditBox / ScrollFrame |
| self = self.obj |
| if not self.entered then |
| self.entered = true |
| self:Fire("OnEnter") |
| end |
| end |
| local function OnLeave(self) -- EditBox / ScrollFrame |
| self = self.obj |
| if self.entered then |
| self.entered = nil |
| self:Fire("OnLeave") |
| end |
| end |
| local function OnMouseUp(self) -- ScrollFrame |
| self = self.obj.editBox |
| self:SetFocus() |
| self:SetCursorPosition(self:GetNumLetters()) |
| end |
| local function OnReceiveDrag(self) -- EditBox / ScrollFrame |
| local type, id, info = GetCursorInfo() |
| if type == "spell" then |
| info = GetSpellInfo(id, info) |
| elseif type ~= "item" then |
| return |
| end |
| ClearCursor() |
| self = self.obj |
| local editBox = self.editBox |
| if not editBox:HasFocus() then |
| editBox:SetFocus() |
| editBox:SetCursorPosition(editBox:GetNumLetters()) |
| end |
| editBox:Insert(info) |
| self.button:Enable() |
| end |
| local function OnSizeChanged(self, width, height) -- ScrollFrame |
| self.obj.editBox:SetWidth(width) |
| end |
| local function OnTextChanged(self, userInput) -- EditBox |
| if userInput then |
| self = self.obj |
| self:Fire("OnTextChanged", self.editBox:GetText()) |
| self.button:Enable() |
| end |
| end |
| local function OnTextSet(self) -- EditBox |
| self:HighlightText(0, 0) |
| self:SetCursorPosition(self:GetNumLetters()) |
| self:SetCursorPosition(0) |
| self.obj.button:Disable() |
| end |
| local function OnVerticalScroll(self, offset) -- ScrollFrame |
| local editBox = self.obj.editBox |
| editBox:SetHitRectInsets(0, 0, offset, editBox:GetHeight() - offset - self:GetHeight()) |
| end |
| --[[----------------------------------------------------------------------------- |
| Methods |
| -------------------------------------------------------------------------------]] |
| local methods = { |
| ["OnAcquire"] = function(self) |
| self.editBox:SetText("") |
| self:SetDisabled(false) |
| self:SetWidth(200) |
| self:DisableButton(false) |
| self:SetNumLines() |
| self.entered = nil |
| self:SetMaxLetters(0) |
| end, |
| -- ["OnRelease"] = nil, |
| ["SetDisabled"] = function(self, disabled) |
| local editBox = self.editBox |
| if disabled then |
| editBox:ClearFocus() |
| editBox:EnableMouse(false) |
| editBox:SetTextColor(0.5, 0.5, 0.5) |
| self.label:SetTextColor(0.5, 0.5, 0.5) |
| self.scrollFrame:EnableMouse(false) |
| self.button:Disable() |
| else |
| editBox:EnableMouse(true) |
| editBox:SetTextColor(1, 1, 1) |
| self.label:SetTextColor(1, 0.82, 0) |
| self.scrollFrame:EnableMouse(true) |
| end |
| end, |
| ["SetLabel"] = function(self, text) |
| if text and text ~= "" then |
| self.label:SetText(text) |
| if self.labelHeight ~= 10 then |
| self.labelHeight = 10 |
| self.label:Show() |
| end |
| elseif self.labelHeight ~= 0 then |
| self.labelHeight = 0 |
| self.label:Hide() |
| end |
| Layout(self) |
| end, |
| ["SetNumLines"] = function(self, value) |
| if not value or value < 4 then |
| value = 4 |
| end |
| self.numlines = value |
| Layout(self) |
| end, |
| ["SetText"] = function(self, text) |
| self.editBox:SetText(text) |
| end, |
| ["GetText"] = function(self) |
| return self.editBox:GetText() |
| end, |
| ["SetMaxLetters"] = function (self, num) |
| self.editBox:SetMaxLetters(num or 0) |
| end, |
| ["DisableButton"] = function(self, disabled) |
| self.disablebutton = disabled |
| if disabled then |
| self.button:Hide() |
| else |
| self.button:Show() |
| end |
| Layout(self) |
| end |
| } |
| --[[----------------------------------------------------------------------------- |
| Constructor |
| -------------------------------------------------------------------------------]] |
| local backdrop = { |
| bgFile = [[Interface\Tooltips\UI-Tooltip-Background]], |
| edgeFile = [[Interface\Tooltips\UI-Tooltip-Border]], edgeSize = 16, |
| insets = { left = 4, right = 3, top = 4, bottom = 3 } |
| } |
| local function Constructor() |
| local frame = CreateFrame("Frame", nil, UIParent) |
| frame:Hide() |
| local widgetNum = AceGUI:GetNextWidgetNum(Type) |
| local label = frame:CreateFontString(nil, "OVERLAY", "GameFontNormalSmall") |
| label:SetPoint("TOPLEFT", frame, "TOPLEFT", 0, -4) |
| label:SetPoint("TOPRIGHT", frame, "TOPRIGHT", 0, -4) |
| label:SetJustifyH("LEFT") |
| label:SetText(ACCEPT) |
| label:SetHeight(10) |
| local button = CreateFrame("Button", ("%s%dButton"):format(Type, widgetNum), frame, "UIPanelButtonTemplate2") |
| button:SetPoint("BOTTOMLEFT", 0, 4) |
| button:SetHeight(22) |
| button:SetWidth(label:GetStringWidth() + 24) |
| button:SetText(ACCEPT) |
| button:SetScript("OnClick", OnClick) |
| button:Disable() |
| local text = button:GetFontString() |
| text:ClearAllPoints() |
| text:SetPoint("TOPLEFT", button, "TOPLEFT", 5, -5) |
| text:SetPoint("BOTTOMRIGHT", button, "BOTTOMRIGHT", -5, 1) |
| text:SetJustifyV("MIDDLE") |
| local scrollBG = CreateFrame("Frame", nil, frame) |
| scrollBG:SetBackdrop(backdrop) |
| scrollBG:SetBackdropColor(0, 0, 0) |
| scrollBG:SetBackdropBorderColor(0.4, 0.4, 0.4) |
| local scrollFrame = CreateFrame("ScrollFrame", ("%s%dScrollFrame"):format(Type, widgetNum), frame, "UIPanelScrollFrameTemplate") |
| local scrollBar = _G[scrollFrame:GetName() .. "ScrollBar"] |
| scrollBar:ClearAllPoints() |
| scrollBar:SetPoint("TOP", label, "BOTTOM", 0, -19) |
| scrollBar:SetPoint("BOTTOM", button, "TOP", 0, 18) |
| scrollBar:SetPoint("RIGHT", frame, "RIGHT") |
| scrollBG:SetPoint("TOPRIGHT", scrollBar, "TOPLEFT", 0, 19) |
| scrollBG:SetPoint("BOTTOMLEFT", button, "TOPLEFT") |
| scrollFrame:SetPoint("TOPLEFT", scrollBG, "TOPLEFT", 5, -6) |
| scrollFrame:SetPoint("BOTTOMRIGHT", scrollBG, "BOTTOMRIGHT", -4, 4) |
| scrollFrame:SetScript("OnEnter", OnEnter) |
| scrollFrame:SetScript("OnLeave", OnLeave) |
| scrollFrame:SetScript("OnMouseUp", OnMouseUp) |
| scrollFrame:SetScript("OnReceiveDrag", OnReceiveDrag) |
| scrollFrame:SetScript("OnSizeChanged", OnSizeChanged) |
| scrollFrame:HookScript("OnVerticalScroll", OnVerticalScroll) |
| local editBox = CreateFrame("EditBox", nil, scrollFrame) |
| editBox:SetAllPoints() |
| editBox:SetFontObject(ChatFontNormal) |
| editBox:SetMultiLine(true) |
| editBox:EnableMouse(true) |
| editBox:SetAutoFocus(false) |
| editBox:SetCountInvisibleLetters(false) |
| editBox:SetScript("OnCursorChanged", OnCursorChanged) |
| editBox:SetScript("OnEditFocusLost", OnEditFocusLost) |
| editBox:SetScript("OnEnter", OnEnter) |
| editBox:SetScript("OnEscapePressed", editBox.ClearFocus) |
| editBox:SetScript("OnLeave", OnLeave) |
| editBox:SetScript("OnMouseDown", OnReceiveDrag) |
| editBox:SetScript("OnReceiveDrag", OnReceiveDrag) |
| editBox:SetScript("OnTextChanged", OnTextChanged) |
| editBox:SetScript("OnTextSet", OnTextSet) |
| scrollFrame:SetScrollChild(editBox) |
| local widget = { |
| button = button, |
| editBox = editBox, |
| frame = frame, |
| label = label, |
| labelHeight = 10, |
| numlines = 4, |
| scrollBar = scrollBar, |
| scrollBG = scrollBG, |
| scrollFrame = scrollFrame, |
| type = Type |
| } |
| for method, func in pairs(methods) do |
| widget[method] = func |
| end |
| button.obj, editBox.obj, scrollFrame.obj = widget, widget, widget |
| return AceGUI:RegisterAsWidget(widget) |
| end |
| AceGUI:RegisterWidgetType(Type, Constructor, Version) |
mRunes/Libs/AceGUI-3.0/widgets/AceGUIWidget-Slider.lua
New file
0,0 → 1,281
| --[[----------------------------------------------------------------------------- |
| Slider Widget |
| Graphical Slider, like, for Range values. |
| -------------------------------------------------------------------------------]] |
| local Type, Version = "Slider", 20 |
| local AceGUI = LibStub and LibStub("AceGUI-3.0", true) |
| if not AceGUI or (AceGUI:GetWidgetVersion(Type) or 0) >= Version then return end |
| -- Lua APIs |
| local min, max, floor = math.min, math.max, math.floor |
| local tonumber, pairs = tonumber, pairs |
| -- WoW APIs |
| local PlaySound = PlaySound |
| local CreateFrame, UIParent = CreateFrame, UIParent |
| -- Global vars/functions that we don't upvalue since they might get hooked, or upgraded |
| -- List them here for Mikk's FindGlobals script |
| -- GLOBALS: GameFontHighlightSmall |
| --[[----------------------------------------------------------------------------- |
| Support functions |
| -------------------------------------------------------------------------------]] |
| local function UpdateText(self) |
| local value = self.value or 0 |
| if self.ispercent then |
| self.editbox:SetText(("%s%%"):format(floor(value * 1000 + 0.5) / 10)) |
| else |
| self.editbox:SetText(floor(value * 100 + 0.5) / 100) |
| end |
| end |
| local function UpdateLabels(self) |
| local min, max = (self.min or 0), (self.max or 100) |
| if self.ispercent then |
| self.lowtext:SetFormattedText("%s%%", (min * 100)) |
| self.hightext:SetFormattedText("%s%%", (max * 100)) |
| else |
| self.lowtext:SetText(min) |
| self.hightext:SetText(max) |
| end |
| end |
| --[[----------------------------------------------------------------------------- |
| Scripts |
| -------------------------------------------------------------------------------]] |
| local function Control_OnEnter(frame) |
| frame.obj:Fire("OnEnter") |
| end |
| local function Control_OnLeave(frame) |
| frame.obj:Fire("OnLeave") |
| end |
| local function Frame_OnMouseDown(frame) |
| frame.obj.slider:EnableMouseWheel(true) |
| AceGUI:ClearFocus() |
| end |
| local function Slider_OnValueChanged(frame) |
| local self = frame.obj |
| if not frame.setup then |
| local newvalue = frame:GetValue() |
| if newvalue ~= self.value and not self.disabled then |
| self.value = newvalue |
| self:Fire("OnValueChanged", newvalue) |
| end |
| if self.value then |
| UpdateText(self) |
| end |
| end |
| end |
| local function Slider_OnMouseUp(frame) |
| local self = frame.obj |
| self:Fire("OnMouseUp", self.value) |
| end |
| local function Slider_OnMouseWheel(frame, v) |
| local self = frame.obj |
| if not self.disabled then |
| local value = self.value |
| if v > 0 then |
| value = min(value + (self.step or 1), self.max) |
| else |
| value = max(value - (self.step or 1), self.min) |
| end |
| self.slider:SetValue(value) |
| end |
| end |
| local function EditBox_OnEscapePressed(frame) |
| frame:ClearFocus() |
| end |
| local function EditBox_OnEnterPressed(frame) |
| local self = frame.obj |
| local value = frame:GetText() |
| if self.ispercent then |
| value = value:gsub('%%', '') |
| value = tonumber(value) / 100 |
| else |
| value = tonumber(value) |
| end |
| if value then |
| PlaySound("igMainMenuOptionCheckBoxOn") |
| self.slider:SetValue(value) |
| self:Fire("OnMouseUp", value) |
| end |
| end |
| local function EditBox_OnEnter(frame) |
| frame:SetBackdropBorderColor(0.5, 0.5, 0.5, 1) |
| end |
| local function EditBox_OnLeave(frame) |
| frame:SetBackdropBorderColor(0.3, 0.3, 0.3, 0.8) |
| end |
| --[[----------------------------------------------------------------------------- |
| Methods |
| -------------------------------------------------------------------------------]] |
| local methods = { |
| ["OnAcquire"] = function(self) |
| self:SetWidth(200) |
| self:SetHeight(44) |
| self:SetDisabled(false) |
| self:SetIsPercent(nil) |
| self:SetSliderValues(0,100,1) |
| self:SetValue(0) |
| self.slider:EnableMouseWheel(false) |
| end, |
| -- ["OnRelease"] = nil, |
| ["SetDisabled"] = function(self, disabled) |
| self.disabled = disabled |
| if disabled then |
| self.slider:EnableMouse(false) |
| self.label:SetTextColor(.5, .5, .5) |
| self.hightext:SetTextColor(.5, .5, .5) |
| self.lowtext:SetTextColor(.5, .5, .5) |
| --self.valuetext:SetTextColor(.5, .5, .5) |
| self.editbox:SetTextColor(.5, .5, .5) |
| self.editbox:EnableMouse(false) |
| self.editbox:ClearFocus() |
| else |
| self.slider:EnableMouse(true) |
| self.label:SetTextColor(1, .82, 0) |
| self.hightext:SetTextColor(1, 1, 1) |
| self.lowtext:SetTextColor(1, 1, 1) |
| --self.valuetext:SetTextColor(1, 1, 1) |
| self.editbox:SetTextColor(1, 1, 1) |
| self.editbox:EnableMouse(true) |
| end |
| end, |
| ["SetValue"] = function(self, value) |
| self.slider.setup = true |
| self.slider:SetValue(value) |
| self.value = value |
| UpdateText(self) |
| self.slider.setup = nil |
| end, |
| ["GetValue"] = function(self) |
| return self.value |
| end, |
| ["SetLabel"] = function(self, text) |
| self.label:SetText(text) |
| end, |
| ["SetSliderValues"] = function(self, min, max, step) |
| local frame = self.slider |
| frame.setup = true |
| self.min = min |
| self.max = max |
| self.step = step |
| frame:SetMinMaxValues(min or 0,max or 100) |
| UpdateLabels(self) |
| frame:SetValueStep(step or 1) |
| if self.value then |
| frame:SetValue(self.value) |
| end |
| frame.setup = nil |
| end, |
| ["SetIsPercent"] = function(self, value) |
| self.ispercent = value |
| UpdateLabels(self) |
| UpdateText(self) |
| end |
| } |
| --[[----------------------------------------------------------------------------- |
| Constructor |
| -------------------------------------------------------------------------------]] |
| local SliderBackdrop = { |
| bgFile = "Interface\\Buttons\\UI-SliderBar-Background", |
| edgeFile = "Interface\\Buttons\\UI-SliderBar-Border", |
| tile = true, tileSize = 8, edgeSize = 8, |
| insets = { left = 3, right = 3, top = 6, bottom = 6 } |
| } |
| local ManualBackdrop = { |
| bgFile = "Interface\\ChatFrame\\ChatFrameBackground", |
| edgeFile = "Interface\\ChatFrame\\ChatFrameBackground", |
| tile = true, edgeSize = 1, tileSize = 5, |
| } |
| local function Constructor() |
| local frame = CreateFrame("Frame", nil, UIParent) |
| frame:EnableMouse(true) |
| frame:SetScript("OnMouseDown", Frame_OnMouseDown) |
| local label = frame:CreateFontString(nil, "OVERLAY", "GameFontNormal") |
| label:SetPoint("TOPLEFT") |
| label:SetPoint("TOPRIGHT") |
| label:SetJustifyH("CENTER") |
| label:SetHeight(15) |
| local slider = CreateFrame("Slider", nil, frame) |
| slider:SetOrientation("HORIZONTAL") |
| slider:SetHeight(15) |
| slider:SetHitRectInsets(0, 0, -10, 0) |
| slider:SetBackdrop(SliderBackdrop) |
| slider:SetThumbTexture("Interface\\Buttons\\UI-SliderBar-Button-Horizontal") |
| slider:SetPoint("TOP", label, "BOTTOM") |
| slider:SetPoint("LEFT", 3, 0) |
| slider:SetPoint("RIGHT", -3, 0) |
| slider:SetValue(0) |
| slider:SetScript("OnValueChanged",Slider_OnValueChanged) |
| slider:SetScript("OnEnter", Control_OnEnter) |
| slider:SetScript("OnLeave", Control_OnLeave) |
| slider:SetScript("OnMouseUp", Slider_OnMouseUp) |
| slider:SetScript("OnMouseWheel", Slider_OnMouseWheel) |
| local lowtext = slider:CreateFontString(nil, "ARTWORK", "GameFontHighlightSmall") |
| lowtext:SetPoint("TOPLEFT", slider, "BOTTOMLEFT", 2, 3) |
| local hightext = slider:CreateFontString(nil, "ARTWORK", "GameFontHighlightSmall") |
| hightext:SetPoint("TOPRIGHT", slider, "BOTTOMRIGHT", -2, 3) |
| local editbox = CreateFrame("EditBox", nil, frame) |
| editbox:SetAutoFocus(false) |
| editbox:SetFontObject(GameFontHighlightSmall) |
| editbox:SetPoint("TOP", slider, "BOTTOM") |
| editbox:SetHeight(14) |
| editbox:SetWidth(70) |
| editbox:SetJustifyH("CENTER") |
| editbox:EnableMouse(true) |
| editbox:SetBackdrop(ManualBackdrop) |
| editbox:SetBackdropColor(0, 0, 0, 0.5) |
| editbox:SetBackdropBorderColor(0.3, 0.3, 0.30, 0.80) |
| editbox:SetScript("OnEnter", EditBox_OnEnter) |
| editbox:SetScript("OnLeave", EditBox_OnLeave) |
| editbox:SetScript("OnEnterPressed", EditBox_OnEnterPressed) |
| editbox:SetScript("OnEscapePressed", EditBox_OnEscapePressed) |
| local widget = { |
| label = label, |
| slider = slider, |
| lowtext = lowtext, |
| hightext = hightext, |
| editbox = editbox, |
| alignoffset = 25, |
| frame = frame, |
| type = Type |
| } |
| for method, func in pairs(methods) do |
| widget[method] = func |
| end |
| slider.obj, editbox.obj = widget, widget |
| return AceGUI:RegisterAsWidget(widget) |
| end |
| AceGUI:RegisterWidgetType(Type,Constructor,Version) |
mRunes/Libs/AceGUI-3.0/widgets/AceGUIContainer-TabGroup.lua
New file
0,0 → 1,348
| --[[----------------------------------------------------------------------------- |
| TabGroup Container |
| Container that uses tabs on top to switch between groups. |
| -------------------------------------------------------------------------------]] |
| local Type, Version = "TabGroup", 30 |
| local AceGUI = LibStub and LibStub("AceGUI-3.0", true) |
| if not AceGUI or (AceGUI:GetWidgetVersion(Type) or 0) >= Version then return end |
| -- Lua APIs |
| local pairs, ipairs, assert, type, wipe = pairs, ipairs, assert, type, wipe |
| -- WoW APIs |
| local PlaySound = PlaySound |
| local CreateFrame, UIParent = CreateFrame, UIParent |
| local _G = _G |
| -- Global vars/functions that we don't upvalue since they might get hooked, or upgraded |
| -- List them here for Mikk's FindGlobals script |
| -- GLOBALS: PanelTemplates_TabResize, PanelTemplates_SetDisabledTabState, PanelTemplates_SelectTab, PanelTemplates_DeselectTab |
| -- local upvalue storage used by BuildTabs |
| local widths = {} |
| local rowwidths = {} |
| local rowends = {} |
| --[[----------------------------------------------------------------------------- |
| Support functions |
| -------------------------------------------------------------------------------]] |
| local function UpdateTabLook(frame) |
| if frame.disabled then |
| PanelTemplates_SetDisabledTabState(frame) |
| elseif frame.selected then |
| PanelTemplates_SelectTab(frame) |
| else |
| PanelTemplates_DeselectTab(frame) |
| end |
| end |
| local function Tab_SetText(frame, text) |
| frame:_SetText(text) |
| local width = frame.obj.frame.width or frame.obj.frame:GetWidth() or 0 |
| PanelTemplates_TabResize(frame, 0, nil, width) |
| end |
| local function Tab_SetSelected(frame, selected) |
| frame.selected = selected |
| UpdateTabLook(frame) |
| end |
| local function Tab_SetDisabled(frame, disabled) |
| frame.disabled = disabled |
| UpdateTabLook(frame) |
| end |
| local function BuildTabsOnUpdate(frame) |
| local self = frame.obj |
| self:BuildTabs() |
| frame:SetScript("OnUpdate", nil) |
| end |
| --[[----------------------------------------------------------------------------- |
| Scripts |
| -------------------------------------------------------------------------------]] |
| local function Tab_OnClick(frame) |
| if not (frame.selected or frame.disabled) then |
| PlaySound("igCharacterInfoTab") |
| frame.obj:SelectTab(frame.value) |
| end |
| end |
| local function Tab_OnEnter(frame) |
| local self = frame.obj |
| self:Fire("OnTabEnter", self.tabs[frame.id].value, frame) |
| end |
| local function Tab_OnLeave(frame) |
| local self = frame.obj |
| self:Fire("OnTabLeave", self.tabs[frame.id].value, frame) |
| end |
| local function Tab_OnShow(frame) |
| _G[frame:GetName().."HighlightTexture"]:SetWidth(frame:GetTextWidth() + 30) |
| end |
| --[[----------------------------------------------------------------------------- |
| Methods |
| -------------------------------------------------------------------------------]] |
| local methods = { |
| ["OnAcquire"] = function(self) |
| self:SetTitle() |
| end, |
| ["OnRelease"] = function(self) |
| self.status = nil |
| for k in pairs(self.localstatus) do |
| self.localstatus[k] = nil |
| end |
| self.tablist = nil |
| for _, tab in pairs(self.tabs) do |
| tab:Hide() |
| end |
| end, |
| ["CreateTab"] = function(self, id) |
| local tabname = ("AceGUITabGroup%dTab%d"):format(self.num, id) |
| local tab = CreateFrame("Button", tabname, self.border, "OptionsFrameTabButtonTemplate") |
| tab.obj = self |
| tab.id = id |
| tab.text = _G[tabname .. "Text"] |
| tab.text:ClearAllPoints() |
| tab.text:SetPoint("LEFT", 14, -3) |
| tab.text:SetPoint("RIGHT", -12, -3) |
| tab:SetScript("OnClick", Tab_OnClick) |
| tab:SetScript("OnEnter", Tab_OnEnter) |
| tab:SetScript("OnLeave", Tab_OnLeave) |
| tab:SetScript("OnShow", Tab_OnShow) |
| tab._SetText = tab.SetText |
| tab.SetText = Tab_SetText |
| tab.SetSelected = Tab_SetSelected |
| tab.SetDisabled = Tab_SetDisabled |
| return tab |
| end, |
| ["SetTitle"] = function(self, text) |
| self.titletext:SetText(text or "") |
| if text and text ~= "" then |
| self.alignoffset = 25 |
| else |
| self.alignoffset = 18 |
| end |
| self:BuildTabs() |
| end, |
| ["SetStatusTable"] = function(self, status) |
| assert(type(status) == "table") |
| self.status = status |
| end, |
| ["SelectTab"] = function(self, value) |
| local status = self.status or self.localstatus |
| local found |
| for i, v in ipairs(self.tabs) do |
| if v.value == value then |
| v:SetSelected(true) |
| found = true |
| else |
| v:SetSelected(false) |
| end |
| end |
| status.selected = value |
| if found then |
| self:Fire("OnGroupSelected",value) |
| end |
| end, |
| ["SetTabs"] = function(self, tabs) |
| self.tablist = tabs |
| self:BuildTabs() |
| end, |
| ["BuildTabs"] = function(self) |
| local hastitle = (self.titletext:GetText() and self.titletext:GetText() ~= "") |
| local status = self.status or self.localstatus |
| local tablist = self.tablist |
| local tabs = self.tabs |
| if not tablist then return end |
| local width = self.frame.width or self.frame:GetWidth() or 0 |
| wipe(widths) |
| wipe(rowwidths) |
| wipe(rowends) |
| --Place Text into tabs and get thier initial width |
| for i, v in ipairs(tablist) do |
| local tab = tabs[i] |
| if not tab then |
| tab = self:CreateTab(i) |
| tabs[i] = tab |
| end |
| tab:Show() |
| tab:SetText(v.text) |
| tab:SetDisabled(v.disabled) |
| tab.value = v.value |
| widths[i] = tab:GetWidth() - 6 --tabs are anchored 10 pixels from the right side of the previous one to reduce spacing, but add a fixed 4px padding for the text |
| end |
| for i = (#tablist)+1, #tabs, 1 do |
| tabs[i]:Hide() |
| end |
| --First pass, find the minimum number of rows needed to hold all tabs and the initial tab layout |
| local numtabs = #tablist |
| local numrows = 1 |
| local usedwidth = 0 |
| for i = 1, #tablist do |
| --If this is not the first tab of a row and there isn't room for it |
| if usedwidth ~= 0 and (width - usedwidth - widths[i]) < 0 then |
| rowwidths[numrows] = usedwidth + 10 --first tab in each row takes up an extra 10px |
| rowends[numrows] = i - 1 |
| numrows = numrows + 1 |
| usedwidth = 0 |
| end |
| usedwidth = usedwidth + widths[i] |
| end |
| rowwidths[numrows] = usedwidth + 10 --first tab in each row takes up an extra 10px |
| rowends[numrows] = #tablist |
| --Fix for single tabs being left on the last row, move a tab from the row above if applicable |
| if numrows > 1 then |
| --if the last row has only one tab |
| if rowends[numrows-1] == numtabs-1 then |
| --if there are more than 2 tabs in the 2nd last row |
| if (numrows == 2 and rowends[numrows-1] > 2) or (rowends[numrows] - rowends[numrows-1] > 2) then |
| --move 1 tab from the second last row to the last, if there is enough space |
| if (rowwidths[numrows] + widths[numtabs-1]) <= width then |
| rowends[numrows-1] = rowends[numrows-1] - 1 |
| rowwidths[numrows] = rowwidths[numrows] + widths[numtabs-1] |
| rowwidths[numrows-1] = rowwidths[numrows-1] - widths[numtabs-1] |
| end |
| end |
| end |
| end |
| --anchor the rows as defined and resize tabs to fill thier row |
| local starttab = 1 |
| for row, endtab in ipairs(rowends) do |
| local first = true |
| for tabno = starttab, endtab do |
| local tab = tabs[tabno] |
| tab:ClearAllPoints() |
| if first then |
| tab:SetPoint("TOPLEFT", self.frame, "TOPLEFT", 0, -(hastitle and 14 or 7)-(row-1)*20 ) |
| first = false |
| else |
| tab:SetPoint("LEFT", tabs[tabno-1], "RIGHT", -10, 0) |
| end |
| end |
| -- equal padding for each tab to fill the available width, |
| -- if the used space is above 75% already |
| local padding = 0 |
| if not (numrows == 1 and rowwidths[1] < width*0.75) then |
| padding = (width - rowwidths[row]) / (endtab - starttab+1) |
| end |
| for i = starttab, endtab do |
| PanelTemplates_TabResize(tabs[i], padding + 4, nil, width) |
| end |
| starttab = endtab + 1 |
| end |
| self.borderoffset = (hastitle and 17 or 10)+((numrows)*20) |
| self.border:SetPoint("TOPLEFT", 1, -self.borderoffset) |
| end, |
| ["OnWidthSet"] = function(self, width) |
| local content = self.content |
| local contentwidth = width - 60 |
| if contentwidth < 0 then |
| contentwidth = 0 |
| end |
| content:SetWidth(contentwidth) |
| content.width = contentwidth |
| self:BuildTabs(self) |
| self.frame:SetScript("OnUpdate", BuildTabsOnUpdate) |
| end, |
| ["OnHeightSet"] = function(self, height) |
| local content = self.content |
| local contentheight = height - (self.borderoffset + 23) |
| if contentheight < 0 then |
| contentheight = 0 |
| end |
| content:SetHeight(contentheight) |
| content.height = contentheight |
| end, |
| ["LayoutFinished"] = function(self, width, height) |
| if self.noAutoHeight then return end |
| self:SetHeight((height or 0) + (self.borderoffset + 23)) |
| end |
| } |
| --[[----------------------------------------------------------------------------- |
| Constructor |
| -------------------------------------------------------------------------------]] |
| local PaneBackdrop = { |
| bgFile = "Interface\\ChatFrame\\ChatFrameBackground", |
| edgeFile = "Interface\\Tooltips\\UI-Tooltip-Border", |
| tile = true, tileSize = 16, edgeSize = 16, |
| insets = { left = 3, right = 3, top = 5, bottom = 3 } |
| } |
| local function Constructor() |
| local num = AceGUI:GetNextWidgetNum(Type) |
| local frame = CreateFrame("Frame",nil,UIParent) |
| frame:SetHeight(100) |
| frame:SetWidth(100) |
| frame:SetFrameStrata("FULLSCREEN_DIALOG") |
| local titletext = frame:CreateFontString(nil,"OVERLAY","GameFontNormal") |
| titletext:SetPoint("TOPLEFT", 14, 0) |
| titletext:SetPoint("TOPRIGHT", -14, 0) |
| titletext:SetJustifyH("LEFT") |
| titletext:SetHeight(18) |
| titletext:SetText("") |
| local border = CreateFrame("Frame", nil, frame) |
| border:SetPoint("TOPLEFT", 1, -27) |
| border:SetPoint("BOTTOMRIGHT", -1, 3) |
| border:SetBackdrop(PaneBackdrop) |
| border:SetBackdropColor(0.1, 0.1, 0.1, 0.5) |
| border:SetBackdropBorderColor(0.4, 0.4, 0.4) |
| local content = CreateFrame("Frame", nil, border) |
| content:SetPoint("TOPLEFT", 10, -7) |
| content:SetPoint("BOTTOMRIGHT", -10, 7) |
| local widget = { |
| num = num, |
| frame = frame, |
| localstatus = {}, |
| alignoffset = 18, |
| titletext = titletext, |
| border = border, |
| borderoffset = 27, |
| tabs = {}, |
| content = content, |
| type = Type |
| } |
| for method, func in pairs(methods) do |
| widget[method] = func |
| end |
| return AceGUI:RegisterAsContainer(widget) |
| end |
| AceGUI:RegisterWidgetType(Type, Constructor, Version) |
mRunes/Libs/AceGUI-3.0/widgets/AceGUIWidget-Keybinding.lua
New file
0,0 → 1,232
| --[[----------------------------------------------------------------------------- |
| Keybinding Widget |
| Set Keybindings in the Config UI. |
| -------------------------------------------------------------------------------]] |
| local Type, Version = "Keybinding", 22 |
| local AceGUI = LibStub and LibStub("AceGUI-3.0", true) |
| if not AceGUI or (AceGUI:GetWidgetVersion(Type) or 0) >= Version then return end |
| -- Lua APIs |
| local pairs = pairs |
| -- WoW APIs |
| local IsShiftKeyDown, IsControlKeyDown, IsAltKeyDown = IsShiftKeyDown, IsControlKeyDown, IsAltKeyDown |
| local CreateFrame, UIParent = CreateFrame, UIParent |
| -- Global vars/functions that we don't upvalue since they might get hooked, or upgraded |
| -- List them here for Mikk's FindGlobals script |
| -- GLOBALS: NOT_BOUND |
| --[[----------------------------------------------------------------------------- |
| Scripts |
| -------------------------------------------------------------------------------]] |
| local function Control_OnEnter(frame) |
| frame.obj:Fire("OnEnter") |
| end |
| local function Control_OnLeave(frame) |
| frame.obj:Fire("OnLeave") |
| end |
| local function Keybinding_OnClick(frame, button) |
| if button == "LeftButton" or button == "RightButton" then |
| local self = frame.obj |
| if self.waitingForKey then |
| frame:EnableKeyboard(false) |
| self.msgframe:Hide() |
| frame:UnlockHighlight() |
| self.waitingForKey = nil |
| else |
| frame:EnableKeyboard(true) |
| self.msgframe:Show() |
| frame:LockHighlight() |
| self.waitingForKey = true |
| end |
| end |
| AceGUI:ClearFocus() |
| end |
| local ignoreKeys = { |
| ["BUTTON1"] = true, ["BUTTON2"] = true, |
| ["UNKNOWN"] = true, |
| ["LSHIFT"] = true, ["LCTRL"] = true, ["LALT"] = true, |
| ["RSHIFT"] = true, ["RCTRL"] = true, ["RALT"] = true, |
| } |
| local function Keybinding_OnKeyDown(frame, key) |
| local self = frame.obj |
| if self.waitingForKey then |
| local keyPressed = key |
| if keyPressed == "ESCAPE" then |
| keyPressed = "" |
| else |
| if ignoreKeys[keyPressed] then return end |
| if IsShiftKeyDown() then |
| keyPressed = "SHIFT-"..keyPressed |
| end |
| if IsControlKeyDown() then |
| keyPressed = "CTRL-"..keyPressed |
| end |
| if IsAltKeyDown() then |
| keyPressed = "ALT-"..keyPressed |
| end |
| end |
| frame:EnableKeyboard(false) |
| self.msgframe:Hide() |
| frame:UnlockHighlight() |
| self.waitingForKey = nil |
| if not self.disabled then |
| self:SetKey(keyPressed) |
| self:Fire("OnKeyChanged", keyPressed) |
| end |
| end |
| end |
| local function Keybinding_OnMouseDown(frame, button) |
| if button == "LeftButton" or button == "RightButton" then |
| return |
| elseif button == "MiddleButton" then |
| button = "BUTTON3" |
| elseif button == "Button4" then |
| button = "BUTTON4" |
| elseif button == "Button5" then |
| button = "BUTTON5" |
| end |
| Keybinding_OnKeyDown(frame, button) |
| end |
| --[[----------------------------------------------------------------------------- |
| Methods |
| -------------------------------------------------------------------------------]] |
| local methods = { |
| ["OnAcquire"] = function(self) |
| self:SetWidth(200) |
| self:SetLabel("") |
| self:SetKey("") |
| self.waitingForKey = nil |
| self.msgframe:Hide() |
| self:SetDisabled(false) |
| self.button:EnableKeyboard(false) |
| end, |
| -- ["OnRelease"] = nil, |
| ["SetDisabled"] = function(self, disabled) |
| self.disabled = disabled |
| if disabled then |
| self.button:Disable() |
| self.label:SetTextColor(0.5,0.5,0.5) |
| else |
| self.button:Enable() |
| self.label:SetTextColor(1,1,1) |
| end |
| end, |
| ["SetKey"] = function(self, key) |
| if (key or "") == "" then |
| self.button:SetText(NOT_BOUND) |
| self.button:SetNormalFontObject("GameFontNormal") |
| else |
| self.button:SetText(key) |
| self.button:SetNormalFontObject("GameFontHighlight") |
| end |
| end, |
| ["GetKey"] = function(self) |
| local key = self.button:GetText() |
| if key == NOT_BOUND then |
| key = nil |
| end |
| return key |
| end, |
| ["SetLabel"] = function(self, label) |
| self.label:SetText(label or "") |
| if (label or "") == "" then |
| self.alignoffset = nil |
| self:SetHeight(24) |
| else |
| self.alignoffset = 30 |
| self:SetHeight(44) |
| end |
| end, |
| } |
| --[[----------------------------------------------------------------------------- |
| Constructor |
| -------------------------------------------------------------------------------]] |
| local ControlBackdrop = { |
| bgFile = "Interface\\Tooltips\\UI-Tooltip-Background", |
| edgeFile = "Interface\\Tooltips\\UI-Tooltip-Border", |
| tile = true, tileSize = 16, edgeSize = 16, |
| insets = { left = 3, right = 3, top = 3, bottom = 3 } |
| } |
| local function keybindingMsgFixWidth(frame) |
| frame:SetWidth(frame.msg:GetWidth() + 10) |
| frame:SetScript("OnUpdate", nil) |
| end |
| local function Constructor() |
| local name = "AceGUI30KeybindingButton" .. AceGUI:GetNextWidgetNum(Type) |
| local frame = CreateFrame("Frame", nil, UIParent) |
| local button = CreateFrame("Button", name, frame, "UIPanelButtonTemplate2") |
| button:EnableMouse(true) |
| button:RegisterForClicks("AnyDown") |
| button:SetScript("OnEnter", Control_OnEnter) |
| button:SetScript("OnLeave", Control_OnLeave) |
| button:SetScript("OnClick", Keybinding_OnClick) |
| button:SetScript("OnKeyDown", Keybinding_OnKeyDown) |
| button:SetScript("OnMouseDown", Keybinding_OnMouseDown) |
| button:SetPoint("BOTTOMLEFT") |
| button:SetPoint("BOTTOMRIGHT") |
| button:SetHeight(24) |
| button:EnableKeyboard(false) |
| local text = button:GetFontString() |
| text:SetPoint("LEFT", 7, 0) |
| text:SetPoint("RIGHT", -7, 0) |
| local label = frame:CreateFontString(nil, "OVERLAY", "GameFontHighlight") |
| label:SetPoint("TOPLEFT") |
| label:SetPoint("TOPRIGHT") |
| label:SetJustifyH("CENTER") |
| label:SetHeight(18) |
| local msgframe = CreateFrame("Frame", nil, UIParent) |
| msgframe:SetHeight(30) |
| msgframe:SetBackdrop(ControlBackdrop) |
| msgframe:SetBackdropColor(0,0,0) |
| msgframe:SetFrameStrata("FULLSCREEN_DIALOG") |
| msgframe:SetFrameLevel(1000) |
| local msg = msgframe:CreateFontString(nil, "OVERLAY", "GameFontNormal") |
| msg:SetText("Press a key to bind, ESC to clear the binding or click the button again to cancel.") |
| msgframe.msg = msg |
| msg:SetPoint("TOPLEFT", 5, -5) |
| msgframe:SetScript("OnUpdate", keybindingMsgFixWidth) |
| msgframe:SetPoint("BOTTOM", button, "TOP") |
| msgframe:Hide() |
| local widget = { |
| button = button, |
| label = label, |
| msgframe = msgframe, |
| frame = frame, |
| alignoffset = 30, |
| type = Type |
| } |
| for method, func in pairs(methods) do |
| widget[method] = func |
| end |
| button.obj = widget |
| return AceGUI:RegisterAsWidget(widget) |
| end |
| AceGUI:RegisterWidgetType(Type, Constructor, Version) |
mRunes/Libs/AceGUI-3.0/widgets/AceGUIWidget-CheckBox.lua
New file
0,0 → 1,289
| --[[----------------------------------------------------------------------------- |
| Checkbox Widget |
| -------------------------------------------------------------------------------]] |
| local Type, Version = "CheckBox", 21 |
| local AceGUI = LibStub and LibStub("AceGUI-3.0", true) |
| if not AceGUI or (AceGUI:GetWidgetVersion(Type) or 0) >= Version then return end |
| -- Lua APIs |
| local select, pairs = select, pairs |
| -- WoW APIs |
| local PlaySound = PlaySound |
| local CreateFrame, UIParent = CreateFrame, UIParent |
| -- Global vars/functions that we don't upvalue since they might get hooked, or upgraded |
| -- List them here for Mikk's FindGlobals script |
| -- GLOBALS: SetDesaturation, GameFontHighlight |
| --[[----------------------------------------------------------------------------- |
| Support functions |
| -------------------------------------------------------------------------------]] |
| local function AlignImage(self) |
| local img = self.image:GetTexture() |
| self.text:ClearAllPoints() |
| if not img then |
| self.text:SetPoint("LEFT", self.checkbg, "RIGHT") |
| self.text:SetPoint("RIGHT") |
| else |
| self.text:SetPoint("LEFT", self.image,"RIGHT", 1, 0) |
| self.text:SetPoint("RIGHT") |
| end |
| end |
| --[[----------------------------------------------------------------------------- |
| Scripts |
| -------------------------------------------------------------------------------]] |
| local function Control_OnEnter(frame) |
| frame.obj:Fire("OnEnter") |
| end |
| local function Control_OnLeave(frame) |
| frame.obj:Fire("OnLeave") |
| end |
| local function CheckBox_OnMouseDown(frame) |
| local self = frame.obj |
| if not self.disabled then |
| if self.image:GetTexture() then |
| self.text:SetPoint("LEFT", self.image,"RIGHT", 2, -1) |
| else |
| self.text:SetPoint("LEFT", self.checkbg, "RIGHT", 1, -1) |
| end |
| end |
| AceGUI:ClearFocus() |
| end |
| local function CheckBox_OnMouseUp(frame) |
| local self = frame.obj |
| if not self.disabled then |
| self:ToggleChecked() |
| if self.checked then |
| PlaySound("igMainMenuOptionCheckBoxOn") |
| else -- for both nil and false (tristate) |
| PlaySound("igMainMenuOptionCheckBoxOff") |
| end |
| self:Fire("OnValueChanged", self.checked) |
| AlignImage(self) |
| end |
| end |
| --[[----------------------------------------------------------------------------- |
| Methods |
| -------------------------------------------------------------------------------]] |
| local methods = { |
| ["OnAcquire"] = function(self) |
| self:SetType() |
| self:SetValue(false) |
| self:SetTriState(nil) |
| -- height is calculated from the width and required space for the description |
| self:SetWidth(200) |
| self:SetImage() |
| self:SetDisabled(nil) |
| self:SetDescription(nil) |
| end, |
| -- ["OnRelease"] = nil, |
| ["OnWidthSet"] = function(self, width) |
| if self.desc then |
| self.desc:SetWidth(width - 30) |
| if self.desc:GetText() and self.desc:GetText() ~= "" then |
| self:SetHeight(28 + self.desc:GetHeight()) |
| end |
| end |
| end, |
| ["SetDisabled"] = function(self, disabled) |
| self.disabled = disabled |
| if disabled then |
| self.frame:Disable() |
| self.text:SetTextColor(0.5, 0.5, 0.5) |
| SetDesaturation(self.check, true) |
| else |
| self.frame:Enable() |
| self.text:SetTextColor(1, 1, 1) |
| if self.tristate and self.checked == nil then |
| SetDesaturation(self.check, true) |
| else |
| SetDesaturation(self.check, false) |
| end |
| end |
| end, |
| ["SetValue"] = function(self,value) |
| local check = self.check |
| self.checked = value |
| if value then |
| SetDesaturation(self.check, false) |
| self.check:Show() |
| else |
| --Nil is the unknown tristate value |
| if self.tristate and value == nil then |
| SetDesaturation(self.check, true) |
| self.check:Show() |
| else |
| SetDesaturation(self.check, false) |
| self.check:Hide() |
| end |
| end |
| self:SetDisabled(self.disabled) |
| end, |
| ["GetValue"] = function(self) |
| return self.checked |
| end, |
| ["SetTriState"] = function(self, enabled) |
| self.tristate = enabled |
| self:SetValue(self:GetValue()) |
| end, |
| ["SetType"] = function(self, type) |
| local checkbg = self.checkbg |
| local check = self.check |
| local highlight = self.highlight |
| local size |
| if type == "radio" then |
| size = 16 |
| checkbg:SetTexture("Interface\\Buttons\\UI-RadioButton") |
| checkbg:SetTexCoord(0, 0.25, 0, 1) |
| check:SetTexture("Interface\\Buttons\\UI-RadioButton") |
| check:SetTexCoord(0.25, 0.5, 0, 1) |
| check:SetBlendMode("ADD") |
| highlight:SetTexture("Interface\\Buttons\\UI-RadioButton") |
| highlight:SetTexCoord(0.5, 0.75, 0, 1) |
| else |
| size = 24 |
| checkbg:SetTexture("Interface\\Buttons\\UI-CheckBox-Up") |
| checkbg:SetTexCoord(0, 1, 0, 1) |
| check:SetTexture("Interface\\Buttons\\UI-CheckBox-Check") |
| check:SetTexCoord(0, 1, 0, 1) |
| check:SetBlendMode("BLEND") |
| highlight:SetTexture("Interface\\Buttons\\UI-CheckBox-Highlight") |
| highlight:SetTexCoord(0, 1, 0, 1) |
| end |
| checkbg:SetHeight(size) |
| checkbg:SetWidth(size) |
| end, |
| ["ToggleChecked"] = function(self) |
| local value = self:GetValue() |
| if self.tristate then |
| --cycle in true, nil, false order |
| if value then |
| self:SetValue(nil) |
| elseif value == nil then |
| self:SetValue(false) |
| else |
| self:SetValue(true) |
| end |
| else |
| self:SetValue(not self:GetValue()) |
| end |
| end, |
| ["SetLabel"] = function(self, label) |
| self.text:SetText(label) |
| end, |
| ["SetDescription"] = function(self, desc) |
| if desc then |
| if not self.desc then |
| local desc = self.frame:CreateFontString(nil, "OVERLAY", "GameFontHighlightSmall") |
| desc:ClearAllPoints() |
| desc:SetPoint("TOPLEFT", self.checkbg, "TOPRIGHT", 5, -21) |
| desc:SetWidth(self.frame.width - 30) |
| desc:SetJustifyH("LEFT") |
| desc:SetJustifyV("TOP") |
| self.desc = desc |
| end |
| self.desc:Show() |
| --self.text:SetFontObject(GameFontNormal) |
| self.desc:SetText(desc) |
| self:SetHeight(28 + self.desc:GetHeight()) |
| else |
| if self.desc then |
| self.desc:SetText("") |
| self.desc:Hide() |
| end |
| --self.text:SetFontObject(GameFontHighlight) |
| self:SetHeight(24) |
| end |
| end, |
| ["SetImage"] = function(self, path, ...) |
| local image = self.image |
| image:SetTexture(path) |
| if image:GetTexture() then |
| local n = select("#", ...) |
| if n == 4 or n == 8 then |
| image:SetTexCoord(...) |
| else |
| image:SetTexCoord(0, 1, 0, 1) |
| end |
| end |
| AlignImage(self) |
| end |
| } |
| --[[----------------------------------------------------------------------------- |
| Constructor |
| -------------------------------------------------------------------------------]] |
| local function Constructor() |
| local frame = CreateFrame("Button", nil, UIParent) |
| frame:Hide() |
| frame:EnableMouse(true) |
| frame:SetScript("OnEnter", Control_OnEnter) |
| frame:SetScript("OnLeave", Control_OnLeave) |
| frame:SetScript("OnMouseDown", CheckBox_OnMouseDown) |
| frame:SetScript("OnMouseUp", CheckBox_OnMouseUp) |
| local checkbg = frame:CreateTexture(nil, "ARTWORK") |
| checkbg:SetWidth(24) |
| checkbg:SetHeight(24) |
| checkbg:SetPoint("TOPLEFT") |
| checkbg:SetTexture("Interface\\Buttons\\UI-CheckBox-Up") |
| local check = frame:CreateTexture(nil, "OVERLAY") |
| check:SetAllPoints(checkbg) |
| check:SetTexture("Interface\\Buttons\\UI-CheckBox-Check") |
| local text = frame:CreateFontString(nil, "OVERLAY", "GameFontHighlight") |
| text:SetJustifyH("LEFT") |
| text:SetHeight(18) |
| text:SetPoint("LEFT", checkbg, "RIGHT") |
| text:SetPoint("RIGHT") |
| local highlight = frame:CreateTexture(nil, "HIGHLIGHT") |
| highlight:SetTexture("Interface\\Buttons\\UI-CheckBox-Highlight") |
| highlight:SetBlendMode("ADD") |
| highlight:SetAllPoints(checkbg) |
| local image = frame:CreateTexture(nil, "OVERLAY") |
| image:SetHeight(16) |
| image:SetWidth(16) |
| image:SetPoint("LEFT", checkbg, "RIGHT", 1, 0) |
| local widget = { |
| checkbg = checkbg, |
| check = check, |
| text = text, |
| highlight = highlight, |
| image = image, |
| frame = frame, |
| type = Type |
| } |
| for method, func in pairs(methods) do |
| widget[method] = func |
| end |
| return AceGUI:RegisterAsWidget(widget) |
| end |
| AceGUI:RegisterWidgetType(Type, Constructor, Version) |
mRunes/Libs/AceGUI-3.0/widgets/AceGUIContainer-BlizOptionsGroup.lua
New file
0,0 → 1,133
| --[[----------------------------------------------------------------------------- |
| BlizOptionsGroup Container |
| Simple container widget for the integration of AceGUI into the Blizzard Interface Options |
| -------------------------------------------------------------------------------]] |
| local Type, Version = "BlizOptionsGroup", 20 |
| local AceGUI = LibStub and LibStub("AceGUI-3.0", true) |
| if not AceGUI or (AceGUI:GetWidgetVersion(Type) or 0) >= Version then return end |
| -- Lua APIs |
| local pairs = pairs |
| -- WoW APIs |
| local CreateFrame = CreateFrame |
| --[[----------------------------------------------------------------------------- |
| Scripts |
| -------------------------------------------------------------------------------]] |
| local function OnShow(frame) |
| frame.obj:Fire("OnShow") |
| end |
| local function OnHide(frame) |
| frame.obj:Fire("OnHide") |
| end |
| --[[----------------------------------------------------------------------------- |
| Support functions |
| -------------------------------------------------------------------------------]] |
| local function okay(frame) |
| frame.obj:Fire("okay") |
| end |
| local function cancel(frame) |
| frame.obj:Fire("cancel") |
| end |
| local function defaults(frame) |
| frame.obj:Fire("defaults") |
| end |
| --[[----------------------------------------------------------------------------- |
| Methods |
| -------------------------------------------------------------------------------]] |
| local methods = { |
| ["OnAcquire"] = function(self) |
| self:SetName() |
| self:SetTitle() |
| end, |
| -- ["OnRelease"] = nil, |
| ["OnWidthSet"] = function(self, width) |
| local content = self.content |
| local contentwidth = width - 63 |
| if contentwidth < 0 then |
| contentwidth = 0 |
| end |
| content:SetWidth(contentwidth) |
| content.width = contentwidth |
| end, |
| ["OnHeightSet"] = function(self, height) |
| local content = self.content |
| local contentheight = height - 26 |
| if contentheight < 0 then |
| contentheight = 0 |
| end |
| content:SetHeight(contentheight) |
| content.height = contentheight |
| end, |
| ["SetName"] = function(self, name, parent) |
| self.frame.name = name |
| self.frame.parent = parent |
| end, |
| ["SetTitle"] = function(self, title) |
| local content = self.content |
| content:ClearAllPoints() |
| if not title or title == "" then |
| content:SetPoint("TOPLEFT", 10, -10) |
| self.label:SetText("") |
| else |
| content:SetPoint("TOPLEFT", 10, -40) |
| self.label:SetText(title) |
| end |
| content:SetPoint("BOTTOMRIGHT", -10, 10) |
| end |
| } |
| --[[----------------------------------------------------------------------------- |
| Constructor |
| -------------------------------------------------------------------------------]] |
| local function Constructor() |
| local frame = CreateFrame("Frame") |
| frame:Hide() |
| -- support functions for the Blizzard Interface Options |
| frame.okay = okay |
| frame.cancel = cancel |
| frame.defaults = defaults |
| frame:SetScript("OnHide", OnHide) |
| frame:SetScript("OnShow", OnShow) |
| local label = frame:CreateFontString(nil, "OVERLAY", "GameFontNormalLarge") |
| label:SetPoint("TOPLEFT", 10, -15) |
| label:SetPoint("BOTTOMRIGHT", frame, "TOPRIGHT", 10, -45) |
| label:SetJustifyH("LEFT") |
| label:SetJustifyV("TOP") |
| --Container Support |
| local content = CreateFrame("Frame", nil, frame) |
| content:SetPoint("TOPLEFT", 10, -10) |
| content:SetPoint("BOTTOMRIGHT", -10, 10) |
| local widget = { |
| label = label, |
| frame = frame, |
| content = content, |
| type = Type |
| } |
| for method, func in pairs(methods) do |
| widget[method] = func |
| end |
| return AceGUI:RegisterAsContainer(widget) |
| end |
| AceGUI:RegisterWidgetType(Type, Constructor, Version) |
mRunes/Libs/AceGUI-3.0/widgets/AceGUIWidget-Icon.lua
New file
0,0 → 1,144
| --[[----------------------------------------------------------------------------- |
| Icon Widget |
| -------------------------------------------------------------------------------]] |
| local Type, Version = "Icon", 20 |
| local AceGUI = LibStub and LibStub("AceGUI-3.0", true) |
| if not AceGUI or (AceGUI:GetWidgetVersion(Type) or 0) >= Version then return end |
| -- Lua APIs |
| local select, pairs, print = select, pairs, print |
| -- WoW APIs |
| local CreateFrame, UIParent, GetBuildInfo = CreateFrame, UIParent, GetBuildInfo |
| --[[----------------------------------------------------------------------------- |
| Scripts |
| -------------------------------------------------------------------------------]] |
| local function Control_OnEnter(frame) |
| frame.obj:Fire("OnEnter") |
| end |
| local function Control_OnLeave(frame) |
| frame.obj:Fire("OnLeave") |
| end |
| local function Button_OnClick(frame, button) |
| frame.obj:Fire("OnClick", button) |
| AceGUI:ClearFocus() |
| end |
| --[[----------------------------------------------------------------------------- |
| Methods |
| -------------------------------------------------------------------------------]] |
| local methods = { |
| ["OnAcquire"] = function(self) |
| self:SetHeight(110) |
| self:SetWidth(110) |
| self:SetLabel() |
| self:SetImage(nil) |
| self:SetImageSize(64, 64) |
| self:SetDisabled(false) |
| end, |
| -- ["OnRelease"] = nil, |
| ["SetLabel"] = function(self, text) |
| if text and text ~= "" then |
| self.label:Show() |
| self.label:SetText(text) |
| self:SetHeight(self.image:GetHeight() + 25) |
| else |
| self.label:Hide() |
| self:SetHeight(self.image:GetHeight() + 10) |
| end |
| end, |
| ["SetImage"] = function(self, path, ...) |
| local image = self.image |
| image:SetTexture(path) |
| if image:GetTexture() then |
| local n = select("#", ...) |
| if n == 4 or n == 8 then |
| image:SetTexCoord(...) |
| else |
| image:SetTexCoord(0, 1, 0, 1) |
| end |
| end |
| end, |
| ["SetImageSize"] = function(self, width, height) |
| self.image:SetWidth(width) |
| self.image:SetHeight(height) |
| --self.frame:SetWidth(width + 30) |
| if self.label:IsShown() then |
| self:SetHeight(height + 25) |
| else |
| self:SetHeight(height + 10) |
| end |
| end, |
| ["SetDisabled"] = function(self, disabled) |
| self.disabled = disabled |
| if disabled then |
| self.frame:Disable() |
| self.label:SetTextColor(0.5, 0.5, 0.5) |
| self.image:SetVertexColor(0.5, 0.5, 0.5, 0.5) |
| else |
| self.frame:Enable() |
| self.label:SetTextColor(1, 1, 1) |
| self.image:SetVertexColor(1, 1, 1) |
| end |
| end |
| } |
| --[[----------------------------------------------------------------------------- |
| Constructor |
| -------------------------------------------------------------------------------]] |
| local function Constructor() |
| local frame = CreateFrame("Button", nil, UIParent) |
| frame:Hide() |
| frame:EnableMouse(true) |
| frame:SetScript("OnEnter", Control_OnEnter) |
| frame:SetScript("OnLeave", Control_OnLeave) |
| frame:SetScript("OnClick", Button_OnClick) |
| local label = frame:CreateFontString(nil, "BACKGROUND", "GameFontHighlight") |
| label:SetPoint("BOTTOMLEFT") |
| label:SetPoint("BOTTOMRIGHT") |
| label:SetJustifyH("CENTER") |
| label:SetJustifyV("TOP") |
| label:SetHeight(18) |
| local image = frame:CreateTexture(nil, "BACKGROUND") |
| image:SetWidth(64) |
| image:SetHeight(64) |
| image:SetPoint("TOP", 0, -5) |
| local highlight = frame:CreateTexture(nil, "HIGHLIGHT") |
| highlight:SetAllPoints(image) |
| highlight:SetTexture("Interface\\PaperDollInfoFrame\\UI-Character-Tab-Highlight") |
| highlight:SetTexCoord(0, 1, 0.23, 0.77) |
| highlight:SetBlendMode("ADD") |
| local widget = { |
| label = label, |
| image = image, |
| frame = frame, |
| type = Type |
| } |
| for method, func in pairs(methods) do |
| widget[method] = func |
| end |
| -- SetText is deprecated, but keep it around for a while. (say, to WoW 4.0) |
| if (select(4, GetBuildInfo()) < 40000) then |
| widget.SetText = widget.SetLabel |
| else |
| widget.SetText = function(self, ...) print("AceGUI-3.0-Icon: SetText is deprecated! Use SetLabel instead!"); self:SetLabel(...) end |
| end |
| return AceGUI:RegisterAsWidget(widget) |
| end |
| AceGUI:RegisterWidgetType(Type, Constructor, Version) |
mRunes/Libs/AceGUI-3.0/widgets/AceGUIContainer-Frame.lua
New file
0,0 → 1,298
| --[[----------------------------------------------------------------------------- |
| Frame Container |
| -------------------------------------------------------------------------------]] |
| local Type, Version = "Frame", 21 |
| local AceGUI = LibStub and LibStub("AceGUI-3.0", true) |
| if not AceGUI or (AceGUI:GetWidgetVersion(Type) or 0) >= Version then return end |
| -- Lua APIs |
| local pairs, assert, type = pairs, assert, type |
| local wipe = table.wipe |
| -- WoW APIs |
| local PlaySound = PlaySound |
| local CreateFrame, UIParent = CreateFrame, UIParent |
| -- Global vars/functions that we don't upvalue since they might get hooked, or upgraded |
| -- List them here for Mikk's FindGlobals script |
| -- GLOBALS: CLOSE |
| --[[----------------------------------------------------------------------------- |
| Scripts |
| -------------------------------------------------------------------------------]] |
| local function Button_OnClick(frame) |
| PlaySound("gsTitleOptionExit") |
| frame.obj:Hide() |
| end |
| local function Frame_OnClose(frame) |
| frame.obj:Fire("OnClose") |
| end |
| local function Frame_OnMouseDown(frame) |
| AceGUI:ClearFocus() |
| end |
| local function Title_OnMouseDown(frame) |
| frame:GetParent():StartMoving() |
| AceGUI:ClearFocus() |
| end |
| local function MoverSizer_OnMouseUp(mover) |
| local frame = mover:GetParent() |
| frame:StopMovingOrSizing() |
| local self = frame.obj |
| local status = self.status or self.localstatus |
| status.width = frame:GetWidth() |
| status.height = frame:GetHeight() |
| status.top = frame:GetTop() |
| status.left = frame:GetLeft() |
| end |
| local function SizerSE_OnMouseDown(frame) |
| frame:GetParent():StartSizing("BOTTOMRIGHT") |
| AceGUI:ClearFocus() |
| end |
| local function SizerS_OnMouseDown(frame) |
| frame:GetParent():StartSizing("BOTTOM") |
| AceGUI:ClearFocus() |
| end |
| local function SizerE_OnMouseDown(frame) |
| frame:GetParent():StartSizing("RIGHT") |
| AceGUI:ClearFocus() |
| end |
| local function StatusBar_OnEnter(frame) |
| frame.obj:Fire("OnEnterStatusBar") |
| end |
| local function StatusBar_OnLeave(frame) |
| frame.obj:Fire("OnLeaveStatusBar") |
| end |
| --[[----------------------------------------------------------------------------- |
| Methods |
| -------------------------------------------------------------------------------]] |
| local methods = { |
| ["OnAcquire"] = function(self) |
| self.frame:SetParent(UIParent) |
| self.frame:SetFrameStrata("FULLSCREEN_DIALOG") |
| self:SetTitle() |
| self:SetStatusText() |
| self:ApplyStatus() |
| self:Show() |
| end, |
| ["OnRelease"] = function(self) |
| self.status = nil |
| wipe(self.localstatus) |
| end, |
| ["OnWidthSet"] = function(self, width) |
| local content = self.content |
| local contentwidth = width - 34 |
| if contentwidth < 0 then |
| contentwidth = 0 |
| end |
| content:SetWidth(contentwidth) |
| content.width = contentwidth |
| end, |
| ["OnHeightSet"] = function(self, height) |
| local content = self.content |
| local contentheight = height - 57 |
| if contentheight < 0 then |
| contentheight = 0 |
| end |
| content:SetHeight(contentheight) |
| content.height = contentheight |
| end, |
| ["SetTitle"] = function(self, title) |
| self.titletext:SetText(title) |
| end, |
| ["SetStatusText"] = function(self, text) |
| self.statustext:SetText(text) |
| end, |
| ["Hide"] = function(self) |
| self.frame:Hide() |
| end, |
| ["Show"] = function(self) |
| self.frame:Show() |
| end, |
| -- called to set an external table to store status in |
| ["SetStatusTable"] = function(self, status) |
| assert(type(status) == "table") |
| self.status = status |
| self:ApplyStatus() |
| end, |
| ["ApplyStatus"] = function(self) |
| local status = self.status or self.localstatus |
| local frame = self.frame |
| self:SetWidth(status.width or 700) |
| self:SetHeight(status.height or 500) |
| frame:ClearAllPoints() |
| if status.top and status.left then |
| frame:SetPoint("TOP", UIParent, "BOTTOM", 0, status.top) |
| frame:SetPoint("LEFT", UIParent, "LEFT", status.left, 0) |
| else |
| frame:SetPoint("CENTER") |
| end |
| end |
| } |
| --[[----------------------------------------------------------------------------- |
| Constructor |
| -------------------------------------------------------------------------------]] |
| local FrameBackdrop = { |
| bgFile = "Interface\\DialogFrame\\UI-DialogBox-Background", |
| edgeFile = "Interface\\DialogFrame\\UI-DialogBox-Border", |
| tile = true, tileSize = 32, edgeSize = 32, |
| insets = { left = 8, right = 8, top = 8, bottom = 8 } |
| } |
| local PaneBackdrop = { |
| bgFile = "Interface\\ChatFrame\\ChatFrameBackground", |
| edgeFile = "Interface\\Tooltips\\UI-Tooltip-Border", |
| tile = true, tileSize = 16, edgeSize = 16, |
| insets = { left = 3, right = 3, top = 5, bottom = 3 } |
| } |
| local function Constructor() |
| local frame = CreateFrame("Frame", nil, UIParent) |
| frame:Hide() |
| frame:EnableMouse(true) |
| frame:SetMovable(true) |
| frame:SetResizable(true) |
| frame:SetFrameStrata("FULLSCREEN_DIALOG") |
| frame:SetBackdrop(FrameBackdrop) |
| frame:SetBackdropColor(0, 0, 0, 1) |
| frame:SetMinResize(400, 200) |
| frame:SetToplevel(true) |
| frame:SetScript("OnHide", Frame_OnClose) |
| frame:SetScript("OnMouseDown", Frame_OnMouseDown) |
| local closebutton = CreateFrame("Button", nil, frame, "UIPanelButtonTemplate") |
| closebutton:SetScript("OnClick", Button_OnClick) |
| closebutton:SetPoint("BOTTOMRIGHT", -27, 17) |
| closebutton:SetHeight(20) |
| closebutton:SetWidth(100) |
| closebutton:SetText(CLOSE) |
| local statusbg = CreateFrame("Button", nil, frame) |
| statusbg:SetPoint("BOTTOMLEFT", 15, 15) |
| statusbg:SetPoint("BOTTOMRIGHT", -132, 15) |
| statusbg:SetHeight(24) |
| statusbg:SetBackdrop(PaneBackdrop) |
| statusbg:SetBackdropColor(0.1,0.1,0.1) |
| statusbg:SetBackdropBorderColor(0.4,0.4,0.4) |
| statusbg:SetScript("OnEnter", StatusBar_OnEnter) |
| statusbg:SetScript("OnLeave", StatusBar_OnLeave) |
| local statustext = statusbg:CreateFontString(nil, "OVERLAY", "GameFontNormal") |
| statustext:SetPoint("TOPLEFT", 7, -2) |
| statustext:SetPoint("BOTTOMRIGHT", -7, 2) |
| statustext:SetHeight(20) |
| statustext:SetJustifyH("LEFT") |
| statustext:SetText("") |
| local titlebg = frame:CreateTexture(nil, "OVERLAY") |
| titlebg:SetTexture("Interface\\DialogFrame\\UI-DialogBox-Header") |
| titlebg:SetTexCoord(0.31, 0.67, 0, 0.63) |
| titlebg:SetPoint("TOP", 0, 12) |
| titlebg:SetWidth(100) |
| titlebg:SetHeight(40) |
| local title = CreateFrame("Frame", nil, frame) |
| title:EnableMouse(true) |
| title:SetScript("OnMouseDown", Title_OnMouseDown) |
| title:SetScript("OnMouseUp", MoverSizer_OnMouseUp) |
| title:SetAllPoints(titlebg) |
| local titletext = title:CreateFontString(nil, "OVERLAY", "GameFontNormal") |
| titletext:SetPoint("TOP", titlebg, "TOP", 0, -14) |
| local titlebg_l = frame:CreateTexture(nil, "OVERLAY") |
| titlebg_l:SetTexture("Interface\\DialogFrame\\UI-DialogBox-Header") |
| titlebg_l:SetTexCoord(0.21, 0.31, 0, 0.63) |
| titlebg_l:SetPoint("RIGHT", titlebg, "LEFT") |
| titlebg_l:SetWidth(30) |
| titlebg_l:SetHeight(40) |
| local titlebg_r = frame:CreateTexture(nil, "OVERLAY") |
| titlebg_r:SetTexture("Interface\\DialogFrame\\UI-DialogBox-Header") |
| titlebg_r:SetTexCoord(0.67, 0.77, 0, 0.63) |
| titlebg_r:SetPoint("LEFT", titlebg, "RIGHT") |
| titlebg_r:SetWidth(30) |
| titlebg_r:SetHeight(40) |
| local sizer_se = CreateFrame("Frame", nil, frame) |
| sizer_se:SetPoint("BOTTOMRIGHT") |
| sizer_se:SetWidth(25) |
| sizer_se:SetHeight(25) |
| sizer_se:EnableMouse() |
| sizer_se:SetScript("OnMouseDown",SizerSE_OnMouseDown) |
| sizer_se:SetScript("OnMouseUp", MoverSizer_OnMouseUp) |
| local line1 = sizer_se:CreateTexture(nil, "BACKGROUND") |
| line1:SetWidth(14) |
| line1:SetHeight(14) |
| line1:SetPoint("BOTTOMRIGHT", -8, 8) |
| line1:SetTexture("Interface\\Tooltips\\UI-Tooltip-Border") |
| local x = 0.1 * 14/17 |
| line1:SetTexCoord(0.05 - x, 0.5, 0.05, 0.5 + x, 0.05, 0.5 - x, 0.5 + x, 0.5) |
| local line2 = sizer_se:CreateTexture(nil, "BACKGROUND") |
| line2:SetWidth(8) |
| line2:SetHeight(8) |
| line2:SetPoint("BOTTOMRIGHT", -8, 8) |
| line2:SetTexture("Interface\\Tooltips\\UI-Tooltip-Border") |
| local x = 0.1 * 8/17 |
| line2:SetTexCoord(0.05 - x, 0.5, 0.05, 0.5 + x, 0.05, 0.5 - x, 0.5 + x, 0.5) |
| local sizer_s = CreateFrame("Frame", nil, frame) |
| sizer_s:SetPoint("BOTTOMRIGHT", -25, 0) |
| sizer_s:SetPoint("BOTTOMLEFT") |
| sizer_s:SetHeight(25) |
| sizer_s:EnableMouse(true) |
| sizer_s:SetScript("OnMouseDown", SizerS_OnMouseDown) |
| sizer_s:SetScript("OnMouseUp", MoverSizer_OnMouseUp) |
| local sizer_e = CreateFrame("Frame", nil, frame) |
| sizer_e:SetPoint("BOTTOMRIGHT", 0, 25) |
| sizer_e:SetPoint("TOPRIGHT") |
| sizer_e:SetWidth(25) |
| sizer_e:EnableMouse(true) |
| sizer_e:SetScript("OnMouseDown", SizerE_OnMouseDown) |
| sizer_e:SetScript("OnMouseUp", MoverSizer_OnMouseUp) |
| --Container Support |
| local content = CreateFrame("Frame", nil, frame) |
| content:SetPoint("TOPLEFT", 17, -27) |
| content:SetPoint("BOTTOMRIGHT", -17, 40) |
| local widget = { |
| localstatus = {}, |
| titletext = titletext, |
| statustext = statustext, |
| content = content, |
| frame = frame, |
| type = Type |
| } |
| for method, func in pairs(methods) do |
| widget[method] = func |
| end |
| closebutton.obj, statusbg.obj = widget, widget |
| return AceGUI:RegisterAsContainer(widget) |
| end |
| AceGUI:RegisterWidgetType(Type, Constructor, Version) |
mRunes/Libs/AceGUI-3.0/widgets/AceGUIContainer-InlineGroup.lua
New file
0,0 → 1,102
| --[[----------------------------------------------------------------------------- |
| InlineGroup Container |
| Simple container widget that creates a visible "box" with an optional title. |
| -------------------------------------------------------------------------------]] |
| local Type, Version = "InlineGroup", 20 |
| local AceGUI = LibStub and LibStub("AceGUI-3.0", true) |
| if not AceGUI or (AceGUI:GetWidgetVersion(Type) or 0) >= Version then return end |
| -- Lua APIs |
| local pairs = pairs |
| -- WoW APIs |
| local CreateFrame, UIParent = CreateFrame, UIParent |
| --[[----------------------------------------------------------------------------- |
| Methods |
| -------------------------------------------------------------------------------]] |
| local methods = { |
| ["OnAcquire"] = function(self) |
| self:SetWidth(300) |
| self:SetHeight(100) |
| end, |
| -- ["OnRelease"] = nil, |
| ["SetTitle"] = function(self,title) |
| self.titletext:SetText(title) |
| end, |
| ["LayoutFinished"] = function(self, width, height) |
| if self.noAutoHeight then return end |
| self:SetHeight((height or 0) + 40) |
| end, |
| ["OnWidthSet"] = function(self, width) |
| local content = self.content |
| local contentwidth = width - 20 |
| if contentwidth < 0 then |
| contentwidth = 0 |
| end |
| content:SetWidth(contentwidth) |
| content.width = contentwidth |
| end, |
| ["OnHeightSet"] = function(self, height) |
| local content = self.content |
| local contentheight = height - 20 |
| if contentheight < 0 then |
| contentheight = 0 |
| end |
| content:SetHeight(contentheight) |
| content.height = contentheight |
| end |
| } |
| --[[----------------------------------------------------------------------------- |
| Constructor |
| -------------------------------------------------------------------------------]] |
| local PaneBackdrop = { |
| bgFile = "Interface\\ChatFrame\\ChatFrameBackground", |
| edgeFile = "Interface\\Tooltips\\UI-Tooltip-Border", |
| tile = true, tileSize = 16, edgeSize = 16, |
| insets = { left = 3, right = 3, top = 5, bottom = 3 } |
| } |
| local function Constructor() |
| local frame = CreateFrame("Frame", nil, UIParent) |
| frame:SetFrameStrata("FULLSCREEN_DIALOG") |
| local titletext = frame:CreateFontString(nil, "OVERLAY", "GameFontNormal") |
| titletext:SetPoint("TOPLEFT", 14, 0) |
| titletext:SetPoint("TOPRIGHT", -14, 0) |
| titletext:SetJustifyH("LEFT") |
| titletext:SetHeight(18) |
| local border = CreateFrame("Frame", nil, frame) |
| border:SetPoint("TOPLEFT", 0, -17) |
| border:SetPoint("BOTTOMRIGHT", -1, 3) |
| border:SetBackdrop(PaneBackdrop) |
| border:SetBackdropColor(0.1, 0.1, 0.1, 0.5) |
| border:SetBackdropBorderColor(0.4, 0.4, 0.4) |
| --Container Support |
| local content = CreateFrame("Frame", nil, border) |
| content:SetPoint("TOPLEFT", 10, -10) |
| content:SetPoint("BOTTOMRIGHT", -10, 10) |
| local widget = { |
| frame = frame, |
| content = content, |
| titletext = titletext, |
| type = Type |
| } |
| for method, func in pairs(methods) do |
| widget[method] = func |
| end |
| return AceGUI:RegisterAsContainer(widget) |
| end |
| AceGUI:RegisterWidgetType(Type, Constructor, Version) |
mRunes/Libs/AceGUI-3.0/widgets/AceGUIWidget-DropDown.lua
New file
0,0 → 1,707
| --[[ $Id: AceGUIWidget-DropDown.lua 916 2010-03-15 12:24:36Z nevcairiel $ ]]-- |
| local AceGUI = LibStub("AceGUI-3.0") |
| -- Lua APIs |
| local min, max, floor = math.min, math.max, math.floor |
| local select, pairs, ipairs = select, pairs, ipairs |
| local tsort = table.sort |
| -- WoW APIs |
| local PlaySound = PlaySound |
| local UIParent, CreateFrame = UIParent, CreateFrame |
| local _G = _G |
| -- Global vars/functions that we don't upvalue since they might get hooked, or upgraded |
| -- List them here for Mikk's FindGlobals script |
| -- GLOBALS: CLOSE |
| local function fixlevels(parent,...) |
| local i = 1 |
| local child = select(i, ...) |
| while child do |
| child:SetFrameLevel(parent:GetFrameLevel()+1) |
| fixlevels(child, child:GetChildren()) |
| i = i + 1 |
| child = select(i, ...) |
| end |
| end |
| local function fixstrata(strata, parent, ...) |
| local i = 1 |
| local child = select(i, ...) |
| parent:SetFrameStrata(strata) |
| while child do |
| fixstrata(strata, child, child:GetChildren()) |
| i = i + 1 |
| child = select(i, ...) |
| end |
| end |
| do |
| local widgetType = "Dropdown-Pullout" |
| local widgetVersion = 3 |
| --[[ Static data ]]-- |
| local backdrop = { |
| bgFile = "Interface\\ChatFrame\\ChatFrameBackground", |
| edgeFile = "Interface\\DialogFrame\\UI-DialogBox-Border", |
| edgeSize = 32, |
| tileSize = 32, |
| tile = true, |
| insets = { left = 11, right = 12, top = 12, bottom = 11 }, |
| } |
| local sliderBackdrop = { |
| bgFile = "Interface\\Buttons\\UI-SliderBar-Background", |
| edgeFile = "Interface\\Buttons\\UI-SliderBar-Border", |
| tile = true, tileSize = 8, edgeSize = 8, |
| insets = { left = 3, right = 3, top = 3, bottom = 3 } |
| } |
| local defaultWidth = 200 |
| local defaultMaxHeight = 600 |
| --[[ UI Event Handlers ]]-- |
| -- HACK: This should be no part of the pullout, but there |
| -- is no other 'clean' way to response to any item-OnEnter |
| -- Used to close Submenus when an other item is entered |
| local function OnEnter(item) |
| local self = item.pullout |
| for k, v in ipairs(self.items) do |
| if v.CloseMenu and v ~= item then |
| v:CloseMenu() |
| end |
| end |
| end |
| -- See the note in Constructor() for each scroll related function |
| local function OnMouseWheel(this, value) |
| this.obj:MoveScroll(value) |
| end |
| local function OnScrollValueChanged(this, value) |
| this.obj:SetScroll(value) |
| end |
| local function OnSizeChanged(this) |
| this.obj:FixScroll() |
| end |
| --[[ Exported methods ]]-- |
| -- exported |
| local function SetScroll(self, value) |
| local status = self.scrollStatus |
| local frame, child = self.scrollFrame, self.itemFrame |
| local height, viewheight = frame:GetHeight(), child:GetHeight() |
| local offset |
| if height > viewheight then |
| offset = 0 |
| else |
| offset = floor((viewheight - height) / 1000 * value) |
| end |
| child:ClearAllPoints() |
| child:SetPoint("TOPLEFT", frame, "TOPLEFT", 0, offset) |
| child:SetPoint("TOPRIGHT", frame, "TOPRIGHT", self.slider:IsShown() and -12 or 0, offset) |
| status.offset = offset |
| status.scrollvalue = value |
| end |
| -- exported |
| local function MoveScroll(self, value) |
| local status = self.scrollStatus |
| local frame, child = self.scrollFrame, self.itemFrame |
| local height, viewheight = frame:GetHeight(), child:GetHeight() |
| if height > viewheight then |
| self.slider:Hide() |
| else |
| self.slider:Show() |
| local diff = height - viewheight |
| local delta = 1 |
| if value < 0 then |
| delta = -1 |
| end |
| self.slider:SetValue(min(max(status.scrollvalue + delta*(1000/(diff/45)),0), 1000)) |
| end |
| end |
| -- exported |
| local function FixScroll(self) |
| local status = self.scrollStatus |
| local frame, child = self.scrollFrame, self.itemFrame |
| local height, viewheight = frame:GetHeight(), child:GetHeight() |
| local offset = status.offset or 0 |
| if viewheight < height then |
| self.slider:Hide() |
| child:SetPoint("TOPRIGHT", frame, "TOPRIGHT", 0, offset) |
| self.slider:SetValue(0) |
| else |
| self.slider:Show() |
| local value = (offset / (viewheight - height) * 1000) |
| if value > 1000 then value = 1000 end |
| self.slider:SetValue(value) |
| self:SetScroll(value) |
| if value < 1000 then |
| child:ClearAllPoints() |
| child:SetPoint("TOPLEFT", frame, "TOPLEFT", 0, offset) |
| child:SetPoint("TOPRIGHT", frame, "TOPRIGHT", -12, offset) |
| status.offset = offset |
| end |
| end |
| end |
| -- exported, AceGUI callback |
| local function OnAcquire(self) |
| self.frame:SetParent(UIParent) |
| --self.itemFrame:SetToplevel(true) |
| end |
| -- exported, AceGUI callback |
| local function OnRelease(self) |
| self:Clear() |
| self.frame:ClearAllPoints() |
| self.frame:Hide() |
| end |
| -- exported |
| local function AddItem(self, item) |
| self.items[#self.items + 1] = item |
| local h = #self.items * 16 |
| self.itemFrame:SetHeight(h) |
| self.frame:SetHeight(min(h + 34, self.maxHeight)) -- +34: 20 for scrollFrame placement (10 offset) and +14 for item placement |
| item.frame:SetPoint("LEFT", self.itemFrame, "LEFT") |
| item.frame:SetPoint("RIGHT", self.itemFrame, "RIGHT") |
| item:SetPullout(self) |
| item:SetOnEnter(OnEnter) |
| end |
| -- exported |
| local function Open(self, point, relFrame, relPoint, x, y) |
| local items = self.items |
| local frame = self.frame |
| local itemFrame = self.itemFrame |
| frame:SetPoint(point, relFrame, relPoint, x, y) |
| local height = 8 |
| for i, item in pairs(items) do |
| if i == 1 then |
| item:SetPoint("TOP", itemFrame, "TOP", 0, -2) |
| else |
| item:SetPoint("TOP", items[i-1].frame, "BOTTOM", 0, 1) |
| end |
| item:Show() |
| height = height + 16 |
| end |
| itemFrame:SetHeight(height) |
| fixstrata("TOOLTIP", frame, frame:GetChildren()) |
| frame:Show() |
| self:Fire("OnOpen") |
| end |
| -- exported |
| local function Close(self) |
| self.frame:Hide() |
| self:Fire("OnClose") |
| end |
| -- exported |
| local function Clear(self) |
| local items = self.items |
| for i, item in pairs(items) do |
| AceGUI:Release(item) |
| items[i] = nil |
| end |
| end |
| -- exported |
| local function IterateItems(self) |
| return ipairs(self.items) |
| end |
| -- exported |
| local function SetHideOnLeave(self, val) |
| self.hideOnLeave = val |
| end |
| -- exported |
| local function SetMaxHeight(self, height) |
| self.maxHeight = height or defaultMaxHeight |
| if self.frame:GetHeight() > height then |
| self.frame:SetHeight(height) |
| elseif (self.itemFrame:GetHeight() + 34) < height then |
| self.frame:SetHeight(self.itemFrame:GetHeight() + 34) -- see :AddItem |
| end |
| end |
| -- exported |
| local function GetRightBorderWidth(self) |
| return 6 + (self.slider:IsShown() and 12 or 0) |
| end |
| -- exported |
| local function GetLeftBorderWidth(self) |
| return 6 |
| end |
| --[[ Constructor ]]-- |
| local function Constructor() |
| local count = AceGUI:GetNextWidgetNum(widgetType) |
| local frame = CreateFrame("Frame", "AceGUI30Pullout"..count, UIParent) |
| local self = {} |
| self.count = count |
| self.type = widgetType |
| self.frame = frame |
| frame.obj = self |
| self.OnAcquire = OnAcquire |
| self.OnRelease = OnRelease |
| self.AddItem = AddItem |
| self.Open = Open |
| self.Close = Close |
| self.Clear = Clear |
| self.IterateItems = IterateItems |
| self.SetHideOnLeave = SetHideOnLeave |
| self.SetScroll = SetScroll |
| self.MoveScroll = MoveScroll |
| self.FixScroll = FixScroll |
| self.SetMaxHeight = SetMaxHeight |
| self.GetRightBorderWidth = GetRightBorderWidth |
| self.GetLeftBorderWidth = GetLeftBorderWidth |
| self.items = {} |
| self.scrollStatus = { |
| scrollvalue = 0, |
| } |
| self.maxHeight = defaultMaxHeight |
| frame:SetBackdrop(backdrop) |
| frame:SetBackdropColor(0, 0, 0) |
| frame:SetFrameStrata("FULLSCREEN_DIALOG") |
| frame:SetClampedToScreen(true) |
| frame:SetWidth(defaultWidth) |
| frame:SetHeight(self.maxHeight) |
| --frame:SetToplevel(true) |
| -- NOTE: The whole scroll frame code is copied from the AceGUI-3.0 widget ScrollFrame |
| local scrollFrame = CreateFrame("ScrollFrame", nil, frame) |
| local itemFrame = CreateFrame("Frame", nil, scrollFrame) |
| self.scrollFrame = scrollFrame |
| self.itemFrame = itemFrame |
| scrollFrame.obj = self |
| itemFrame.obj = self |
| local slider = CreateFrame("Slider", "AceGUI30PulloutScrollbar"..count, scrollFrame) |
| slider:SetOrientation("VERTICAL") |
| slider:SetHitRectInsets(0, 0, -10, 0) |
| slider:SetBackdrop(sliderBackdrop) |
| slider:SetWidth(8) |
| slider:SetThumbTexture("Interface\\Buttons\\UI-SliderBar-Button-Vertical") |
| slider:SetFrameStrata("FULLSCREEN_DIALOG") |
| self.slider = slider |
| slider.obj = self |
| scrollFrame:SetScrollChild(itemFrame) |
| scrollFrame:SetPoint("TOPLEFT", frame, "TOPLEFT", 6, -12) |
| scrollFrame:SetPoint("BOTTOMRIGHT", frame, "BOTTOMRIGHT", -6, 12) |
| scrollFrame:EnableMouseWheel(true) |
| scrollFrame:SetScript("OnMouseWheel", OnMouseWheel) |
| scrollFrame:SetScript("OnSizeChanged", OnSizeChanged) |
| scrollFrame:SetToplevel(true) |
| scrollFrame:SetFrameStrata("FULLSCREEN_DIALOG") |
| itemFrame:SetPoint("TOPLEFT", scrollFrame, "TOPLEFT", 0, 0) |
| itemFrame:SetPoint("TOPRIGHT", scrollFrame, "TOPRIGHT", -12, 0) |
| itemFrame:SetHeight(400) |
| itemFrame:SetToplevel(true) |
| itemFrame:SetFrameStrata("FULLSCREEN_DIALOG") |
| slider:SetPoint("TOPLEFT", scrollFrame, "TOPRIGHT", -16, 0) |
| slider:SetPoint("BOTTOMLEFT", scrollFrame, "BOTTOMRIGHT", -16, 0) |
| slider:SetScript("OnValueChanged", OnScrollValueChanged) |
| slider:SetMinMaxValues(0, 1000) |
| slider:SetValueStep(1) |
| slider:SetValue(0) |
| scrollFrame:Show() |
| itemFrame:Show() |
| slider:Hide() |
| self:FixScroll() |
| AceGUI:RegisterAsWidget(self) |
| return self |
| end |
| AceGUI:RegisterWidgetType(widgetType, Constructor, widgetVersion) |
| end |
| do |
| local widgetType = "Dropdown" |
| local widgetVersion = 22 |
| --[[ Static data ]]-- |
| --[[ UI event handler ]]-- |
| local function Control_OnEnter(this) |
| this.obj:Fire("OnEnter") |
| end |
| local function Control_OnLeave(this) |
| this.obj:Fire("OnLeave") |
| end |
| local function Dropdown_OnHide(this) |
| local self = this.obj |
| if self.open then |
| self.pullout:Close() |
| end |
| end |
| local function Dropdown_TogglePullout(this) |
| local self = this.obj |
| PlaySound("igMainMenuOptionCheckBoxOn") -- missleading name, but the Blizzard code uses this sound |
| if self.open then |
| self.open = nil |
| self.pullout:Close() |
| AceGUI:ClearFocus() |
| else |
| self.open = true |
| self.pullout:SetWidth(self.frame:GetWidth()) |
| self.pullout:Open("TOPLEFT", self.frame, "BOTTOMLEFT", 0, self.label:IsShown() and -2 or 0) |
| AceGUI:SetFocus(self) |
| end |
| end |
| local function OnPulloutOpen(this) |
| local self = this.userdata.obj |
| local value = self.value |
| if not self.multiselect then |
| for i, item in this:IterateItems() do |
| item:SetValue(item.userdata.value == value) |
| end |
| end |
| self.open = true |
| end |
| local function OnPulloutClose(this) |
| local self = this.userdata.obj |
| self.open = nil |
| self:Fire("OnClosed") |
| end |
| local function ShowMultiText(self) |
| local text |
| for i, widget in self.pullout:IterateItems() do |
| if widget.type == "Dropdown-Item-Toggle" then |
| if widget:GetValue() then |
| if text then |
| text = text..", "..widget:GetText() |
| else |
| text = widget:GetText() |
| end |
| end |
| end |
| end |
| self:SetText(text) |
| end |
| local function OnItemValueChanged(this, event, checked) |
| local self = this.userdata.obj |
| if self.multiselect then |
| self:Fire("OnValueChanged", this.userdata.value, checked) |
| ShowMultiText(self) |
| else |
| if checked then |
| self:SetValue(this.userdata.value) |
| self:Fire("OnValueChanged", this.userdata.value) |
| else |
| this:SetValue(true) |
| end |
| if self.open then |
| self.pullout:Close() |
| end |
| end |
| end |
| --[[ Exported methods ]]-- |
| -- exported, AceGUI callback |
| local function OnAcquire(self) |
| local pullout = AceGUI:Create("Dropdown-Pullout") |
| self.pullout = pullout |
| pullout.userdata.obj = self |
| pullout:SetCallback("OnClose", OnPulloutClose) |
| pullout:SetCallback("OnOpen", OnPulloutOpen) |
| self.pullout.frame:SetFrameLevel(self.frame:GetFrameLevel() + 1) |
| fixlevels(self.pullout.frame, self.pullout.frame:GetChildren()) |
| self:SetHeight(44) |
| self:SetWidth(200) |
| end |
| -- exported, AceGUI callback |
| local function OnRelease(self) |
| if self.open then |
| self.pullout:Close() |
| end |
| AceGUI:Release(self.pullout) |
| self.pullout = nil |
| self:SetText("") |
| self:SetLabel("") |
| self:SetDisabled(false) |
| self:SetMultiselect(false) |
| self.value = nil |
| self.list = nil |
| self.open = nil |
| self.hasClose = nil |
| self.frame:ClearAllPoints() |
| self.frame:Hide() |
| end |
| -- exported |
| local function SetDisabled(self, disabled) |
| self.disabled = disabled |
| if disabled then |
| self.text:SetTextColor(0.5,0.5,0.5) |
| self.button:Disable() |
| self.label:SetTextColor(0.5,0.5,0.5) |
| else |
| self.button:Enable() |
| self.label:SetTextColor(1,.82,0) |
| self.text:SetTextColor(1,1,1) |
| end |
| end |
| -- exported |
| local function ClearFocus(self) |
| if self.open then |
| self.pullout:Close() |
| end |
| end |
| -- exported |
| local function SetText(self, text) |
| self.text:SetText(text or "") |
| end |
| -- exported |
| local function SetLabel(self, text) |
| if text and text ~= "" then |
| self.label:SetText(text) |
| self.label:Show() |
| self.dropdown:SetPoint("TOPLEFT",self.frame,"TOPLEFT",-15,-18) |
| self.frame:SetHeight(44) |
| else |
| self.label:SetText("") |
| self.label:Hide() |
| self.dropdown:SetPoint("TOPLEFT",self.frame,"TOPLEFT",-15,0) |
| self.frame:SetHeight(26) |
| end |
| end |
| -- exported |
| local function SetValue(self, value) |
| if self.list then |
| self:SetText(self.list[value] or "") |
| end |
| self.value = value |
| end |
| -- exported |
| local function GetValue(self) |
| return self.value |
| end |
| -- exported |
| local function SetItemValue(self, item, value) |
| if not self.multiselect then return end |
| for i, widget in self.pullout:IterateItems() do |
| if widget.userdata.value == item then |
| if widget.SetValue then |
| widget:SetValue(value) |
| end |
| end |
| end |
| ShowMultiText(self) |
| end |
| -- exported |
| local function SetItemDisabled(self, item, disabled) |
| for i, widget in self.pullout:IterateItems() do |
| if widget.userdata.value == item then |
| widget:SetDisabled(disabled) |
| end |
| end |
| end |
| local function AddListItem(self, value, text) |
| local item = AceGUI:Create("Dropdown-Item-Toggle") |
| item:SetText(text) |
| item.userdata.obj = self |
| item.userdata.value = value |
| item:SetCallback("OnValueChanged", OnItemValueChanged) |
| self.pullout:AddItem(item) |
| end |
| local function AddCloseButton(self) |
| if not self.hasClose then |
| local close = AceGUI:Create("Dropdown-Item-Execute") |
| close:SetText(CLOSE) |
| self.pullout:AddItem(close) |
| self.hasClose = true |
| end |
| end |
| -- exported |
| local sortlist = {} |
| local function SetList(self, list) |
| self.list = list |
| self.pullout:Clear() |
| self.hasClose = nil |
| if not list then return end |
| for v in pairs(list) do |
| sortlist[#sortlist + 1] = v |
| end |
| tsort(sortlist) |
| for i, value in pairs(sortlist) do |
| AddListItem(self, value, list[value]) |
| sortlist[i] = nil |
| end |
| if self.multiselect then |
| ShowMultiText(self) |
| AddCloseButton(self) |
| end |
| end |
| -- exported |
| local function AddItem(self, value, text) |
| if self.list then |
| self.list[value] = text |
| AddListItem(self, value, text) |
| end |
| end |
| -- exported |
| local function SetMultiselect(self, multi) |
| self.multiselect = multi |
| if multi then |
| ShowMultiText(self) |
| AddCloseButton(self) |
| end |
| end |
| -- exported |
| local function GetMultiselect(self) |
| return self.multiselect |
| end |
| --[[ Constructor ]]-- |
| local function Constructor() |
| local count = AceGUI:GetNextWidgetNum(widgetType) |
| local frame = CreateFrame("Frame", nil, UIParent) |
| local dropdown = CreateFrame("Frame", "AceGUI30DropDown"..count, frame, "UIDropDownMenuTemplate") |
| local self = {} |
| self.type = widgetType |
| self.frame = frame |
| self.dropdown = dropdown |
| self.count = count |
| frame.obj = self |
| dropdown.obj = self |
| self.OnRelease = OnRelease |
| self.OnAcquire = OnAcquire |
| self.ClearFocus = ClearFocus |
| self.SetText = SetText |
| self.SetValue = SetValue |
| self.GetValue = GetValue |
| self.SetList = SetList |
| self.SetLabel = SetLabel |
| self.SetDisabled = SetDisabled |
| self.AddItem = AddItem |
| self.SetMultiselect = SetMultiselect |
| self.GetMultiselect = GetMultiselect |
| self.SetItemValue = SetItemValue |
| self.SetItemDisabled = SetItemDisabled |
| self.alignoffset = 31 |
| frame:SetHeight(44) |
| frame:SetWidth(200) |
| frame:SetScript("OnHide",Dropdown_OnHide) |
| dropdown:ClearAllPoints() |
| dropdown:SetPoint("TOPLEFT",frame,"TOPLEFT",-15,0) |
| dropdown:SetPoint("BOTTOMRIGHT",frame,"BOTTOMRIGHT",17,0) |
| dropdown:SetScript("OnHide", nil) |
| local left = _G[dropdown:GetName() .. "Left"] |
| local middle = _G[dropdown:GetName() .. "Middle"] |
| local right = _G[dropdown:GetName() .. "Right"] |
| middle:ClearAllPoints() |
| right:ClearAllPoints() |
| middle:SetPoint("LEFT", left, "RIGHT", 0, 0) |
| middle:SetPoint("RIGHT", right, "LEFT", 0, 0) |
| right:SetPoint("TOPRIGHT", dropdown, "TOPRIGHT", 0, 17) |
| local button = _G[dropdown:GetName() .. "Button"] |
| self.button = button |
| button.obj = self |
| button:SetScript("OnEnter",Control_OnEnter) |
| button:SetScript("OnLeave",Control_OnLeave) |
| button:SetScript("OnClick",Dropdown_TogglePullout) |
| local text = _G[dropdown:GetName() .. "Text"] |
| self.text = text |
| text.obj = self |
| text:ClearAllPoints() |
| text:SetPoint("RIGHT", right, "RIGHT" ,-43, 2) |
| text:SetPoint("LEFT", left, "LEFT", 25, 2) |
| local label = frame:CreateFontString(nil,"OVERLAY","GameFontNormalSmall") |
| label:SetPoint("TOPLEFT",frame,"TOPLEFT",0,0) |
| label:SetPoint("TOPRIGHT",frame,"TOPRIGHT",0,0) |
| label:SetJustifyH("LEFT") |
| label:SetHeight(18) |
| label:Hide() |
| self.label = label |
| AceGUI:RegisterAsWidget(self) |
| return self |
| end |
| AceGUI:RegisterWidgetType(widgetType, Constructor, widgetVersion) |
| end |
mRunes/Libs/AceGUI-3.0/widgets/AceGUIWidget-EditBox.lua
New file
0,0 → 1,232
| --[[----------------------------------------------------------------------------- |
| EditBox Widget |
| -------------------------------------------------------------------------------]] |
| local Type, Version = "EditBox", 23 |
| local AceGUI = LibStub and LibStub("AceGUI-3.0", true) |
| if not AceGUI or (AceGUI:GetWidgetVersion(Type) or 0) >= Version then return end |
| -- Lua APIs |
| local tostring, pairs = tostring, pairs |
| -- WoW APIs |
| local PlaySound = PlaySound |
| local GetCursorInfo, ClearCursor, GetSpellInfo = GetCursorInfo, ClearCursor, GetSpellInfo |
| local CreateFrame, UIParent = CreateFrame, UIParent |
| local _G = _G |
| -- Global vars/functions that we don't upvalue since they might get hooked, or upgraded |
| -- List them here for Mikk's FindGlobals script |
| -- GLOBALS: AceGUIEditBoxInsertLink, ChatFontNormal, OKAY |
| --[[----------------------------------------------------------------------------- |
| Support functions |
| -------------------------------------------------------------------------------]] |
| if not AceGUIEditBoxInsertLink then |
| -- upgradeable hook |
| hooksecurefunc("ChatEdit_InsertLink", function(...) return _G.AceGUIEditBoxInsertLink(...) end) |
| end |
| function _G.AceGUIEditBoxInsertLink(text) |
| for i = 1, AceGUI:GetWidgetCount(Type) do |
| local editbox = _G["AceGUI-3.0EditBox"..i] |
| if editbox and editbox:IsVisible() and editbox:HasFocus() then |
| editbox:Insert(text) |
| return true |
| end |
| end |
| end |
| local function ShowButton(self) |
| if not self.disablebutton then |
| self.button:Show() |
| self.editbox:SetTextInsets(0, 20, 3, 3) |
| end |
| end |
| local function HideButton(self) |
| self.button:Hide() |
| self.editbox:SetTextInsets(0, 0, 3, 3) |
| end |
| --[[----------------------------------------------------------------------------- |
| Scripts |
| -------------------------------------------------------------------------------]] |
| local function Control_OnEnter(frame) |
| frame.obj:Fire("OnEnter") |
| end |
| local function Control_OnLeave(frame) |
| frame.obj:Fire("OnLeave") |
| end |
| local function EditBox_OnEscapePressed(frame) |
| AceGUI:ClearFocus() |
| end |
| local function EditBox_OnEnterPressed(frame) |
| local self = frame.obj |
| local value = frame:GetText() |
| local cancel = self:Fire("OnEnterPressed", value) |
| if not cancel then |
| PlaySound("igMainMenuOptionCheckBoxOn") |
| HideButton(self) |
| end |
| end |
| local function EditBox_OnReceiveDrag(frame) |
| local self = frame.obj |
| local type, id, info = GetCursorInfo() |
| if type == "item" then |
| self:SetText(info) |
| self:Fire("OnEnterPressed", info) |
| ClearCursor() |
| elseif type == "spell" then |
| local name = GetSpellInfo(id, info) |
| self:SetText(name) |
| self:Fire("OnEnterPressed", name) |
| ClearCursor() |
| end |
| HideButton(self) |
| AceGUI:ClearFocus() |
| end |
| local function EditBox_OnTextChanged(frame) |
| local self = frame.obj |
| local value = frame:GetText() |
| if tostring(value) ~= tostring(self.lasttext) then |
| self:Fire("OnTextChanged", value) |
| self.lasttext = value |
| ShowButton(self) |
| end |
| end |
| local function Button_OnClick(frame) |
| local editbox = frame.obj.editbox |
| editbox:ClearFocus() |
| EditBox_OnEnterPressed(editbox) |
| end |
| --[[----------------------------------------------------------------------------- |
| Methods |
| -------------------------------------------------------------------------------]] |
| local methods = { |
| ["OnAcquire"] = function(self) |
| -- height is controlled by SetLabel |
| self:SetWidth(200) |
| self:SetDisabled(false) |
| self:SetLabel() |
| self:SetText() |
| self:DisableButton(false) |
| self:SetMaxLetters(0) |
| end, |
| -- ["OnRelease"] = nil, |
| ["SetDisabled"] = function(self, disabled) |
| self.disabled = disabled |
| if disabled then |
| self.editbox:EnableMouse(false) |
| self.editbox:ClearFocus() |
| self.editbox:SetTextColor(0.5,0.5,0.5) |
| self.label:SetTextColor(0.5,0.5,0.5) |
| else |
| self.editbox:EnableMouse(true) |
| self.editbox:SetTextColor(1,1,1) |
| self.label:SetTextColor(1,.82,0) |
| end |
| end, |
| ["SetText"] = function(self, text) |
| self.lasttext = text or "" |
| self.editbox:SetText(text or "") |
| self.editbox:SetCursorPosition(0) |
| HideButton(self) |
| end, |
| ["GetText"] = function(self, text) |
| return self.editbox:GetText() |
| end, |
| ["SetLabel"] = function(self, text) |
| if text and text ~= "" then |
| self.label:SetText(text) |
| self.label:Show() |
| self.editbox:SetPoint("TOPLEFT",self.frame,"TOPLEFT",7,-18) |
| self:SetHeight(44) |
| self.alignoffset = 30 |
| else |
| self.label:SetText("") |
| self.label:Hide() |
| self.editbox:SetPoint("TOPLEFT",self.frame,"TOPLEFT",7,0) |
| self:SetHeight(26) |
| self.alignoffset = 12 |
| end |
| end, |
| ["DisableButton"] = function(self, disabled) |
| self.disablebutton = disabled |
| if disabled then |
| HideButton(self) |
| end |
| end, |
| ["SetMaxLetters"] = function (self, num) |
| self.editbox:SetMaxLetters(num or 0) |
| end |
| } |
| --[[----------------------------------------------------------------------------- |
| Constructor |
| -------------------------------------------------------------------------------]] |
| local function Constructor() |
| local num = AceGUI:GetNextWidgetNum(Type) |
| local frame = CreateFrame("Frame", nil, UIParent) |
| frame:Hide() |
| local editbox = CreateFrame("EditBox", "AceGUI-3.0EditBox"..num, frame, "InputBoxTemplate") |
| editbox:SetAutoFocus(false) |
| editbox:SetFontObject(ChatFontNormal) |
| editbox:SetScript("OnEnter", Control_OnEnter) |
| editbox:SetScript("OnLeave", Control_OnLeave) |
| editbox:SetScript("OnEscapePressed", EditBox_OnEscapePressed) |
| editbox:SetScript("OnEnterPressed", EditBox_OnEnterPressed) |
| editbox:SetScript("OnTextChanged", EditBox_OnTextChanged) |
| editbox:SetScript("OnReceiveDrag", EditBox_OnReceiveDrag) |
| editbox:SetScript("OnMouseDown", EditBox_OnReceiveDrag) |
| editbox:SetTextInsets(0, 0, 3, 3) |
| editbox:SetMaxLetters(256) |
| editbox:SetPoint("BOTTOMLEFT", 6, 0) |
| editbox:SetPoint("BOTTOMRIGHT") |
| editbox:SetHeight(19) |
| local label = frame:CreateFontString(nil, "OVERLAY", "GameFontNormalSmall") |
| label:SetPoint("TOPLEFT", 0, -2) |
| label:SetPoint("TOPRIGHT", 0, -2) |
| label:SetJustifyH("LEFT") |
| label:SetHeight(18) |
| local button = CreateFrame("Button", nil, editbox, "UIPanelButtonTemplate") |
| button:SetWidth(40) |
| button:SetHeight(20) |
| button:SetPoint("RIGHT", -2, 0) |
| button:SetText(OKAY) |
| button:SetScript("OnClick", Button_OnClick) |
| button:Hide() |
| local widget = { |
| alignoffset = 30, |
| editbox = editbox, |
| label = label, |
| button = button, |
| frame = frame, |
| type = Type |
| } |
| for method, func in pairs(methods) do |
| widget[method] = func |
| end |
| editbox.obj, button.obj = widget, widget |
| return AceGUI:RegisterAsWidget(widget) |
| end |
| AceGUI:RegisterWidgetType(Type, Constructor, Version) |
mRunes/Libs/AceGUI-3.0/widgets/AceGUIWidget-Heading.lua
New file
0,0 → 1,78
| --[[----------------------------------------------------------------------------- |
| Heading Widget |
| -------------------------------------------------------------------------------]] |
| local Type, Version = "Heading", 20 |
| local AceGUI = LibStub and LibStub("AceGUI-3.0", true) |
| if not AceGUI or (AceGUI:GetWidgetVersion(Type) or 0) >= Version then return end |
| -- Lua APIs |
| local pairs = pairs |
| -- WoW APIs |
| local CreateFrame, UIParent = CreateFrame, UIParent |
| --[[----------------------------------------------------------------------------- |
| Methods |
| -------------------------------------------------------------------------------]] |
| local methods = { |
| ["OnAcquire"] = function(self) |
| self:SetText() |
| self:SetFullWidth() |
| self:SetHeight(18) |
| end, |
| -- ["OnRelease"] = nil, |
| ["SetText"] = function(self, text) |
| self.label:SetText(text or "") |
| if text and text ~= "" then |
| self.left:SetPoint("RIGHT", self.label, "LEFT", -5, 0) |
| self.right:Show() |
| else |
| self.left:SetPoint("RIGHT", -3, 0) |
| self.right:Hide() |
| end |
| end |
| } |
| --[[----------------------------------------------------------------------------- |
| Constructor |
| -------------------------------------------------------------------------------]] |
| local function Constructor() |
| local frame = CreateFrame("Frame", nil, UIParent) |
| frame:Hide() |
| local label = frame:CreateFontString(nil, "BACKGROUND", "GameFontNormal") |
| label:SetPoint("TOP") |
| label:SetPoint("BOTTOM") |
| label:SetJustifyH("CENTER") |
| local left = frame:CreateTexture(nil, "BACKGROUND") |
| left:SetHeight(8) |
| left:SetPoint("LEFT", 3, 0) |
| left:SetPoint("RIGHT", label, "LEFT", -5, 0) |
| left:SetTexture("Interface\\Tooltips\\UI-Tooltip-Border") |
| left:SetTexCoord(0.81, 0.94, 0.5, 1) |
| local right = frame:CreateTexture(nil, "BACKGROUND") |
| right:SetHeight(8) |
| right:SetPoint("RIGHT", -3, 0) |
| right:SetPoint("LEFT", label, "RIGHT", 5, 0) |
| right:SetTexture("Interface\\Tooltips\\UI-Tooltip-Border") |
| right:SetTexCoord(0.81, 0.94, 0.5, 1) |
| local widget = { |
| label = label, |
| left = left, |
| right = right, |
| frame = frame, |
| type = Type |
| } |
| for method, func in pairs(methods) do |
| widget[method] = func |
| end |
| return AceGUI:RegisterAsWidget(widget) |
| end |
| AceGUI:RegisterWidgetType(Type, Constructor, Version) |
mRunes/Libs/AceGUI-3.0/AceGUI-3.0.xml
New file
0,0 → 1,28
| <Ui xmlns="http://www.blizzard.com/wow/ui/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.blizzard.com/wow/ui/ |
| ..\FrameXML\UI.xsd"> |
| <Script file="AceGUI-3.0.lua"/> |
| <!-- Container --> |
| <Script file="widgets\AceGUIContainer-BlizOptionsGroup.lua"/> |
| <Script file="widgets\AceGUIContainer-DropDownGroup.lua"/> |
| <Script file="widgets\AceGUIContainer-Frame.lua"/> |
| <Script file="widgets\AceGUIContainer-InlineGroup.lua"/> |
| <Script file="widgets\AceGUIContainer-ScrollFrame.lua"/> |
| <Script file="widgets\AceGUIContainer-SimpleGroup.lua"/> |
| <Script file="widgets\AceGUIContainer-TabGroup.lua"/> |
| <Script file="widgets\AceGUIContainer-TreeGroup.lua"/> |
| <Script file="widgets\AceGUIContainer-Window.lua"/> |
| <!-- Widgets --> |
| <Script file="widgets\AceGUIWidget-Button.lua"/> |
| <Script file="widgets\AceGUIWidget-CheckBox.lua"/> |
| <Script file="widgets\AceGUIWidget-ColorPicker.lua"/> |
| <Script file="widgets\AceGUIWidget-DropDown.lua"/> |
| <Script file="widgets\AceGUIWidget-DropDown-Items.lua"/> |
| <Script file="widgets\AceGUIWidget-EditBox.lua"/> |
| <Script file="widgets\AceGUIWidget-Heading.lua"/> |
| <Script file="widgets\AceGUIWidget-Icon.lua"/> |
| <Script file="widgets\AceGUIWidget-InteractiveLabel.lua"/> |
| <Script file="widgets\AceGUIWidget-Keybinding.lua"/> |
| <Script file="widgets\AceGUIWidget-Label.lua"/> |
| <Script file="widgets\AceGUIWidget-MultiLineEditBox.lua"/> |
| <Script file="widgets\AceGUIWidget-Slider.lua"/> |
| </Ui> |
mRunes/Libs/AceGUI-3.0/AceGUI-3.0.lua
New file
0,0 → 1,805
| --- **AceGUI-3.0** provides access to numerous widgets which can be used to create GUIs. |
| -- AceGUI is used by AceConfigDialog to create the option GUIs, but you can use it by itself |
| -- to create any custom GUI. There are more extensive examples in the test suite in the Ace3 |
| -- stand-alone distribution. |
| -- |
| -- **Note**: When using AceGUI-3.0 directly, please do not modify the frames of the widgets directly, |
| -- as any "unknown" change to the widgets will cause addons that get your widget out of the widget pool |
| -- to misbehave. If you think some part of a widget should be modifiable, please open a ticket, and we"ll |
| -- implement a proper API to modify it. |
| -- @usage |
| -- local AceGUI = LibStub("AceGUI-3.0") |
| -- -- Create a container frame |
| -- local f = AceGUI:Create("Frame") |
| -- f:SetCallback("OnClose",function(widget) AceGUI:Release(widget) end) |
| -- f:SetTitle("AceGUI-3.0 Example") |
| -- f:SetStatusText("Status Bar") |
| -- f:SetLayout("Flow") |
| -- -- Create a button |
| -- local btn = AceGUI:Create("Button") |
| -- btn:SetWidth(170) |
| -- btn:SetText("Button !") |
| -- btn:SetCallback("OnClick", function() print("Click!") end) |
| -- -- Add the button to the container |
| -- f:AddChild(btn) |
| -- @class file |
| -- @name AceGUI-3.0 |
| -- @release $Id: AceGUI-3.0.lua 924 2010-05-13 15:12:20Z nevcairiel $ |
| local ACEGUI_MAJOR, ACEGUI_MINOR = "AceGUI-3.0", 33 |
| local AceGUI, oldminor = LibStub:NewLibrary(ACEGUI_MAJOR, ACEGUI_MINOR) |
| if not AceGUI then return end -- No upgrade needed |
| -- Lua APIs |
| local tconcat, tremove, tinsert = table.concat, table.remove, table.insert |
| local select, pairs, next, type = select, pairs, next, type |
| local error, assert, loadstring = error, assert, loadstring |
| local setmetatable, rawget, rawset = setmetatable, rawget, rawset |
| local math_max = math.max |
| -- WoW APIs |
| local UIParent = UIParent |
| -- Global vars/functions that we don't upvalue since they might get hooked, or upgraded |
| -- List them here for Mikk's FindGlobals script |
| -- GLOBALS: geterrorhandler, LibStub |
| --local con = LibStub("AceConsole-3.0",true) |
| AceGUI.WidgetRegistry = AceGUI.WidgetRegistry or {} |
| AceGUI.LayoutRegistry = AceGUI.LayoutRegistry or {} |
| AceGUI.WidgetBase = AceGUI.WidgetBase or {} |
| AceGUI.WidgetContainerBase = AceGUI.WidgetContainerBase or {} |
| AceGUI.WidgetVersions = AceGUI.WidgetVersions or {} |
| -- local upvalues |
| local WidgetRegistry = AceGUI.WidgetRegistry |
| local LayoutRegistry = AceGUI.LayoutRegistry |
| local WidgetVersions = AceGUI.WidgetVersions |
| --[[ |
| xpcall safecall implementation |
| ]] |
| local xpcall = xpcall |
| local function errorhandler(err) |
| return geterrorhandler()(err) |
| end |
| local function CreateDispatcher(argCount) |
| local code = [[ |
| local xpcall, eh = ... |
| local method, ARGS |
| local function call() return method(ARGS) end |
| local function dispatch(func, ...) |
| method = func |
| if not method then return end |
| ARGS = ... |
| return xpcall(call, eh) |
| end |
| return dispatch |
| ]] |
| local ARGS = {} |
| for i = 1, argCount do ARGS[i] = "arg"..i end |
| code = code:gsub("ARGS", tconcat(ARGS, ", ")) |
| return assert(loadstring(code, "safecall Dispatcher["..argCount.."]"))(xpcall, errorhandler) |
| end |
| local Dispatchers = setmetatable({}, {__index=function(self, argCount) |
| local dispatcher = CreateDispatcher(argCount) |
| rawset(self, argCount, dispatcher) |
| return dispatcher |
| end}) |
| Dispatchers[0] = function(func) |
| return xpcall(func, errorhandler) |
| end |
| local function safecall(func, ...) |
| return Dispatchers[select("#", ...)](func, ...) |
| end |
| -- Recycling functions |
| local newWidget, delWidget |
| do |
| -- Version Upgrade in Minor 29 |
| -- Internal Storage of the objects changed, from an array table |
| -- to a hash table, and additionally we introduced versioning on |
| -- the widgets which would discard all widgets from a pre-29 version |
| -- anyway, so we just clear the storage now, and don't try to |
| -- convert the storage tables to the new format. |
| -- This should generally not cause *many* widgets to end up in trash, |
| -- since once dialogs are opened, all addons should be loaded already |
| -- and AceGUI should be on the latest version available on the users |
| -- setup. |
| -- -- nevcairiel - Nov 2nd, 2009 |
| if oldminor and oldminor < 29 and AceGUI.objPools then |
| AceGUI.objPools = nil |
| end |
| AceGUI.objPools = AceGUI.objPools or {} |
| local objPools = AceGUI.objPools |
| --Returns a new instance, if none are available either returns a new table or calls the given contructor |
| function newWidget(type) |
| if not WidgetRegistry[type] then |
| error("Attempt to instantiate unknown widget type", 2) |
| end |
| if not objPools[type] then |
| objPools[type] = {} |
| end |
| local newObj = next(objPools[type]) |
| if not newObj then |
| newObj = WidgetRegistry[type]() |
| newObj.AceGUIWidgetVersion = WidgetVersions[type] |
| else |
| objPools[type][newObj] = nil |
| -- if the widget is older then the latest, don't even try to reuse it |
| -- just forget about it, and grab a new one. |
| if not newObj.AceGUIWidgetVersion or newObj.AceGUIWidgetVersion < WidgetVersions[type] then |
| return newWidget(type) |
| end |
| end |
| return newObj |
| end |
| -- Releases an instance to the Pool |
| function delWidget(obj,type) |
| if not objPools[type] then |
| objPools[type] = {} |
| end |
| if objPools[type][obj] then |
| error("Attempt to Release Widget that is already released", 2) |
| end |
| objPools[type][obj] = true |
| end |
| end |
| ------------------- |
| -- API Functions -- |
| ------------------- |
| -- Gets a widget Object |
| --- Create a new Widget of the given type. |
| -- This function will instantiate a new widget (or use one from the widget pool), and call the |
| -- OnAcquire function on it, before returning. |
| -- @param type The type of the widget. |
| -- @return The newly created widget. |
| function AceGUI:Create(type) |
| if WidgetRegistry[type] then |
| local widget = newWidget(type) |
| if rawget(widget, "Acquire") then |
| widget.OnAcquire = widget.Acquire |
| widget.Acquire = nil |
| elseif rawget(widget, "Aquire") then |
| widget.OnAcquire = widget.Aquire |
| widget.Aquire = nil |
| end |
| if rawget(widget, "Release") then |
| widget.OnRelease = rawget(widget, "Release") |
| widget.Release = nil |
| end |
| if widget.OnAcquire then |
| widget:OnAcquire() |
| else |
| error(("Widget type %s doesn't supply an OnAcquire Function"):format(type)) |
| end |
| -- Set the default Layout ("List") |
| safecall(widget.SetLayout, widget, "List") |
| safecall(widget.ResumeLayout, widget) |
| return widget |
| end |
| end |
| --- Releases a widget Object. |
| -- This function calls OnRelease on the widget and places it back in the widget pool. |
| -- Any data on the widget is being erased, and the widget will be hidden.\\ |
| -- If this widget is a Container-Widget, all of its Child-Widgets will be releases as well. |
| -- @param widget The widget to release |
| function AceGUI:Release(widget) |
| safecall(widget.PauseLayout, widget) |
| widget:Fire("OnRelease") |
| safecall(widget.ReleaseChildren, widget) |
| if widget.OnRelease then |
| widget:OnRelease() |
| -- else |
| -- error(("Widget type %s doesn't supply an OnRelease Function"):format(widget.type)) |
| end |
| for k in pairs(widget.userdata) do |
| widget.userdata[k] = nil |
| end |
| for k in pairs(widget.events) do |
| widget.events[k] = nil |
| end |
| widget.width = nil |
| widget.relWidth = nil |
| widget.height = nil |
| widget.relHeight = nil |
| widget.noAutoHeight = nil |
| widget.frame:ClearAllPoints() |
| widget.frame:Hide() |
| widget.frame:SetParent(UIParent) |
| widget.frame.width = nil |
| widget.frame.height = nil |
| if widget.content then |
| widget.content.width = nil |
| widget.content.height = nil |
| end |
| delWidget(widget, widget.type) |
| end |
| ----------- |
| -- Focus -- |
| ----------- |
| --- Called when a widget has taken focus. |
| -- e.g. Dropdowns opening, Editboxes gaining kb focus |
| -- @param widget The widget that should be focused |
| function AceGUI:SetFocus(widget) |
| if self.FocusedWidget and self.FocusedWidget ~= widget then |
| safecall(self.FocusedWidget.ClearFocus, self.FocusedWidget) |
| end |
| self.FocusedWidget = widget |
| end |
| --- Called when something has happened that could cause widgets with focus to drop it |
| -- e.g. titlebar of a frame being clicked |
| function AceGUI:ClearFocus() |
| if self.FocusedWidget then |
| safecall(self.FocusedWidget.ClearFocus, self.FocusedWidget) |
| self.FocusedWidget = nil |
| end |
| end |
| ------------- |
| -- Widgets -- |
| ------------- |
| --[[ |
| Widgets must provide the following functions |
| OnAcquire() - Called when the object is acquired, should set everything to a default hidden state |
| And the following members |
| frame - the frame or derivitive object that will be treated as the widget for size and anchoring purposes |
| type - the type of the object, same as the name given to :RegisterWidget() |
| Widgets contain a table called userdata, this is a safe place to store data associated with the wigdet |
| It will be cleared automatically when a widget is released |
| Placing values directly into a widget object should be avoided |
| If the Widget can act as a container for other Widgets the following |
| content - frame or derivitive that children will be anchored to |
| The Widget can supply the following Optional Members |
| :OnRelease() - Called when the object is Released, should remove any additional anchors and clear any data |
| :OnWidthSet(width) - Called when the width of the widget is changed |
| :OnHeightSet(height) - Called when the height of the widget is changed |
| Widgets should not use the OnSizeChanged events of thier frame or content members, use these methods instead |
| AceGUI already sets a handler to the event |
| :LayoutFinished(width, height) - called after a layout has finished, the width and height will be the width and height of the |
| area used for controls. These can be nil if the layout used the existing size to layout the controls. |
| ]] |
| -------------------------- |
| -- Widget Base Template -- |
| -------------------------- |
| do |
| local WidgetBase = AceGUI.WidgetBase |
| WidgetBase.SetParent = function(self, parent) |
| local frame = self.frame |
| frame:SetParent(nil) |
| frame:SetParent(parent.content) |
| self.parent = parent |
| end |
| WidgetBase.SetCallback = function(self, name, func) |
| if type(func) == "function" then |
| self.events[name] = func |
| end |
| end |
| WidgetBase.Fire = function(self, name, ...) |
| if self.events[name] then |
| local success, ret = safecall(self.events[name], self, name, ...) |
| if success then |
| return ret |
| end |
| end |
| end |
| WidgetBase.SetWidth = function(self, width) |
| self.frame:SetWidth(width) |
| self.frame.width = width |
| if self.OnWidthSet then |
| self:OnWidthSet(width) |
| end |
| end |
| WidgetBase.SetRelativeWidth = function(self, width) |
| if width <= 0 or width > 1 then |
| error(":SetRelativeWidth(width): Invalid relative width.", 2) |
| end |
| self.relWidth = width |
| self.width = "relative" |
| end |
| WidgetBase.SetHeight = function(self, height) |
| self.frame:SetHeight(height) |
| self.frame.height = height |
| if self.OnHeightSet then |
| self:OnHeightSet(height) |
| end |
| end |
| --[[ WidgetBase.SetRelativeHeight = function(self, height) |
| if height <= 0 or height > 1 then |
| error(":SetRelativeHeight(height): Invalid relative height.", 2) |
| end |
| self.relHeight = height |
| self.height = "relative" |
| end ]] |
| WidgetBase.IsVisible = function(self) |
| return self.frame:IsVisible() |
| end |
| WidgetBase.IsShown= function(self) |
| return self.frame:IsShown() |
| end |
| WidgetBase.Release = function(self) |
| AceGUI:Release(self) |
| end |
| WidgetBase.SetPoint = function(self, ...) |
| return self.frame:SetPoint(...) |
| end |
| WidgetBase.ClearAllPoints = function(self) |
| return self.frame:ClearAllPoints() |
| end |
| WidgetBase.GetNumPoints = function(self) |
| return self.frame:GetNumPoints() |
| end |
| WidgetBase.GetPoint = function(self, ...) |
| return self.frame:GetPoint(...) |
| end |
| WidgetBase.GetUserDataTable = function(self) |
| return self.userdata |
| end |
| WidgetBase.SetUserData = function(self, key, value) |
| self.userdata[key] = value |
| end |
| WidgetBase.GetUserData = function(self, key) |
| return self.userdata[key] |
| end |
| WidgetBase.IsFullHeight = function(self) |
| return self.height == "fill" |
| end |
| WidgetBase.SetFullHeight = function(self, isFull) |
| if isFull then |
| self.height = "fill" |
| else |
| self.height = nil |
| end |
| end |
| WidgetBase.IsFullWidth = function(self) |
| return self.width == "fill" |
| end |
| WidgetBase.SetFullWidth = function(self, isFull) |
| if isFull then |
| self.width = "fill" |
| else |
| self.width = nil |
| end |
| end |
| -- local function LayoutOnUpdate(this) |
| -- this:SetScript("OnUpdate",nil) |
| -- this.obj:PerformLayout() |
| -- end |
| local WidgetContainerBase = AceGUI.WidgetContainerBase |
| WidgetContainerBase.PauseLayout = function(self) |
| self.LayoutPaused = true |
| end |
| WidgetContainerBase.ResumeLayout = function(self) |
| self.LayoutPaused = nil |
| end |
| WidgetContainerBase.PerformLayout = function(self) |
| if self.LayoutPaused then |
| return |
| end |
| safecall(self.LayoutFunc, self.content, self.children) |
| end |
| --call this function to layout, makes sure layed out objects get a frame to get sizes etc |
| WidgetContainerBase.DoLayout = function(self) |
| self:PerformLayout() |
| -- if not self.parent then |
| -- self.frame:SetScript("OnUpdate", LayoutOnUpdate) |
| -- end |
| end |
| WidgetContainerBase.AddChild = function(self, child, beforeWidget) |
| if beforeWidget then |
| local siblingIndex = 1 |
| for _, widget in pairs(self.children) do |
| if widget == beforeWidget then |
| break |
| end |
| siblingIndex = siblingIndex + 1 |
| end |
| tinsert(self.children, siblingIndex, child) |
| else |
| tinsert(self.children, child) |
| end |
| child:SetParent(self) |
| child.frame:Show() |
| self:DoLayout() |
| end |
| WidgetContainerBase.AddChildren = function(self, ...) |
| for i = 1, select("#", ...) do |
| local child = select(i, ...) |
| tinsert(self.children, child) |
| child:SetParent(self) |
| child.frame:Show() |
| end |
| self:DoLayout() |
| end |
| WidgetContainerBase.ReleaseChildren = function(self) |
| local children = self.children |
| for i = 1,#children do |
| AceGUI:Release(children[i]) |
| children[i] = nil |
| end |
| end |
| WidgetContainerBase.SetLayout = function(self, Layout) |
| self.LayoutFunc = AceGUI:GetLayout(Layout) |
| end |
| WidgetContainerBase.SetAutoAdjustHeight = function(self, adjust) |
| if adjust then |
| self.noAutoHeight = nil |
| else |
| self.noAutoHeight = true |
| end |
| end |
| local function FrameResize(this) |
| local self = this.obj |
| if this:GetWidth() and this:GetHeight() then |
| if self.OnWidthSet then |
| self:OnWidthSet(this:GetWidth()) |
| end |
| if self.OnHeightSet then |
| self:OnHeightSet(this:GetHeight()) |
| end |
| end |
| end |
| local function ContentResize(this) |
| if this:GetWidth() and this:GetHeight() then |
| this.width = this:GetWidth() |
| this.height = this:GetHeight() |
| this.obj:DoLayout() |
| end |
| end |
| setmetatable(WidgetContainerBase, {__index=WidgetBase}) |
| --One of these function should be called on each Widget Instance as part of its creation process |
| --- Register a widget-class as a container for newly created widgets. |
| -- @param widget The widget class |
| function AceGUI:RegisterAsContainer(widget) |
| widget.children = {} |
| widget.userdata = {} |
| widget.events = {} |
| widget.base = WidgetContainerBase |
| widget.content.obj = widget |
| widget.frame.obj = widget |
| widget.content:SetScript("OnSizeChanged", ContentResize) |
| widget.frame:SetScript("OnSizeChanged", FrameResize) |
| setmetatable(widget, {__index = WidgetContainerBase}) |
| widget:SetLayout("List") |
| return widget |
| end |
| --- Register a widget-class as a widget. |
| -- @param widget The widget class |
| function AceGUI:RegisterAsWidget(widget) |
| widget.userdata = {} |
| widget.events = {} |
| widget.base = WidgetBase |
| widget.frame.obj = widget |
| widget.frame:SetScript("OnSizeChanged", FrameResize) |
| setmetatable(widget, {__index = WidgetBase}) |
| return widget |
| end |
| end |
| ------------------ |
| -- Widget API -- |
| ------------------ |
| --- Registers a widget Constructor, this function returns a new instance of the Widget |
| -- @param Name The name of the widget |
| -- @param Constructor The widget constructor function |
| -- @param Version The version of the widget |
| function AceGUI:RegisterWidgetType(Name, Constructor, Version) |
| assert(type(Constructor) == "function") |
| assert(type(Version) == "number") |
| local oldVersion = WidgetVersions[Name] |
| if oldVersion and oldVersion >= Version then return end |
| WidgetVersions[Name] = Version |
| WidgetRegistry[Name] = Constructor |
| end |
| --- Registers a Layout Function |
| -- @param Name The name of the layout |
| -- @param LayoutFunc Reference to the layout function |
| function AceGUI:RegisterLayout(Name, LayoutFunc) |
| assert(type(LayoutFunc) == "function") |
| if type(Name) == "string" then |
| Name = Name:upper() |
| end |
| LayoutRegistry[Name] = LayoutFunc |
| end |
| --- Get a Layout Function from the registry |
| -- @param Name The name of the layout |
| function AceGUI:GetLayout(Name) |
| if type(Name) == "string" then |
| Name = Name:upper() |
| end |
| return LayoutRegistry[Name] |
| end |
| AceGUI.counts = AceGUI.counts or {} |
| --- A type-based counter to count the number of widgets created. |
| -- This is used by widgets that require a named frame, e.g. when a Blizzard |
| -- Template requires it. |
| -- @param type The widget type |
| function AceGUI:GetNextWidgetNum(type) |
| if not self.counts[type] then |
| self.counts[type] = 0 |
| end |
| self.counts[type] = self.counts[type] + 1 |
| return self.counts[type] |
| end |
| --- Return the number of created widgets for this type. |
| -- In contrast to GetNextWidgetNum, the number is not incremented. |
| -- @param type The widget type |
| function AceGUI:GetWidgetCount(type) |
| return self.counts[type] or 0 |
| end |
| --- Return the version of the currently registered widget type. |
| -- @param type The widget type |
| function AceGUI:GetWidgetVersion(type) |
| return WidgetVersions[type] |
| end |
| ------------- |
| -- Layouts -- |
| ------------- |
| --[[ |
| A Layout is a func that takes 2 parameters |
| content - the frame that widgets will be placed inside |
| children - a table containing the widgets to layout |
| ]] |
| -- Very simple Layout, Children are stacked on top of each other down the left side |
| AceGUI:RegisterLayout("List", |
| function(content, children) |
| local height = 0 |
| local width = content.width or content:GetWidth() or 0 |
| for i = 1, #children do |
| local child = children[i] |
| local frame = child.frame |
| frame:ClearAllPoints() |
| frame:Show() |
| if i == 1 then |
| frame:SetPoint("TOPLEFT", content) |
| else |
| frame:SetPoint("TOPLEFT", children[i-1].frame, "BOTTOMLEFT") |
| end |
| if child.width == "fill" then |
| child:SetWidth(width) |
| frame:SetPoint("RIGHT", content) |
| if child.DoLayout then |
| child:DoLayout() |
| end |
| elseif child.width == "relative" then |
| child:SetWidth(width * child.relWidth) |
| if child.DoLayout then |
| child:DoLayout() |
| end |
| end |
| height = height + (frame.height or frame:GetHeight() or 0) |
| end |
| safecall(content.obj.LayoutFinished, content.obj, nil, height) |
| end) |
| -- A single control fills the whole content area |
| AceGUI:RegisterLayout("Fill", |
| function(content, children) |
| if children[1] then |
| children[1]:SetWidth(content:GetWidth() or 0) |
| children[1]:SetHeight(content:GetHeight() or 0) |
| children[1].frame:SetAllPoints(content) |
| children[1].frame:Show() |
| safecall(content.obj.LayoutFinished, content.obj, nil, children[1].frame:GetHeight()) |
| end |
| end) |
| AceGUI:RegisterLayout("Flow", |
| function(content, children) |
| --used height so far |
| local height = 0 |
| --width used in the current row |
| local usedwidth = 0 |
| --height of the current row |
| local rowheight = 0 |
| local rowoffset = 0 |
| local lastrowoffset |
| local width = content.width or content:GetWidth() or 0 |
| --control at the start of the row |
| local rowstart |
| local rowstartoffset |
| local lastrowstart |
| local isfullheight |
| local frameoffset |
| local lastframeoffset |
| local oversize |
| for i = 1, #children do |
| local child = children[i] |
| oversize = nil |
| local frame = child.frame |
| local frameheight = frame.height or frame:GetHeight() or 0 |
| local framewidth = frame.width or frame:GetWidth() or 0 |
| lastframeoffset = frameoffset |
| -- HACK: Why did we set a frameoffset of (frameheight / 2) ? |
| -- That was moving all widgets half the widgets size down, is that intended? |
| -- Actually, it seems to be neccessary for many cases, we'll leave it in for now. |
| -- If widgets seem to anchor weirdly with this, provide a valid alignoffset for them. |
| -- TODO: Investigate moar! |
| frameoffset = child.alignoffset or (frameheight / 2) |
| if child.width == "relative" then |
| framewidth = width * child.relWidth |
| end |
| frame:Show() |
| frame:ClearAllPoints() |
| if i == 1 then |
| -- anchor the first control to the top left |
| frame:SetPoint("TOPLEFT", content) |
| rowheight = frameheight |
| rowoffset = frameoffset |
| rowstart = frame |
| rowstartoffset = frameoffset |
| usedwidth = framewidth |
| if usedwidth > width then |
| oversize = true |
| end |
| else |
| -- if there isn't available width for the control start a new row |
| -- if a control is "fill" it will be on a row of its own full width |
| if usedwidth == 0 or ((framewidth) + usedwidth > width) or child.width == "fill" then |
| if isfullheight then |
| -- a previous row has already filled the entire height, there's nothing we can usefully do anymore |
| -- (maybe error/warn about this?) |
| break |
| end |
| --anchor the previous row, we will now know its height and offset |
| rowstart:SetPoint("TOPLEFT", content, "TOPLEFT", 0, -(height + (rowoffset - rowstartoffset) + 3)) |
| height = height + rowheight + 3 |
| --save this as the rowstart so we can anchor it after the row is complete and we have the max height and offset of controls in it |
| rowstart = frame |
| rowstartoffset = frameoffset |
| rowheight = frameheight |
| rowoffset = frameoffset |
| usedwidth = framewidth |
| if usedwidth > width then |
| oversize = true |
| end |
| -- put the control on the current row, adding it to the width and checking if the height needs to be increased |
| else |
| --handles cases where the new height is higher than either control because of the offsets |
| --math.max(rowheight-rowoffset+frameoffset, frameheight-frameoffset+rowoffset) |
| --offset is always the larger of the two offsets |
| rowoffset = math_max(rowoffset, frameoffset) |
| rowheight = math_max(rowheight, rowoffset + (frameheight / 2)) |
| frame:SetPoint("TOPLEFT", children[i-1].frame, "TOPRIGHT", 0, frameoffset - lastframeoffset) |
| usedwidth = framewidth + usedwidth |
| end |
| end |
| if child.width == "fill" then |
| child:SetWidth(width) |
| frame:SetPoint("RIGHT", content) |
| usedwidth = 0 |
| rowstart = frame |
| rowstartoffset = frameoffset |
| if child.DoLayout then |
| child:DoLayout() |
| end |
| rowheight = frame.height or frame:GetHeight() or 0 |
| rowoffset = child.alignoffset or (rowheight / 2) |
| rowstartoffset = rowoffset |
| elseif child.width == "relative" then |
| child:SetWidth(width * child.relWidth) |
| if child.DoLayout then |
| child:DoLayout() |
| end |
| elseif oversize then |
| if width > 1 then |
| frame:SetPoint("RIGHT", content) |
| end |
| end |
| if child.height == "fill" then |
| frame:SetPoint("BOTTOM", content) |
| isfullheight = true |
| end |
| end |
| --anchor the last row, if its full height needs a special case since its height has just been changed by the anchor |
| if isfullheight then |
| rowstart:SetPoint("TOPLEFT", content, "TOPLEFT", 0, -height) |
| elseif rowstart then |
| rowstart:SetPoint("TOPLEFT", content, "TOPLEFT", 0, -(height + (rowoffset - rowstartoffset) + 3)) |
| end |
| height = height + rowheight + 3 |
| safecall(content.obj.LayoutFinished, content.obj, nil, height) |
| end) |
mRunes/Libs/LibSharedMedia-3.0/lib.xml
New file
0,0 → 1,4
\ No newline at end of file
| <Ui xmlns="http://www.blizzard.com/wow/ui/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.blizzard.com/wow/ui/ |
| ..\FrameXML\UI.xsd"> |
| <Script file="LibSharedMedia-3.0.lua" /> |
| </Ui> |
mRunes/Libs/LibSharedMedia-3.0/LibSharedMedia-3.0.lua
New file
0,0 → 1,235
| --[[ |
| Name: LibSharedMedia-3.0 |
| Revision: $Revision: 62 $ |
| Author: Elkano (elkano@gmx.de) |
| Inspired By: SurfaceLib by Haste/Otravi (troeks@gmail.com) |
| Website: http://www.wowace.com/projects/libsharedmedia-3-0/ |
| Description: Shared handling of media data (fonts, sounds, textures, ...) between addons. |
| Dependencies: LibStub, CallbackHandler-1.0 |
| License: LGPL v2.1 |
| ]] |
| local MAJOR, MINOR = "LibSharedMedia-3.0", 100001 -- increase manualy on changes |
| local lib = LibStub:NewLibrary(MAJOR, MINOR) |
| if not lib then return end |
| local _G = getfenv(0) |
| local pairs = _G.pairs |
| local type = _G.type |
| local band = _G.bit.band |
| local table_insert = _G.table.insert |
| local table_sort = _G.table.sort |
| local locale = GetLocale() |
| local locale_is_western |
| local LOCALE_MASK = 0 |
| lib.LOCALE_BIT_koKR = 1 |
| lib.LOCALE_BIT_ruRU = 2 |
| lib.LOCALE_BIT_zhCN = 4 |
| lib.LOCALE_BIT_zhTW = 8 |
| lib.LOCALE_BIT_western = 128 |
| local CallbackHandler = LibStub:GetLibrary("CallbackHandler-1.0") |
| lib.callbacks = lib.callbacks or CallbackHandler:New(lib) |
| lib.DefaultMedia = lib.DefaultMedia or {} |
| lib.MediaList = lib.MediaList or {} |
| lib.MediaTable = lib.MediaTable or {} |
| lib.MediaType = lib.MediaType or {} |
| lib.OverrideMedia = lib.OverrideMedia or {} |
| local defaultMedia = lib.DefaultMedia |
| local mediaList = lib.MediaList |
| local mediaTable = lib.MediaTable |
| local overrideMedia = lib.OverrideMedia |
| -- create mediatype constants |
| lib.MediaType.BACKGROUND = "background" -- background textures |
| lib.MediaType.BORDER = "border" -- border textures |
| lib.MediaType.FONT = "font" -- fonts |
| lib.MediaType.STATUSBAR = "statusbar" -- statusbar textures |
| lib.MediaType.SOUND = "sound" -- sound files |
| -- populate lib with default Blizzard data |
| -- BACKGROUND |
| if not lib.MediaTable.background then lib.MediaTable.background = {} end |
| lib.MediaTable.background["Blizzard Dialog Background"] = [[Interface\DialogFrame\UI-DialogBox-Background]] |
| lib.MediaTable.background["Blizzard Dialog Background Dark"] = [[Interface\DialogFrame\UI-DialogBox-Background-Dark]] |
| lib.MediaTable.background["Blizzard Dialog Background Gold"] = [[Interface\DialogFrame\UI-DialogBox-Gold-Background]] |
| lib.MediaTable.background["Blizzard Low Health"] = [[Interface\FullScreenTextures\LowHealth]] |
| lib.MediaTable.background["Blizzard Marble"] = [[Interface\FrameGeneral\UI-Background-Marble]] |
| lib.MediaTable.background["Blizzard Out of Control"] = [[Interface\FullScreenTextures\OutOfControl]] |
| lib.MediaTable.background["Blizzard Parchment"] = [[Interface\AchievementFrame\UI-Achievement-Parchment-Horizontal]] |
| lib.MediaTable.background["Blizzard Parchment 2"] = [[Interface\AchievementFrame\UI-GuildAchievement-Parchment-Horizontal]] |
| lib.MediaTable.background["Blizzard Rock"] = [[Interface\FrameGeneral\UI-Background-Rock]] |
| lib.MediaTable.background["Blizzard Tabard Background"] = [[Interface\TabardFrame\TabardFrameBackground]] |
| lib.MediaTable.background["Blizzard Tooltip"] = [[Interface\Tooltips\UI-Tooltip-Background]] |
| lib.MediaTable.background["Solid"] = [[Interface\Buttons\WHITE8X8]] |
| -- BORDER |
| if not lib.MediaTable.border then lib.MediaTable.border = {} end |
| lib.MediaTable.border["None"] = [[Interface\None]] |
| lib.MediaTable.border["Blizzard Achievement Wood"] = [[Interface\AchievementFrame\UI-Achievement-WoodBorder]] |
| lib.MediaTable.border["Blizzard Chat Bubble"] = [[Interface\Tooltips\ChatBubble-Backdrop]] |
| lib.MediaTable.border["Blizzard Dialog"] = [[Interface\DialogFrame\UI-DialogBox-Border]] |
| lib.MediaTable.border["Blizzard Dialog Gold"] = [[Interface\DialogFrame\UI-DialogBox-Gold-Border]] |
| lib.MediaTable.border["Blizzard Party"] = [[Interface\CHARACTERFRAME\UI-Party-Border]] |
| lib.MediaTable.border["Blizzard Tooltip"] = [[Interface\Tooltips\UI-Tooltip-Border]] |
| -- FONT |
| if not lib.MediaTable.font then lib.MediaTable.font = {} end |
| local SML_MT_font = lib.MediaTable.font |
| if locale == "koKR" then |
| LOCALE_MASK = lib.LOCALE_BIT_koKR |
| -- |
| SML_MT_font["êµµì ê¸ê¼´"] = [[Fonts\2002B.TTF]] |
| SML_MT_font["기본 ê¸ê¼´"] = [[Fonts\2002.TTF]] |
| SML_MT_font["ë°ë¯¸ì§ ê¸ê¼´"] = [[Fonts\K_Damage.TTF]] |
| SML_MT_font["íì¤í¸ ê¸ê¼´"] = [[Fonts\K_Pagetext.TTF]] |
| -- |
| lib.DefaultMedia["font"] = "기본 ê¸ê¼´" -- someone from koKR please adjust if needed |
| -- |
| elseif locale == "zhCN" then |
| LOCALE_MASK = lib.LOCALE_BIT_zhCN |
| -- |
| SML_MT_font["伤害æ°å"] = [[Fonts\ZYKai_C.ttf]] |
| SML_MT_font["é»è®¤"] = [[Fonts\ZYKai_T.ttf]] |
| SML_MT_font["è天"] = [[Fonts\ZYHei.ttf]] |
| -- |
| lib.DefaultMedia["font"] = "é»è®¤" -- someone from zhCN please adjust if needed |
| -- |
| elseif locale == "zhTW" then |
| LOCALE_MASK = lib.LOCALE_BIT_zhTW |
| -- |
| SML_MT_font["æ示è¨æ¯"] = [[Fonts\bHEI00M.ttf]] |
| SML_MT_font["è天"] = [[Fonts\bHEI01B.ttf]] |
| SML_MT_font["å·å®³æ¸å"] = [[Fonts\bKAI00M.ttf]] |
| SML_MT_font["é è¨"] = [[Fonts\bLEI00D.ttf]] |
| -- |
| lib.DefaultMedia["font"] = "é è¨" -- someone from zhTW please adjust if needed |
| elseif locale == "ruRU" then |
| LOCALE_MASK = lib.LOCALE_BIT_ruRU |
| -- |
| SML_MT_font["Arial Narrow"] = [[Fonts\ARIALN.TTF]] |
| SML_MT_font["Friz Quadrata TT"] = [[Fonts\FRIZQT__.TTF]] |
| SML_MT_font["Morpheus"] = [[Fonts\MORPHEUS.TTF]] |
| SML_MT_font["Nimrod MT"] = [[Fonts\NIM_____.ttf]] |
| SML_MT_font["Skurri"] = [[Fonts\SKURRI.TTF]] |
| -- |
| lib.DefaultMedia.font = "Friz Quadrata TT" |
| -- |
| else |
| LOCALE_MASK = lib.LOCALE_BIT_western |
| locale_is_western = true |
| -- |
| SML_MT_font["Arial Narrow"] = [[Fonts\ARIALN.TTF]] |
| SML_MT_font["Friz Quadrata TT"] = [[Fonts\FRIZQT__.TTF]] |
| SML_MT_font["Morpheus"] = [[Fonts\MORPHEUS.TTF]] |
| SML_MT_font["Skurri"] = [[Fonts\SKURRI.TTF]] |
| -- |
| lib.DefaultMedia.font = "Friz Quadrata TT" |
| -- |
| end |
| -- STATUSBAR |
| if not lib.MediaTable.statusbar then lib.MediaTable.statusbar = {} end |
| lib.MediaTable.statusbar["Blizzard"] = [[Interface\TargetingFrame\UI-StatusBar]] |
| lib.MediaTable.statusbar["Blizzard Character Skills Bar"] = [[Interface\PaperDollInfoFrame\UI-Character-Skills-Bar]] |
| lib.DefaultMedia.statusbar = "Blizzard" |
| -- SOUND |
| if not lib.MediaTable.sound then lib.MediaTable.sound = {} end |
| lib.MediaTable.sound["None"] = [[Interface\Quiet.ogg]] -- Relies on the fact that PlaySound[File] doesn't error on non-existing input. |
| lib.DefaultMedia.sound = "None" |
| local function rebuildMediaList(mediatype) |
| local mtable = mediaTable[mediatype] |
| if not mtable then return end |
| if not mediaList[mediatype] then mediaList[mediatype] = {} end |
| local mlist = mediaList[mediatype] |
| -- list can only get larger, so simply overwrite it |
| local i = 0 |
| for k in pairs(mtable) do |
| i = i + 1 |
| mlist[i] = k |
| end |
| table_sort(mlist) |
| end |
| function lib:Register(mediatype, key, data, langmask) |
| if type(mediatype) ~= "string" then |
| error(MAJOR..":Register(mediatype, key, data, langmask) - mediatype must be string, got "..type(mediatype)) |
| end |
| if type(key) ~= "string" then |
| error(MAJOR..":Register(mediatype, key, data, langmask) - key must be string, got "..type(key)) |
| end |
| mediatype = mediatype:lower() |
| if mediatype == lib.MediaType.FONT and ((langmask and band(langmask, LOCALE_MASK) == 0) or not (langmask or locale_is_western)) then return false end |
| if not mediaTable[mediatype] then mediaTable[mediatype] = {} end |
| local mtable = mediaTable[mediatype] |
| if mtable[key] then return false end |
| mtable[key] = data |
| rebuildMediaList(mediatype) |
| self.callbacks:Fire("LibSharedMedia_Registered", mediatype, key) |
| return true |
| end |
| function lib:Fetch(mediatype, key, noDefault) |
| local mtt = mediaTable[mediatype] |
| local overridekey = overrideMedia[mediatype] |
| local result = mtt and ((overridekey and mtt[overridekey] or mtt[key]) or (not noDefault and defaultMedia[mediatype] and mtt[defaultMedia[mediatype]])) or nil |
| return result |
| end |
| function lib:IsValid(mediatype, key) |
| return mediaTable[mediatype] and (not key or mediaTable[mediatype][key]) and true or false |
| end |
| function lib:HashTable(mediatype) |
| return mediaTable[mediatype] |
| end |
| function lib:List(mediatype) |
| if not mediaTable[mediatype] then |
| return nil |
| end |
| if not mediaList[mediatype] then |
| rebuildMediaList(mediatype) |
| end |
| return mediaList[mediatype] |
| end |
| function lib:GetGlobal(mediatype) |
| return overrideMedia[mediatype] |
| end |
| function lib:SetGlobal(mediatype, key) |
| if not mediaTable[mediatype] then |
| return false |
| end |
| overrideMedia[mediatype] = (key and mediaTable[mediatype][key]) and key or nil |
| self.callbacks:Fire("LibSharedMedia_SetGlobal", mediatype, overrideMedia[mediatype]) |
| return true |
| end |
| function lib:GetDefault(mediatype) |
| return defaultMedia[mediatype] |
| end |
| function lib:SetDefault(mediatype, key) |
| if mediaTable[mediatype] and mediaTable[mediatype][key] and not defaultMedia[mediatype] then |
| defaultMedia[mediatype] = key |
| return true |
| else |
| return false |
| end |
| end |
mRunes/Libs/AceAddon-3.0/AceAddon-3.0.xml
New file
0,0 → 1,4
\ No newline at end of file
| <Ui xmlns="http://www.blizzard.com/wow/ui/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.blizzard.com/wow/ui/ |
| ..\FrameXML\UI.xsd"> |
| <Script file="AceAddon-3.0.lua"/> |
| </Ui> |
mRunes/Libs/AceAddon-3.0/AceAddon-3.0.lua
New file
0,0 → 1,658
| --- **AceAddon-3.0** provides a template for creating addon objects. |
| -- It'll provide you with a set of callback functions that allow you to simplify the loading |
| -- process of your addon.\\ |
| -- Callbacks provided are:\\ |
| -- * **OnInitialize**, which is called directly after the addon is fully loaded. |
| -- * **OnEnable** which gets called during the PLAYER_LOGIN event, when most of the data provided by the game is already present. |
| -- * **OnDisable**, which is only called when your addon is manually being disabled. |
| -- @usage |
| -- -- A small (but complete) addon, that doesn't do anything, |
| -- -- but shows usage of the callbacks. |
| -- local MyAddon = LibStub("AceAddon-3.0"):NewAddon("MyAddon") |
| -- |
| -- function MyAddon:OnInitialize() |
| -- -- do init tasks here, like loading the Saved Variables, |
| -- -- or setting up slash commands. |
| -- end |
| -- |
| -- function MyAddon:OnEnable() |
| -- -- Do more initialization here, that really enables the use of your addon. |
| -- -- Register Events, Hook functions, Create Frames, Get information from |
| -- -- the game that wasn't available in OnInitialize |
| -- end |
| -- |
| -- function MyAddon:OnDisable() |
| -- -- Unhook, Unregister Events, Hide frames that you created. |
| -- -- You would probably only use an OnDisable if you want to |
| -- -- build a "standby" mode, or be able to toggle modules on/off. |
| -- end |
| -- @class file |
| -- @name AceAddon-3.0.lua |
| -- @release $Id: AceAddon-3.0.lua 980 2010-10-27 14:20:11Z nevcairiel $ |
| local MAJOR, MINOR = "AceAddon-3.0", 10 |
| local AceAddon, oldminor = LibStub:NewLibrary(MAJOR, MINOR) |
| if not AceAddon then return end -- No Upgrade needed. |
| AceAddon.frame = AceAddon.frame or CreateFrame("Frame", "AceAddon30Frame") -- Our very own frame |
| AceAddon.addons = AceAddon.addons or {} -- addons in general |
| AceAddon.statuses = AceAddon.statuses or {} -- statuses of addon. |
| AceAddon.initializequeue = AceAddon.initializequeue or {} -- addons that are new and not initialized |
| AceAddon.enablequeue = AceAddon.enablequeue or {} -- addons that are initialized and waiting to be enabled |
| AceAddon.embeds = AceAddon.embeds or setmetatable({}, {__index = function(tbl, key) tbl[key] = {} return tbl[key] end }) -- contains a list of libraries embedded in an addon |
| -- Lua APIs |
| local tinsert, tconcat, tremove = table.insert, table.concat, table.remove |
| local fmt, tostring = string.format, tostring |
| local select, pairs, next, type, unpack = select, pairs, next, type, unpack |
| local loadstring, assert, error = loadstring, assert, error |
| local setmetatable, getmetatable, rawset, rawget = setmetatable, getmetatable, rawset, rawget |
| -- Global vars/functions that we don't upvalue since they might get hooked, or upgraded |
| -- List them here for Mikk's FindGlobals script |
| -- GLOBALS: LibStub, IsLoggedIn, geterrorhandler |
| --[[ |
| xpcall safecall implementation |
| ]] |
| local xpcall = xpcall |
| local function errorhandler(err) |
| return geterrorhandler()(err) |
| end |
| local function CreateDispatcher(argCount) |
| local code = [[ |
| local xpcall, eh = ... |
| local method, ARGS |
| local function call() return method(ARGS) end |
| local function dispatch(func, ...) |
| method = func |
| if not method then return end |
| ARGS = ... |
| return xpcall(call, eh) |
| end |
| return dispatch |
| ]] |
| local ARGS = {} |
| for i = 1, argCount do ARGS[i] = "arg"..i end |
| code = code:gsub("ARGS", tconcat(ARGS, ", ")) |
| return assert(loadstring(code, "safecall Dispatcher["..argCount.."]"))(xpcall, errorhandler) |
| end |
| local Dispatchers = setmetatable({}, {__index=function(self, argCount) |
| local dispatcher = CreateDispatcher(argCount) |
| rawset(self, argCount, dispatcher) |
| return dispatcher |
| end}) |
| Dispatchers[0] = function(func) |
| return xpcall(func, errorhandler) |
| end |
| local function safecall(func, ...) |
| -- we check to see if the func is passed is actually a function here and don't error when it isn't |
| -- this safecall is used for optional functions like OnInitialize OnEnable etc. When they are not |
| -- present execution should continue without hinderance |
| if type(func) == "function" then |
| return Dispatchers[select('#', ...)](func, ...) |
| end |
| end |
| -- local functions that will be implemented further down |
| local Enable, Disable, EnableModule, DisableModule, Embed, NewModule, GetModule, GetName, SetDefaultModuleState, SetDefaultModuleLibraries, SetEnabledState, SetDefaultModulePrototype |
| -- used in the addon metatable |
| local function addontostring( self ) return self.name end |
| --- Create a new AceAddon-3.0 addon. |
| -- Any libraries you specified will be embeded, and the addon will be scheduled for |
| -- its OnInitialize and OnEnable callbacks. |
| -- The final addon object, with all libraries embeded, will be returned. |
| -- @paramsig [object ,]name[, lib, ...] |
| -- @param object Table to use as a base for the addon (optional) |
| -- @param name Name of the addon object to create |
| -- @param lib List of libraries to embed into the addon |
| -- @usage |
| -- -- Create a simple addon object |
| -- MyAddon = LibStub("AceAddon-3.0"):NewAddon("MyAddon", "AceEvent-3.0") |
| -- |
| -- -- Create a Addon object based on the table of a frame |
| -- local MyFrame = CreateFrame("Frame") |
| -- MyAddon = LibStub("AceAddon-3.0"):NewAddon(MyFrame, "MyAddon", "AceEvent-3.0") |
| function AceAddon:NewAddon(objectorname, ...) |
| local object,name |
| local i=1 |
| if type(objectorname)=="table" then |
| object=objectorname |
| name=... |
| i=2 |
| else |
| name=objectorname |
| end |
| if type(name)~="string" then |
| error(("Usage: NewAddon([object,] name, [lib, lib, lib, ...]): 'name' - string expected got '%s'."):format(type(name)), 2) |
| end |
| if self.addons[name] then |
| error(("Usage: NewAddon([object,] name, [lib, lib, lib, ...]): 'name' - Addon '%s' already exists."):format(name), 2) |
| end |
| object = object or {} |
| object.name = name |
| local addonmeta = {} |
| local oldmeta = getmetatable(object) |
| if oldmeta then |
| for k, v in pairs(oldmeta) do addonmeta[k] = v end |
| end |
| addonmeta.__tostring = addontostring |
| setmetatable( object, addonmeta ) |
| self.addons[name] = object |
| object.modules = {} |
| object.orderedModules = {} |
| object.defaultModuleLibraries = {} |
| Embed( object ) -- embed NewModule, GetModule methods |
| self:EmbedLibraries(object, select(i,...)) |
| -- add to queue of addons to be initialized upon ADDON_LOADED |
| tinsert(self.initializequeue, object) |
| return object |
| end |
| --- Get the addon object by its name from the internal AceAddon registry. |
| -- Throws an error if the addon object cannot be found (except if silent is set). |
| -- @param name unique name of the addon object |
| -- @param silent if true, the addon is optional, silently return nil if its not found |
| -- @usage |
| -- -- Get the Addon |
| -- MyAddon = LibStub("AceAddon-3.0"):GetAddon("MyAddon") |
| function AceAddon:GetAddon(name, silent) |
| if not silent and not self.addons[name] then |
| error(("Usage: GetAddon(name): 'name' - Cannot find an AceAddon '%s'."):format(tostring(name)), 2) |
| end |
| return self.addons[name] |
| end |
| -- - Embed a list of libraries into the specified addon. |
| -- This function will try to embed all of the listed libraries into the addon |
| -- and error if a single one fails. |
| -- |
| -- **Note:** This function is for internal use by :NewAddon/:NewModule |
| -- @paramsig addon, [lib, ...] |
| -- @param addon addon object to embed the libs in |
| -- @param lib List of libraries to embed into the addon |
| function AceAddon:EmbedLibraries(addon, ...) |
| for i=1,select("#", ... ) do |
| local libname = select(i, ...) |
| self:EmbedLibrary(addon, libname, false, 4) |
| end |
| end |
| -- - Embed a library into the addon object. |
| -- This function will check if the specified library is registered with LibStub |
| -- and if it has a :Embed function to call. It'll error if any of those conditions |
| -- fails. |
| -- |
| -- **Note:** This function is for internal use by :EmbedLibraries |
| -- @paramsig addon, libname[, silent[, offset]] |
| -- @param addon addon object to embed the library in |
| -- @param libname name of the library to embed |
| -- @param silent marks an embed to fail silently if the library doesn't exist (optional) |
| -- @param offset will push the error messages back to said offset, defaults to 2 (optional) |
| function AceAddon:EmbedLibrary(addon, libname, silent, offset) |
| local lib = LibStub:GetLibrary(libname, true) |
| if not lib and not silent then |
| error(("Usage: EmbedLibrary(addon, libname, silent, offset): 'libname' - Cannot find a library instance of %q."):format(tostring(libname)), offset or 2) |
| elseif lib and type(lib.Embed) == "function" then |
| lib:Embed(addon) |
| tinsert(self.embeds[addon], libname) |
| return true |
| elseif lib then |
| error(("Usage: EmbedLibrary(addon, libname, silent, offset): 'libname' - Library '%s' is not Embed capable"):format(libname), offset or 2) |
| end |
| end |
| --- Return the specified module from an addon object. |
| -- Throws an error if the addon object cannot be found (except if silent is set) |
| -- @name //addon//:GetModule |
| -- @paramsig name[, silent] |
| -- @param name unique name of the module |
| -- @param silent if true, the module is optional, silently return nil if its not found (optional) |
| -- @usage |
| -- -- Get the Addon |
| -- MyAddon = LibStub("AceAddon-3.0"):GetAddon("MyAddon") |
| -- -- Get the Module |
| -- MyModule = MyAddon:GetModule("MyModule") |
| function GetModule(self, name, silent) |
| if not self.modules[name] and not silent then |
| error(("Usage: GetModule(name, silent): 'name' - Cannot find module '%s'."):format(tostring(name)), 2) |
| end |
| return self.modules[name] |
| end |
| local function IsModuleTrue(self) return true end |
| --- Create a new module for the addon. |
| -- The new module can have its own embeded libraries and/or use a module prototype to be mixed into the module.\\ |
| -- A module has the same functionality as a real addon, it can have modules of its own, and has the same API as |
| -- an addon object. |
| -- @name //addon//:NewModule |
| -- @paramsig name[, prototype|lib[, lib, ...]] |
| -- @param name unique name of the module |
| -- @param prototype object to derive this module from, methods and values from this table will be mixed into the module (optional) |
| -- @param lib List of libraries to embed into the addon |
| -- @usage |
| -- -- Create a module with some embeded libraries |
| -- MyModule = MyAddon:NewModule("MyModule", "AceEvent-3.0", "AceHook-3.0") |
| -- |
| -- -- Create a module with a prototype |
| -- local prototype = { OnEnable = function(self) print("OnEnable called!") end } |
| -- MyModule = MyAddon:NewModule("MyModule", prototype, "AceEvent-3.0", "AceHook-3.0") |
| function NewModule(self, name, prototype, ...) |
| if type(name) ~= "string" then error(("Usage: NewModule(name, [prototype, [lib, lib, lib, ...]): 'name' - string expected got '%s'."):format(type(name)), 2) end |
| if type(prototype) ~= "string" and type(prototype) ~= "table" and type(prototype) ~= "nil" then error(("Usage: NewModule(name, [prototype, [lib, lib, lib, ...]): 'prototype' - table (prototype), string (lib) or nil expected got '%s'."):format(type(prototype)), 2) end |
| if self.modules[name] then error(("Usage: NewModule(name, [prototype, [lib, lib, lib, ...]): 'name' - Module '%s' already exists."):format(name), 2) end |
| -- modules are basically addons. We treat them as such. They will be added to the initializequeue properly as well. |
| -- NewModule can only be called after the parent addon is present thus the modules will be initialized after their parent is. |
| local module = AceAddon:NewAddon(fmt("%s_%s", self.name or tostring(self), name)) |
| module.IsModule = IsModuleTrue |
| module:SetEnabledState(self.defaultModuleState) |
| module.moduleName = name |
| if type(prototype) == "string" then |
| AceAddon:EmbedLibraries(module, prototype, ...) |
| else |
| AceAddon:EmbedLibraries(module, ...) |
| end |
| AceAddon:EmbedLibraries(module, unpack(self.defaultModuleLibraries)) |
| if not prototype or type(prototype) == "string" then |
| prototype = self.defaultModulePrototype or nil |
| end |
| if type(prototype) == "table" then |
| local mt = getmetatable(module) |
| mt.__index = prototype |
| setmetatable(module, mt) -- More of a Base class type feel. |
| end |
| safecall(self.OnModuleCreated, self, module) -- Was in Ace2 and I think it could be a cool thing to have handy. |
| self.modules[name] = module |
| tinsert(self.orderedModules, module) |
| return module |
| end |
| --- Returns the real name of the addon or module, without any prefix. |
| -- @name //addon//:GetName |
| -- @paramsig |
| -- @usage |
| -- print(MyAddon:GetName()) |
| -- -- prints "MyAddon" |
| function GetName(self) |
| return self.moduleName or self.name |
| end |
| --- Enables the Addon, if possible, return true or false depending on success. |
| -- This internally calls AceAddon:EnableAddon(), thus dispatching a OnEnable callback |
| -- and enabling all modules of the addon (unless explicitly disabled).\\ |
| -- :Enable() also sets the internal `enableState` variable to true |
| -- @name //addon//:Enable |
| -- @paramsig |
| -- @usage |
| -- -- Enable MyModule |
| -- MyAddon = LibStub("AceAddon-3.0"):GetAddon("MyAddon") |
| -- MyModule = MyAddon:GetModule("MyModule") |
| -- MyModule:Enable() |
| function Enable(self) |
| self:SetEnabledState(true) |
| return AceAddon:EnableAddon(self) |
| end |
| --- Disables the Addon, if possible, return true or false depending on success. |
| -- This internally calls AceAddon:DisableAddon(), thus dispatching a OnDisable callback |
| -- and disabling all modules of the addon.\\ |
| -- :Disable() also sets the internal `enableState` variable to false |
| -- @name //addon//:Disable |
| -- @paramsig |
| -- @usage |
| -- -- Disable MyAddon |
| -- MyAddon = LibStub("AceAddon-3.0"):GetAddon("MyAddon") |
| -- MyAddon:Disable() |
| function Disable(self) |
| self:SetEnabledState(false) |
| return AceAddon:DisableAddon(self) |
| end |
| --- Enables the Module, if possible, return true or false depending on success. |
| -- Short-hand function that retrieves the module via `:GetModule` and calls `:Enable` on the module object. |
| -- @name //addon//:EnableModule |
| -- @paramsig name |
| -- @usage |
| -- -- Enable MyModule using :GetModule |
| -- MyAddon = LibStub("AceAddon-3.0"):GetAddon("MyAddon") |
| -- MyModule = MyAddon:GetModule("MyModule") |
| -- MyModule:Enable() |
| -- |
| -- -- Enable MyModule using the short-hand |
| -- MyAddon = LibStub("AceAddon-3.0"):GetAddon("MyAddon") |
| -- MyAddon:EnableModule("MyModule") |
| function EnableModule(self, name) |
| local module = self:GetModule( name ) |
| return module:Enable() |
| end |
| --- Disables the Module, if possible, return true or false depending on success. |
| -- Short-hand function that retrieves the module via `:GetModule` and calls `:Disable` on the module object. |
| -- @name //addon//:DisableModule |
| -- @paramsig name |
| -- @usage |
| -- -- Disable MyModule using :GetModule |
| -- MyAddon = LibStub("AceAddon-3.0"):GetAddon("MyAddon") |
| -- MyModule = MyAddon:GetModule("MyModule") |
| -- MyModule:Disable() |
| -- |
| -- -- Disable MyModule using the short-hand |
| -- MyAddon = LibStub("AceAddon-3.0"):GetAddon("MyAddon") |
| -- MyAddon:DisableModule("MyModule") |
| function DisableModule(self, name) |
| local module = self:GetModule( name ) |
| return module:Disable() |
| end |
| --- Set the default libraries to be mixed into all modules created by this object. |
| -- Note that you can only change the default module libraries before any module is created. |
| -- @name //addon//:SetDefaultModuleLibraries |
| -- @paramsig lib[, lib, ...] |
| -- @param lib List of libraries to embed into the addon |
| -- @usage |
| -- -- Create the addon object |
| -- MyAddon = LibStub("AceAddon-3.0"):NewAddon("MyAddon") |
| -- -- Configure default libraries for modules (all modules need AceEvent-3.0) |
| -- MyAddon:SetDefaultModuleLibraries("AceEvent-3.0") |
| -- -- Create a module |
| -- MyModule = MyAddon:NewModule("MyModule") |
| function SetDefaultModuleLibraries(self, ...) |
| if next(self.modules) then |
| error("Usage: SetDefaultModuleLibraries(...): cannot change the module defaults after a module has been registered.", 2) |
| end |
| self.defaultModuleLibraries = {...} |
| end |
| --- Set the default state in which new modules are being created. |
| -- Note that you can only change the default state before any module is created. |
| -- @name //addon//:SetDefaultModuleState |
| -- @paramsig state |
| -- @param state Default state for new modules, true for enabled, false for disabled |
| -- @usage |
| -- -- Create the addon object |
| -- MyAddon = LibStub("AceAddon-3.0"):NewAddon("MyAddon") |
| -- -- Set the default state to "disabled" |
| -- MyAddon:SetDefaultModuleState(false) |
| -- -- Create a module and explicilty enable it |
| -- MyModule = MyAddon:NewModule("MyModule") |
| -- MyModule:Enable() |
| function SetDefaultModuleState(self, state) |
| if next(self.modules) then |
| error("Usage: SetDefaultModuleState(state): cannot change the module defaults after a module has been registered.", 2) |
| end |
| self.defaultModuleState = state |
| end |
| --- Set the default prototype to use for new modules on creation. |
| -- Note that you can only change the default prototype before any module is created. |
| -- @name //addon//:SetDefaultModulePrototype |
| -- @paramsig prototype |
| -- @param prototype Default prototype for the new modules (table) |
| -- @usage |
| -- -- Define a prototype |
| -- local prototype = { OnEnable = function(self) print("OnEnable called!") end } |
| -- -- Set the default prototype |
| -- MyAddon:SetDefaultModulePrototype(prototype) |
| -- -- Create a module and explicitly Enable it |
| -- MyModule = MyAddon:NewModule("MyModule") |
| -- MyModule:Enable() |
| -- -- should print "OnEnable called!" now |
| -- @see NewModule |
| function SetDefaultModulePrototype(self, prototype) |
| if next(self.modules) then |
| error("Usage: SetDefaultModulePrototype(prototype): cannot change the module defaults after a module has been registered.", 2) |
| end |
| if type(prototype) ~= "table" then |
| error(("Usage: SetDefaultModulePrototype(prototype): 'prototype' - table expected got '%s'."):format(type(prototype)), 2) |
| end |
| self.defaultModulePrototype = prototype |
| end |
| --- Set the state of an addon or module |
| -- This should only be called before any enabling actually happend, e.g. in/before OnInitialize. |
| -- @name //addon//:SetEnabledState |
| -- @paramsig state |
| -- @param state the state of an addon or module (enabled=true, disabled=false) |
| function SetEnabledState(self, state) |
| self.enabledState = state |
| end |
| --- Return an iterator of all modules associated to the addon. |
| -- @name //addon//:IterateModules |
| -- @paramsig |
| -- @usage |
| -- -- Enable all modules |
| -- for name, module in MyAddon:IterateModules() do |
| -- module:Enable() |
| -- end |
| local function IterateModules(self) return pairs(self.modules) end |
| -- Returns an iterator of all embeds in the addon |
| -- @name //addon//:IterateEmbeds |
| -- @paramsig |
| local function IterateEmbeds(self) return pairs(AceAddon.embeds[self]) end |
| --- Query the enabledState of an addon. |
| -- @name //addon//:IsEnabled |
| -- @paramsig |
| -- @usage |
| -- if MyAddon:IsEnabled() then |
| -- MyAddon:Disable() |
| -- end |
| local function IsEnabled(self) return self.enabledState end |
| local mixins = { |
| NewModule = NewModule, |
| GetModule = GetModule, |
| Enable = Enable, |
| Disable = Disable, |
| EnableModule = EnableModule, |
| DisableModule = DisableModule, |
| IsEnabled = IsEnabled, |
| SetDefaultModuleLibraries = SetDefaultModuleLibraries, |
| SetDefaultModuleState = SetDefaultModuleState, |
| SetDefaultModulePrototype = SetDefaultModulePrototype, |
| SetEnabledState = SetEnabledState, |
| IterateModules = IterateModules, |
| IterateEmbeds = IterateEmbeds, |
| GetName = GetName, |
| } |
| local function IsModule(self) return false end |
| local pmixins = { |
| defaultModuleState = true, |
| enabledState = true, |
| IsModule = IsModule, |
| } |
| -- Embed( target ) |
| -- target (object) - target object to embed aceaddon in |
| -- |
| -- this is a local function specifically since it's meant to be only called internally |
| function Embed(target, skipPMixins) |
| for k, v in pairs(mixins) do |
| target[k] = v |
| end |
| if not skipPMixins then |
| for k, v in pairs(pmixins) do |
| target[k] = target[k] or v |
| end |
| end |
| end |
| -- - Initialize the addon after creation. |
| -- This function is only used internally during the ADDON_LOADED event |
| -- It will call the **OnInitialize** function on the addon object (if present), |
| -- and the **OnEmbedInitialize** function on all embeded libraries. |
| -- |
| -- **Note:** Do not call this function manually, unless you're absolutely sure that you know what you are doing. |
| -- @param addon addon object to intialize |
| function AceAddon:InitializeAddon(addon) |
| safecall(addon.OnInitialize, addon) |
| local embeds = self.embeds[addon] |
| for i = 1, #embeds do |
| local lib = LibStub:GetLibrary(embeds[i], true) |
| if lib then safecall(lib.OnEmbedInitialize, lib, addon) end |
| end |
| -- we don't call InitializeAddon on modules specifically, this is handled |
| -- from the event handler and only done _once_ |
| end |
| -- - Enable the addon after creation. |
| -- Note: This function is only used internally during the PLAYER_LOGIN event, or during ADDON_LOADED, |
| -- if IsLoggedIn() already returns true at that point, e.g. for LoD Addons. |
| -- It will call the **OnEnable** function on the addon object (if present), |
| -- and the **OnEmbedEnable** function on all embeded libraries.\\ |
| -- This function does not toggle the enable state of the addon itself, and will return early if the addon is disabled. |
| -- |
| -- **Note:** Do not call this function manually, unless you're absolutely sure that you know what you are doing. |
| -- Use :Enable on the addon itself instead. |
| -- @param addon addon object to enable |
| function AceAddon:EnableAddon(addon) |
| if type(addon) == "string" then addon = AceAddon:GetAddon(addon) end |
| if self.statuses[addon.name] or not addon.enabledState then return false end |
| -- set the statuses first, before calling the OnEnable. this allows for Disabling of the addon in OnEnable. |
| self.statuses[addon.name] = true |
| safecall(addon.OnEnable, addon) |
| -- make sure we're still enabled before continueing |
| if self.statuses[addon.name] then |
| local embeds = self.embeds[addon] |
| for i = 1, #embeds do |
| local lib = LibStub:GetLibrary(embeds[i], true) |
| if lib then safecall(lib.OnEmbedEnable, lib, addon) end |
| end |
| -- enable possible modules. |
| local modules = addon.orderedModules |
| for i = 1, #modules do |
| self:EnableAddon(modules[i]) |
| end |
| end |
| return self.statuses[addon.name] -- return true if we're disabled |
| end |
| -- - Disable the addon |
| -- Note: This function is only used internally. |
| -- It will call the **OnDisable** function on the addon object (if present), |
| -- and the **OnEmbedDisable** function on all embeded libraries.\\ |
| -- This function does not toggle the enable state of the addon itself, and will return early if the addon is still enabled. |
| -- |
| -- **Note:** Do not call this function manually, unless you're absolutely sure that you know what you are doing. |
| -- Use :Disable on the addon itself instead. |
| -- @param addon addon object to enable |
| function AceAddon:DisableAddon(addon) |
| if type(addon) == "string" then addon = AceAddon:GetAddon(addon) end |
| if not self.statuses[addon.name] then return false end |
| -- set statuses first before calling OnDisable, this allows for aborting the disable in OnDisable. |
| self.statuses[addon.name] = false |
| safecall( addon.OnDisable, addon ) |
| -- make sure we're still disabling... |
| if not self.statuses[addon.name] then |
| local embeds = self.embeds[addon] |
| for i = 1, #embeds do |
| local lib = LibStub:GetLibrary(embeds[i], true) |
| if lib then safecall(lib.OnEmbedDisable, lib, addon) end |
| end |
| -- disable possible modules. |
| local modules = addon.orderedModules |
| for i = 1, #modules do |
| self:DisableAddon(modules[i]) |
| end |
| end |
| return not self.statuses[addon.name] -- return true if we're disabled |
| end |
| --- Get an iterator over all registered addons. |
| -- @usage |
| -- -- Print a list of all installed AceAddon's |
| -- for name, addon in AceAddon:IterateAddons() do |
| -- print("Addon: " .. name) |
| -- end |
| function AceAddon:IterateAddons() return pairs(self.addons) end |
| --- Get an iterator over the internal status registry. |
| -- @usage |
| -- -- Print a list of all enabled addons |
| -- for name, status in AceAddon:IterateAddonStatus() do |
| -- if status then |
| -- print("EnabledAddon: " .. name) |
| -- end |
| -- end |
| function AceAddon:IterateAddonStatus() return pairs(self.statuses) end |
| -- Following Iterators are deprecated, and their addon specific versions should be used |
| -- e.g. addon:IterateEmbeds() instead of :IterateEmbedsOnAddon(addon) |
| function AceAddon:IterateEmbedsOnAddon(addon) return pairs(self.embeds[addon]) end |
| function AceAddon:IterateModulesOfAddon(addon) return pairs(addon.modules) end |
| -- Event Handling |
| local function onEvent(this, event, arg1) |
| if event == "ADDON_LOADED" or event == "PLAYER_LOGIN" then |
| -- if a addon loads another addon, recursion could happen here, so we need to validate the table on every iteration |
| while(#AceAddon.initializequeue > 0) do |
| local addon = tremove(AceAddon.initializequeue, 1) |
| -- this might be an issue with recursion - TODO: validate |
| if event == "ADDON_LOADED" then addon.baseName = arg1 end |
| AceAddon:InitializeAddon(addon) |
| tinsert(AceAddon.enablequeue, addon) |
| end |
| if IsLoggedIn() then |
| while(#AceAddon.enablequeue > 0) do |
| local addon = tremove(AceAddon.enablequeue, 1) |
| AceAddon:EnableAddon(addon) |
| end |
| end |
| end |
| end |
| AceAddon.frame:RegisterEvent("ADDON_LOADED") |
| AceAddon.frame:RegisterEvent("PLAYER_LOGIN") |
| AceAddon.frame:SetScript("OnEvent", onEvent) |
| -- upgrade embeded |
| for name, addon in pairs(AceAddon.addons) do |
| Embed(addon, true) |
| end |
| -- 2010-10-27 nevcairiel - add new "orderedModules" table |
| if oldminor and oldminor < 10 then |
| for name, addon in pairs(AceAddon.addons) do |
| addon.orderedModules = {} |
| for module_name, module in pairs(addon.modules) do |
| tinsert(addon.orderedModules, module) |
| end |
| end |
| end |
mRunes/Libs/AceDB-3.0/AceDB-3.0.xml
New file
0,0 → 1,4
\ No newline at end of file
| <Ui xmlns="http://www.blizzard.com/wow/ui/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.blizzard.com/wow/ui/ |
| ..\FrameXML\UI.xsd"> |
| <Script file="AceDB-3.0.lua"/> |
| </Ui> |
mRunes/Libs/AceDB-3.0/AceDB-3.0.lua
New file
0,0 → 1,728
| --- **AceDB-3.0** manages the SavedVariables of your addon. |
| -- It offers profile management, smart defaults and namespaces for modules.\\ |
| -- Data can be saved in different data-types, depending on its intended usage. |
| -- The most common data-type is the `profile` type, which allows the user to choose |
| -- the active profile, and manage the profiles of all of his characters.\\ |
| -- The following data types are available: |
| -- * **char** Character-specific data. Every character has its own database. |
| -- * **realm** Realm-specific data. All of the players characters on the same realm share this database. |
| -- * **class** Class-specific data. All of the players characters of the same class share this database. |
| -- * **race** Race-specific data. All of the players characters of the same race share this database. |
| -- * **faction** Faction-specific data. All of the players characters of the same faction share this database. |
| -- * **factionrealm** Faction and realm specific data. All of the players characters on the same realm and of the same faction share this database. |
| -- * **global** Global Data. All characters on the same account share this database. |
| -- * **profile** Profile-specific data. All characters using the same profile share this database. The user can control which profile should be used. |
| -- |
| -- Creating a new Database using the `:New` function will return a new DBObject. A database will inherit all functions |
| -- of the DBObjectLib listed here. \\ |
| -- If you create a new namespaced child-database (`:RegisterNamespace`), you'll get a DBObject as well, but note |
| -- that the child-databases cannot individually change their profile, and are linked to their parents profile - and because of that, |
| -- the profile related APIs are not available. Only `:RegisterDefaults` and `:ResetProfile` are available on child-databases. |
| -- |
| -- For more details on how to use AceDB-3.0, see the [[AceDB-3.0 Tutorial]]. |
| -- |
| -- You may also be interested in [[libdualspec-1-0|LibDualSpec-1.0]] to do profile switching automatically when switching specs. |
| -- |
| -- @usage |
| -- MyAddon = LibStub("AceAddon-3.0"):NewAddon("DBExample") |
| -- |
| -- -- declare defaults to be used in the DB |
| -- local defaults = { |
| -- profile = { |
| -- setting = true, |
| -- } |
| -- } |
| -- |
| -- function MyAddon:OnInitialize() |
| -- -- Assuming the .toc says ## SavedVariables: MyAddonDB |
| -- self.db = LibStub("AceDB-3.0"):New("MyAddonDB", defaults, true) |
| -- end |
| -- @class file |
| -- @name AceDB-3.0.lua |
| -- @release $Id: AceDB-3.0.lua 940 2010-06-19 08:01:47Z nevcairiel $ |
| local ACEDB_MAJOR, ACEDB_MINOR = "AceDB-3.0", 21 |
| local AceDB, oldminor = LibStub:NewLibrary(ACEDB_MAJOR, ACEDB_MINOR) |
| if not AceDB then return end -- No upgrade needed |
| -- Lua APIs |
| local type, pairs, next, error = type, pairs, next, error |
| local setmetatable, getmetatable, rawset, rawget = setmetatable, getmetatable, rawset, rawget |
| -- WoW APIs |
| local _G = _G |
| -- Global vars/functions that we don't upvalue since they might get hooked, or upgraded |
| -- List them here for Mikk's FindGlobals script |
| -- GLOBALS: LibStub |
| AceDB.db_registry = AceDB.db_registry or {} |
| AceDB.frame = AceDB.frame or CreateFrame("Frame") |
| local CallbackHandler |
| local CallbackDummy = { Fire = function() end } |
| local DBObjectLib = {} |
| --[[------------------------------------------------------------------------- |
| AceDB Utility Functions |
| ---------------------------------------------------------------------------]] |
| -- Simple shallow copy for copying defaults |
| local function copyTable(src, dest) |
| if type(dest) ~= "table" then dest = {} end |
| if type(src) == "table" then |
| for k,v in pairs(src) do |
| if type(v) == "table" then |
| -- try to index the key first so that the metatable creates the defaults, if set, and use that table |
| v = copyTable(v, dest[k]) |
| end |
| dest[k] = v |
| end |
| end |
| return dest |
| end |
| -- Called to add defaults to a section of the database |
| -- |
| -- When a ["*"] default section is indexed with a new key, a table is returned |
| -- and set in the host table. These tables must be cleaned up by removeDefaults |
| -- in order to ensure we don't write empty default tables. |
| local function copyDefaults(dest, src) |
| -- this happens if some value in the SV overwrites our default value with a non-table |
| --if type(dest) ~= "table" then return end |
| for k, v in pairs(src) do |
| if k == "*" or k == "**" then |
| if type(v) == "table" then |
| -- This is a metatable used for table defaults |
| local mt = { |
| -- This handles the lookup and creation of new subtables |
| __index = function(t,k) |
| if k == nil then return nil end |
| local tbl = {} |
| copyDefaults(tbl, v) |
| rawset(t, k, tbl) |
| return tbl |
| end, |
| } |
| setmetatable(dest, mt) |
| -- handle already existing tables in the SV |
| for dk, dv in pairs(dest) do |
| if not rawget(src, dk) and type(dv) == "table" then |
| copyDefaults(dv, v) |
| end |
| end |
| else |
| -- Values are not tables, so this is just a simple return |
| local mt = {__index = function(t,k) return k~=nil and v or nil end} |
| setmetatable(dest, mt) |
| end |
| elseif type(v) == "table" then |
| if not rawget(dest, k) then rawset(dest, k, {}) end |
| if type(dest[k]) == "table" then |
| copyDefaults(dest[k], v) |
| if src['**'] then |
| copyDefaults(dest[k], src['**']) |
| end |
| end |
| else |
| if rawget(dest, k) == nil then |
| rawset(dest, k, v) |
| end |
| end |
| end |
| end |
| -- Called to remove all defaults in the default table from the database |
| local function removeDefaults(db, defaults, blocker) |
| -- remove all metatables from the db, so we don't accidentally create new sub-tables through them |
| setmetatable(db, nil) |
| -- loop through the defaults and remove their content |
| for k,v in pairs(defaults) do |
| if k == "*" or k == "**" then |
| if type(v) == "table" then |
| -- Loop through all the actual k,v pairs and remove |
| for key, value in pairs(db) do |
| if type(value) == "table" then |
| -- if the key was not explicitly specified in the defaults table, just strip everything from * and ** tables |
| if defaults[key] == nil and (not blocker or blocker[key] == nil) then |
| removeDefaults(value, v) |
| -- if the table is empty afterwards, remove it |
| if next(value) == nil then |
| db[key] = nil |
| end |
| -- if it was specified, only strip ** content, but block values which were set in the key table |
| elseif k == "**" then |
| removeDefaults(value, v, defaults[key]) |
| end |
| end |
| end |
| elseif k == "*" then |
| -- check for non-table default |
| for key, value in pairs(db) do |
| if defaults[key] == nil and v == value then |
| db[key] = nil |
| end |
| end |
| end |
| elseif type(v) == "table" and type(db[k]) == "table" then |
| -- if a blocker was set, dive into it, to allow multi-level defaults |
| removeDefaults(db[k], v, blocker and blocker[k]) |
| if next(db[k]) == nil then |
| db[k] = nil |
| end |
| else |
| -- check if the current value matches the default, and that its not blocked by another defaults table |
| if db[k] == defaults[k] and (not blocker or blocker[k] == nil) then |
| db[k] = nil |
| end |
| end |
| end |
| end |
| -- This is called when a table section is first accessed, to set up the defaults |
| local function initSection(db, section, svstore, key, defaults) |
| local sv = rawget(db, "sv") |
| local tableCreated |
| if not sv[svstore] then sv[svstore] = {} end |
| if not sv[svstore][key] then |
| sv[svstore][key] = {} |
| tableCreated = true |
| end |
| local tbl = sv[svstore][key] |
| if defaults then |
| copyDefaults(tbl, defaults) |
| end |
| rawset(db, section, tbl) |
| return tableCreated, tbl |
| end |
| -- Metatable to handle the dynamic creation of sections and copying of sections. |
| local dbmt = { |
| __index = function(t, section) |
| local keys = rawget(t, "keys") |
| local key = keys[section] |
| if key then |
| local defaultTbl = rawget(t, "defaults") |
| local defaults = defaultTbl and defaultTbl[section] |
| if section == "profile" then |
| local new = initSection(t, section, "profiles", key, defaults) |
| if new then |
| -- Callback: OnNewProfile, database, newProfileKey |
| t.callbacks:Fire("OnNewProfile", t, key) |
| end |
| elseif section == "profiles" then |
| local sv = rawget(t, "sv") |
| if not sv.profiles then sv.profiles = {} end |
| rawset(t, "profiles", sv.profiles) |
| elseif section == "global" then |
| local sv = rawget(t, "sv") |
| if not sv.global then sv.global = {} end |
| if defaults then |
| copyDefaults(sv.global, defaults) |
| end |
| rawset(t, section, sv.global) |
| else |
| initSection(t, section, section, key, defaults) |
| end |
| end |
| return rawget(t, section) |
| end |
| } |
| local function validateDefaults(defaults, keyTbl, offset) |
| if not defaults then return end |
| offset = offset or 0 |
| for k in pairs(defaults) do |
| if not keyTbl[k] or k == "profiles" then |
| error(("Usage: AceDBObject:RegisterDefaults(defaults): '%s' is not a valid datatype."):format(k), 3 + offset) |
| end |
| end |
| end |
| local preserve_keys = { |
| ["callbacks"] = true, |
| ["RegisterCallback"] = true, |
| ["UnregisterCallback"] = true, |
| ["UnregisterAllCallbacks"] = true, |
| ["children"] = true, |
| } |
| local realmKey = GetRealmName() |
| local charKey = UnitName("player") .. " - " .. realmKey |
| local _, classKey = UnitClass("player") |
| local _, raceKey = UnitRace("player") |
| local factionKey = UnitFactionGroup("player") |
| local factionrealmKey = factionKey .. " - " .. realmKey |
| -- Actual database initialization function |
| local function initdb(sv, defaults, defaultProfile, olddb, parent) |
| -- Generate the database keys for each section |
| -- map "true" to our "Default" profile |
| if defaultProfile == true then defaultProfile = "Default" end |
| local profileKey |
| if not parent then |
| -- Make a container for profile keys |
| if not sv.profileKeys then sv.profileKeys = {} end |
| -- Try to get the profile selected from the char db |
| profileKey = sv.profileKeys[charKey] or defaultProfile or charKey |
| -- save the selected profile for later |
| sv.profileKeys[charKey] = profileKey |
| else |
| -- Use the profile of the parents DB |
| profileKey = parent.keys.profile or defaultProfile or charKey |
| -- clear the profileKeys in the DB, namespaces don't need to store them |
| sv.profileKeys = nil |
| end |
| -- This table contains keys that enable the dynamic creation |
| -- of each section of the table. The 'global' and 'profiles' |
| -- have a key of true, since they are handled in a special case |
| local keyTbl= { |
| ["char"] = charKey, |
| ["realm"] = realmKey, |
| ["class"] = classKey, |
| ["race"] = raceKey, |
| ["faction"] = factionKey, |
| ["factionrealm"] = factionrealmKey, |
| ["profile"] = profileKey, |
| ["global"] = true, |
| ["profiles"] = true, |
| } |
| validateDefaults(defaults, keyTbl, 1) |
| -- This allows us to use this function to reset an entire database |
| -- Clear out the old database |
| if olddb then |
| for k,v in pairs(olddb) do if not preserve_keys[k] then olddb[k] = nil end end |
| end |
| -- Give this database the metatable so it initializes dynamically |
| local db = setmetatable(olddb or {}, dbmt) |
| if not rawget(db, "callbacks") then |
| -- try to load CallbackHandler-1.0 if it loaded after our library |
| if not CallbackHandler then CallbackHandler = LibStub:GetLibrary("CallbackHandler-1.0", true) end |
| db.callbacks = CallbackHandler and CallbackHandler:New(db) or CallbackDummy |
| end |
| -- Copy methods locally into the database object, to avoid hitting |
| -- the metatable when calling methods |
| if not parent then |
| for name, func in pairs(DBObjectLib) do |
| db[name] = func |
| end |
| else |
| -- hack this one in |
| db.RegisterDefaults = DBObjectLib.RegisterDefaults |
| db.ResetProfile = DBObjectLib.ResetProfile |
| end |
| -- Set some properties in the database object |
| db.profiles = sv.profiles |
| db.keys = keyTbl |
| db.sv = sv |
| --db.sv_name = name |
| db.defaults = defaults |
| db.parent = parent |
| -- store the DB in the registry |
| AceDB.db_registry[db] = true |
| return db |
| end |
| -- handle PLAYER_LOGOUT |
| -- strip all defaults from all databases |
| -- and cleans up empty sections |
| local function logoutHandler(frame, event) |
| if event == "PLAYER_LOGOUT" then |
| for db in pairs(AceDB.db_registry) do |
| db.callbacks:Fire("OnDatabaseShutdown", db) |
| db:RegisterDefaults(nil) |
| -- cleanup sections that are empty without defaults |
| local sv = rawget(db, "sv") |
| for section in pairs(db.keys) do |
| if rawget(sv, section) then |
| -- global is special, all other sections have sub-entrys |
| -- also don't delete empty profiles on main dbs, only on namespaces |
| if section ~= "global" and (section ~= "profiles" or rawget(db, "parent")) then |
| for key in pairs(sv[section]) do |
| if not next(sv[section][key]) then |
| sv[section][key] = nil |
| end |
| end |
| end |
| if not next(sv[section]) then |
| sv[section] = nil |
| end |
| end |
| end |
| end |
| end |
| end |
| AceDB.frame:RegisterEvent("PLAYER_LOGOUT") |
| AceDB.frame:SetScript("OnEvent", logoutHandler) |
| --[[------------------------------------------------------------------------- |
| AceDB Object Method Definitions |
| ---------------------------------------------------------------------------]] |
| --- Sets the defaults table for the given database object by clearing any |
| -- that are currently set, and then setting the new defaults. |
| -- @param defaults A table of defaults for this database |
| function DBObjectLib:RegisterDefaults(defaults) |
| if defaults and type(defaults) ~= "table" then |
| error("Usage: AceDBObject:RegisterDefaults(defaults): 'defaults' - table or nil expected.", 2) |
| end |
| validateDefaults(defaults, self.keys) |
| -- Remove any currently set defaults |
| if self.defaults then |
| for section,key in pairs(self.keys) do |
| if self.defaults[section] and rawget(self, section) then |
| removeDefaults(self[section], self.defaults[section]) |
| end |
| end |
| end |
| -- Set the DBObject.defaults table |
| self.defaults = defaults |
| -- Copy in any defaults, only touching those sections already created |
| if defaults then |
| for section,key in pairs(self.keys) do |
| if defaults[section] and rawget(self, section) then |
| copyDefaults(self[section], defaults[section]) |
| end |
| end |
| end |
| end |
| --- Changes the profile of the database and all of it's namespaces to the |
| -- supplied named profile |
| -- @param name The name of the profile to set as the current profile |
| function DBObjectLib:SetProfile(name) |
| if type(name) ~= "string" then |
| error("Usage: AceDBObject:SetProfile(name): 'name' - string expected.", 2) |
| end |
| -- changing to the same profile, dont do anything |
| if name == self.keys.profile then return end |
| local oldProfile = self.profile |
| local defaults = self.defaults and self.defaults.profile |
| -- Callback: OnProfileShutdown, database |
| self.callbacks:Fire("OnProfileShutdown", self) |
| if oldProfile and defaults then |
| -- Remove the defaults from the old profile |
| removeDefaults(oldProfile, defaults) |
| end |
| self.profile = nil |
| self.keys["profile"] = name |
| -- if the storage exists, save the new profile |
| -- this won't exist on namespaces. |
| if self.sv.profileKeys then |
| self.sv.profileKeys[charKey] = name |
| end |
| -- populate to child namespaces |
| if self.children then |
| for _, db in pairs(self.children) do |
| DBObjectLib.SetProfile(db, name) |
| end |
| end |
| -- Callback: OnProfileChanged, database, newProfileKey |
| self.callbacks:Fire("OnProfileChanged", self, name) |
| end |
| --- Returns a table with the names of the existing profiles in the database. |
| -- You can optionally supply a table to re-use for this purpose. |
| -- @param tbl A table to store the profile names in (optional) |
| function DBObjectLib:GetProfiles(tbl) |
| if tbl and type(tbl) ~= "table" then |
| error("Usage: AceDBObject:GetProfiles(tbl): 'tbl' - table or nil expected.", 2) |
| end |
| -- Clear the container table |
| if tbl then |
| for k,v in pairs(tbl) do tbl[k] = nil end |
| else |
| tbl = {} |
| end |
| local curProfile = self.keys.profile |
| local i = 0 |
| for profileKey in pairs(self.profiles) do |
| i = i + 1 |
| tbl[i] = profileKey |
| if curProfile and profileKey == curProfile then curProfile = nil end |
| end |
| -- Add the current profile, if it hasn't been created yet |
| if curProfile then |
| i = i + 1 |
| tbl[i] = curProfile |
| end |
| return tbl, i |
| end |
| --- Returns the current profile name used by the database |
| function DBObjectLib:GetCurrentProfile() |
| return self.keys.profile |
| end |
| --- Deletes a named profile. This profile must not be the active profile. |
| -- @param name The name of the profile to be deleted |
| -- @param silent If true, do not raise an error when the profile does not exist |
| function DBObjectLib:DeleteProfile(name, silent) |
| if type(name) ~= "string" then |
| error("Usage: AceDBObject:DeleteProfile(name): 'name' - string expected.", 2) |
| end |
| if self.keys.profile == name then |
| error("Cannot delete the active profile in an AceDBObject.", 2) |
| end |
| if not rawget(self.profiles, name) and not silent then |
| error("Cannot delete profile '" .. name .. "'. It does not exist.", 2) |
| end |
| self.profiles[name] = nil |
| -- populate to child namespaces |
| if self.children then |
| for _, db in pairs(self.children) do |
| DBObjectLib.DeleteProfile(db, name, true) |
| end |
| end |
| -- Callback: OnProfileDeleted, database, profileKey |
| self.callbacks:Fire("OnProfileDeleted", self, name) |
| end |
| --- Copies a named profile into the current profile, overwriting any conflicting |
| -- settings. |
| -- @param name The name of the profile to be copied into the current profile |
| -- @param silent If true, do not raise an error when the profile does not exist |
| function DBObjectLib:CopyProfile(name, silent) |
| if type(name) ~= "string" then |
| error("Usage: AceDBObject:CopyProfile(name): 'name' - string expected.", 2) |
| end |
| if name == self.keys.profile then |
| error("Cannot have the same source and destination profiles.", 2) |
| end |
| if not rawget(self.profiles, name) and not silent then |
| error("Cannot copy profile '" .. name .. "'. It does not exist.", 2) |
| end |
| -- Reset the profile before copying |
| DBObjectLib.ResetProfile(self, nil, true) |
| local profile = self.profile |
| local source = self.profiles[name] |
| copyTable(source, profile) |
| -- populate to child namespaces |
| if self.children then |
| for _, db in pairs(self.children) do |
| DBObjectLib.CopyProfile(db, name, true) |
| end |
| end |
| -- Callback: OnProfileCopied, database, sourceProfileKey |
| self.callbacks:Fire("OnProfileCopied", self, name) |
| end |
| --- Resets the current profile to the default values (if specified). |
| -- @param noChildren if set to true, the reset will not be populated to the child namespaces of this DB object |
| -- @param noCallbacks if set to true, won't fire the OnProfileReset callback |
| function DBObjectLib:ResetProfile(noChildren, noCallbacks) |
| local profile = self.profile |
| for k,v in pairs(profile) do |
| profile[k] = nil |
| end |
| local defaults = self.defaults and self.defaults.profile |
| if defaults then |
| copyDefaults(profile, defaults) |
| end |
| -- populate to child namespaces |
| if self.children and not noChildren then |
| for _, db in pairs(self.children) do |
| DBObjectLib.ResetProfile(db, nil, noCallbacks) |
| end |
| end |
| -- Callback: OnProfileReset, database |
| if not noCallbacks then |
| self.callbacks:Fire("OnProfileReset", self) |
| end |
| end |
| --- Resets the entire database, using the string defaultProfile as the new default |
| -- profile. |
| -- @param defaultProfile The profile name to use as the default |
| function DBObjectLib:ResetDB(defaultProfile) |
| if defaultProfile and type(defaultProfile) ~= "string" then |
| error("Usage: AceDBObject:ResetDB(defaultProfile): 'defaultProfile' - string or nil expected.", 2) |
| end |
| local sv = self.sv |
| for k,v in pairs(sv) do |
| sv[k] = nil |
| end |
| local parent = self.parent |
| initdb(sv, self.defaults, defaultProfile, self) |
| -- fix the child namespaces |
| if self.children then |
| if not sv.namespaces then sv.namespaces = {} end |
| for name, db in pairs(self.children) do |
| if not sv.namespaces[name] then sv.namespaces[name] = {} end |
| initdb(sv.namespaces[name], db.defaults, self.keys.profile, db, self) |
| end |
| end |
| -- Callback: OnDatabaseReset, database |
| self.callbacks:Fire("OnDatabaseReset", self) |
| -- Callback: OnProfileChanged, database, profileKey |
| self.callbacks:Fire("OnProfileChanged", self, self.keys["profile"]) |
| return self |
| end |
| --- Creates a new database namespace, directly tied to the database. This |
| -- is a full scale database in it's own rights other than the fact that |
| -- it cannot control its profile individually |
| -- @param name The name of the new namespace |
| -- @param defaults A table of values to use as defaults |
| function DBObjectLib:RegisterNamespace(name, defaults) |
| if type(name) ~= "string" then |
| error("Usage: AceDBObject:RegisterNamespace(name, defaults): 'name' - string expected.", 2) |
| end |
| if defaults and type(defaults) ~= "table" then |
| error("Usage: AceDBObject:RegisterNamespace(name, defaults): 'defaults' - table or nil expected.", 2) |
| end |
| if self.children and self.children[name] then |
| error ("Usage: AceDBObject:RegisterNamespace(name, defaults): 'name' - a namespace with that name already exists.", 2) |
| end |
| local sv = self.sv |
| if not sv.namespaces then sv.namespaces = {} end |
| if not sv.namespaces[name] then |
| sv.namespaces[name] = {} |
| end |
| local newDB = initdb(sv.namespaces[name], defaults, self.keys.profile, nil, self) |
| if not self.children then self.children = {} end |
| self.children[name] = newDB |
| return newDB |
| end |
| --- Returns an already existing namespace from the database object. |
| -- @param name The name of the new namespace |
| -- @param silent if true, the addon is optional, silently return nil if its not found |
| -- @usage |
| -- local namespace = self.db:GetNamespace('namespace') |
| -- @return the namespace object if found |
| function DBObjectLib:GetNamespace(name, silent) |
| if type(name) ~= "string" then |
| error("Usage: AceDBObject:GetNamespace(name): 'name' - string expected.", 2) |
| end |
| if not silent and not (self.children and self.children[name]) then |
| error ("Usage: AceDBObject:GetNamespace(name): 'name' - namespace does not exist.", 2) |
| end |
| if not self.children then self.children = {} end |
| return self.children[name] |
| end |
| --[[------------------------------------------------------------------------- |
| AceDB Exposed Methods |
| ---------------------------------------------------------------------------]] |
| --- Creates a new database object that can be used to handle database settings and profiles. |
| -- By default, an empty DB is created, using a character specific profile. |
| -- |
| -- You can override the default profile used by passing any profile name as the third argument, |
| -- or by passing //true// as the third argument to use a globally shared profile called "Default". |
| -- |
| -- Note that there is no token replacement in the default profile name, passing a defaultProfile as "char" |
| -- will use a profile named "char", and not a character-specific profile. |
| -- @param tbl The name of variable, or table to use for the database |
| -- @param defaults A table of database defaults |
| -- @param defaultProfile The name of the default profile. If not set, a character specific profile will be used as the default. |
| -- You can also pass //true// to use a shared global profile called "Default". |
| -- @usage |
| -- -- Create an empty DB using a character-specific default profile. |
| -- self.db = LibStub("AceDB-3.0"):New("MyAddonDB") |
| -- @usage |
| -- -- Create a DB using defaults and using a shared default profile |
| -- self.db = LibStub("AceDB-3.0"):New("MyAddonDB", defaults, true) |
| function AceDB:New(tbl, defaults, defaultProfile) |
| if type(tbl) == "string" then |
| local name = tbl |
| tbl = _G[name] |
| if not tbl then |
| tbl = {} |
| _G[name] = tbl |
| end |
| end |
| if type(tbl) ~= "table" then |
| error("Usage: AceDB:New(tbl, defaults, defaultProfile): 'tbl' - table expected.", 2) |
| end |
| if defaults and type(defaults) ~= "table" then |
| error("Usage: AceDB:New(tbl, defaults, defaultProfile): 'defaults' - table expected.", 2) |
| end |
| if defaultProfile and type(defaultProfile) ~= "string" and defaultProfile ~= true then |
| error("Usage: AceDB:New(tbl, defaults, defaultProfile): 'defaultProfile' - string or true expected.", 2) |
| end |
| return initdb(tbl, defaults, defaultProfile) |
| end |
| -- upgrade existing databases |
| for db in pairs(AceDB.db_registry) do |
| if not db.parent then |
| for name,func in pairs(DBObjectLib) do |
| db[name] = func |
| end |
| else |
| db.RegisterDefaults = DBObjectLib.RegisterDefaults |
| db.ResetProfile = DBObjectLib.ResetProfile |
| end |
| end |
mRunes/mRunes.lua
New file
0,0 → 1,344
\ No newline at end of file
| local _, class = UnitClass("player") |
| if class ~= "DEATHKNIGHT" then |
| return |
| end |
| mRunes = LibStub("AceAddon-3.0"):NewAddon("mRunes", "AceEvent-3.0", "AceConsole-3.0") |
| local mRunes = mRunes |
| local LSM = LibStub("LibSharedMedia-3.0") |
| local FA = LibStub("LibFrameAnchorRegistry-1.0") |
| LSM:Register("font", "accid", [[Interface\AddOns\mRunes\accid.ttf]]) |
| LSM:Register("statusbar", "HalD", [[Interface\AddOns\mRunes\HalD.tga]]) |
| -- Locals |
| local db |
| local runicPowerBar |
| local FontFlagList = {OUTLINE = "Outline", THICKOUTLINE = "Thick Outline", NONE = "None", MONOCHROME = "Monochrome"} |
| -- Rune Types |
| local RUNETYPE_BLOOD = 1; |
| local RUNETYPE_UNHOLY = 2; |
| local RUNETYPE_FROST = 3; |
| local RUNETYPE_DEATH = 4; |
| -- GUI |
| local UIF |
| local AceGUI = LibStub("AceGUI-3.0") |
| function mRunes:OnInitialize() |
| local defaults = { |
| profile = { |
| Enabled = true, |
| Width = 100, |
| Height = 100, |
| Show = false, |
| x = 0, |
| y = -100, |
| } |
| } |
| self.db = LibStub("AceDB-3.0"):New("mRunesDB", defaults, "Default") |
| self.db.RegisterCallback(self, "OnProfileChanged", "ProfileChanged") |
| self.db.RegisterCallback(self, "OnProfileCopied", "ProfileChanged") |
| self.db.RegisterCallback(self, "OnProfileReset", "ProfileChanged") |
| db = self.db.profile |
| self.Callbacks = LibStub("CallbackHandler-1.0"):New(self) |
| self:RegisterChatCommand("mr", "ToggleConfig") |
| self:SetupLDB() |
| self:SetEnabledState(db.Enabled) |
| local UIFSettings = { |
| font = LibStub("LibSharedMedia-3.0"):Fetch("font", "accid"), |
| fontSize = 16, |
| Text2 = { |
| fontSize = 14, |
| fontColor = {1, 0.2, 0.2}, |
| } |
| } |
| UIF = LibStub("LibGUIFactory-1.0"):GetFactory("mRunes", UIFSettings) |
| end |
| function mRunes:OnEnable() |
| if not self.MainFrame then |
| self:CreateMainFrame() |
| end |
| -- Register Events |
| self:RegisterEvent("PLAYER_REGEN_DISABLED", "EnterCombat") |
| self:RegisterEvent("PLAYER_REGEN_ENABLED", "LeaveCombat") |
| FA.RegisterCallback(self, "FrameRegistered", "ApplySettings") |
| self:ApplySettings() |
| end |
| function mRunes:OnDisable() |
| end |
| function mRunes:ProfileChanged() |
| db = self.db.profile |
| self:ApplySettings() |
| end |
| -- ~~~~~~~~~~~~~~~~~~~~~~ |
| -- Events ~~~~~~~~~~~~~~~ |
| -- ~~~~~~~~~~~~~~~~~~~~~~ |
| function mRunes:EnterCombat(event) |
| self.Callbacks:Fire("EnteringCombat") |
| end |
| function mRunes:LeaveCombat(event) |
| self.Callbacks:Fire("LeavingCombat") |
| end |
| -- ~~~~~~~~~~~~~~~~~~~~~~ |
| -- Frame ~~~~~~~~~~~~~~~~ |
| -- ~~~~~~~~~~~~~~~~~~~~~~ |
| function mRunes:CreateMainFrame() |
| local frame = CreateFrame("Frame", nil, UIParent) |
| local t = frame:CreateTexture() |
| t:SetAllPoints() |
| t:SetTexture(0, 1, 1, 0.5) |
| frame.bg = t |
| FA:RegisterAnchor("mRunes", "Center", "mRunesCenter", frame) |
| local text = frame:CreateFontString(nil) |
| text:SetFont(LSM:Fetch("font", "accid"), 20, "OUTLINE") |
| text:SetText("mRunes Center") |
| text:SetAllPoints() |
| frame:Hide() |
| self.MainFrame = frame |
| end |
| -- ~~~~~~~~~~~~~~~~~~~~~~ |
| -- Settings ~~~~~~~~~~~~~ |
| -- ~~~~~~~~~~~~~~~~~~~~~~ |
| function mRunes:ApplySettings() |
| self.MainFrame:ClearAllPoints() |
| self.MainFrame:SetPoint("CENTER", db.x, db.y) |
| self.MainFrame:SetWidth(db.Width) |
| self.MainFrame:SetHeight(db.Height) |
| if db.Show then |
| self.FadeIn(self.MainFrame) |
| else |
| self.FadeOut(self.MainFrame) |
| end |
| end |
| -- ~~~~~~~~~~~~~~~~~~~~~~~ |
| -- Anchoring ~~~~~~~~~~~~~ |
| -- ~~~~~~~~~~~~~~~~~~~~~~~ |
| do |
| local AnchorList = {} |
| function mRunes:GetAnchorList() |
| AnchorList = AnchorList or {} |
| AnchorList["TOPLEFT"] = "Top left" |
| AnchorList["TOP"] = "Top" |
| AnchorList["TOPRIGHT"] = "Top Right" |
| AnchorList["RIGHT"] = "Right" |
| AnchorList["BOTTOMRIGHT"] = "Bottom right" |
| AnchorList["BOTTOM"] = "Bottom" |
| AnchorList["BOTTOMLEFT"] = "Bottom left" |
| AnchorList["LEFT"] = "Left" |
| AnchorList["CENTER"] = "Center" |
| return AnchorList |
| end |
| end |
| -- ~~~~~~~~~~~~~~~~~~~~~~ |
| -- Config ~~~~~~~~~~~~~~~ |
| -- ~~~~~~~~~~~~~~~~~~~~~~ |
| do |
| local configMode = false |
| local function ToggleConfigMode() |
| configMode = not configMode |
| mRunes.Callbacks:Fire("ToggleConfigMode", configMode) |
| end |
| local function Callback() |
| mRunes:ApplySettings() |
| end |
| local SortedModules = {} |
| local OptionsStatus = {} |
| local OptionsFrame |
| local function SortModules(a, b) |
| return a.DisplayOrder < b.DisplayOrder |
| end |
| function mRunes:ToggleConfig() |
| if not OptionsFrame then |
| OptionsFrame = UIF:Frame("mRunes") |
| OptionsFrame:SetLayout("Flow") |
| OptionsFrame:SetWidth(813) |
| OptionsFrame:SetHeight(630) |
| OptionsFrame:Hide() |
| OptionsFrame:SetCallback("OnClose", function(widget) |
| OptionsFrame:ReleaseChildren() |
| OptionsFrame.frame:Hide() |
| end) |
| end |
| if OptionsFrame.frame:IsShown() then |
| OptionsFrame:Hide() |
| return |
| else |
| OptionsFrame:AddChild(UIF:Button("Toggle Config Mode", ToggleConfigMode)) |
| m = UIF:TreeGroup() |
| m:SetFullHeight(true) |
| m:SetLayout("Fill") |
| m:SetCallback("OnGroupSelected", function(self, event, group) |
| SelectedOption = group |
| self:DoLayout() |
| self.parent:DoLayout() |
| end) |
| OptionsFrame:AddChild(m) |
| end |
| m:AddGroup({{text = "Main", value = "Main"}}, function() |
| local returnGroup = AceGUI:Create("SimpleGroup") |
| returnGroup:SetLayout("Flow") |
| returnGroup:SetFullWidth(true) |
| returnGroup:AddChild(UIF:CheckBox("Show mRunes Center", db, "Show", Callback, "The center is the point hat all modules position around")) |
| local group = UIF:InlineGroup1("Position") |
| returnGroup:AddChild(group) |
| group:AddChild(UIF:Text1("This position will effect all modules. Use to move mRunes around as a whole when you have positioned each item relative to eachother as you want them.")) |
| group:AddChild(UIF:PositionSlider("x", "X", db, "x", 0.1, Callback, 0.5)) |
| group:AddChild(UIF:PositionSlider("y", "Y", db, "y", 0.1, Callback, 0.5)) |
| return returnGroup |
| end) |
| wipe(SortedModules) |
| for moduleName, module in self:IterateModules() do |
| if module.GetOptions and type(module.GetOptions) == "function" then |
| tinsert(SortedModules, module) |
| end |
| end |
| table.sort(SortedModules, SortModules) |
| for i, module in pairs(SortedModules) do |
| if module.GetOptions and type(module.GetOptions) == "function" then |
| m:AddGroup({{text = module.DisplayName or module:GetName(), value = module:GetName()}}, module:GetOptions()) |
| end |
| end |
| m:AddGroup({{text = "Profile", value = "Profile"}}, function() |
| return UIF:AceProfileOption(mRunes.db) |
| end) |
| m:SetSelected(SelectedOption or "Main") |
| m:SetStatusTable(OptionsStatus) |
| OptionsFrame:Show() |
| end |
| function mRunes:SetupLDB() |
| local LDB = LibStub("LibDataBroker-1.1") |
| if not LDB then return end |
| local l = LDB:NewDataObject("mRunes") |
| l.type = "launcher" |
| l.icon = [[Interface\Icons\Spell_DeathKnight_RuneTap]] |
| l.tocname = "mRunes" |
| l.label = "mRunes" |
| l.OnClick = function(self, button) |
| mRunes:ToggleConfig() |
| end |
| l.OnTooltipShow = function(tt) |
| tt:AddLine("mRunes") |
| tt:AddLine("Click to toggle configuration") |
| end |
| self.ldbojb = l |
| end |
| end |
| -- OnUpdate Stuff ------------------- |
| ------------------------------------- |
| do |
| local OnUpdateFuncs = {} |
| local FuncElapsed = {} |
| local UpdateFrame = CreateFrame("Frame") |
| UpdateFrame:SetScript("OnUpdate", function(self, elapsed) |
| for module, functions in pairs(OnUpdateFuncs) do |
| if functions then |
| for func, data in pairs(functions) do |
| if data.updateRate then |
| data.elapsed = data.elapsed + elapsed |
| if data.elapsed > data.updateRate then |
| func(module, data.elapsed) |
| data.elapsed = 0 |
| end |
| else |
| func(module, elapsed) |
| end |
| end |
| end |
| end |
| end) |
| function mRunes:RegisterOnUpdate(module, func, updateRate) |
| OnUpdateFuncs[module] = OnUpdateFuncs[module] or {} |
| OnUpdateFuncs[module][func] = {updateRate = updateRate, elapsed = 0} |
| end |
| function mRunes:UnregisterOnUpdate(module, func) |
| if OnUpdateFuncs[module] then |
| OnUpdateFuncs[module][func] = nil |
| end |
| end |
| local function Fader(self, elapsed) |
| local currentAlpha = self:GetAlpha() |
| if self.fadingIn then |
| self:Show() |
| if currentAlpha >= self.fadeInTarget then |
| mRunes:UnregisterOnUpdate(self, Fader) |
| self:SetAlpha(self.fadeInTarget) |
| self.fadeInTarget = nil |
| self.fadingIn = false |
| return |
| end |
| self:SetAlpha(self:GetAlpha() + elapsed * 2) |
| else |
| if currentAlpha <= self.fadeOutTarget then |
| self:SetAlpha(self.fadeOutTarget) |
| if self.fadeOutTarget <= 0 then |
| self:Hide() |
| end |
| self.fadeOutTarget = nil |
| mRunes:UnregisterOnUpdate(self, Fader) |
| return |
| end |
| self:SetAlpha(self:GetAlpha() - elapsed * 2) |
| end |
| end |
| function mRunes.FadeIn(frame, reset, target) |
| frame.fadingIn = true |
| frame.fadeInTarget = target or 1 |
| if reset then frame:SetAlpha(0) end |
| mRunes:RegisterOnUpdate(frame, Fader) |
| end |
| function mRunes.FadeOut(frame, target) |
| frame.fadingIn = nil |
| frame.fadeOutTarget = target or 0 |
| mRunes:RegisterOnUpdate(frame, Fader) |
| end |
| end |
mRunes/Changelog-mRunes-1.23.txt
New file
0,0 → 1,13
| tag 1.23 |
| 693c999a86675c5c887dfcbe2898cd57d5d57e13 |
| Mange <> |
| 2010-10-31 19:38:47 +0100 |
| Tagging |
| -------------------- |
| Mange: |
| - Still issues with LibBackdrop, so not using it for now. |
| - Fixed typo on rune names. |
mRunes/mRunes.toc
New file
0,0 → 1,19
\ No newline at end of file
| ## Interface: 40000 |
| ## Title: m|cffe6b155R|runes |
| ## Notes: Replacement for default Rune Frame and more. |
| ## Author: mangeg |
| ## SavedVariables: mRunesDB |
| ## OptionalDeps: Ace3, LibBackdrop1.0, LibSharedMedia-3.0, AceGUI-3.0-SharedMediaWidgets, LibDataBroker-1.1, LibGUIFactory-1.0, LibFrameAnchorRegistry-1.0 |
| ## Version: 1.23 |
| ## X-Curse-Packaged-Version: 1.23 |
| ## X-Curse-Project-Name: mRunes |
| ## X-Curse-Project-ID: mrunes |
| ## X-Curse-Repository-ID: wow/mrunes/mainline |
| Libs\modules.xml |
| mRunes.lua |
| Modules\Runes.lua |
| Modules\RunicPower.lua |
| Modules\Timers.lua |
mRunes/accid.ttf
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
Property changes :
Added: svn:mime-type
+ application/octet-stream
mRunes/HalD.tga
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
Property changes :
Added: svn:mime-type
+ application/octet-stream
WoWInterface
AddOn Sites
© 2004 - 2022 MMOUI
vBulletin © 2024, Jelsoft Enterprises Ltd