Freewood/Freewood-OctoWoW-Core
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
118aee6161915e4c040bf0fb17fa1ce54929d2a1
Freewood-OctoWoW-Core/UI/Kit.lua
T
Freewood 25b4ed3abf Dateien nach "UI" hochladen
2026-10-27 14:06:11 +00:00

1040 lines
34 KiB
Lua
Raw Blame History

-- Freewood-OctoWoW-Core: UI-Bausteine im Stil "Azeroth Codex"
-- Alles aus Farbflaechen, 1-Pixel-Raendern und Spielschriften. Keine eigenen Bilddateien.
-- Farben stammen aus den DESIGN.md-Dateien der Projektideen.
local ADDON, FW = ...
local UI = {}
FW.UI = UI
------------------------------------------------------------------------
-- Farben
------------------------------------------------------------------------
UI.hex = {
bgDeep = "0c0e14",
bg = "0f131f",
panel = "141824",
card = "1a2030",
hover = "242b40",
gold = "c89b3c",
goldLight = "f0bf5c",
goldAntique = "dfb75c",
bronze = "9d7826",
text = "e6e2d6",
textDim = "9a978c",
danger = "e0645a",
success = "6cc070",
}
UI.rarity = {
[0] = "9d9d9d", -- Schlecht
[1] = "ffffff", -- Gewoehnlich
[2] = "1eff00", -- Ungewoehnlich
[3] = "0070dd", -- Selten
[4] = "a335ee", -- Episch
[5] = "ff8000", -- Legendaer
[6] = "e6cc80", -- Artefakt
[7] = "00ccff", -- Erbstueck
}
local colorCache = {}
local function HexToRGB(hex)
return tonumber(hex:sub(1, 2), 16) / 255,
tonumber(hex:sub(3, 4), 16) / 255,
tonumber(hex:sub(5, 6), 16) / 255
end
-- key: Name aus UI.hex oder ein Hex-Wert wie "ff8000". Rueckgabe: r, g, b, a
function UI.Color(key, alpha)
local c = colorCache[key]
if not c then
c = { HexToRGB(UI.hex[key] or key) }
colorCache[key] = c
end
return c[1], c[2], c[3], alpha or 1
end
function UI.Hex(key)
return UI.hex[key] or key
end
function UI.RarityHex(quality)
return UI.rarity[quality or 1] or UI.rarity[1]
end
------------------------------------------------------------------------
-- Schriften
------------------------------------------------------------------------
function UI.GetFontPath(kind)
if kind == "heading" then
return "Fonts\\FRIZQT__.TTF"
end
return STANDARD_TEXT_FONT or "Fonts\\FRIZQT__.TTF"
end
function UI.SetFont(fontString, kind, size, flags)
local ok = fontString:SetFont(UI.GetFontPath(kind), size or 12, flags or "")
if not ok then
fontString:SetFont(STANDARD_TEXT_FONT or "Fonts\\FRIZQT__.TTF", size or 12, flags or "")
end
end
-- opts: font ("body"/"heading"), size, color, justify, justifyV, flags, layer
function UI.CreateLabel(parent, text, opts)
opts = opts or {}
local fs = parent:CreateFontString(nil, opts.layer or "OVERLAY")
UI.SetFont(fs, opts.font or "body", opts.size or 12, opts.flags)
fs:SetTextColor(UI.Color(opts.color or "text"))
fs:SetJustifyH(opts.justify or "LEFT")
fs:SetJustifyV(opts.justifyV or "MIDDLE")
fs:SetText(text or "")
return fs
end
------------------------------------------------------------------------
-- Flaechen und Raender
------------------------------------------------------------------------
function UI.AddBorder(frame, colorKey, alpha, thickness)
thickness = thickness or 1
local b = {}
b.top = frame:CreateTexture(nil, "BORDER")
b.top:SetPoint("TOPLEFT", frame, "TOPLEFT", 0, 0)
b.top:SetPoint("TOPRIGHT", frame, "TOPRIGHT", 0, 0)
b.top:SetHeight(thickness)
b.bottom = frame:CreateTexture(nil, "BORDER")
b.bottom:SetPoint("BOTTOMLEFT", frame, "BOTTOMLEFT", 0, 0)
b.bottom:SetPoint("BOTTOMRIGHT", frame, "BOTTOMRIGHT", 0, 0)
b.bottom:SetHeight(thickness)
b.left = frame:CreateTexture(nil, "BORDER")
b.left:SetPoint("TOPLEFT", frame, "TOPLEFT", 0, -thickness)
b.left:SetPoint("BOTTOMLEFT", frame, "BOTTOMLEFT", 0, thickness)
b.left:SetWidth(thickness)
b.right = frame:CreateTexture(nil, "BORDER")
b.right:SetPoint("TOPRIGHT", frame, "TOPRIGHT", 0, -thickness)
b.right:SetPoint("BOTTOMRIGHT", frame, "BOTTOMRIGHT", 0, thickness)
b.right:SetWidth(thickness)
frame.fwBorder = b
UI.SetBorderColor(frame, colorKey, alpha)
return b
end
function UI.SetBorderColor(frame, colorKey, alpha)
local b = frame.fwBorder
if not b then
return
end
local r, g, bl, a = UI.Color(colorKey, alpha)
b.top:SetColorTexture(r, g, bl, a)
b.bottom:SetColorTexture(r, g, bl, a)
b.left:SetColorTexture(r, g, bl, a)
b.right:SetColorTexture(r, g, bl, a)
end
function UI.CreatePanel(parent, bgKey, borderKey)
local p = CreateFrame("Frame", nil, parent)
p.bg = p:CreateTexture(nil, "BACKGROUND")
p.bg:SetAllPoints()
p.bg:SetColorTexture(UI.Color(bgKey or "panel"))
if borderKey then
UI.AddBorder(p, borderKey)
end
return p
end
function UI.CreateDivider(parent, colorKey, alpha)
local t = parent:CreateTexture(nil, "ARTWORK")
t:SetHeight(1)
t:SetColorTexture(UI.Color(colorKey or "bronze", alpha or 0.6))
return t
end
------------------------------------------------------------------------
-- Tooltips
------------------------------------------------------------------------
-- title: Text oder Funktion; lines: Text, Liste von Texten oder Funktion
function UI.AttachTooltip(frame, title, lines, anchor)
frame:HookScript("OnEnter", function(self)
GameTooltip:SetOwner(self, anchor or "ANCHOR_RIGHT")
local t = type(title) == "function" and title() or title
GameTooltip:SetText(t or "", 1, 1, 1)
local l = type(lines) == "function" and lines() or lines
if type(l) == "string" then
l = { l }
end
for _, line in ipairs(l or {}) do
GameTooltip:AddLine(line, 0.8, 0.8, 0.8, true)
end
GameTooltip:Show()
end)
frame:HookScript("OnLeave", function()
GameTooltip:Hide()
end)
end
------------------------------------------------------------------------
-- Knoepfe
------------------------------------------------------------------------
local BUTTON_STYLES = {
default = { bg = "card", bgHover = "hover", border = "bronze", borderHover = "gold", text = "text" },
primary = { bg = "gold", bgHover = "goldLight", border = "goldLight", borderHover = "goldAntique", text = "bgDeep" },
ghost = { bg = "bg", bgHover = "hover", border = "bg", borderHover = "bronze", text = "text" },
-- Zerstoerende Aktionen: normal unauffaellig, beim Darueberfahren rot
danger = { bg = "card", bgHover = "hover", border = "bronze", borderHover = "danger", text = "text" },
dangerActive = { bg = "card", bgHover = "hover", border = "danger", borderHover = "danger", text = "danger" },
}
local function RefreshButton(b)
local style = BUTTON_STYLES[b.fwStyleName] or BUTTON_STYLES.default
local enabled = b:IsEnabled() and true or false
local hovered = b.fwHover and enabled
b.bg:SetColorTexture(UI.Color(hovered and style.bgHover or style.bg))
UI.SetBorderColor(b, hovered and style.borderHover or style.border)
b.label:SetTextColor(UI.Color(style.text))
b:SetAlpha(enabled and 1 or 0.45)
end
-- styleName: "default", "primary" oder "ghost"
function UI.CreateButton(parent, text, width, height, onClick, styleName)
local b = CreateFrame("Button", nil, parent)
b:SetSize(width or 120, height or 28)
b.fwStyleName = styleName or "default"
b.bg = b:CreateTexture(nil, "BACKGROUND")
b.bg:SetAllPoints()
UI.AddBorder(b, (BUTTON_STYLES[b.fwStyleName] or BUTTON_STYLES.default).border)
b.label = UI.CreateLabel(b, text, { size = 12, justify = "CENTER" })
b.label:SetPoint("CENTER", 0, 0)
b:SetScript("OnEnter", function(self)
self = self or this
if not self then return end
self.fwHover = true
RefreshButton(self)
end)
b:SetScript("OnLeave", function(self)
self = self or this
if not self then return end
self.fwHover = false
RefreshButton(self)
end)
b:SetScript("OnClick", function(self, ...)
if onClick then
onClick(self, ...)
end
end)
function b:SetLabel(newText)
self.label:SetText(newText)
end
function b:SetStyle(name)
self.fwStyleName = name
RefreshButton(self)
end
function b:SetButtonEnabled(on)
if on then
self:Enable()
else
self:Disable()
end
RefreshButton(self)
end
RefreshButton(b)
return b
end
-- Tab-Knopf mit Goldlinie fuer den aktiven Zustand
function UI.CreateTabButton(parent, text)
local b = CreateFrame("Button", nil, parent)
b:SetHeight(34)
b.hl = b:CreateTexture(nil, "BACKGROUND")
b.hl:SetAllPoints()
b.hl:SetColorTexture(UI.Color("hover", 0.5))
b.hl:Hide()
b.under = b:CreateTexture(nil, "ARTWORK")
b.under:SetHeight(2)
b.under:SetPoint("BOTTOMLEFT", b, "BOTTOMLEFT", 0, 0)
b.under:SetPoint("BOTTOMRIGHT", b, "BOTTOMRIGHT", 0, 0)
b.under:SetColorTexture(UI.Color("gold"))
b.under:Hide()
b.label = UI.CreateLabel(b, text, { font = "heading", size = 13, color = "textDim", justify = "CENTER" })
b.label:SetPoint("CENTER", 0, 1)
b:SetWidth(math.max(90, b.label:GetStringWidth() + 36))
function b:SetActive(active)
self.fwActive = active
if active then
self.label:SetTextColor(UI.Color("goldLight"))
self.under:Show()
self.hl:Hide()
else
self.label:SetTextColor(UI.Color("textDim"))
self.under:Hide()
end
end
function b:SetLabel(newText)
self.label:SetText(newText)
self:SetWidth(math.max(90, self.label:GetStringWidth() + 36))
end
b:SetScript("OnEnter", function(self)
if not self.fwActive then
self.hl:Show()
self.label:SetTextColor(UI.Color("text"))
end
end)
b:SetScript("OnLeave", function(self)
self.hl:Hide()
if not self.fwActive then
self.label:SetTextColor(UI.Color("textDim"))
end
end)
return b
end
------------------------------------------------------------------------
-- Kontrollkaestchen
------------------------------------------------------------------------
-- Hoehe eines umbrochenen Textes (Zeilen mal Zeilenhoehe, falls die Schrift keine Hoehe meldet)
function UI.TextHeight(fs, minHeight)
local h = fs.GetStringHeight and fs:GetStringHeight()
if type(h) ~= "number" or h <= 0 then
h = 14
end
return math.max(h, minHeight or 0)
end
-- Text auf eine Breite setzen und umbrechen; gibt die Hoehe zurueck
function UI.FitLabel(fs, width, minHeight)
if width and width > 0 then
fs:SetWidth(width)
end
fs:SetWordWrap(true)
fs:SetJustifyV("TOP")
fs:SetHeight(0) -- feste Hoehe aufheben, sonst misst die Schrift nur die abgeschnittene Hoehe
local h = UI.TextHeight(fs, minHeight)
fs:SetHeight(h)
return h
end
-- Kontrollkaestchen. c:Fit(breite) setzt die Breite, bricht den Text um und passt die Hoehe an
-- (Rueckgabe: Hoehe). Haengt das Kaestchen links und rechts an einem Rahmen, passt es sich
-- beim Aendern der Fenstergroesse selbst an.
local CHECK_TEXT_X = 28
local CHECK_MIN_H = 22
function UI.CreateCheckbox(parent, labelText, getFn, setFn)
local c = CreateFrame("Button", nil, parent)
c:SetHeight(24)
local box = UI.CreatePanel(c, "card", "bronze")
box:SetSize(18, 18)
box:SetPoint("LEFT", c, "LEFT", 0, 0)
local check = box:CreateTexture(nil, "ARTWORK")
check:SetPoint("TOPLEFT", box, "TOPLEFT", 4, -4)
check:SetPoint("BOTTOMRIGHT", box, "BOTTOMRIGHT", -4, 4)
check:SetColorTexture(UI.Color("goldLight"))
c.label = UI.CreateLabel(c, labelText, { size = 12 })
c.label:SetPoint("LEFT", box, "RIGHT", 10, 0)
c:SetWidth(math.max(120, c.label:GetStringWidth() + 40))
c.fitWidth = nil
c.isFit = true
function c:Fit(width)
width = width or self:GetWidth()
if not width or width <= 0 then
return self:GetHeight()
end
if not self.fitWidth then
-- erstes Fit: Kaestchen und Text oben ausrichten (mehrzeiliger Text)
box:ClearAllPoints()
box:SetPoint("TOPLEFT", self, "TOPLEFT", 0, -2)
self.label:ClearAllPoints()
self.label:SetPoint("TOPLEFT", self, "TOPLEFT", CHECK_TEXT_X, -4)
end
self.fitWidth = width
self:SetWidth(width)
self.label:SetWidth(math.max(40, width - CHECK_TEXT_X))
self.label:SetWordWrap(true)
self.label:SetJustifyV("TOP")
self.label:SetHeight(0)
local h = math.max(CHECK_MIN_H, UI.TextHeight(self.label, 14) + 8)
self.label:SetHeight(h - 4)
self:SetHeight(h)
return h
end
function c:SetLabel(text)
self.label:SetText(text or "")
if self.fitWidth then
self:Fit(self.fitWidth)
end
end
c:SetScript("OnSizeChanged", function(self)
-- Breite immer vom Rahmen selbst lesen (die Argumente des Ereignisses sind im Client nicht verlaesslich)
local w = self:GetWidth()
if self.fitWidth and type(w) == "number" and w > 0 and math.abs(w - self.fitWidth) > 0.5 then
self:Fit(w)
end
end)
function c:Refresh()
if getFn() then
check:Show()
else
check:Hide()
end
end
c:SetScript("OnClick", function(self)
setFn(not getFn())
self:Refresh()
end)
c:SetScript("OnEnter", function()
UI.SetBorderColor(box, "gold")
end)
c:SetScript("OnLeave", function()
UI.SetBorderColor(box, "bronze")
end)
c:Refresh()
return c
end
------------------------------------------------------------------------
-- Vertikaler Stapel: ordnet Bausteine untereinander an und passt sich der Breite an
-- local stack = UI.CreateStack(frame, { gap = 6, x = 0, y = 0 })
-- stack:Add(widget, { gap = 10, indent = 0, stretch = true, fit = true, height = 30 })
-- fit Kontrollkaestchen/Text: wird auf die Breite umgebrochen, Hoehe folgt dem Text
-- stretch Baustein haengt auch am rechten Rand (Trennlinien, Textblock)
-- height feste Hoehe (sonst die aktuelle Hoehe des Bausteins)
-- stack:Layout() ordnet neu; stack.height ist die Gesamthoehe. Aenderungen der Breite des
-- Rahmens ordnen automatisch neu an (stack.onHeight wird danach gerufen).
------------------------------------------------------------------------
function UI.CreateStack(parent, opts)
opts = opts or {}
local stack = { items = {}, gap = opts.gap or 6, x = opts.x or 0, y = opts.y or 0, pad = opts.pad or 0, height = 0 }
function stack:Add(widget, o)
o = o or {}
self.items[#self.items + 1] = { w = widget, gap = o.gap, indent = o.indent or 0, stretch = o.stretch,
fit = o.fit, height = o.height, minHeight = o.minHeight }
return widget
end
function stack:Width()
local w = parent.GetWidth and parent:GetWidth() or 0
return math.max(0, (w or 0) - self.x - self.pad)
end
function stack:Layout()
local width = self:Width()
local y = self.y
for _, it in ipairs(self.items) do
local w = it.w
if not w.stackHidden then
local avail = width - it.indent
local h
if it.fit then
if w.isFit then
h = w:Fit(avail)
else
h = UI.FitLabel(w, avail, it.minHeight)
end
elseif it.height then
h = it.height
w:SetHeight(h)
else
h = w:GetHeight() or 0
end
y = y + (it.gap or self.gap)
w:ClearAllPoints()
w:SetPoint("TOPLEFT", parent, "TOPLEFT", self.x + it.indent, -y)
if it.stretch then
w:SetPoint("TOPRIGHT", parent, "TOPRIGHT", -self.pad, -y)
end
y = y + h
end
end
self.height = y + self.pad
if self.onHeight then
self.onHeight(self.height)
end
return self.height
end
function stack:Hook()
local old = parent.GetScript and parent:GetScript("OnSizeChanged")
parent:SetScript("OnSizeChanged", function(f, w, h)
if old then old(f, w, h) end
w = f:GetWidth()
if type(w) == "number" and w > 0 and math.abs(w - (stack.lastW or 0)) > 0.5 then
stack.lastW = w
stack:Layout()
end
end)
end
stack:Hook()
return stack
end
------------------------------------------------------------------------
-- Schieberegler (waagerecht). Der Wert wird beim Loslassen uebernommen (setFn), waehrend des
-- Ziehens zeigt nur die Anzeige den Wert; so ruckelt nichts, wenn der Regler selbst die Groesse aendert.
-- local s = UI.CreateSlider(parent, 150, { min = 50, max = 150, step = 5, get = fn, set = fn, format = fn })
------------------------------------------------------------------------
function UI.CreateSlider(parent, width, opts)
local s = CreateFrame("Button", nil, parent)
s:SetSize(width or 150, 20)
local lo, hi, step = opts.min or 0, opts.max or 100, opts.step or 1
local track = s:CreateTexture(nil, "BACKGROUND")
track:SetColorTexture(UI.Color("card"))
track:SetHeight(4)
track:SetPoint("LEFT", s, "LEFT", 0, 0)
track:SetPoint("RIGHT", s, "RIGHT", 0, 0)
local fill = s:CreateTexture(nil, "ARTWORK")
fill:SetColorTexture(UI.Color("bronze"))
fill:SetHeight(4)
fill:SetPoint("LEFT", s, "LEFT", 0, 0)
local thumb = s:CreateTexture(nil, "OVERLAY")
thumb:SetSize(8, 16)
thumb:SetColorTexture(UI.Color("goldLight"))
local value = lo
local function Snap(v)
v = math.floor((v - lo) / step + 0.5) * step + lo
return math.max(lo, math.min(hi, v))
end
local function Show(v)
value = Snap(v)
local frac = (hi > lo) and ((value - lo) / (hi - lo)) or 0
local travel = math.max(1, (s:GetWidth() or width or 150) - 8)
thumb:ClearAllPoints()
thumb:SetPoint("LEFT", s, "LEFT", frac * travel, 0)
fill:SetWidth(math.max(1, frac * travel + 4))
if s.onText then s.onText(value) end
end
function s:SetValue(v) Show(v) end
function s:GetValue() return value end
function s:Refresh() Show(opts.get and opts.get() or lo) end
local function FromCursor()
local x = GetCursorPosition()
local scale = s:GetEffectiveScale() or 1
local left = s:GetLeft()
if not x or not left then return value end
local travel = math.max(1, (s:GetWidth() or 150) - 8)
local frac = ((x / scale) - left - 4) / travel
return lo + math.max(0, math.min(1, frac)) * (hi - lo)
end
s:SetScript("OnMouseDown", function(self)
Show(FromCursor())
self:SetScript("OnUpdate", function() Show(FromCursor()) end)
end)
s:SetScript("OnMouseUp", function(self)
self:SetScript("OnUpdate", nil)
Show(FromCursor())
if opts.set then opts.set(value) end
end)
s:SetScript("OnSizeChanged", function() Show(value) end)
s:SetScript("OnEnter", function() thumb:SetColorTexture(UI.Color("gold")) end)
s:SetScript("OnLeave", function() thumb:SetColorTexture(UI.Color("goldLight")) end)
return s
end
------------------------------------------------------------------------
-- Scrollbereich mit schmaler eigener Leiste
-- Ergebnis: holder (Frame). holder.child ist der Inhalt, holder:SetContentHeight(h)
-- passt die Hoehe an. Groesse ueber SetSize oder Anker festlegen.
------------------------------------------------------------------------
function UI.CreateScrollFrame(parent, width, height)
local holder = CreateFrame("Frame", nil, parent)
if width and height then
holder:SetSize(width, height)
end
local sf = CreateFrame("ScrollFrame", nil, holder)
sf:SetPoint("TOPLEFT", holder, "TOPLEFT", 0, 0)
sf:SetPoint("BOTTOMRIGHT", holder, "BOTTOMRIGHT", -12, 0)
local child = CreateFrame("Frame", nil, sf)
child:SetSize(1, 1)
sf:SetScrollChild(child)
local track = holder:CreateTexture(nil, "BACKGROUND")
track:SetColorTexture(UI.Color("card", 0.7))
track:SetWidth(6)
track:SetPoint("TOPRIGHT", holder, "TOPRIGHT", 0, 0)
track:SetPoint("BOTTOMRIGHT", holder, "BOTTOMRIGHT", 0, 0)
local thumb = CreateFrame("Button", nil, holder)
thumb:SetWidth(6)
local thumbTex = thumb:CreateTexture(nil, "OVERLAY")
thumbTex:SetAllPoints()
thumbTex:SetColorTexture(UI.Color("bronze"))
thumb:Hide()
thumb:SetScript("OnEnter", function()
thumbTex:SetColorTexture(UI.Color("gold"))
end)
thumb:SetScript("OnLeave", function()
thumbTex:SetColorTexture(UI.Color("bronze"))
end)
local contentHeight = 1
local function MaxScroll()
return math.max(0, contentHeight - sf:GetHeight())
end
local function Update()
-- Breite des Inhalts nachziehen, falls OnSizeChanged sie nicht (rechtzeitig) gesetzt hat
local sw = sf:GetWidth()
if sw and sw > 1 and math.abs((child:GetWidth() or 0) - sw) > 0.5 then
child:SetWidth(sw)
end
local viewH = sf:GetHeight()
local range = MaxScroll()
if range <= 0 or viewH <= 0 then
thumb:Hide()
track:Hide()
sf:SetVerticalScroll(0)
return
end
track:Show()
local current = math.min(math.max(sf:GetVerticalScroll(), 0), range)
if current ~= sf:GetVerticalScroll() then
sf:SetVerticalScroll(current)
end
local thumbH = math.max(24, viewH * viewH / contentHeight)
thumb:SetHeight(thumbH)
thumb:ClearAllPoints()
thumb:SetPoint("TOPRIGHT", holder, "TOPRIGHT", 0, -(current / range) * (viewH - thumbH))
thumb:Show()
end
sf:EnableMouseWheel(true)
sf:SetScript("OnMouseWheel", function(self, delta)
local target = self:GetVerticalScroll() - delta * 48
self:SetVerticalScroll(math.min(math.max(target, 0), MaxScroll()))
Update()
end)
sf:SetScript("OnSizeChanged", function(self, w)
w = tonumber(w) or self:GetWidth()
if w and w > 0 then
child:SetWidth(w)
end
Update()
end)
thumb:SetScript("OnMouseDown", function(self)
local _, startY = GetCursorPosition()
local startScroll = sf:GetVerticalScroll()
local scale = self:GetEffectiveScale()
self:SetScript("OnUpdate", function()
local _, y = GetCursorPosition()
local free = sf:GetHeight() - self:GetHeight()
if free <= 0 then
return
end
local target = startScroll + ((startY - y) / scale) * (MaxScroll() / free)
sf:SetVerticalScroll(math.min(math.max(target, 0), MaxScroll()))
Update()
end)
end)
thumb:SetScript("OnMouseUp", function(self)
self:SetScript("OnUpdate", nil)
end)
holder.scroll = sf
holder.child = child
holder.UpdateScroll = Update
function holder:SetContentHeight(h)
contentHeight = math.max(1, h)
child:SetHeight(contentHeight)
Update()
end
function holder:ScrollToTop()
sf:SetVerticalScroll(0)
Update()
end
return holder
end
------------------------------------------------------------------------
-- Mehrzeiliges Textfeld (zum Kopieren und Einfuegen von Codes)
-- Ergebnis: area (Frame) mit area.edit (EditBox)
------------------------------------------------------------------------
function UI.CreateTextArea(parent, width, height)
local area = UI.CreateScrollFrame(parent, width, height)
local back = area:CreateTexture(nil, "BACKGROUND", nil, -1)
back:SetPoint("TOPLEFT", area, "TOPLEFT", 0, 0)
back:SetPoint("BOTTOMRIGHT", area, "BOTTOMRIGHT", -12, 0)
back:SetColorTexture(UI.Color("bgDeep", 0.9))
local frame = CreateFrame("Frame", nil, area)
frame:SetPoint("TOPLEFT", area, "TOPLEFT", 0, 0)
frame:SetPoint("BOTTOMRIGHT", area, "BOTTOMRIGHT", -12, 0)
UI.AddBorder(frame, "bronze")
local edit = CreateFrame("EditBox", nil, area.child)
edit:SetMultiLine(true)
edit:SetAutoFocus(false)
edit:SetMaxLetters(420000)
edit:SetTextInsets(8, 8, 6, 6)
edit:SetPoint("TOPLEFT", area.child, "TOPLEFT", 0, 0)
edit:SetPoint("TOPRIGHT", area.child, "TOPRIGHT", 0, 0)
if not edit:SetFont(UI.GetFontPath("body"), 12, "") then
edit:SetFont("Fonts\\FRIZQT__.TTF", 12, "")
end
edit:SetTextColor(UI.Color("text"))
local function Resize()
local h = math.max(area.scroll:GetHeight(), edit:GetHeight() or 0)
area:SetContentHeight(h)
end
edit:SetScript("OnTextChanged", function()
C_Timer.After(0, Resize)
end)
edit:SetScript("OnEscapePressed", function(self)
self:ClearFocus()
end)
-- Klick in den leeren Bereich setzt den Cursor ins Feld
area.scroll:EnableMouse(true)
area.scroll:SetScript("OnMouseDown", function()
edit:SetFocus()
end)
area.edit = edit
function area:SetText(text)
edit:SetText(text or "")
C_Timer.After(0, Resize)
end
function area:GetText()
return edit:GetText()
end
function area:SelectAll()
edit:SetFocus()
edit:HighlightText()
end
return area
end
------------------------------------------------------------------------
-- Item-Platz (Symbol mit Seltenheitsrahmen)
------------------------------------------------------------------------
function UI.CreateItemSlot(parent, size)
size = size or 44
local slot = UI.CreatePanel(parent, "bgDeep", "bronze")
slot:SetSize(size, size)
slot.icon = slot:CreateTexture(nil, "ARTWORK")
slot.icon:SetPoint("TOPLEFT", slot, "TOPLEFT", 2, -2)
slot.icon:SetPoint("BOTTOMRIGHT", slot, "BOTTOMRIGHT", -2, 2)
slot.icon:SetTexCoord(0.07, 0.93, 0.07, 0.93)
function slot:SetItem(itemID)
self.itemID = itemID
if not itemID then
self.icon:SetTexture(nil)
UI.SetBorderColor(self, "bronze")
return
end
FW.Util.RequestItem(itemID, function(info)
if self.itemID ~= itemID or not info then
return
end
self.icon:SetTexture(info.icon)
UI.SetBorderColor(self, UI.RarityHex(info.quality))
end)
end
return slot
end
------------------------------------------------------------------------
-- Kennzahl-Karte (kleine Beschriftung oben, Wert darunter)
-- card:SetValue(text, colorKey)
------------------------------------------------------------------------
function UI.CreateStatCard(parent, labelText, width, height)
local card = UI.CreatePanel(parent, "card", "bronze")
card:SetSize(width or 150, height or 54)
card.label = UI.CreateLabel(card, labelText, { size = 10, color = "textDim", flags = "" })
card.label:SetPoint("TOPLEFT", card, "TOPLEFT", 10, -8)
card.value = UI.CreateLabel(card, "-", { font = "heading", size = 15, color = "text" })
card.value:SetPoint("BOTTOMLEFT", card, "BOTTOMLEFT", 10, 8)
function card:SetValue(text, colorKey)
self.value:SetText(text or "-")
self.value:SetTextColor(UI.Color(colorKey or "text"))
end
function card:SetLabel(text)
self.label:SetText(text)
end
return card
end
------------------------------------------------------------------------
-- Marke (eckig, kein Pillenformat), z. B. fuer Raenge und Filter
-- chip:SetText(text, colorKey)
------------------------------------------------------------------------
function UI.CreateChip(parent, text, colorKey)
local chip = UI.CreatePanel(parent, "bgDeep", colorKey or "bronze")
chip:SetHeight(20)
chip.label = UI.CreateLabel(chip, text, { size = 11, color = colorKey or "goldLight", justify = "CENTER" })
chip.label:SetPoint("CENTER", chip, "CENTER", 0, 0)
chip:SetWidth(math.max(28, chip.label:GetStringWidth() + 16))
function chip:SetText(newText, newColorKey)
self.label:SetText(newText)
if newColorKey then
self.label:SetTextColor(UI.Color(newColorKey))
UI.SetBorderColor(self, newColorKey)
end
self:SetWidth(math.max(28, self.label:GetStringWidth() + 16))
end
return chip
end
------------------------------------------------------------------------
-- Dropdown-Auswahl
-- opts.prefix Text vor dem Wert, zum Beispiel "Typ" ergibt "Typ: Waffe"
-- opts.allText Text fuer "keine Auswahl" (Wert nil); fehlt er, gibt es diesen Eintrag nicht
-- opts.getOptions Funktion, die eine Liste { { value = ..., text = ... }, ... } liefert (beim Oeffnen gelesen)
-- opts.textOf Funktion(value) -> Text, spart das Lesen der ganzen Liste fuer die Beschriftung (optional)
-- opts.onChange Funktion(value) nach einer Auswahl durch den Benutzer
-- opts.maxRows sichtbare Zeilen, bevor gescrollt wird (Standard 12)
-- Rueckgabe: Button mit :SetValue(v), :GetValue(), :Refresh(), :Open(), :Close()
------------------------------------------------------------------------
local DD_ROW = 20
local ddPopup, ddCatcher, ddOwner
local function CloseDropdown()
if ddPopup then ddPopup:Hide() end
if ddCatcher then ddCatcher:Hide() end
local owner = ddOwner
ddOwner = nil
if owner and owner.Refresh then owner:Refresh() end
end
UI.CloseDropdown = CloseDropdown
local function EnsureDropdownPopup()
if ddPopup then
return
end
-- unsichtbare Flaeche hinter der Liste: ein Klick daneben schliesst sie
ddCatcher = CreateFrame("Button", nil, UIParent)
ddCatcher:SetAllPoints(UIParent)
ddCatcher:SetFrameStrata("FULLSCREEN_DIALOG")
ddCatcher:RegisterForClicks("AnyUp")
ddCatcher:SetScript("OnClick", CloseDropdown)
ddCatcher:Hide()
ddPopup = UI.CreatePanel(UIParent, "bgDeep", "gold")
ddPopup:SetFrameStrata("FULLSCREEN_DIALOG")
ddPopup:SetFrameLevel((ddCatcher:GetFrameLevel() or 1) + 5)
ddPopup:EnableMouse(true)
ddPopup.list = UI.CreateScrollFrame(ddPopup)
ddPopup.list:SetPoint("TOPLEFT", ddPopup, "TOPLEFT", 2, -2)
ddPopup.list:SetPoint("BOTTOMRIGHT", ddPopup, "BOTTOMRIGHT", -2, 2)
ddPopup.rows = {}
ddPopup:Hide()
end
local function DropdownRow(index)
local row = ddPopup.rows[index]
if row then
return row
end
local child = ddPopup.list.child
row = CreateFrame("Button", nil, child)
row:SetHeight(DD_ROW)
row:SetPoint("TOPLEFT", child, "TOPLEFT", 0, -(index - 1) * DD_ROW)
row:SetPoint("TOPRIGHT", child, "TOPRIGHT", 0, -(index - 1) * DD_ROW)
row.hl = row:CreateTexture(nil, "BACKGROUND")
row.hl:SetAllPoints()
row.hl:SetColorTexture(UI.Color("hover", 0.9))
row.hl:Hide()
row.label = UI.CreateLabel(row, "", { size = 12 })
row.label:SetPoint("LEFT", row, "LEFT", 8, 0)
row.label:SetPoint("RIGHT", row, "RIGHT", -6, 0)
row.label:SetWordWrap(false)
row:SetScript("OnEnter", function(self) self.hl:Show() end)
row:SetScript("OnLeave", function(self) self.hl:Hide() end)
row:SetScript("OnClick", function(self)
local owner = ddOwner
local value = self.value
CloseDropdown()
if owner then
owner:SetValue(value)
if owner.fwOnChange then owner.fwOnChange(value) end
end
end)
ddPopup.rows[index] = row
return row
end
function UI.CreateDropdown(parent, width, height, opts)
opts = opts or {}
local dd = UI.CreateButton(parent, "", width or 150, height or 20, nil, "default")
dd.fwOnChange = opts.onChange
dd.fwValue = nil
dd.label:ClearAllPoints()
dd.label:SetPoint("LEFT", dd, "LEFT", 8, 0)
dd.label:SetPoint("RIGHT", dd, "RIGHT", -20, 0)
dd.label:SetJustifyH("LEFT")
dd.label:SetWordWrap(false)
dd.arrow = dd:CreateTexture(nil, "OVERLAY")
dd.arrow:SetTexture("Interface\\Minimap\\ROTATING-MINIMAPARROW")
dd.arrow:SetTexCoord(0, 1, 1, 0) -- Pfeil nach unten
dd.arrow:SetVertexColor(UI.Color("goldLight"))
dd.arrow:SetSize(12, 12)
dd.arrow:SetPoint("RIGHT", dd, "RIGHT", -5, -1)
local function Options()
local list = {}
if opts.allText then
list[1] = { value = nil, text = opts.allText }
end
local given = opts.getOptions and opts.getOptions() or {}
for _, o in ipairs(given) do
list[#list + 1] = o
end
return list
end
local function TextOf(value)
if value == nil then
return opts.allText or ""
end
if opts.textOf then
return opts.textOf(value)
end
for _, o in ipairs(Options()) do
if o.value == value then
return o.text
end
end
return tostring(value)
end
-- Beschriftung und Hervorhebung nach dem Wert richten
function dd:Refresh()
local text = TextOf(self.fwValue)
if opts.prefix then
text = opts.prefix .. ": " .. text
end
self:SetLabel(text)
if self.fwValue ~= nil or ddOwner == self then
self:SetStyle("primary")
else
self:SetStyle("default")
end
end
function dd:SetValue(value)
self.fwValue = value
self:Refresh()
end
function dd:GetValue()
return self.fwValue
end
function dd:Close()
if ddOwner == self then CloseDropdown() end
end
function dd:Open()
EnsureDropdownPopup()
local list = Options()
if #list == 0 then
return
end
ddOwner = self
local rows = math.min(#list, opts.maxRows or 12)
local w = math.max(self:GetWidth() or 0, 150)
ddPopup:SetSize(w, rows * DD_ROW + 4)
ddPopup:ClearAllPoints()
local bottom = self:GetBottom()
if bottom and bottom - (rows * DD_ROW + 8) < 0 then
ddPopup:SetPoint("BOTTOMLEFT", self, "TOPLEFT", 0, 2) -- unten kein Platz: darueber oeffnen
else
ddPopup:SetPoint("TOPLEFT", self, "BOTTOMLEFT", 0, -2)
end
for i, o in ipairs(list) do
local row = DropdownRow(i)
row.value = o.value
row.label:SetText(o.text)
if o.value == self.fwValue then
row.label:SetTextColor(UI.Color("goldLight"))
else
row.label:SetTextColor(UI.Color("text"))
end
row:Show()
end
for i = #list + 1, #ddPopup.rows do
ddPopup.rows[i]:Hide()
end
ddPopup.list:SetContentHeight(#list * DD_ROW)
ddPopup.list:ScrollToTop()
ddCatcher:Show()
ddPopup:Show()
self:Refresh()
end
dd:SetScript("OnClick", function(self)
if ddOwner == self then
CloseDropdown()
else
if ddOwner then CloseDropdown() end
self:Open()
end
end)
dd:SetScript("OnHide", function(self) self:Close() end)
dd:Refresh()
return dd
end
Reference in New Issue View Git Blame Copy Permalink