brues/pfUI
1
1
Fork 0
mirror of https://github.com/brues-code/pfUI.git synced 2026-09-22 15:46:56 +00:00
Code Issues 1 Packages Projects Releases Wiki Activity

Compare commits

base: brues/pfUI:v9.0.7
Branches Tags
brues/pfUI:master brues/pfUI:classicapi_next
brues/pfUI:v9.0.26 brues/pfUI:v9.0.25 brues/pfUI:v9.0.24 brues/pfUI:v9.0.23 brues/pfUI:v9.0.22 brues/pfUI:v9.0.21 brues/pfUI:v9.0.20 brues/pfUI:v9.0.19 brues/pfUI:v9.0.18 brues/pfUI:v9.0.17 brues/pfUI:v9.0.16 brues/pfUI:v9.0.15 brues/pfUI:v9.0.14 brues/pfUI:v9.0.13 brues/pfUI:v9.0.12 brues/pfUI:v9.0.11 brues/pfUI:v9.0.10 brues/pfUI:v9.0.9 brues/pfUI:v9.0.8 brues/pfUI:v9.0.7 brues/pfUI:v9.0.6 brues/pfUI:v9.0.5 brues/pfUI:v9.0.4 brues/pfUI:v9.0.3 brues/pfUI:v9.0.2 brues/pfUI:v9.0.1 brues/pfUI:v9.0.0
...
compare: brues/pfUI:classicapi_next
Branches Tags
brues/pfUI:master brues/pfUI:classicapi_next
brues/pfUI:v9.0.26 brues/pfUI:v9.0.25 brues/pfUI:v9.0.24 brues/pfUI:v9.0.23 brues/pfUI:v9.0.22 brues/pfUI:v9.0.21 brues/pfUI:v9.0.20 brues/pfUI:v9.0.19 brues/pfUI:v9.0.18 brues/pfUI:v9.0.17 brues/pfUI:v9.0.16 brues/pfUI:v9.0.15 brues/pfUI:v9.0.14 brues/pfUI:v9.0.13 brues/pfUI:v9.0.12 brues/pfUI:v9.0.11 brues/pfUI:v9.0.10 brues/pfUI:v9.0.9 brues/pfUI:v9.0.8 brues/pfUI:v9.0.7 brues/pfUI:v9.0.6 brues/pfUI:v9.0.5 brues/pfUI:v9.0.4 brues/pfUI:v9.0.3 brues/pfUI:v9.0.2 brues/pfUI:v9.0.1 brues/pfUI:v9.0.0

192 Commits
v9.0.7 ... classicapi_next

Author SHA1 Message Date
Brues cc8b8b476b Removed macrotweak 2026-09-09 23:05:10 -05:00
Brues bd2b6c3105 no need to load macrotweak if ClassicAPI 1.15 is found 2026-09-09 21:48:13 -05:00
Brues 5bede33f00 energytick: sweep the real regen clock, and stop it stuttering 
The mana spark modelled a tick clock that does not exist. Spending mana
restarted the sweep with a five-second span, then it cycled at two seconds
until the next spend -- so every cast reset the phase, and the spark drew a
period the server never runs. There is one regen timer for every power,
REGEN_TIME_FULL (2s), re-armed with `+=` in Player::RegenerateAll and never
touched by casting. The five-second rule is a separate countdown that
SetLastManaUse arms on any mana-costing cast; it changes what a tick pays,
never when ticks land. Inside the window the tick still fires and still pays
mp5 plus whatever share of spirit the player keeps.

That share is common and not computable here. The amounts are readable now
(C_Spell.GetSpellEffectInfo), and the talent, racial and buff sources could be
enumerated -- but the Casting Regen item ladder is equip auras that never
appear in the buff list, and m_modManaRegenInterrupt is never sent. A floor
that is wrong whenever the player wears such an item is worse than showing
what happens: the spark starts an FSR window dim and goes solid on the first
tick that lands inside it.

The sweep is a free-running phase lock on that one clock. Every positive mana
delta used to re-anchor it, and most are not the tick -- Illumination refunds,
Judgement of Wisdom, potions, a Mana Spring totem on its own 2s clock at
another phase -- so the spark snapped back to the edge mid-sweep several times
a cycle. A gain re-anchors only if it lands within 250ms of the predicted
boundary. Two rejected gains exactly one period apart are the real clock and
move the lock, which is how a wrong first lock heals. Rollover advances by
whole periods from the anchor instead of restarting from now, so frame timing
no longer accumulates into drift the lock then has to chase.

Even a correct tick used to hitch the spark: re-anchoring to arrival time
moved it by the jitter, 20-80ms, right at the wrap. Inside an 80ms band the
tick now confirms the sweep and leaves the anchor alone; only the excess is
pulled in. With no self-drift left there is nothing systematic in that band.

The rule is armed from UNIT_SPELLCAST_SUCCEEDED filtered through
C_Spell.GetSpellPowerCost, mirroring Spell::TakePower's condition, rather than
from a mana decrease -- Mana Burn lowers mana without arming the rule.
UNIT_SPELLCAST_CHANNEL_STOP re-arms it, since Unit::Update will not expire it
while the spending spell is still channeling.

The energy period no longer names a spell. Player::RegenerateAll sums
SPELL_AURA_MOD_ENERGY_REGEN_TIME and takes amount * agility / 10 off the timer
in milliseconds; everything in that sum is readable here. The player's own
spells carrying aura 217 come from C_SpellBook.GetPlayerSpellsByAura, passives
count while known (current rank only), anything else while it is up in the
buff list, and each amount is basePoints + baseDice from the effect data. So
Blade Rush is found without GetTalentInfo(2, 16) -- an ordinal into the talent
grid that does not fail when the tree changes but reads another talent's rank
(index 16 is Vigor one tab over) -- and a retune or a second source needs no
edit. The sum is cached and dropped on SPELLS_CHANGED and
PLAYER_AURAS_CHANGED, the two events its two halves move on, so a tick costs
no spellbook walk; agility stays live, it is one call.

The CHAT_MSG_SPELL_SELF_BUFF "You gain ... Energy from" filter is gone. The
phase lock rejects Relentless Strikes and Thistle Tea the same way it rejects
a paladin's refunds, it was English-only, and its ignore-the-next-gain logic
could eat a real tick if events reordered.
 2026-09-09 13:24:17 -05:00
Brues a286843b18 nameplates: gate the per-plate update before classifying it 
The central loop calls the per-plate update for every visible plate ~100 times
a second, and the plate's own throttle sat at the bottom of the function. Above
it ran the whole classification: a GetAlpha call, a castbar IsShown, a cast
lookup, and one or two libthrottle:Get resolutions -- all to work out which
throttle applied, on plates throttled to 10fps that were going to return
anyway. Forty plates makes that four thousand times a second.

Add a cheap gate first, against the floor across all four throttle categories.
Nothing that would have updated can be turned away by it -- a plate past its
real throttle is necessarily past the minimum -- and the category-specific gate
still runs after the classification, unchanged. Event flags are read before
both and bypass both, as they did before.

libthrottle:Get is not a lookup: it walks the saved variables, a defaults
fallback and a preset table, and can build a "<category>_custom" key. Resolve
the four categories in CacheConfig instead, where config changes already land,
and read them from cfg on the hot path. That covers the two calls in the
castbar branch as well.

The castbar hide moves below the cheap gate, which is safe rather than merely
tolerable: a plate showing a castbar sets isCastingNonTarget, which selects the
castbar throttle -- one of the four the floor is derived from -- so it always
clears the first gate and reaches the hide at its normal rate.
 2026-09-09 13:24:17 -05:00
Brues 39840c10fd unitframes: let UpdateVisibility own the event subscriptions 
Every unit frame registered fifteen unit events globally and then sorted them
out per event:

  arg1 == this.label .. this.id or (UnitGUID and arg1 == UnitGUID(this.label .. this.id))

A string concat -- and on a miss a second concat plus a UnitGUID call -- for
every frame, for every unit event fired by anything in the world. Forty-five
frames in a raid, on every health tick of every raider, to conclude "not mine".

UpdateVisibility is the single place a frame's label and id are ever assigned,
and it already pushed the result to SetAttribute("unit", ...). It now caches
the unitstr and points the subscriptions at it, so there is one hook rather
than a set of transitions to catch, and visibilityscan re-running it five
times a second makes it self-healing. A frame that is not in use drops its
unit events entirely.

EnableEvents no longer registers them: a registration keeps its kind, so
plain-registering first would make every later RegisterUnitEvent a no-op.

UNIT_PET and UNIT_HAPPINESS stay plain deliberately. Their branches key on the
frame's label, and UNIT_PET's arg1 is the pet's OWNER -- "player" for a "pet"
frame -- so filtering them by the frame's own unit would drop them.

The GUID alternative is gone. These events fire once per token that resolves
to the unit AND once with the raw GUID, so the token form always arrives and
the GUID clause was only ever a duplicate wake. It dates from b7a0912e, before
ClassicAPI's TokenObserver made synthetic tokens first-class event sources.

Two teardown paths needed help. UnregisterAllEvents drops the filters with the
registrations, so the cached unit has to be cleared or the next
UpdateVisibility believes they are still in place. And PLAYER_LOGOUT silences
the frame while visibilityscan keeps ticking, which would re-register
everything it just dropped -- the crash 132 that branch exists to prevent -- so
the frame now takes itself off the scan list.
 2026-09-09 13:24:17 -05:00
Brues ab98bb7ab5 nameplates: let each plate watch its own unit 
The central handler registered UNIT_AURA, UNIT_FLAGS and the four
UNIT_SPELLCAST_* globally, so every unit event in the world woke it for a
"^nameplate" prefix test, and each of the four branches that survived the test
then resolved the plate back out of arg1 -- UnitGUID + plateByGuid, or
GetNamePlateForUnit.

Register them per plate instead, on the plate's own frame against its own
token. The token is the subscription, so the event only reaches the plate it
concerns and `this` is already that plate: the aura branch is now one
assignment where it used to be a prefix test, an API call and a table lookup.

This is also what makes the approach viable at all. A central listener would
have had to name every token it might care about, and nameplate slots have no
cap -- Events.cpp keeps them in a vector that grows by push_back, with only a
"<80 even in AV-scale scenes" comment for sizing. Any nameplate1..N list would
have been a guess that fails silently in exactly the crowded scenes where
plates matter.

Lifecycle: NAME_PLATE_UNIT_ADDED points the registrations at the new token,
replacing the previous unit rather than stacking, since RegisterUnitEvent over
an already-filtered registration swaps the units. NAME_PLATE_UNIT_REMOVED
unregisters, which is required -- freed slots are reused, and a stale token
would feed the frame another unit's events.

PLAYER_LOGOUT now tears down the plates too. It silenced only the central
frame before; leaving forty plate frames dispatching through logout is the
crash 132 that branch exists to prevent.
 2026-09-09 13:24:17 -05:00
Brues 73f4999004 marktracking: filter to the mark tokens and idle when solo 
UNIT_HEALTH/UNIT_MAXHEALTH register through RegisterUnitEvent for mark1
through mark8, so the scanner stops waking for every unit in the world. Eight
tokens is past the four other clients accept; ClassicAPI takes as many as it
is given, so this file is fork-only.

That makes arg1 always one of eight known strings, so the handler looks the
row index up in a table built alongside markerTokens, instead of running
string.match + tonumber -- which allocated a capture and parsed it on every
health tick of every marked unit.

The fallback poll was the larger cost and the filtering did not touch it: a
full eight-row rebuild once a second for the whole session, whether or not a
marker existed anywhere. Raid markers are a group feature, so the scanner now
watches PARTY_MEMBERS_CHANGED / RAID_ROSTER_UPDATE and creates or cancels the
ticker with group membership -- outside a group no timer is queued at all,
rather than one waking every second to return early. It is deliberately not
keyed on a mark being visible: a marker set on a unit that is out of range
shows no row, and that is precisely the case the poll exists to catch.

The mark-token capability probe at the top goes too. ClassicAPI is a hard
dependency, so the tokens are always there to resolve.
 2026-09-09 13:24:17 -05:00
Brues b7c3fe5333 Filter unit events with RegisterUnitEvent 
ClassicAPI's RegisterUnitEvent registers for an event but only delivers it
when arg1 is one of the given units, so a handler for one unit stops waking
for every other one in the world. Convert the 26 registrations whose unit set
is fixed and known at registration time.

The rule throughout is register the superset and keep the handler's own
check: the filter narrows what arrives, it does not decide what to act on.
castbar is the case that matters -- the player's own casts only ever fire
arg1=="player", never "target"/"focus", so the target and focus bars must
register "player" too, and their UnitIsUnit test is what still rejects a
"player" event while you are targeting a mob.

Two that are not one-line swaps:

  actionbar's two unit events are keys in tables that also drive dispatch, so
  they cannot leave the tables -- and they cannot be plain-registered first,
  because a registration keeps its kind and RegisterUnitEvent over a plain
  one stays plain. They route through a small event_units map instead.

  swingtimer's UNIT_DIED carries a GUID, not a token. The filter is a plain
  case-insensitive string compare with no GUID resolution, so the player's
  own GUID -- fixed for the session -- filters it exactly.

Guards that are now unreachable stay put: the filter applies only when arg1
is a string, so an event that ever fires with a number or no argument is
delivered as if plainly registered, and the handler's own test is what still
rejects it.

Left alone: api/unitframes.lua (the frame's unit changes at runtime and the
handler also matches on GUID), nameplates' six nameplateN events, libdebuff
and libpredict's UNIT_HEALTH (genuinely any unit), and raid.lua's UNIT_PET
(any raid member can own the pet).
 2026-09-09 13:24:17 -05:00
Brues 8e109a585a eqcompare: place the compare after the tooltip settles when Guda is loaded 
Guda anchors its item tooltips with ANCHOR_NONE and its own SetPoint, and
the tooltip module then relocates every ANCHOR_NONE tooltip to its
configured spot. eqcompare picked left or right from GetLeft/GetRight
inside the Set* call -- against the position the tooltip was about to
leave -- so for an item in the left half of the screen the shopping
tooltips anchored to the right edge and rode the relocation off-screen
(vatichild/guda#41). Guda's own inventory block also widens the tooltip
after our hook has run.

With Guda present, resolve the link in the hook but hand the placement to
RunNextFrame, skipping it if the tooltip has hidden since. Guda lists
pfUI as a dependency, so it loads after us: gate on DoesAddOnExist and
flip the flag from ContinueOnAddOnLoaded. Without Guda the hook is
unchanged.
 2026-09-09 13:23:53 -05:00
Brues 83f89be14a unitframes: compare indicator auras without case folding 
The indicator scan lowercased the aura's name and icon on every aura of every
unit, and SetupBuffIndicators lowercased the other side to match. Both sides
come out of the same DBC records byte for byte, so the comparison already held
without any of it: the aura's name and icon are Spell.dbc's localized name and
SpellIcon.dbc's path (aura/Data.cpp fills one struct and emits it as either the
AuraData table or the positional UnitAura tuple), and the indicator record
reads those same two fields through C_Spell.GetSpellName / GetSpellTexture.

So this was two string allocations per aura per scan to reach a result it
already had -- and on Lua 5.0 that is an allocate-and-hash each time, since the
VM interns even when the string exists. RefreshUnit runs this for every unit
frame, which in a raid is 40 frames against up to 32 auras each.

Checked every rank of all 65 indicator spells in Spell.dbc: name and icon are
byte-identical across a spell's whole ladder, no case or spelling drift, so
nothing depended on the fold.

It also drops a crash path. aura/Data.cpp yields nil for the icon when a
spell's SpellIconID is 0, and icon:lower() would have errored on that; name was
guarded on the line above but icon never was. A raw compare is just false.

The equality is now load-bearing, so AddIndicator's comment says to feed it
spell ids and never a hand-written name or icon path -- a literal
"interface\icons\foo" in that table would silently match nothing.
 2026-09-08 16:35:31 -05:00
Brues e59158764c unitframes: identify buff indicators by spell id, not icon path 
Spell.dbc reuses icons freely across unrelated spells, so matching an aura on
its icon alone lit the indicator for the wrong buff. Blessing of Sanctuary
fired on Lightning Shield and Shadowguard, Blessing of Kings on Mage Armor and
Commanding Shout, and Totemic Power on the Blessed Sunfruit food buff -- the
last of which the code already carried a comment about. Fixes #55.

Each entry is now a spell id, resolved once into the aura's name plus its icon,
and a match needs both. Name alone is no better than icon alone: creature and
item auras reuse player spell names, so a mob's "Renew" or a trinket's
"Rejuvenation" would light a HoT indicator. Every rank of a spell carries the
same name and icon, so one id covers the whole rank ladder without listing it.

HOT_INDICATORS folds away with this. It existed to name-check exactly the three
HoTs whose icons were known to collide; that check is now what every entry
does, and the table's only remaining job -- naming a HoT's libpredict key -- is
an argument on the Renew, Regrowth and Rejuvenation entries.

Deriving the name from an id also picks up this client's renames for free. The
paladin blessings are "Hand of Freedom", "Hand of Protection" and "Greater
Blessing of Sacrifice" here, which hardcoded English names would have missed.

All 65 ids were checked against the client's Spell.dbc, SpellIcon.dbc and
SkillLineAbility.dbc: each resolves to the intended aura, with its full rank
ladder sitting on the icon the old list matched.

That check also turned up five entries matching no spell at all on this
client. ability_hunter_misdirection, spell_holy_prayerofmendingtga and
inv_misc_herb_felblossom are TBC leftovers and are gone.
spell_nature_giftofthewild was never right -- Gift of the Wild uses Mark of the
Wild's icon -- and is now covered by id 21849. ability_warrior_rallyingcry
hosts no Commanding Shout either, so that entry now points at the real spell
(45580) and works for the first time.

Unrelated to the above, this file's string.fn(s, ...) calls become s:fn(...).
 2026-09-08 16:28:51 -05:00
Brues 863d99647d Draw the loot history and map overlays from real pools 
Both modules had already grown a pool by hand. loothistory kept usedPlayers /
freePlayers tables with a recycle loop and a table.remove acquire; mapreveal
kept pfOverlays keyed by index, a pfOverlayMax high-water mark, and a
hide-the-tail loop. Replace both with ClassicAPI's Pools.lua backport, which
is what modules/tooltip.lua already uses for its buff icons.

The map explore icons change shape rather than just plumbing. Everything
constant -- size, scripts, mouse, frame level, the magnifying glass texture --
moves into the pool's creator instead of being re-set on every overlay on
every map update, and the acquire moves inside the visibility test. The old
loop built and configured an icon for every overlay in the zone and then hid
most of them again; with "mapexploration" off it built the whole set and hid
all of them. Now nothing is acquired for an icon that will not be shown.

The tile textures lose their pfRevealN names, since pools create anonymous
regions. They were already unique, so nothing was being clobbered -- this
only costs their labels in /fstack.
 2026-09-07 18:41:54 -05:00
Brues 06b3ae8d22 cooldown: stop shadowing the global time() 
`local time = time()` bound the timestamp over the top of the time function
inside that branch, so any later call in the same scope would have indexed a
number. Nothing did, but the name is a trap. Call it currentTime.
 2026-09-07 18:39:28 -05:00
Brues 879d7afe83 cooldown: throttle before the work, not after 
The 0.1s gate sat below the hidden-cooldown check, so every frame, for every
ticking cooldown, the update built "<parent>Cooldown" twice and did two _G
lookups with it. Lua 5.0 interns on every concat -- it allocates and hashes
even when the string already exists -- so this was allocating garbage at the
frame rate times the number of live cooldowns. A profiler run had it at 24s
of accumulated CPU.

Move the gate to the top so a non-tick frame costs one GetTime() and a
compare. The name lookup goes away entirely: pfCreateCoolDown already has the
cooldown frame, so it stashes the reference instead. That is also more
correct than deriving it from the parent's name, which silently skipped the
check for any cooldown not named "<parent>Cooldown".

The text frame and its fontstring were both created with a fixed name, so
every one of the hundreds in a UI clobbered _G.pfCooldownFrame and left it
pointing at whichever was made last. Name them after the cooldown they render
for, falling back to a counter for anonymous ones.

One behavior change: the hidden-cooldown check is now throttled too, so text
can linger up to 100ms after its cooldown frame hides. It only refreshes at
0.1s anyway, and expiry still runs through the remaining < 0 branch.
 2026-09-07 18:14:33 -05:00
Brues 4eab494a01 Name the installed ClassicAPI version in the outdated popup 
"cannot run on this ClassicAPI" named no version, so the player had nothing
to compare against the requirement, and it overstated the failure: pfUI does
load on an old DLL, it just throws wherever it reaches for an API that isn't
there. Put the installed version in the headline and soften it to "will not
work correctly"; the detail line then only has to state the requirement.
 2026-09-07 17:55:56 -05:00
Brues bb8ce8fd63 apparently some addons can't figure out -1 for themselves 2026-09-05 07:19:58 -05:00
brues-code 75c4657ab9 ClassicAPI flavor TOCs, and drop the multi-client scaffolding (#53) 
* nameplates: source totem icons from UnitCreatedBySpell

Read the totem's icon from the totem-drop spell (UnitCreatedBySpell +
GetSpellTexture) instead of the self-aura at index 1 plus a
UNIT_SPELLCAST_SUCCEEDED capture for active totems. The drop spell is a
broadcast descriptor field present for every summoned unit in range, so
it resolves immediately for passive and active totems alike and gives the
totem's own icon rather than the attack-spell proxy. Drops the
UNIT_SPELLCAST_SUCCEEDED registration and handler.

Re-read the spell each render and key the cached texture on the spell id
so an in-place totem swap (same unit, new drop spell -- no plate re-add)
refreshes the icon without needing the plate to leave and re-enter view.

* CAPI min bumped to 1.13.1

* Gracefully disable pfUI when ClassicAPI is missing

Add API_Check.lua as the first TOC entry. When the ClassicAPI DLL is
absent or below the minimum version it sets pfUI_disabled and stands up
an inert stub so the rest of the addon no-ops instead of flooding load
errors: modules and skins register their bodies into no-ops, and the
setfenv'd api/lib files run inside an environment where CreateFrame and
any missing global resolve to a null object -- so no real frames or live
handlers are created and missing API calls just return null. pfUI.lua
bails early on pfUI_disabled.

* auras: scan through GetAuraSlots instead of by-index loops

Every aura scan loop (unit frame buffs/debuffs, dispel indicators, buff and
custom indicators, player buff frame, buffwatch bars, tooltip buff row) now
enumerates a unit's auras once with C_UnitAuras.GetAuraSlots and reads each
aura by slot id via the positional C_UnitAuras.UnitAuraBySlot. The by-index
getters re-walk the aura array from slot 0 on every call, so a per-button
loop over them was quadratic in the aura count; one enumeration plus a
by-slot read per aura is linear.

pfUI.api.ScanAuraSlots(unit, filter, buf, max) wraps GetAuraSlots' fill-a-
table form (table as the 5th argument) so no vararg Lua frame is involved:
Lua 5.0 allocates an `arg` table for every vararg call, which showed up as
nameplate OnUpdate/OnEvent memory growth in the first cut of this change.

Single by-index reads in tooltip and click handlers are unchanged (one call
each, and SetUnitAura takes the same index).

Requires the ClassicAPI build that adds GetAuraSlots' fill form; on an older
DLL the 5th argument is ignored and ScanAuraSlots would read the first slot
id as the count.

* Show Faction/Race icons in chat

* Load pfUI through ClassicAPI's flavor TOCs

ClassicAPI redirects the read of pfUI\pfUI.toc to a flavored file whenever
the DLL is installed, so which TOC the client opens already answers whether
ClassicAPI is there. Split the manifest three ways and let that do the work:

  pfUI.toc             fallback, reached only when ClassicAPI is missing;
                       loads API_Check.lua and nothing else
  pfUI_ClassicAPI.toc  full addon, every non-Turtle client
  pfUI_Turtle.toc      full addon plus init\turtle.xml, on Turtle

The fallback TOC declares no SavedVariables. It used to, while API_Check.lua
reset pfUI_profiles to an empty table on the disabled path -- which truncated
the player's profiles on logout.

With the missing-DLL case handled by TOC selection, API_Check.lua drops the
null object stub that kept the other ~140 files quiet, along with
pfUI_disabled and the now unreachable early return in pfUI.lua. It keeps the
version gate, which still matters: the flavor redirect landed in ClassicAPI
v1.11.0, below the v1.13.1 pfUI needs, so an old DLL still gets served a
flavor TOC. pfUI.lua also loses a verbatim duplicate of the whole check.

Turtle-only files move to init\turtle.xml: modules\turtle-wow.lua (its
TURTLE_WOW_VERSION guard is now redundant) and the lft, turtle_shop,
barbershop, transmog and ebc skins. turtle-wow registers last instead of
75th of 84; the only ordering it relies on is pfUI.chat, registered 8th.

pfSellData moves to env\selldata.lua, listed only in pfUI_ClassicAPI.toc,
since turtle-wow.lua replaces the table wholesale on Turtle. env\tables.lua
keeps an empty declaration so sellvalue.lua has something to index when the
turtle-wow module is disabled.

The release workflow pinned PFUI_CLASSIC_API_LATEST in pfUI.lua, which has
not held that constant since it moved to API_Check.lua, so the pin was
silently doing nothing. It also switches to brues-code/packager@vCAPI, which
recognizes the _ClassicAPI and _Turtle suffixes and applies the TOC build
type filters to them.

* Split the vendor price tables into their own manifests

Turtle's pfSellData moves out of modules\turtle-wow.lua into
env\selldata_turtle.lua, matching env\selldata.lua for the stock list, and
each is pulled in by the manifest for its client: init\stock.xml from
pfUI_ClassicAPI.toc, init\turtle.xml from pfUI_Turtle.toc. Either way it
loads after init\env.xml and replaces the empty pfSellData declared there.

Turtle's prices used to be assigned inside the turtle-wow module body, which
put them on pfUI.env and skipped them entirely when that module was
disabled. At file scope they land on _G and apply either way.

* Drop the vanilla compat layer

compat\vanilla.lua named the handful of things that differed between clients
back when pfUI targeted several. Only one client remains, so every constant
had exactly one value. Inline each at its use site and delete the file,
init\compat.xml, and both TOC entries.

  COOLDOWN_FRAME_TYPE                    -> "Model"
  LOOT_BUTTON_FRAME_TYPE                 -> "LootButton"
  MINIMAP_TRACKING_FRAME                 -> _G.MiniMapTrackingFrame
  FRIENDS_NAME_LOCATION                  -> "ButtonTextNameLocation"
  EVENTS_MINIMAP_ZONE_UPDATE             -> the event list, in panel.lua
  MICRO_BUTTONS                          -> a local in panel.lua
  NAMEPLATE_OBJECTORDER                  -> a local in nameplates.lua
  ACTIONBAR_SECURE_TEMPLATE_BAR/_BUTTON  -> nil, so the argument goes away

NAMEPLATE_FRAMETYPE and PLAYER_BUFF_START_ID had no readers left.

RunMacroText moves to pfUI.lua. compat\vanilla.lua was setfenv'd into the
pfUI environment, so the function only ever existed on pfUI.env; at file
scope it lands on _G as a real export instead. Nothing in pfUI calls it, and
ClassicAPI neither defines nor looks for a RunMacroText global -- it does
the same throwaway edit box natively in src/macro/Execute.cpp and only
defers to a global RunMacro.

* bump CAPI min to 11303

* auras: uncap the self-debuff tooltip lookup

With selfdebuff on, the displayed debuff list is PLAYER-filtered while
GameTooltip:SetUnitAura indexes the unfiltered HARMFUL list, so both
handlers map one to the other by matching name + sourceGUID. That mapping
scanned slots 1..16 only.

The unfiltered harmful list is not capped at 16. Once a unit's 16 debuff
slots are full the server parks further debuffs in buff slots, and
C_UnitAuras classifies by the aura's polarity flag rather than its slot
range, so it reports those as harmful too -- verified live at 18 harmful on
a 20-aura target. Past the sixteenth the lookup found nothing and fell
through to the raw filtered index, opening the wrong tooltip or none.

Both now enumerate however many harmful auras the unit actually has, via
ScanAuraSlots, which also drops the per-index rescan the by-index accessor
was doing. Each handler gets its own slot buffer: OnEnter can fire while a
refresh is showing/hiding frames under the cursor, so sharing the refresh
buffer could clobber a scan mid-walk.

The nameplate module still collects at most 16 debuffs per plate. That one
is a display cap matching its 16 configured icon frames, not an aura-count
assumption, so it is left alone.

* bump CAPI min to 11304
 2026-09-04 19:57:57 -05:00
Brues 5815b9e81e chat: let pfUI's chat colors own their alpha and apply live 
Two problems with routing the native transparency slider into the pfUI panel.

RefreshBackgroundAlpha overwrote the alpha of C.chat.global.background on every
refresh, so anyone with custom colors enabled saw their configured opacity
revert on reload, tab switch and dock change. That value carries its own alpha,
is set by the shipped profiles and is shared with the meter skins, so the slider
must not own it. Skip the alpha mirror entirely when custom colors are on; the
slider still drives the panel on the default theme, which is what issue #48 was
actually about.

The colors were also only applied at module load, so the pickers needed a
/reload to show anything. Extract that into ApplyPanelColors and expose it as
pfUI.chat:UpdateConfig, which the gui resolves as U["chat"], so the three chat
color settings take effect on the spot. CreateBackdrop is re-run first to
restore the appearance theme, which is what lets toggling custom colors back
off return the panel to the global theme without a reload.
 2026-09-02 11:40:20 -05:00
Brues 60f953178f nameplates: validate unitstr before filling the per-unit cache 
cache.player and cache.minion were filled from unitstr before the two guards
that validate it, so a stale identifier poisoned the cache -- and because the
fill is gated on `== nil`, the wrong answer was never recomputed. Players read
back as cache.player == false until the plate was hidden and shown again, which
only appeared to fix it because pool reuse tripped the name/guid wipe.

Two paths produce a stale unitstr: OnUpdate dispatches a targetUpdate to
OnDataChanged before it refreshes plate.istarget, and frameState.mouseoverGuid
is only updated on gaining mouseover, never on losing it.

Hoist the PLAYER_TARGET_CHANGED distrust and the UnitName mismatch check above
the cache fill so an unverified unitstr leaves the cache nil for the next tick
instead of locking in a wrong answer.
 2026-09-02 10:56:46 -05:00
Brues 1dc10964a2 luarc: use nested config form so diagnostics settings apply 2026-09-02 10:31:03 -05:00
Brues 0fc08e77c0 Create .pkgmeta 2026-09-02 10:26:28 -05:00
Brues 7f3795b45b Add .luarc.json for Lua 5.1 language server diagnostics 2026-09-02 10:23:48 -05:00
Brues 8eee766652 chat: apply Blizzard per-window transparency to docked backdrops 
The native chat background transparency slider drives FCF_SetWindowAlpha,
which only touches the ChatFrame*Background textures pfUI hides on docked
frames, so the visible pfUI backdrop never responded to it.

Mirror the selected window's stored alpha (GetChatWindowInfo) onto the pfUI
backdrop and refresh it from RefreshChat, FCF_SetWindowAlpha and
FCF_SelectDockFrame so the native slider drives it live and persists across
/reload. Default the SetupPositions window alpha to 0.8 to keep the historical
look, and migrate existing installs whose windows still carry the old hard-0
alpha so their chat background is not suddenly transparent.

Fixes #48
 2026-09-02 01:05:47 -05:00
Brues 2b5288a688 nameplates: don't run GetUnitInfo for minions 2026-08-31 16:43:38 -05:00
Brues daba4e202e Default saved variables with 'or {}' instead of overwriting 
Seed the SavedVariables globals only when absent (X = X or {}) rather
than unconditionally assigning {}. Behaviorally identical under the
current load order -- a returning character's data is restored over these
between file load and ADDON_LOADED -- but expresses intent as a default
and won't clobber data if that timing ever changed.
 2026-08-31 12:04:00 -05:00
Brues 98c7751416 Utilize CAPI Tracking functions 
commit 8ea5c81789
Author: Brues <5278969+brues-code@users.noreply.github.com>
Date:   Mon Aug 24 23:40:01 2026 -0500

    bump CAPI min to 1.12.4

commit 39a46563a1
Author: Brues <5278969+brues-code@users.noreply.github.com>
Date:   Mon Aug 24 23:35:49 2026 -0500

    tracking: use native ClassicAPI tracking API

    Replace the hardcoded knownTrackingSpells class table and the
    icon-substring spellbook scan with ClassicAPI's native tracking
    functions:

    - RefreshSpells now enumerates GetNumTrackingTypes() / GetTrackingInfo(),
      which the DLL derives from the spellbook by tracking-aura effect. This
      drops the per-class spell/icon table and picks up server-custom
      trackers (e.g. Turtle's Find Trees) automatically.
    - Selecting a tracker in the menu uses SetTracking(index) instead of
      CastSpell(slot, BOOKTYPE_SPELL).
    - Keep the Druid Cat Form gate on Track Humanoids (5225) and the
      existing invalidSpells filter. Falls back to no entries if the tracking
      API is absent.

    Active icon (GetTrackingTexture), cancel (CancelTrackingBuff), and the
    hover tooltip (GameTooltip:SetTrackingSpell) were already native and are
    unchanged.

Fixes #42
 2026-08-30 17:19:17 -05:00
Brues 8796fab6d8 libpredict: predict incoming heals for built-in click casting (#44) 
Built-in click casting drives the cast through secure frame attributes,
bypassing the CastSpell/CastSpellByName/UseAction hooks that populate
spell_queue -- so the heal-prediction lookup in the SPELL_START_SELF
handler missed and no incoming heal showed.

Populate spell_queue from the cast's own rank-specific spellId (via
C_Spell.GetSpellName/GetSpellSubtext) right before the cache lookup, so
prediction works regardless of how the cast was initiated. Deriving the
rank from the actual spellId also fixes stale-rank lookups when a prior
keybind cast left a different rank of the same spell queued.
 2026-08-24 21:37:41 -05:00
brues-code 7ca0e40d8b CAPI needs 1.12.1 for UnitAura changes 2026-08-24 12:05:18 -05:00
brues-code 2f93b246a1 Accidentally bumped ClassicAPI to the wrong version 2026-08-24 11:48:54 -05:00
Brues c647698f8f bump CAPI min 2026-08-24 11:07:38 -05:00
Brues 48026008b6 buffwatch: use official dispel-type colours for debuff bars 
The debuff-bar auto colour read the vanilla DebuffTypeColor global,
diverging from unitframes/buff which use C_UnitAuras.GetAuraDispelTypeColor
(the BC GlobalColor.dbc palette ClassicAPI ships). Switch buffwatch to the
same accessor so all aura displays share one palette; nil/unknown types
fall back to DEBUFF_TYPE_NONE instead of the old ad-hoc (1, .2, .2).
 2026-08-24 11:07:38 -05:00
Brues c1d96bae58 buff/buffwatch: positional aura reads in hot refresh loops 
buff.lua RefreshBuffButton runs 50x per PLAYER_AURAS_CHANGED and
buffwatch.lua GetBuffData runs 32x per RefreshBuffBarFrame; both now use
the zero-allocation positional C_UnitAuras.UnitAura instead of the
table-allocating GetAuraDataByIndex.

buffwatch also threads the aura's dispelType out of GetBuffData onto the
frame.buffs row, so the debuff-bar colour reads it from the row instead
of re-fetching the aura with GetDebuffDataByIndex on every name change.

Cold single-lookups (hover/click tooltips) keep the readable table API.
 2026-08-24 11:07:38 -05:00
Brues 1d44c5ec6f unitframes: scan debuff slots once for dispel indicators 
The dispellable-indicator block re-scanned all 16 harmful slots for
every dispellable type (O(types x 16) UnitDebuff calls per refresh).
Scan the 16 slots once into a reusable set, then have the per-type loop
check the set. Zero-allocation (the set is cleared and reused within the
single RefreshUnit call).
 2026-08-24 11:07:38 -05:00
Brues 8f88dfd852 Use positional C_UnitAuras accessors in hot aura scans 
Swap the per-frame aura-refresh loops from table-allocating
GetAuraDataByIndex/GetBuffDataByIndex/GetDebuffDataByIndex/GetUnitAuras
to the zero-allocation positional C_UnitAuras.UnitAura/UnitBuff/UnitDebuff.

unitframes: buff/debuff icon loops, the dispellable-indicator 16-slot
scan, the two GetUnitAuras indicator passes, and the custom-debuff scan.
nameplates: the per-plate debuff scan now writes positional results
straight into the reusable display buffer, dropping the per-aura tables
and the result array.

Filters change from HARMFUL|PLAYER/HARMFUL to PLAYER/nil since UnitBuff/
UnitDebuff lock the range and still honor the PLAYER predicate. Cold
single-lookups (hover/click, tooltip, totem icon, libdebuff) keep the
readable table API.
 2026-08-24 11:07:37 -05:00
Brues a57214aeb0 Bump ClassicAPI minimum version 2026-08-24 11:07:37 -05:00
Brues 9bde843e33 utlize inline icons and CreateGoldString in repair module 2026-08-24 11:07:37 -05:00
Brues ad13e6ace3 Utilize SetFormattedText 
This change updates several text setters to use `SetFormattedText` instead of passing `string.format(...)` into `SetText`. It also switches a few regex captures from `string.find` to `string.match` for cleaner capture handling, and replaces explicit width/height setters with `SetSize` in the first-run dialog for consistency.
 2026-08-24 11:07:37 -05:00
Brues 82c74c2db5 Skip declaring pfSellData on turtle client 
This giant table is just going to be immediately replaced so there's no point in declaring it.
 2026-08-21 14:59:19 -05:00
roby-brok a3cfd711fe nameplates: read friendly name colours from the class table 
The class-colour write sourced r, g, b from the health bar rather than
from PFUI_CLASS_COLORS[class], which the condition tested for but never
read. So "class colours on friendly names" only produced a class colour
when friendclassc - a bar option - happened to be on as well; otherwise
the name took the generic friendly colour. In every case it also
inherited the tapped-grey and barcombatstate overrides meant for the bar,
neither of which belongs on the name.

The name now reads the class table directly.

The discarded "and PFUI_CLASS_COLORS[class]" term was dead weight: the
table carries an __index metamethod returning a grey ColorMixin for any
missing key, so it was always truthy and merely allocated a throwaway
table per evaluation. "and class" is the real guard. One behaviour change
falls out - a friendly player of an unrecognised class now takes that
grey fallback rather than the bar colour, which is what the option means.

(cherry picked from commit f880dc3528db2ba0d0936b00a4dff8deec48e6d2)
(cherry picked from commit 111d70004d4fb172f168aa48a4cb6177a7f0d393)
 2026-08-21 13:31:07 -05:00
roby-brok a7ad1f073f nameplates: give the name colour a single owner 
cache.namecolor was written by two writers holding unrelated quantities:
the computed health-bar colour in OnDataChanged, which class-colours
friendly player names when friendclassnamec is on, and Blizzard's own
name FontString in the OnUpdate sync. Sharing one key let either suppress
the other, so the option silently lost - names came out white with
namefightcolor off, or the plain reaction colour with it on.

It also forced a full data pass every throttled tick, because the sync
writer sets update = true whenever it writes and the two kept flipping
the key. That defeats the half-second tick gate entirely.

Compounded by nameplate.cache surviving pool reuse: OnShow re-runs the
data pass but never clears the table, which is built once at plate
creation, so a recycled plate could inherit the previous unit's name
colour.

Ownership is now explicit through cache.ownname, each writer keeps its
own key, and both are invalidated when ownership flips.

(cherry picked from commit 0a4b3a7d6ae523cf70584adbb694a8740024b7cd)
(cherry picked from commit 0df9bb9fa907349182fb03217cab6aa1777aa7d9)
 2026-08-21 13:31:07 -05:00
roby-brok fe5b3b135b nameplates: use true difficulty colours for level text 
The level string was brightened by +0.3 on all three channels before
display, in the levelFromDB path and again in the OnUpdate colour sync.
A flat offset desaturates toward white and costs the high tiers most,
because their green/blue channels start near zero: verydifficult
1.00/0.50/0.25 becomes 1.00/0.80/0.55 and reads as yellow, impossible
1.00/0.10/0.10 becomes 1.00/0.40/0.40 and reads as orange. Orange and
yellow ended up 0.2 apart on a single channel, so a mob 3-4 levels above
the player showed yellow and a skull-range mob showed orange.

Both offsets dropped. Ownership of the colour is now explicit through
cache.levelfromdb so the two writers no longer race: the sync block
stands down on ?? plates, and the DB path clears cache.levelcolor so the
sync re-asserts cleanly once the level resolves. That also fixes a stale
cache - nameplate.cache is built once at plate creation and survives pool
reuse, so a recycled plate could keep the previous unit's colour.

Deleting the sync block instead would be wrong: it is the only thing that
colours the level on non-?? plates, and plate.level is created with no
colour at all.

Reported by Iden via Discord.

(cherry picked from commit eaa9beac51953d2a959c67d5ff5bc50273a919c3)
(cherry picked from commit 3fdb3b23136b260d111509e24e6d7b0d0b9b1b33)
 2026-08-21 13:31:07 -05:00
Brues 9c29f0c7d4 Add handlesHookScript capability flag 
Introduce pfUI.handlesHookScript boolean in pfUI.lua to signal that this fork's actionbar buttons correctly support the modern HookScript widget method. This prevents ClassicAPI's AddOnCompat shim from shadowing HookScript during actionbar load. The flag documents behavior (not identity): forks that maintain HookScript-correct actionbar code should keep the flag; forks that do not should clear it to opt into the safe compatibility fallback.
 2026-08-21 13:26:09 -05:00
Brues 685ecb4a3e Removed !!!ClassicAPI from toc dependencies 
Addon is now baked into the DLL and !!!ClassicAPI will always load before pfUI so this only served to confuse users
 2026-08-18 10:35:31 -05:00
Brues 8cdaf1fc00 Prefer GetCoinTextureString in CreateGoldString 
If the global GetCoinTextureString exists, use it to format money (wrapped in white color codes) for CreateGoldString. Keeps the existing numeric fallback formatting for environments without GetCoinTextureString.
 2026-08-18 04:38:09 -05:00
Brues bb39c9d94e Add localized race info to pfUI environment 
Initialize pfUI.env.L["race"] by iterating C_CreatureInfo.GetRaceInfo and C_CreatureInfo.GetFactionInfo. Builds a table keyed by clientFileString containing raceName, raceID and faction (groupTag).
 2026-08-18 04:34:34 -05:00
Brues 18059ffbb7 Class-color aura caster name in tooltips 2026-08-18 04:29:33 -05:00
Brues d75e280238 Show party pets in raidpet frames under raidforgroup 
When "Use Raid Frames To Display Group Members" is on and in a party,
raid pet frames tried to show raidpet1..40 (nonexistent in a party)
instead of the player pet and partypet1..4.

Remap raidpet grid slots to pet / partypet<N> in UpdateVisibility,
keyed on a stable pfRaidPet<N> slot, mirroring the raid player frames.
LayoutPets now mirror-places the party pet slots, and the raid updater
runs LayoutPets when in a party (not just a raid).

Also exclude raid pet frames (label "partypet", cache_raidpet set) from
the hide_in_raid group-hiding clause so they are not hidden.
 2026-08-13 18:03:56 -05:00
Brues 9eb34b8f0a Revert "40-y rangecheck on by default" 
This reverts commit af6893c10c.
 2026-08-13 17:43:13 -05:00
Brues f8dde49f09 Add IsPlayerGuid API wrapper 
Expose the built-in IsPlayerGuid helper through pfUI.api so callers can check whether a GUID or unit token matches the local player. This keeps the pfUI API surface consistent with the underlying WoW API while making the check available through the addon namespace.
 2026-08-13 17:32:47 -05:00
Brues 74fbbb6154 Use PFUI_CLASS_COLORS in loothistory 2026-08-12 14:33:05 -05:00
Brues af6893c10c 40-y rangecheck on by default 2026-08-12 14:25:37 -05:00
Brues be6b2ea036 Support binding a click to a named macro 
Accept "macro:<name>" in a click-cast action to run a saved macro by
name via the secure `macro` attribute (leading space after the colon is
trimmed). ClassicAPI dispatches it through RunMacro, so a conditional
addon still evaluates the macro body.
 2026-08-12 00:33:49 -05:00
roby-brok afdb6c3862 unitframes: stop UnitHasAggro rescanning and reallocating on every call 
Two costs on the hot path. It concatenated '<u>target' and '<u>targettarget'
per call per unit, though pfValidUnits never changes after load -- now built
once into a static triple list. And only positive results were cached, so the
common case (nothing has aggro) rescanned the entire unit table on every call;
negative results now cache for 0.3s, short enough that aggro still appears
promptly.
 2026-08-11 02:06:28 -05:00
Brues b230a45b92 Show spell and unit IDs on tooltips 
Add "Show Spell IDs" and "Show Unit IDs" options alongside the existing
item-ID line. Spell IDs come from GameTooltip:GetSpell() on spell
tooltips and from the aura's spellId on unit-aura tooltips; unit IDs
come from C_CreatureInfo.GetCreatureID on the mouseover unit's GUID
(skipped for players and guarded when the GUID carries no entry).
 2026-08-11 00:38:28 -05:00
Brues ef1fa47539 Dock GreedMeter into the chat panel 
Register GreedMeter's primary window on the meter dock's damage slot,
mirroring the ShaguDPS integration. GreedMeter builds its windows lazily
and supports several, so frames are resolved at call time.

A second GreedMeter window docks into the panel's other half: pfUI's
dock decides fill-vs-split by whether the threat slot is filled, so hook
GreedMeter's window add/remove to reconcile that slot and re-run the
resize. Only the first two windows fit the panel; any beyond that float.
 2026-08-10 23:52:52 -05:00
Brues ab0ad7dcf9 Group tooltip settings into sections 2026-08-10 15:07:01 -05:00
Brues c82813df5b Use GetRGB() for NORMAL_FONT_COLOR 2026-08-10 15:05:48 -05:00
Brues 6e1f8095a2 Allow whitespace-only macro names 
strtrim collapsed a name like " " to "" and the empty guard then
rejected the save, but a whitespace-only name is valid in vanilla and a
common way to make a name-less macro. Save the raw text and only reject
a truly empty box.
 2026-08-10 09:53:34 -05:00
Brues 9cabdf2974 Revert the pixel-perfect scale change 
GetPerfectPixel switched to UIParent:GetEffectiveScale(), which reports
the true unclamped scale (e.g. 1.42 on the larger pixelperfect presets,
since the module calls UIParent:SetScale past the uiScale cvar's 1.0
cap). At that scale 768/screenheight/scale drops below half a pixel and
the border edgeSize rounds to zero, so button borders disappeared.

The uiScale cvar's <=1.0 cap was load-bearing, not a bug: it keeps the
1px borders from vanishing. Restore the cvar-based measurement and move
pixelperfect back to its original load position.
 2026-08-10 01:27:27 -05:00
Brues b6931359b0 Use the real UKNOWNBEING global in libpredict guards 
The 1.12 client defines Blizzard's own misspelling, UKNOWNBEING
("Unknown Being"); UNKNOWNBEING does not exist and resolves to nil, so
both guards never matched. Point them at the real global.
 2026-08-10 01:13:47 -05:00
roby-brok e017dbf515 Fix guards, cache keys and comparisons that never match (#40) 
* chat: detect whispers before the timestamp is prepended

Whisper detection tests for the whisper colour code at position 1, but the
timestamp is prepended first, so with timestamps enabled the code is no longer
at position 1 and every whisper failed the test -- losing both the recolour and
the correct chat-history entry.

(cherry picked from commit 4b69d597631c422d9360a94ff129323288a28cc2)

* macrotweak + libpredict: inverted install guard, misspelled globals

macrotweak: _AddHistoryLine is the backup slot this block creates, so it is nil
until line 18 runs. Guarding on its truthiness meant the chat-history filter
never installed at all -- macro calls kept landing in chat input history.

libpredict: UKNOWNBEING / UNKOWNBEING are misspelled, so both resolve to nil and
the guards never matched the real UNKNOWNBEING. Neutral if the global is absent
on this client, correct if present.

Not needed: his libpredict already fixed the always-true
'event == "A" or "B"' condition (libs/libpredict.lua:828).

(cherry picked from commit 4068110dc4134823f1c09f60ca5f8959302cd14f)

* mapreveal: look the explore cache up by the key it is actually stored under

explorecaches is keyed by the plain area name (line ~160), but the hover frame
carried only a decorated 'mapFileName (area)' display string, so every lookup
missed and the hover highlight never fired. Store the plain name alongside it
and key off that; the tooltip keeps the decorated string.

(cherry picked from commit 5e6fe969a03a88c68e28614548b9d44db562ab9a)

* socialmod: don't clobber the friend-online match with the offline one

The offline match was assigned unconditionally over the online match, so a
friend coming online never had lastseen recorded.

(cherry picked from commit ad927806c46042163f84bde4db1082726bedf28b)

* swingtimer: off-hand weapons are inventory type 22, not 21

The off-hand slot accepts one-hand (13) and off-hand (22) weapons. Type 21 is
INVTYPE_WEAPONMAINHAND and can never be equipped there, so the off-hand swing
timer never recognised a real off-hand weapon.

The other two swingtimer fixes are not needed here: his hunter check already
uses UnitClassBase (locale-independent, better than our UnitClass second
return), and his generic on-next-swing detection covers Raptor Strike without
our hardcoded spell-id list.

(cherry picked from commit 9ab7f5f7224d12361ca6cd5a49181cbb4bebd387)

* superwow: compare the version numerically, not by exact string

SUPERWOW_VERSION == "1.5" silently disables the GUID-to-name combat text hook
on any release past 1.5. Currently 1.5 here, so this is forward-compat only.

Not needed: the clickthrough slash commands already go through
RegisterSlashCommand, which writes _G properly.

(cherry picked from commit 82a37752a5782479849ce7e1304c24733c2ff97a)

* api: measure a real pixel against UIParent, not the uiScale cvar

The uiScale cvar caps at 1.0 while both the pixelperfect module and the
firstrun slider push UIParent past it via SetScale, and it is ignored entirely
while useUiScale is off, so borders came out the wrong thickness on the
Huge/Large presets. Ask the frame for its effective scale instead, and guard an
unparseable gxResolution.

Also cache GetItemLinkByName and count its failures: the scan walked every id
on each call with no memory, so an unresolvable name hitched on every tooltip
hover. Raise the ceiling from 25818 to 61000 as well -- Octo/Turtle custom
items live well past the vanilla range and never resolved.

(cherry picked from commit dac2d3416aef85a4c4b71c0239d93d309e76e30b)

* init: load pixelperfect first so GetPerfectPixel caches the right scale

pixelperfect sets the UI scale that GetPerfectPixel measures against, and that
value is cached on first use. Loading it 56th baked in the previous scale.

(cherry picked from commit dd89a210330583f890a51a82b29e968f3ad36b34)

* modules: route two global overrides through _G so they leave the sandbox

pfUI.env has __index but no __newindex, so a bare global assignment inside a
RegisterModule closure is written into the sandbox table and never reaches _G.
unitxp's BattlefieldFrame_Show override therefore never fired the BG queue-pop
notification, and RaidFrame.lua never saw GROUP_REPLACE_PARTY.

The slash-command half of this fix is not needed here: RegisterSlashCommand
already writes through _G.

(cherry picked from commit 617c8320aca2465af62cf0ff5be7dceaed29a3b2)

* bags: remove the duplicate search OnHide handler

Two byte-identical frame.search OnHide handlers were installed back to back;
the second overwrote the first, so the first was dead code.

(cherry picked from commit e77650448b92e5d7f18ae58632e4531cb2813ea6)

* buffwatch: invalidate the filter cache when a skill is listed

fcache is built once per config table and never cleared, so ctrl/shift-clicking
a skill onto the whitelist or blacklist had no effect until the next reload.

* roll: actually capture the everyone-passed subject

strfind(LOOT_ROLL_ALL_PASSED, LOOT_ROLL_PASSED) has no captures, so `everyone`
was always nil, never reached the blacklist, and "Everyone has passed on: X"
was recorded as a real player passing.

Builds a sample from LOOT_ROLL_ALL_PASSED and runs the same LOOT_ROLL_PASSED
match the scanner uses, so the subject is captured the way it will actually
appear.
 2026-08-10 01:13:32 -05:00
roby-brok 69d778d6d6 Fix two dangling skin includes and four error paths (#39) 
* skins: drop includes for two files that were never committed

init/skins.xml referenced custom_merchant.lua and arena_score.lua, neither of
which is tracked in git. Every install -- release zips included, since the
release workflow packages the repo -- throws two 'Error loading' lines at
login and ships without those two skins.

(cherry picked from commit b338b4a16d0def4ae89fde5c6026e58a796b8c00)

* map: don't re-anchor the world map to the frame GetPoint returned

Ctrl+scroll rescales the map and repositions it to keep the top-left fixed, but
it re-anchored using the relative frame GetPoint handed back. Once anything else
is anchored to WorldMapFrame that throws

  WorldMapFrame:SetPoint(): <unnamed> is dependent on this

and the error aborts the rest of the zoom handler, so SetScale never runs.

Anchor to the parent instead. That is what the rest of pfUI's movable system
already assumes -- LoadMovable uses the 3-arg form and SaveMovable stores only
xpos/ypos with no relative frame.

(cherry picked from commit bf055d87fc0a04ac912c13fa874a4331f47bdfa8)

* firstrun: return after bailing on a disabled chat module

All three chat setup steps printed 'Chat module is disabled' and then carried on
into the nil pfUI.chat they had just tested for.

(cherry picked from commit 1af427e3b38bb7c13f645ae7a48b8ade3e7455a9)

* unitxp: stop the free-frame distance poller on logout

The PLAYER_LOGOUT handler stops the indicators to avoid the UnitXP crash on
exit, but in free-frame distance mode the polling runs on a separate scanner
frame that was never exposed, so the handler could not reach it and its
OnUpdate kept calling into UnitXP during teardown.

Exposes the frame as pfUI.uf.target.distanceScanner and stops it alongside the
others.

* roll: bail out on an item the client has not cached

C_Item.GetItemInfo returns nil for an item that is not cached yet, and the next
line assigns pfUI.roll.cache[itemName], which throws "table index is nil" on a
nil key. Easy to hit on a fresh login when someone rolls on an item you have
never seen.

* cooldown: return after hiding on a nil parent

Without the return it falls straight through to parent:GetName() on the nil it
just tested for.
 2026-08-10 01:00:47 -05:00
Brues 75a25cf614 Show a mouseover unit's buffs on the tooltip 
Add a "Show Unit Buffs" option that draws a row of buff icons above the
tooltip for mouseover units. Icons come from a ClassicAPI object pool
and are re-anchored left-to-right on each refresh; a single throttled
ticker counts down the remaining time on the visible icons.
 2026-08-09 23:12:20 -05:00
Brues 9daf6165fd Show a note-only menu for offline friends 
The friend right-click menu only opens for online players, so notes
could not be edited on offline friends. The full menu is useless
offline anyway (Whisper/Invite/Target need an online player), so open
a menu of our own with just the note editor for offline friends.
 2026-08-09 22:47:28 -05:00
Brues 06768c985a Merge classicapi-next: friend list and spell fields on ClassicAPI 
Squashed from the classicapi-next branch:
- Read spell fields through ClassicAPI instead of nampower (libdebuff, swingtimer)
- Read friend and who-list class tokens from C_FriendList (socialmod, libunitscan)
- Count online friends with C_FriendList.GetNumOnlineFriends
- Add a friend notes module (modules/friendnotes.lua)
- Bump ClassicAPI minimum version to 10906
 2026-08-09 19:14:40 -05:00
Brues 881a17e508 Build the class name lookup from FillLocalizedClassList 
Replace the hardcoded per-locale ["class"] reverse-lookup tables (localized
class name -> token) with a runtime build in GetEnvironment:

  L["class"] = tInvert(FillLocalizedClassList({}))

The client's own class list supplies the localized names for whatever locale is
running, so the tables were pure duplication -- and this also covers locales the
hardcoded tables never listed. Consumers (libunitscan, panel, socialmod) are
unchanged. Drop ["class"] from every locale file.
 2026-08-09 19:03:29 -05:00
Brues 4e461d766e Read debuff durations from C_UnitAuras instead of a static table 
Rewrite libdebuff's duration lookups on ClassicAPI's C_UnitAuras, whose
expirationTime carries the real, talent-modified remaining time:

- GetDuration reads the live duration of a matching aura on the player
  (C_UnitAuras.GetAuraDataBySpellName) instead of L["debuffs"][effect][rank].
- GetBestAuraCast reads the active aura's expirationTime directly rather than
  scanning the ownDebuffs/allAuraCasts cast tables -- a unit only ever holds one
  instance of a given spell, so that is inherently the effective one.
- GetMaxRank deleted (it only fed the old GetDuration); AddPending's
  known-debuff guard removed.

The public tracking tables (pfUI.libdebuff_*) are untouched. Drop the now-unused
L["debuffs"] and L["dyndebuffs"] tables from every locale.
 2026-08-09 19:02:35 -05:00
Brues 2dfaa65168 Gate combopoint updates and fold player class-color branches 
- combopoints: only ever show on the target's plate, so re-issue Show/Hide
  only when the target's combo count changes, and skip non-target plates once
  cleared (they start hidden) -- instead of hiding all five every tick on every
  plate. plate.cpShown tracks the shown count and stays in sync with the frames.
- player class color: merge the identical ENEMY_PLAYER / FRIENDLY_PLAYER
  branches into one condition.
 2026-08-09 13:01:29 -05:00
Brues 97ef039d3a Fetch the totem buff icon via GetBuffDataByIndex 
Use C_UnitAuras.GetBuffDataByIndex(guid, 1) instead of GetUnitAuras(guid)[1]:
a passive totem's provided buff is its single helpful aura, so the buff-
filtered single-slot fetch is both more precise and cheaper than building the
full aura list to take the first entry.
 2026-08-09 03:39:11 -05:00
Brues 25ef02705c Remove dead totems and critters locale tables 
Nameplate totem/critter detection now uses UnitCreatureTypeID instead of
name-matching, so the L["totems"] and L["critters"] tables have no remaining
readers. Drop them from every locale file.
 2026-08-09 03:17:00 -05:00
Brues 48d1da2015 Localize hardcoded user-facing nameplate/bag/frame strings 
Route the remaining hardcoded English labels through the T translation
table and register the keys in enUS:

- bags: "Sort Bags" / "Sort Bank" tooltips
- farmmode: "FARM MODE" overlay
- unitxp: "BEHIND" / "NO LOS" target indicators
- unitframes: raid group header "Group" (reuses the existing key)
- bgscore: "Battleground Frames" mover title
 2026-08-09 03:15:01 -05:00
Brues ff29e9d3c2 Detect nameplate totems and critters by creature type 
Replace the localized L["totems"] / L["critters"] name-substring matching
with ClassicAPI's UnitCreatureTypeID (CreatureType.dbc: 8 = Critter,
11 = Totem), cached per plate and reset on reuse. Locale-independent,
covers custom/Turtle units, rejects mobs merely named "...Totem...", and
cheaper than the per-plate name loop.

Totem icons now come straight from the game instead of a hand-picked table:
passive totems self-cast their provided buff, so their single aura's icon
is read via C_UnitAuras.GetUnitAuras; active totems (Searing/Magma/Fire Nova)
carry no self-aura, so their icon is captured from UNIT_SPELLCAST_SUCCEEDED
(C_Spell.GetSpellTexture) and cached. Detection and icons read through the
plate's ClassicAPI-provided GUID (cachedGuid).
 2026-08-09 03:15:01 -05:00
Brues f0f1c80e24 autoshift: stub shapeshifts table for pfUI-turtle compatibility 
Closes #38
 2026-08-08 19:59:36 -05:00
Brues 5b4cb2bc9f Hide redundant Total line in item count tooltip and localize labels 
Only show "Total" when the item is split across more than one location;
a single-location item made "Total" duplicate the one breakdown line
(e.g. "Equipped: 1 / Total: 1").

Route the Bags/Bank/Equipped/Total labels through the T translation table
and add the keys to every locale file, using the Blizzard GlobalStrings as
the reference for each localized term.
 2026-08-08 19:24:42 -05:00
Brues 5a3a962c90 Remove dead unitframes showtooltip setting 
The mouseover-scripts migration dropped the unit frame OnEnter/OnLeave
handlers that read C.unitframes[unit].showtooltip, so nothing consulted the
setting anymore. The engine mouseover (driven by the frame's unit attribute)
now shows the native tooltip unconditionally, so the option could not gate it
even if a reader remained.

Drop the config default, the "Enable Mouseover Tooltip" GUI checkbox, and the
now-orphaned locale string from all translation files.
 2026-08-08 16:16:33 -05:00
Brues cd08db75d2 Color button highlights from PFUI_CLASS_COLORS 
Read the player class color from PFUI_CLASS_COLORS instead of
GetClassColor in SkinButton, SetHighlight, and SkinDropDown.
GetClassColor returns the stock pink for Shaman, but pfUI remaps it to
blue, so the button highlights and locked borders now match.
 2026-08-07 23:52:22 -05:00
Brues 6365f0cdb1 Read the innervate cooldown through ClassicAPI 
Replace nampower's GetSpellIdCooldown with C_Spell.GetSpellCooldown, and
compute the remaining time from startTime plus duration (both seconds).
Drop the presence guard, since ClassicAPI is a hard dependency. The
module still needs nampower for the AURA_CAST events.
 2026-08-07 18:29:37 -05:00
Brues faa801e27d Read spell range through ClassicAPI in the hunter bar 
Replace nampower's IsSpellInRange with C_Spell.IsSpellInRange. This drops
the last unguarded nampower call. The ClassicAPI function returns true,
false, or nil, so test == true and == false and leave the bar unchanged
on nil.
 2026-08-07 17:39:10 -05:00
Brues 421a103f22 Show action button spell tooltips by spell ID 
libspell.GetSpellInfo now returns the spell ID at position 9 and caches
it with SafePack and unpack.

The action bar tracks self.spellID for macro-cast spells and shows the
tooltip with GameTooltip:SetSpellByID. Gather the slot, book type, and
spell ID from one GetSpellInfo call instead of a separate GetSpellIndex
lookup.
 2026-08-06 23:08:32 -05:00
Brues ecb28fb194 Strip leading 'v' from version tags before parsing 
Release tags often include a leading 'v' (e.g. "v9.0.18"). Previously the code split the raw tag directly which could yield a nil major version and fall back to 0.
 2026-08-06 22:10:21 -05:00
Brues 94268b1162 Add option to always show equipment slot flyouts 
The per-slot popout arrows previously appeared only while the equipment
manager sidecar was open. Add a "Always Show Equipment Slot Flyouts"
option under Character -> Inventory (character.inventory.equipflyout,
off by default) that instead ties them to the paperdoll, so gear can be
swapped without opening the equipment manager.

Centralize the show/hide in a single UpdatePopouts(): by default the
arrows follow the sidecar, with the option on they follow PaperDollFrame.
Both the sidecar OnShow/OnHide and new PaperDollFrame OnShow/OnHide hooks
route through it, and the flyout hides whenever the arrows go inactive.
 2026-08-06 20:28:32 -05:00
Brues 1c7c91fdf7 Fix power bar rendering black behind its backdrop 
The power bar's frame level was pinned to f.power's live level
(f.power:GetFrameLevel() + 1). CreateBackdrop caches the backdrop at
f.power's level when it first builds it, but f.power's level can shift
afterward as strata changes propagate across UpdateConfig re-runs. When
it shifts below the cached backdrop, the fill drops behind the dark
backdrop and the bar renders black -- which reproduced on some clients
but not others depending on how the levels resolved.

Anchor the fill to the backdrop's own level instead
(f.power.backdrop:GetFrameLevel() + 1). The backdrop's level is fixed
once created, so the fill is always exactly one level above it
regardless of f.power's value, and the bar can never fall behind it.
 2026-08-06 19:16:49 -05:00
brues-code 7f5d18bc30 Update README to simplify project description 2026-08-06 13:29:49 -05:00
Brues 7efc3334ae Add an aura caster line to tooltips 
Hook GameTooltip:SetUnitAura to append the caster's name; every pfUI aura
tooltip (player buffs, buffwatch, unitframes) routes through it, so one hook
covers them all. Resolve the name from the live sourceUnit token, falling
back to the sourceGUID name cache (players only) when the token is gone.

Gated behind a new tooltip.aurasource option (off by default) with a matching
"Show Aura Caster" checkbox. The toggle reloads the UI, so the hook is
installed conditionally at load rather than re-checking the flag per tooltip.
 2026-08-06 02:51:08 -05:00
Brues f322fbd6c6 CancelItemTempEnchantment can't exist in vanilla without server change 2026-08-06 02:03:21 -05:00
brues-code 41b77a5728 Add the macro icon picker and improve the equipment manager (#35) 
* Add pfUI-native macro icon picker

Replace Blizzard's MacroPopupFrame (the name + icon dialog) with a
custom pfUI picker driven by IconDataProviderMixin, so the full spell +
item + loose icon set is available instead of the stock spell-only list.
It has a searchable, filterable icon grid and saves through
C_Macro.CreateMacro / C_Macro.EditMacro, which take the icon as a texture
string -- so arbitrary icons (including index-less INV_* item icons)
persist. The macro-frame API is identical on the modern (Turtle/Octo)
and stock-vanilla macro UIs, so the picker works on both with no client
detection.

The new macroicons module takes over the New / Change-Icon buttons and
retires the stock popup; the blizzard macro skin now only skins
MacroPopupFrame when that module is disabled.

* Gate the macro icon hook behind a config flag

Run the Blizzard_MacroUI hook only when C.disabled["macroicons"] is
"1".

* Add search to the icon pickers and fix set editing

Equipment manager:
- Move the OK button next to Cancel at the bottom-right.
- Add an icon search box in the freed bottom-left space.
- Shift the popup contents up and shrink the window after the title
  was removed.
- Show the current icon when you edit a set. Keep a full icon path as
  is instead of adding a second prefix, and match grid icons by name.
- Close the name/icon popup when the manager frame closes. Remove the
  duplicate OnHide hook.

Both pickers now use Blizzard global strings for the labels and the
icon filters.

* Replace the row hover poll with OnLeave handlers

The gear button sits inside the set row's rectangle, so MouseIsOver(row)
is true for both. Show the gear on row enter. Hide it from a shared
OnLeave on the row and the gear when the cursor leaves the row. This
removes the per-frame OnUpdate poll.

* Handle missing C_Macro.CreateMacro API

Add guards to detect if C_Macro.CreateMacro is unavailable. The macroicons module now returns early if the API doesn't exist, and turtle-wow.lua uses the alternative Blizzard_MacroUI fallback path in such cases.

* Remove the macro picker title and shrink the window

Delete the title font string and its SetText calls. Move every
top-anchored element up 14px and shrink the window height from 498 to
484. The OK, Cancel, and search controls are bottom-anchored, so they
keep their spacing to the grid.

* bump ClassicAPI min version to 1.9.3

* Extract a shared icon picker widget

The macro icon picker and the equipment manager's name/icon popup carried
near-identical copies of the icon grid, All/Spells/Items filter, name search,
and the IconDataProvider state machine. Pull that into a single
pfUI.api.CreateIconPicker helper; each module keeps only its own frame shell,
buttons, and save flow.

Also fix the grid tooltip: pass white to GameTooltip:SetText (it defaults to
red) and derive the icon name with the case-insensitive basename key so
mixed-case provider paths show a clean name instead of the full path.
 2026-08-05 22:33:37 -05:00
Brues 06fea6c889 Cache the player guild name for nameplate coloring 
Compare each plate's guild name against a cached myGuild value instead
of calling UnitIsInMyGuild for every plate. Refresh the cache on
PLAYER_GUILD_UPDATE and PLAYER_ENTERING_WORLD. This replaces a per-plate
C call with a Lua string compare.
 2026-08-05 21:43:08 -05:00
Brues 940a1adae0 Restore Clique support on unit frames 
Fixes #33.

Clique's pfUI plugin replaces pfUI.uf.ClickAction and calls it from an
OnClick script. The move to secure attribute clicks removed that
function, so Clique stopped working.

Add the legacy Lua click path back for Clique. When Clique is loaded,
EnableScripts sets an OnClick script that runs ClickAction. When Clique
is not loaded, the frames keep the secure attribute path.

Skip the secure attributes in Clique mode. The type1 target attribute
switches the target before Clique can cast. Right-click opens the unit
menu through ClassicAPI_ToggleUnitMenu.
 2026-08-05 21:43:08 -05:00
Brues d13710c5a4 Rebuild macro icon list from the icon data provider 
Hook Blizzard_MacroUI and replace UpdateMacroIconFilenames. The new
function reads each icon from IconDataProviderMixin, strips the path
prefix, and adds the name to MACRO_ICON_FILENAMES. A seen table skips
duplicate names.
 2026-08-05 03:02:43 -05:00
Brues c3dd7cb601 Refactor player info: simplify haste and SP display 
Minor readability and style cleanup.
 2026-08-05 00:28:55 -05:00
Brues 9190b88974 Cache player color codes and use full ARGB hex 
Replace the cfgColorToHex function with a memoized table. The table
caches the color code for each config string on first use.

Build the code with C_ColorUtil.GenerateTextColorCode instead of
string.format. Change the spell-school colors and the format strings
to 8-character ARGB hex with the |c prefix.
 2026-08-04 23:00:51 -05:00
Brues fe0ec82ede Route config color strings through GetStringColor cache 
Replace raw strsplit(",", ...) color parsing across action bars, chat,
nameplates, third-party skins, player, and roll with the cached
GetStringColor / GetStringColorObject helpers, dropping the per-build
string-table allocations they created.
 2026-08-04 22:27:43 -05:00
Brues 350b1d63ae Revert breaking change for WorldMapFrame 2026-08-04 21:29:03 -05:00
Brues c7f42491ef Update README.md 2026-08-04 16:28:08 -05:00
brues-code 6b458c9e27 Modernize cast bars, unit-frame clicks, and mark tracking with ClassicAPI (#32) 
* Migrate player castbar to ClassicAPI UNIT_SPELLCAST_* events

Drive the player cast path off ClassicAPI's synthesized, player-only
UNIT_SPELLCAST_* events instead of the vanilla SPELLCAST_* plus nampower
SPELL_{START,GO,DELAYED}_SELF mix. START/CHANNEL_START poll UnitCastingInfo/
UnitChannelInfo and stamp; STOP/CHANNEL_STOP/FAILED/INTERRUPTED clear;
SUCCEEDED drives tradeskill craft counting; DELAYED/CHANNEL_UPDATE re-poll.
Since UNIT_SPELLCAST_START fires for chained same-spell recasts, the nampower
SELF deps and their RunNextFrame co-hook-ordering workarounds are gone.
Remote target/focus bars keep SPELL_*_OTHER (the new events are player-only).

Fix the cast-start flash: StampBar now primes the fill on the stamp frame,
and ClearBar no longer snaps the bar to full (that snap lingered in the fade
tail and flashed when the next cast stamped).

Add a red flash on a cancelled cast: new appearance.castbar.failcolor,
flashed by ClearBar only when a cast was actually in progress.

Handle pushback Quartz-style: DELAYED/CHANNEL_UPDATE re-poll just the times
and accumulate the endMs shift into this.delay for the +/- indicator (cast
+X, channel -X), rather than a full restamp.

* Route target/focus castbars through remote UNIT_SPELLCAST_*

ClassicAPI now fires UNIT_SPELLCAST_* for remote tokens (target/focus/...)
via PollRemote, so drop the nampower SPELL_*_OTHER path and drive all three
bars off one event model. The gate is now token-based (arg1 == this.unitstr,
plus the arg1=="player" + UnitIsUnit case for target=self); the RunNextFrame
defer is gone since the remote poll fires after UnitCastingInfo is readable.
Cast detection is now nampower-free across every bar.

Use the event's rank payload (arg5): thread it through RefreshBar into
StampBar, which now only calls C_Spell.GetSpellSubtext as a fallback on the
retarget re-poll (PLAYER_TARGET/FOCUS_CHANGED) where no event is in hand.

* Drive nameplate castbars off UNIT_SPELLCAST_*

ClassicAPI now fires UNIT_SPELLCAST_* for nameplate tokens, so populate the
per-GUID castState cache from UNIT_SPELLCAST_{START,CHANNEL_START} (poll
PollCastInfo for the timing the payload omits) and clear it on
{STOP,CHANNEL_STOP} -- the remote poll fires STOP for natural end, interrupt,
and cancel alike. Replaces the nampower SPELL_{START,FAILED}_OTHER path; the
^nameplate arg1 gate ignores the target/focus/party fires of the same events,
and the NAME_PLATE_UNIT_ADDED seed still catches a plate spawning mid-cast.
Nameplate cast detection is now nampower-free.

* We no longer use these features from SuperWoW/Nampower

* Use secure unit attributes; remove mouseover scripts

Switch unitframes to attribute-driven clicks and remove mouseover tooltip handlers. Adds SetAttribute("unit") in UpdateVisibility and sets frame attributes (unit and type1='target') when creating frames. Removes OnEnter/OnLeave functions and their SetScript registrations and eliminates direct TargetUnit calls in ClickAction

* Use SetShown and simplify component default

Replace explicit Show/Hide conditionals in api/unitframes.lua with SetShown(...) for ressIcon, leaderIcon, lootIcon, pvpIcon, and restIcon to reduce branching and improve readability. Also remove the local shadowing of the parameter 'component' by using assignment (component = component or ""). No intended behavior changes.

* Drive unit-frame clicks via secure attributes

Replace the Lua OnClick dispatch (OnClick/ClickAction/RightClickAction) with
secure frame attributes: default type1=target / type2=menu, and EnableClickCast
now writes type/spell/macrotext/menu/target/focus attributes per button+modifier
instead of caching a clickactions table read at click time. Drops the now-dead
clickactions table and buttons list.

Also set a "unit" attribute on each frame (at creation and re-synced in
UpdateVisibility to the live token, so a party shown on the raid grid reports
partyN, not raidN) so the hovered unit resolves from the frame.

Match the target/focus/menu click keywords exactly rather than by prefix, so a
spell whose name starts with "focus"/"target"/"menu" (e.g. Focus Magic) casts
instead of being swallowed as the keyword action.

* Simplify marktracking colors and refresh per mark

Replace the hand-rolled ParseColor plus its default-color table with
GetStringColor -- the raidmarkercolor_* config keys already carry those same
defaults, so the fallback was dead code.

Restructure the refresh off observed mark tokens: UNIT_HEALTH/UNIT_MAXHEALTH
now arrive as arg1 == "markN", so refresh just that one row (UpdateRow) instead
of rescanning all eight on every nearby unit's health tick. A visibility flip
(into range / death / hp crossing 0) re-packs the rows, so UpdateRow hands off
to a full UpdateDisplay; RAID_TARGET_UPDATE / PLAYER_ENTERING_WORLD stay full
refreshes, with the 1s poll as the range-change backstop.

* not true anymore

* Poll marktracking fallback via C_Timer instead of OnUpdate

The 1s range-change safety net ran a per-frame OnUpdate that no-oped ~59 of
every 60 frames. Replace it with C_Timer.NewTicker(FALLBACK_INTERVAL,
UpdateDisplay) -- one wakeup per second off the shared timer driver -- and drop
the elapsed accumulator. The scanner frame is now purely event-driven.

* SuperWoW is now optional

* Update README feature list

Add 'Mouseover Unit Frames' and 'Click-casting' to the main features list. Update the SuperWoW entry to reflect that it tracks party/raid units on the minimap (replacing the prior SetMouseoverUnit note).

* Replace fixed-interval OnUpdate polls with C_Timer/RunNextFrame

Swap hand-rolled per-frame throttles for the modern timer primitives:

- turtle-wow: one-shot next-frame defer (self-hiding OnUpdate frame) -> RunNextFrame
- panel: clock, combat, and fps widgets -> NewTicker(1); guild roster -> NewTicker(60)
- minimap: coordinates text -> NewTicker(0.1)
- addonbuttons: one-shot init -> RunNextFrame; 5s button rescan -> NewTicker(5),
  guarded by IsShown() to preserve the old "paused while hidden" behavior

Ticker callbacks reference frames via upvalue since 'this' is unbound outside
OnUpdate. Genuine per-frame work (bar fills, fades, drag) and polls already
coordinated through pfUI.throttle are left as-is.

* update pfQuest link

* Use SetShown/SetSize in panel module

Replace manual Show/Hide toggles with SetShown(not ... ) and replace SetWidth/SetHeight with SetSize in modules/panel.lua. Changes simplify toggle logic (timer, WorldMap, chat hide buttons) and unify sizing calls for timer, frames, textures, and microbutton. No behavior changes intended; purely refactor for conciseness and consistency.

* Bump ClassicAPI min version to 1.9.0

* Drive reagent counter from events instead of a polling OnUpdate

The pfReagentCounter frame ran an OnUpdate that (1) progressively rescanned
all 120 action slots one-per-100ms on any slot change and (2) recounted
reagent inventory on a 1s throttle. Replace both with direct event handling:

- ACTIONBAR_SLOT_CHANGED updates just the changed slot (arg1), full-scanning
  only when arg1 is 0/nil, instead of restarting a ~12s rescan on every edit
- BAG_UPDATE_DELAYED recounts tracked reagents directly (it is already
  Blizzard's coalesced bag event, so the extra 1s throttle was redundant)
- PLAYER_ENTERING_WORLD seeds the full reagent map once

UpdateSlot now seeds a new reagent's real count via GetItemCount so a freshly
placed reagent spell shows the correct number immediately. The updatecache ->
BarsUpdate render path and the IsReagentAction/GetReagentCount accessors are
unchanged.
 2026-08-04 14:27:15 -05:00
Brues f338deebe7 UNITFRAME_SECURE_TEMPLATE is always nil in vanilla 2026-08-01 13:12:14 -05:00
Brues c994d00596 Toggle bagslots visibility via SetShown 
Replace explicit if/else calling :Hide()/:Show() with :SetShown(not IsShown())
 2026-07-31 13:22:17 -05:00
Brues 4be680183a Use GetSize/SetSize for size operations 
Replace separate GetWidth/GetHeight and SetWidth/SetHeight calls with GetSize/SetSize for consistency and brevity. Updated modules: addonbuttons (store size via GetSize), chatcopy (use SetSize), easteregg (use SetSize for explosions), farmmode (use GetSize/SetSize when adjusting map size), and game_menu (use GetSize/SetSize when resizing frame).
 2026-07-30 14:29:30 -05:00
Brues 2352f1c6ed Use GetSize/SetSize for map frame and buttons 
Replace separate GetWidth/GetHeight and SetWidth/SetHeight calls with GetSize and SetSize in modules/map.lua.
 2026-07-30 14:11:34 -05:00
Brues 305ff6c86e Collapse frameState.hasTarget into targetGuid 
hasTarget was always snapshotted alongside targetGuid (UnitExists("target")
next to UnitGUID("target")), so it was just targetGuid ~= nil. Drop the
field and derive it from targetGuid at both read sites; remove the now-unused
UnitExists perf-cache local.
 2026-07-30 13:45:53 -05:00
Brues a8b131898b Event-drive nameplate target state; drop per-tick poll and targetPlateGuid 
frameState.hasTarget/targetGuid were polled via UnitExists("target") every
central-loop tick, while targetPlateGuid held the same guid but was already
event-driven -- redundant. Set frameState target fields in PLAYER_TARGET_CHANGED
(seeded on PLAYER_ENTERING_WORLD for a target held across reload), remove the
poll, and collapse targetPlateGuid into frameState.targetGuid (the castbar
frame now reads that). The central loop's only remaining per-tick poll is
GetTime().
 2026-07-30 11:59:56 -05:00
Brues 1f9be33772 Use GetStringColorObject for buffbar colors; numeric border check 
Store the buffbar color/bordercolor/textcolor as cached read-only ColorMixins
via GetStringColorObject instead of building per-bar {r,g,b,a} tables from
GetStringColor. These color tables are only ever read (SetStatusBarColor /
SetTextColor / the border check), so sharing the cached objects is safe and
drops the intermediate locals and per-bar allocations.

GetStringColorObject's components are numbers, so fix CreateBuffBarFrame's
border check from ~= "0" (string) to ~= 0.
 2026-07-30 02:44:56 -05:00
Brues a798e67b7f Use GetStringColor for buffbar color parsing 
Route the three buffbar color config splits through GetStringColor (cached)
instead of bare strsplit. GetStringColor returns strings, so this is
behavior-preserving -- including the bordercolor ~= "0" check in
CreateBuffBarFrame -- and just adds the shared color cache and consistency
with the rest of the codebase.
 2026-07-30 02:39:56 -05:00
Brues 8b87e30266 Revert GetStringColor to strings; keep object numeric; tidy cmatch 
- GetStringColor returns strings again (its lifelong contract). The earlier
  numeric conversion was a return-type change that could break any caller
  doing string comparisons on components (e.g. buffwatch's `~= "0"`); every
  caller was written against strings and color setters coerce, so reverting
  is the safe fix without a codebase-wide audit.
- GetStringColorObject now tonumbers its own inputs, so its ColorMixin stays
  numerically correct (GenerateHexColor/IsEqualTo) independent of the above.
- cmatch: move its a-e / va-ve / ra-re scratch out of module scope into clear
  function-locals (idx*/val*/out*). Strict 1:1 rename, logic unchanged; also
  drops the shared-upvalue reentrancy concern.
 2026-07-30 02:39:16 -05:00
Brues f68b14e53b Use SetSize instead of SetWidth/SetHeight 
Replaced numerous SetWidth/SetHeight calls with SetSize for consistency and brevity across UI code. Touched api/ui-widgets.lua, api/unitframes.lua and multiple modules (actionbar, addonbuttons, addons, afkcam, autovendor, bags, bgscore, buff, buffwatch, nameplates). Also simplified some sizing math in buff module. No functional behavior intended to change — code modernization only.
 2026-07-30 02:27:03 -05:00
Brues 8ab6fab04f Event-drive nameplate mouseover via UPDATE_MOUSEOVER_UNIT 
ClassicAPI polyfills UPDATE_MOUSEOVER_UNIT to fire on mouseover loss as well
as gain (src/unit/Mouseover.cpp), so the per-tick UnitGUID("mouseover") poll
in the central loop is no longer needed. Update frameState.mouseoverGuid on
the event and flag just the plates losing/gaining hover (via plateByGuid,
which holds overlays) for an immediate refresh.
 2026-07-30 02:01:10 -05:00
Brues 6d1bfe805e Use UnitClassBase for class detection 2026-07-30 01:26:29 -05:00
Brues 838f7f5d25 guard against nil units 
UPDATE_MOUSEOVER_UNIT can fire when unit is dropped now so guard against that
 2026-07-30 01:20:50 -05:00
Brues fad078fa87 Drop dead GUID-label branch in unit frame OnEnter 
No unit frame ever has a GUID label -- CreateUnitFrame is only ever called
with fixed type names (Player/Target/Focus/Party/Raid/...), and .label is only
ever assigned those. The string.find(this.label, "^0x") branch was a leftover
from an older focus implementation; focus now uses the real "focus" unit
token, so OnEnter always resolves the mouseover via the normal unitstr path.
 2026-07-30 01:09:53 -05:00
Brues 48d76138ed Iterate active nameplates only; fix global eventcache propagation 
- The central OnUpdate looped the entire plate pool (registry) every tick with
  an IsVisible guard. Maintain a visiblePlates set via NAME_PLATE_UNIT_ADDED/
  _REMOVED and iterate that instead, so hidden pool slots aren't touched. The
  IsVisible guard stays as a safety net.
- Fix the global refresh propagation: it set .eventcache on the base frame,
  but OnUpdate reads/clears it on the overlay (nameplate) -- so the propagation
  was a no-op and global refreshes (e.g. target-change alpha/strata) fell
  through to the 0.5s catch-all timer. Set plate.nameplate.eventcache and scope
  to visiblePlates, so those refreshes land on the next tick as intended.

OnConfigChange still iterates the full registry (hidden plates must pick up
config changes before they next show).
 2026-07-29 23:43:27 -05:00
Brues fe22dfc456 Detect nameplate mouseover by GUID compare, not Blizzard glow texture 
Both mouseover checks relied on original.glow:IsShown() (a fragile proxy for
the hovered plate, on a Blizzard texture pfUI hides/restyles) gated by
UnitExists("mouseover"). Cache the engine mouseover unit's GUID once per
central-loop tick (frameState.mouseoverGuid) and have each plate compare its
cachedGuid against it.

More correct for the data path: the "mouseover" unit token is only chosen
for the plate whose GUID actually matches the engine's mouseover unit, so
overlapping plates can't double-match and paint the wrong unit's data. Also
cheaper -- one UnitGUID("mouseover") per tick plus a per-plate table compare,
versus the old per-plate IsShown gated on a per-tick UnitExists.
 2026-07-29 16:57:25 -05:00
Brues 5eaab2784f Resolve target castbar plate via cached GUID, not per-frame lookup 
The unthrottled target castbar frame called C_NamePlate.GetNamePlateForUnit
every frame. Stash the target's GUID on PLAYER_TARGET_CHANGED (seeded on
PLAYER_ENTERING_WORLD for a target held across reload) and resolve the plate
through plateByGuid instead -- a table lookup plus a real idle skip when
there's no target. The plate is looked up per frame (not cached) so a plate
spawning/despawning while the unit stays targeted still resolves correctly.
 2026-07-29 16:36:29 -05:00
Brues f41d5ac6d0 Make nameplate castbars event-driven; unthrottle target bar 
Previously every visible plate polled C_Spell.UnitCastingInfo each throttled
tick just to detect casts. Now cast state is event-driven:

- SPELL_START_OTHER (nampower) stamps a per-GUID castState cache (spellId,
  timing, channel flag from spellType); SPELL_FAILED_OTHER clears it; normal
  completion expires at endTime. GetCastInfo just reads the cache, so all
  call sites (castbar update, non-target detection, casting name-color) stop
  polling.
- plateByGuid routes events to plates in O(1) and bounds the cache to on-screen
  casters; NAME_PLATE_UNIT_ADDED seeds an already-casting unit with one poll.
- The vestigial nameplate.castUpdate flag now fires on cast start to bypass the
  throttle for an immediate bar.

With the poll gone, per-tick work is a cache read + SetValue, so the dedicated
target castbar frame now runs unthrottled (every frame) for the smoothest
sweep, and the non-target nameplates_castbar default rises 50 -> 100 FPS.

Known limits: other-unit cast pushback isn't reported by nampower, and a
mob-cancelled channel with no fail event lingers until endTime.
 2026-07-29 16:29:12 -05:00
Brues af8780bb41 Use GetStringColor for newitem glow color 
Replace CreateColor/Color:GetRGBA usage with pfUI.api.GetStringColor in modules/newitem.lua
 2026-07-29 14:39:25 -05:00
Brues ea37f41db1 Check r[3] instead of table.getn in rgbhex 
Replace table.getn(r) >= 3 with r[3] ~= nil in api/api.lua
 2026-07-29 14:35:44 -05:00
Brues 6f36da7aa1 Cache and streamline color helpers in api 
- GetStringColor: memoize via a metatable __index cache (single lookup on
  hits) and store numeric components so ColorMixin comparisons/arithmetic
  behave, not just setter coercion.
- GetStringColorObject: new accessor returning a cached, shared read-only
  ColorMixin for callers that want an object instead of raw values.
- rgbhex: memoize the markup keyed on the byte values that actually determine
  the output (Round(x*255)), so continuously-varying inputs like health
  gradients collapse onto a bounded set instead of leaking a cache entry per
  shade. Build misses via C_ColorUtil.GenerateTextColorCode on a plain table
  instead of allocating a throwaway ColorMixin. Fix a latent bug where the
  r/g/b/a temporaries were file-scoped, so a malformed input returned the
  previous call's color instead of an empty string.
 2026-07-29 14:06:25 -05:00
Brues 149d5dd362 Scope tooltip cursor-follow to when shown; default it to smooth 
The cursor-follow OnUpdate polled GetCursorPosition() 10x/second forever,
even with no tooltip visible. Rework it so the follower frame is created
once, hidden, and only shown while a tooltip is up -- an OnUpdate fires only
while its frame is shown, so the poll now runs solely during tooltip display.
Position the follower immediately on show to avoid a one-frame flash.

Also bump the tooltip_cursor throttle default from custom/10 FPS to the
fastest preset (50 FPS) so cursor tracking is smooth out of the box while
the Throttling tooltip knob stays available for low-end machines.
 2026-07-29 11:42:18 -05:00
Brues 0156d9dfec Harden strsplit against third-party global clobbering 
BigWigs (SpellRequests) redefines the global string:split to return a table,
and another addon clobbers the strsplit global too. pfUI.api.strsplit and the
bare strsplit callers inherited the broken versions depending on load order,
producing 'attempt to compare number with nil' from GetStringColor.

- Make pfUI.api.strsplit fully self-contained (no delegation to global
  strsplit / string.split), so no override can reach it.
- Optimize the hot path: single-char delimiters use plain-text find (no
  pattern compilation, no per-call char-class string); localize string.find
  and string.sub.
- Route the per-frame castbar/nameplate color splits through GetStringColor,
  which caches, instead of re-splitting a constant string every update.
 2026-07-29 10:37:29 -05:00
Brues 6b945c2c97 buff min classicapi version to 1.8.2 2026-07-28 19:26:09 -05:00
Brues 452eef3864 Drop custom debuff durations from turtle-wow.lua 
C_UnitAuras supplies Turtle-adjusted durations directly to the aura readers,
so the L["debuffs"] database fallback for these four custom debuffs is dead.
 2026-07-28 13:29:11 -05:00
Brues 6f7a57f530 Restore UnitDebuff/UnitOwnDebuff as C_UnitAuras adapters 
Third-party addons (e.g. pfUI-WeakIcons) still expect libdebuff's legacy
multi-return reader signature. Reimplement UnitDebuff/UnitOwnDebuff as thin
adapters over C_UnitAuras that remap AuraData onto:
  effect, rank, texture, stacks, dtype, duration, timeleft, caster

No GetUnitField slot mapping or ownDebuffs/allAuraCasts bookkeeping involved;
C_UnitAuras already resolves source and expiration. timeleft is gated on
duration > 0 to avoid stale expirationTime on permanent auras.
 2026-07-28 10:48:42 -05:00
Brues a55460e543 Add reverse sort direction and priority options to bag sorter 
libbagsort:Sort now accepts an opts table:
  - reverse: place the first-ranked item into the last slot of the last
    bag (junk fills from the opposite end)
  - reversePrio: flip the category ranking (e.g. hearthstone sorts last)

Wired to two new checkboxes under Bags & Bank, both defaulting off.
 2026-07-27 18:15:07 -05:00
Brues 58aaeef5f0 can't have any fun 2026-07-27 17:17:56 -05:00
Brues 487af0c8f4 Use string.split instead of strsplit 
Some users have addons that pollute the global namespace with a version of strsplit that doesn't match Blizzard's spec
Closes #31
 2026-07-27 15:47:28 -05:00
Brues 00292ca3b4 Focus/Nameplates now respond solely to UNIT_* events 
commit 70b1e66c2d
Author: Brues <5278969+brues-code@users.noreply.github.com>
Date:   Sun Jul 26 18:30:18 2026 -0500

    Use SetSize/SetShown and simplify minimap/map

commit 7b6bfe9975
Author: Brues <5278969+brues-code@users.noreply.github.com>
Date:   Sat Jul 25 11:27:14 2026 -0500

    Include raidpet frames in /pftest test mode

    The unit-frame test toggle (showall) only previews frames that exist and
    are positioned. Raidpet frames are created when raidpet.visible == "1",
    but LayoutPets' collapse mode only positions pets whose raidpet<N> unit
    actually exists, so solo/in test mode they stayed hidden.

    Add a showall branch to LayoutPets that mirror-lays every pet cell and
    shows it (bypassing collapse and the roster gate), still guarded by the
    existing showpets check so nothing happens when raidpet is disabled. Call
    LayoutPets from the /pftest handler so the grid updates immediately on
    toggle-on and restores to the normal layout on toggle-off.

commit 4c65c38647
Author: Brues <5278969+brues-code@users.noreply.github.com>
Date:   Sat Jul 25 10:34:33 2026 -0500

    Remove unused RangeCache local in UnitInRange

commit 6c96bbbe6c
Author: Brues <5278969+brues-code@users.noreply.github.com>
Date:   Sat Jul 25 10:34:33 2026 -0500

    Use Clamp() for the two-sided clamps in ui-widgets

    Replace the hand-rolled math.min/math.max and if/elseif clamp idioms in the
    status bar and scroll frame with Clamp(). Equivalent for every value seen
    (min <= max always holds), just clearer.

commit 830e0a0be1
Author: Brues <5278969+brues-code@users.noreply.github.com>
Date:   Sat Jul 25 10:34:33 2026 -0500

    Drop vanilla GetItemInfo shim for C_Item.GetItemInfo

    The compat/vanilla.lua GetItemInfo override reshaped vanilla's tuple into
    retail order by inserting nil at slot 4 (itemLevel), but truncated at 8
    fields, dropping itemEquipLoc/itemTexture. ClassicAPI's global GetItemInfo
    keeps the vanilla shape (its hook only warms the item cache), so the shim
    stayed necessary but incomplete.

    Remove it and point the three callers at ClassicAPI's C_Item.GetItemInfo,
    which returns the full 18-field retail tuple. Positions 1-8 are identical
    to the old shim output, so bags/roll are unchanged; character.lua's
    itemSlot (equipLoc, field 9) was always nil under the truncating shim and
    now resolves correctly for ShaguScore.

commit c0da63657d
Author: Brues <5278969+brues-code@users.noreply.github.com>
Date:   Sat Jul 25 10:09:34 2026 -0500

    Various cleanup

    Removes version compatibility checks for TBC/Vanilla, consolidating code to target a single WoW version. Refactors repetitive SetWidth/SetHeight calls to SetSize for cleaner code. Removes duplicate function definitions from unitxp module and simplifies conditional show/hide operations using SetShown.

commit 11a6302c2d
Author: Brues <5278969+brues-code@users.noreply.github.com>
Date:   Sat Jul 25 09:53:37 2026 -0500

    Delegate pfUI.api.strsplit to ClassicAPI's strsplit

    Replace the Lua pattern-based implementation with a thin wrapper around
    ClassicAPI's C-level strsplit. Keeps the pfUI.api.strsplit entry point for
    backwards compatibility with addons that call it, while dropping the
    redundant reimplementation.

    Behavioral note: the old version used ([^delim]+) which silently collapsed
    empty fields; delegating to real strsplit now preserves them
    ("a,,b" -> "a", "", "b"). All in-repo callers split numeric color tuples,
    version strings, or build name-keyed lookup tables, none of which are
    affected by empty-field preservation.

commit 67c126eac8
Author: Brues <5278969+brues-code@users.noreply.github.com>
Date:   Sat Jul 25 01:01:02 2026 -0500

    Bump ClassicAPI minimum version to 1.8.0

commit a6cf157518
Author: Brues <5278969+brues-code@users.noreply.github.com>
Date:   Sat Jul 25 00:49:50 2026 -0500

    read spell rank via C_Spell.GetSpellSubtext

    The rank string comes from the spell subtext ("Rank N"), which ClassicAPI's
    C_Spell.GetSpellSubtext returns directly -- so drop nampower's
    GetSpellRecField(spellId, "rank") here. The existing "Rank " gsub parse is
    unchanged.

commit 4b1ba99b4f
Author: Brues <5278969+brues-code@users.noreply.github.com>
Date:   Sat Jul 25 00:33:20 2026 -0500

    Move player info overlay onto ClassicAPI (drop Nampower)

    The haste/spell-power overlay read both values through Nampower and disabled
    itself entirely without it. Move both to ClassicAPI so it works on any
    ClassicAPI client:

    - Spell power: GetSpellPower("net") (nampower) -> GetSpellBonusDamage(i)
      (ClassicAPI, same per-school field). Merged the build+scan into one loop;
      the default school seeds the tiebreak so equal schools still favor it.
    - Haste: GetUnitField("player", "modCastSpeed") -> UnitSpellHaste("player"),
      which returns the haste percentage directly (the (1/modCastSpeed-1)*100
      conversion is now baked in, off the same UNIT_MOD_CAST_SPEED field, signed).
    - Dropped the "if not GetUnitField then return" gate -- UpdateInfoText no
      longer touches Nampower, so the overlay runs everywhere.

commit 7df4aa6d50
Author: Brues <5278969+brues-code@users.noreply.github.com>
Date:   Sat Jul 25 00:32:44 2026 -0500

    Hook the real global _G.UnitHealth for feign death

    Inside a RegisterModule body, `function UnitHealth(...)` defines UnitHealth on
    the pfUI environment, not the real global -- so the feign-death real-HP fix
    only reached callers that resolve UnitHealth through pfUI's env, and missed
    _G consumers (Blizzard frames, other addons). Hook _G.UnitHealth explicitly
    (and capture oldUnitHealth from _G) so the un-gate applies everywhere.

commit b0bf2fd869
Author: Brues <5278969+brues-code@users.noreply.github.com>
Date:   Fri Jul 24 21:10:58 2026 -0500

    Refactor nampower module

    Simplify reactive spell storage by using spell IDs instead of texture/name tables. Update to use modern C_Spell APIs (GetSpellTexture, GetSpellName) instead of manual texture paths. Consolidate SetWidth/SetHeight calls to SetSize and use print() instead of DEFAULT_CHAT_FRAME:AddMessage().

commit 0b06961333
Author: Brues <5278969+brues-code@users.noreply.github.com>
Date:   Fri Jul 24 20:54:23 2026 -0500

    Use GetNamePlateForUnit for target lookups; drop dead ScanGuid block

    - Replace the three GetNamePlateForGUID(UnitGUID("target")) round-trips with
      GetNamePlateForUnit("target"), which resolves the token to a GUID internally
      -- no UnitGUID string detour, and it returns nil for no-target/no-plate so
      the UnitExists guards collapse. GetNamePlateForGUID is left for raw-GUID cases.
    - Remove the dead libunitscan.ScanGuid nameplate block (ScanGuid was deleted
      from libunitscan long ago, so the guard was never true) -- it carried the
      last GetUnitField("npcFlags") read.

commit 3e6210086e
Author: Brues <5278969+brues-code@users.noreply.github.com>
Date:   Fri Jul 24 20:54:23 2026 -0500

    Drop Nampower stats system and polling from unit frames

    GetUnitStats now reads health/power straight from UnitHealth/UnitPower
    (the descriptor fields the server broadcasts) -- for a real unit token
    GetUnitField read nothing different, so the whole Nampower-vs-fallback
    apparatus was measuring a distinction that no longer exists. Removed:

    - The stats system: pfUI.uf.stats, pfUIStatsFrame + UpdateStatsDisplay, the
      lastUnitStats change-cache, the /pfuistats slash command, and every counter
      increment (event/heartbeat/earlyReturn/throttledSkip/nampower/fallback).
    - All GetUnitField health reads (GetUnitStats, heal-prediction, health-gradient
      color) -- collapsed to the UnitHealth/UnitHealthMax they already fell back to.
    - The heartbeat-polling backstop and its fallbackThrottle/lastEventUpdate deps.
      Frames now refresh on events only; eventless frames still use their own tick,
      and range/aggro still run in the eventless-actions block.

commit 63001b7b0c
Author: Brues <5278969+brues-code@users.noreply.github.com>
Date:   Fri Jul 24 20:09:42 2026 -0500

    Move nameplates onto ClassicAPI stable nameplate tokens

    ClassicAPI now assigns retail-exact, per-plate-stable "nameplateN" tokens and
    fires vanilla UNIT_* events for them, so the nameplate module can key off the
    token instead of Nampower/SuperWoW GUID primitives:

    - Events: UNIT_AURA_GUID/UNIT_FLAGS_GUID -> UNIT_AURA/UNIT_FLAGS, matched by
      the "nameplateN" token (guarded on the token prefix, since these also fire
      for target/party/raid). Registered unconditionally -- no GetUnitField gate.
    - Health: GetUnitField(guid, "health"/"maxHealth") -> UnitHealth/UnitHealthMax
      on the plate's cached token. Same UNIT_FIELD_HEALTH the server broadcasts
      (real HP on Turtle; the ~= 100 scaled-vs-real guard is unchanged).
    - Combat/target in GetCombatStateColor: GetUnitField("flags") + HasFlag ->
      UnitAffectingCombat(token); GetUnitField("target") + SuperWoW "<guid>target"
      -> the "nameplateNtarget" chain. Dropped the now-dead HasFlag,
      UNIT_FLAG_IN_COMBAT, and guidTargetTokenCache.
    - GetCastInfo now takes the token directly; every caller already holds it, so
      the UnitTokenFromGUID(guid) round-trip is gone (unused module-wide now).

    NAME_PLATE_UNIT_ADDED caches the token as plate.nameplate.unit alongside the
    GUID; REMOVED clears both. GUID is retained only as the stable cache key
    (debuffCache/threatMemory/combatColorCache). Only GetUnitField("npcFlags")
    remains -- it has no token/vanilla equivalent.

commit ce1c49fcbb
Author: Brues <5278969+brues-code@users.noreply.github.com>
Date:   Fri Jul 24 18:20:06 2026 -0500

    Make focus/focustarget event-driven via ClassicAPI unit events

    ClassicAPI now fires UNIT_* (health/mana/aura/...) with arg1 == "focus" and
    arg1 == "focustarget", observed per-unit like target/party/raid. Both frames
    already registered those events (focus/focustarget are in pfValidUnits) and
    their OnEvent already matches arg1 == label, so the 0.2s polling ticks were
    pure workarounds for the missing events. Drop both ticks; the frames now
    refresh on-event like target, with range/glow still on the shared 0.5s state
    pass and PLAYER_FOCUS_CHANGED still driving assign/clear.
 2026-07-26 18:32:36 -05:00
Brues cba3604906 Use UnitGUID instead of UnitExists for GUID 
Replace the previous extended UnitExists GUID retrieval with UnitGUID and simplify the Nampower health lookup flow. Also minor whitespace/formatting cleanup.
 2026-07-24 17:06:12 -05:00
Brues a31d10384b Read unit power from ClassicAPI instead of Nampower's GetUnitField 
GetUnitStats parsed the power type out of the bytes0 descriptor field and
read each power slot via GetUnitField(guid, "powerN")/"maxPowerN", manually
dividing rage by 10. ClassicAPI's UnitPower/UnitPowerMax read the same
descriptor slots and apply the engine's own power-divisor table (rage /10,
happiness scaling), so:

  powerType = UnitPowerType(unitstr) or 0
  power = UnitPower(unitstr, powerType)
  maxPower = UnitPowerMax(unitstr, powerType)

is equivalent and drops nine GetUnitField calls plus the bytes0 parsing.
Power now resolves through the hard-dep ClassicAPI even without Nampower;
GetUnitField in this path is left only for health, which has no ClassicAPI
real-HP equivalent.
 2026-07-24 17:01:09 -05:00
Brues f06af48bc2 nampower: Use SetSize, UnitClassBase and simplify icon logic 
Replace SetWidth/SetHeight with SetSize for pfUI.spellqueue and reactive icons. Use UnitClassBase("player") to obtain the player's class token. Simplify reactive icon visibility by using SetShown and aggregating a single anyVisible flag, then calling SetShown on the parent frame. Minor readability and API modernization changes.
 2026-07-24 16:49:35 -05:00
Brues d73c4de695 Modernize power-API usage onto ClassicAPI 
- Replace all UnitMana/UnitManaMax calls with UnitPower/UnitPowerMax. The
  no-arg form returns the unit's primary power from the same field vanilla's
  UnitMana read, so these are behavior-preserving. Drops two dead
  UnitMana/UnitManaMax local caches in nameplates.lua.
- Replace magic power-type numbers (0/1/2/3) with Enum.PowerType.Mana/Rage/
  Focus/Energy in the GetUnitStats branches, the power-bar color block, the
  druid mana bar, GetStatusValue's powerdyn, and energytick's mode checks.
 2026-07-24 16:37:34 -05:00
Brues dd8c529463 Move druid mana bar into the unit frame, off nampower 
The druid secondary mana bar (shown while shapeshifted into a form that
uses energy/rage) lived in nampower.lua and read base mana through
nampower's GetUnitField. Extract it into the unit frame proper and drive
it with ClassicAPI instead:

- Create pfDruidMana_<unit> as f.druidmana in CreateUnitFrame (player and
  target), lay it out in UpdateConfig from the existing C.unitframes.druidmana*
  keys, and update it in a new pfUI.uf:UpdateDruidMana driven by the frame's
  own base-refresh pass (UNIT_MANA / UNIT_DISPLAYPOWER). No separate event
  frames, no nampower dependency.
- Read mana via UnitPower(unit, 0) / UnitPowerMax(unit, 0), the ClassicAPI
  slot getters that return the mana pool regardless of the active power, so
  it works while in Cat/Bear form.
- Add a "Show Druid Mana Bar Text" toggle (druidmanatext) so the current/max
  readout can be hidden while keeping the bar; config default, GUI checkbox,
  and locale stubs.
- Remove the now-dead block from nampower.lua.
 2026-07-24 16:23:28 -05:00
Brues 47a7b4c686 Simplify totems frame sizing 
Replace separate SetWidth/SetHeight calls with a single SetSize using precomputed 'thickness' and 'length' values. This refactors the totems layout math into clearer variables (thickness = iconsize + spacing*2, length = thickness * count) for horizontal and vertical directions, improving readability and maintainability without changing behavior.
 2026-07-24 16:08:36 -05:00
Brues cf3f1e5440 Rework raid self/group frame visibility and rename the solo option 
- selfinraid now gates on `not IsInGroup()`, so "show self in raid frames"
  applies only when truly solo (both party and raid suppress it), matching
  the option's actual behavior.
- Hide the redundant group frames when a party is promoted to the raid grid
  (raidforgroup + hide_in_raid), not just in an actual raid. A shared
  hide_group local drives both the party-member and self branches; the
  party-member branch is scoped to cache_raid == 0 so the raidforgroup-mapped
  raid frames (which themselves carry label "party") aren't hidden too.
- Rename "Always Show Self In Raid Frames" to "Show Self In Raid Frames When
  Solo" in gui.lua and all locale files; the four previously-translated
  strings are reset to nil stubs since the meaning changed.
 2026-07-24 15:02:38 -05:00
Brues 182127bd67 Refactor totems to use CreateColor API 
Replace manual color tables with CreateColor() function calls for better code consistency and API usage. Update tooltip color handling to use WHITE_FONT_COLOR:GetRGB() instead of hardcoded hex color codes. Rename 'slots' variable to 'slotColors' for clarity.
 2026-07-24 15:00:16 -05:00
Brues 3d2e6e202b corrected rangecheck vanilla label 2026-07-24 14:14:46 -05:00
Brues 3a062ee2ac Recast Totem will now use the same rank totem 2026-07-24 10:00:22 -05:00
Brues 5ed1d98ecc Raid Pets and Optimized Chat Bubble Styling 
commit f19d7402810637fc32460864104cb792ac5af863
Author: Brues <5278969+brues-code@users.noreply.github.com>
Date:   Wed Jul 22 01:05:52 2026 -0500

    remove comment

commit 60f4968f06d19d42bdc6347f98ff4d5a34785e97
Author: Brues <5278969+brues-code@users.noreply.github.com>
Date:   Wed Jul 22 01:05:06 2026 -0500

    Bump ClassicAPI minimum version to 10705

    Update the minimum required ClassicAPI version from 10704 (1.7.4) to 10705 (1.7.5).

commit 088dba4c23f4aa7ce98b9ce9d75bc5892cd40520
Author: Brues <5278969+brues-code@users.noreply.github.com>
Date:   Wed Jul 22 01:04:04 2026 -0500

    Add raid-pet frames: an independent, roster-driven pet grid

    New "raidpet" unitframe type that shows raid members' pets (raidpet1..40)
    in their own movable block (pfRaidPetCluster), off by default. It's a
    flat pool of frames laid out by pfUI.uf.raid:LayoutPets straight from the
    raid roster -- cell N shows raidpet<N> -- so it's fully decoupled from how
    the raid grid arranges its own slots.

    Layout is independent of the raid grid: raidpet carries its own
    width/height plus a Layout section (raidlayout / raidpadding / raidfill),
    and its own Collapse Empty Slots toggle that packs only the pets that
    exist into the leading cells. The raid grid gets the same collapse option
    (sequential slot assignment in AddUnitToGroup instead of by subgroup).
    Collapsed pets re-pack on roster changes and on UNIT_PET so summons and
    dismisses track live without polling.

    Also:
    - unitframes: a "raidpet" branch in UpdateVisibility (hide when the pet is
      out of range or its raid<N> owner is gone), and fix cache_raid so the
      "pfRaid" prefix check doesn't misread pfRaidPet<n> frames (char 7 is
      non-numeric -> nil compare crash).
    - New "Owner Name" text option: on any pet frame (raidpet/partypet/pet) it
      shows the owner's class-colored name so you can tell whose pet it is.
    - unlock: a pfRaidPet drag cluster, a numeric-suffix guard so pfRaid no
      longer matches (and crashes on) pet frames, and RaidPet config mappings.
    - config/gui/translations for all of the above.

commit 52f02c8963fe7ec90f36100ebe069c7807529301
Author: Brues <5278969+brues-code@users.noreply.github.com>
Date:   Mon Jul 20 23:09:06 2026 -0500

    Enumerate chat bubbles via ClassicAPI instead of scanning WorldFrame

    ClassicAPI's C_ChatBubbles.GetAllChatBubbles() walks the engine's own
    bubble list and returns the exact set of live bubble frames, with real
    GetRegions(), so the decoration idiom works unchanged. Replace the
    WorldFrame:GetChildren() sweep and drop the IsBubble heuristic (unnamed
    frame whose first region is the ChatBubble-Background texture) -- the API
    only ever hands back bubbles, so that guess is both redundant and more
    fragile than the engine list. Cheaper too: it iterates only live bubbles
    rather than every world child on each chat event.
 2026-07-23 23:08:05 -05:00
Brues fa1dc5637e Bump ClassicAPI min to 1.7.4 
Totem functions!
 2026-07-20 22:17:49 -05:00
Brues 8506f5ffbf Localize the totem tooltip click hints 
Add a Left Click / Right Click hint to the totem icon tooltip via
AddDoubleLine, matching the panel.lua convention. Reuses the existing
"Left Click" / "Right Click" strings and adds "Recast Totem" /
"Target Totem" as new translation keys (stubbed across all locales; they
fall back to English until translated).

Also drop the now-orphaned "Range Check Interval" string from every
locale manifest -- the setting was removed when librange stopped
scanning, but its translation stubs were left behind.
 2026-07-20 22:16:05 -05:00
Brues 9c529512d1 Replace libtotem with ClassicAPI's native totem tracker 
ClassicAPI now ships GetTotemInfo/GetTotemTimeLeft/GetTotemDuration/
TargetTotem plus a native PLAYER_TOTEM_UPDATE event, backed by a
data-driven tracker (slot from the Spell.dbc summon effect, duration from
SpellDuration.dbc, and object-manager death detection). That's exactly
what libtotem hand-rolled -- and better -- so delete the library outright:
its spellid/icon tables, the CastSpellByName/CastSpell/UseAction hooks,
the SPELL_GO commit path, and the active-totem bookkeeping.

modules/totems.lua becomes a thin consumer of the native API:
- Driven by PLAYER_TOTEM_UPDATE; drop the shaman tick-poller that only
  existed because vanilla had no totem event.
- Fix the GetTotemInfo call sites: the native 1st return is tool presence,
  not "summoned", so key active state on name/start instead.
- Right-click a totem icon to TargetTotem it; tooltip shows remaining time
  via GetTotemTimeLeft.

modules/turtle-wow.lua: drop the Totemic Recall handler that poked
libtotem:Clean() -- the native tracker detects the totems despawning and
clears the slots itself. Also clean up the now-orphaned translation string
and a stale libtotem mention in libdebuff's comment.
 2026-07-20 21:51:08 -05:00
Brues 88d0f7bf74 Use table.wipe to reset spell caches 
Clear existing spell cache tables with table.wipe instead of creating new tables when LEARNED_SPELL_IN_TAB fires. This preserves existing table references (spellmaxrank, spellindex, spellinfo), avoiding stale references and potential bugs while being slightly more efficient. Change applied in libs/libspell.lua.
 2026-07-20 21:35:31 -05:00
Brues a3ff20782d Use table.wipe and table.insert for tables 
Replace custom wipe implementation with a call to table.wipe in api/api.lua and update its doc comment to explain behavior (resets Lua 5.0 length via luaL_setn, advises using table.insert). Replace manual table.getn(t)+1 array appends with table.insert in modules/loot.lua (two sites). Makes table operations safer and more idiomatic, avoiding manual metatable handling and getn-based append idioms.
 2026-07-20 21:16:12 -05:00
Brues 88c2462fbd CLASS_SORT_ORDER is already defined by !!!ClassicAPI 2026-07-20 21:15:25 -05:00
Brues e28a7e5606 Optimize isempty function using next() 2026-07-20 18:46:09 -05:00
Brues dfa74c5756 Make the bag sort family-aware and locale-independent 
Two fixes to libbagsort's planning stage.

Family-aware placement: the sort treated every bag in the list as
interchangeable storage, so with a quiver / soul / profession bag in the
set it would try to swap a general item into a slot that can't hold it.
The client rejects that swap, but the grid was updated as if it
succeeded, desyncing the plan and corrupting the sort from there on. Now
each destination slot is tagged with its bag's family (via ClassicAPI's
GetItemFamily, which reports bag families reliably) and every item is
routed to a cell that accepts it -- matching specialty bag first,
overflowing to general -- so nothing lands where it can't go and family
items consolidate into their bags for free.

Locale-independent categories: SortCategoryPrefix compared the localized
itemType/quality strings from GetItemInfo, which silently miscategorize
everything on a non-enUS client. Switch to the numeric classID/quality
via C_Item.GetItemInfo and ClassicAPI's Enum.ItemClass / Enum.ItemQuality.
 2026-07-20 17:46:37 -05:00
Brues 1c0c9dc019 Replace librange's position scan with ClassicAPI's UnitInRange 
librange was a per-frame position scanner: it swept party/raid unit
tokens, cached each one's distance via UnitPosition, and answered range
queries from that cache. All of it existed only because 1.12 had no cheap
way to check an arbitrary unit's distance. ClassicAPI's UnitInRange does
exactly that C-side (fixed 40y healing range, position miss reported via
the second return), so the whole library collapses to a direct call.

Wins from dropping the cache:
- No staleness. The scanner's zone-death and roster-reindex bugs simply
  can't exist without a cache to go stale, so this supersedes the
  keep-alive fixes from 756e8840.
- All classes get target-frame range fading. The old target path faked a
  40y check via IsActionInRange on a healing spell found on the action
  bar, so classes without such a spell (GetRangeSlot returned nil) never
  had a working target range check.

The rangecheck == "0" master switch used to be enforced by hiding the
scanner; with no scanner, move that gate into pfUI.api.UnitInRange so
disabling the check still means nothing fades. Threshold is now 40y (the
ClassicAPI constant) rather than the old 45y. Drop the now-dead
rangechecki (Range Check Interval) setting, its GUI row, and migration.
 2026-07-20 16:54:27 -05:00
Brues 801935130e Update GetItemLinkByName to use C_Item API 
Replace vanilla GetItemInfo and manual link construction with C_Item.GetItemNameByID and C_Item.GetItemInfo
 2026-07-20 15:11:50 -05:00
Brues 8cdced5ec0 Simplify modf function 
Delegate to ClassicAPI
 2026-07-20 15:10:31 -05:00
Brues 756e8840af Keep the rangecheck scanner alive across zones and roster changes 
PLAYER_LEAVING_WORLD fires on every loading screen, not just logout, but
librange treated it as terminal: it latched librange_isLoggingOut and
tore OnUpdate off the frame, neither of which was ever restored. So the
first zone (into a BG, dungeon, etc.) permanently killed the distance
scan -- unitdata stopped updating and UnitInSpellRange defaulted every
unit to in-range until /reload, which the next loading screen then undid.
Only PLAYER_LOGOUT is terminal now; PLAYER_LEAVING_WORLD just hides for
the loading screen and PLAYER_ENTERING_WORLD re-shows it.

Also invalidate on RAID_ROSTER_UPDATE / PARTY_MEMBERS_CHANGED: the range
state is cached per unit token, so a roster re-index leaves each unitN
mapped to a different player with stale data. Clear the token cache and
restart the sweep so shifted/joined slots are re-evaluated within one
pass instead of inheriting the previous occupant's range.
 2026-07-20 14:12:07 -05:00
Brues b2db091d54 bump min ClassicAPI version 2026-07-20 02:42:34 -05:00
Brues 5fae0bd459 Add priest shadowform auto-paging, sharing the druid-stealth flag 
Mirror the druid-stealth page switch for priests: swap to the auto page
(8) while in Shadowform, back to the default page when it drops. Driven
by UPDATE_SHAPESHIFT_FORM (form ID 28), which fully covers shadowform on
its own -- no prowl-style stealth substate to chase.

Fold the new state into the existing prowl machinery instead of
duplicating it: prowl/shadowform are mutually exclusive by class, so one
shared `formpaging` flag and one page constant serve both, and the
OnUpdate switch collapses to a single class-gated block.
 2026-07-20 02:40:37 -05:00
Brues 3deddf2b08 Drive questitem off QUEST_ACCEPTED/QUEST_REMOVED instead of rescanning 
The item->quest map only changes when a quest enters or leaves the log,
not on progress, yet it was fully rebuilt on every QUEST_LOG_UPDATE burst
(a whole log walk + GetQuestDetails per quest). Maintain it incrementally
from ClassicAPI's QUEST_ACCEPTED / QUEST_REMOVED, keyed on the stable
questID with title/level cached at add time (the old log index shifted on
any add/remove). QUEST_LOG_UPDATE now only drives a one-time login seed
until the detail cache warms, since QUEST_ACCEPTED is suppressed for the
bulk sync; afterward it's a no-op and questing does no rebuilds.
 2026-07-19 02:25:23 -05:00
Brues 650bcda001 Allocate newitem glow lazily, only for slots that go new 
UpdateSlot previously created the glow texture and OnEnter acknowledge
hook on the first pass over every slot, then toggled visibility. Move
both inside the "is new" branch so a slot only allocates when it actually
holds a new item -- most bag/bank slots never do. Behavior is unchanged:
the glow is still created once per slot and reused, and the hook is
installed exactly when it's first needed.
 2026-07-17 16:04:03 -05:00
Brues 931fe6c22d Harden the ClassicAPI-missing path so the disable notice can show 
pfUI's TOC depends on the !!!ClassicAPI addon, so a nil CLASSIC_API_VERSION
means the addon loaded but the DLL isn't present -- yet the graceful-disable
branch itself called ClassicAPI APIs (EventUtil.ContinueOnPlayerLogin, and
Mixin/CallbackRegistryMixin for pfUI.events), so it crashed instead of
informing the user.

- Defer the popup with a bare PLAYER_ENTERING_WORLD frame (stock 1.12)
  instead of EventUtil/IsLoggedIn/PLAYER_LOGIN (ClassicAPI-era).
- Read the editbox via getglobal rather than _G.
- Guard pfUI.events creation behind `not pfUI.disabled`.
- Reword the notice: since the addon is present but the DLL isn't (or is
  outdated), tell the user the addon ships bundled with the DLL and to
  delete the !!!ClassicAPI folder and (re)install the latest release.
 2026-07-17 15:12:30 -05:00
Brues bd4a40b0f2 Add newitem module: highlight freshly-acquired bag items 
New module built on ClassicAPI's C_NewItems + BAG_NEW_ITEMS_UPDATED.
Glows bag slots (bags 0-4) holding items acquired since login, keyed on
item GUID so the flag survives rearranging. Hovering an item
acknowledges it (RemoveNewItem); closing the bags clears the rest via
ClearAll. Glow is UI-ActionButton-Border, sized off the slot width so it
tracks the icon_size config.

To stay decoupled from the bag frames, the bag module now broadcasts a
reusable "bag:closed" event through pfUI.events from its OnHide (carrying
the container so subscribers can tell backpack from bank), guarded so the
initial setup Hide() doesn't fire a phantom close.

Config: appearance.bags.newitem + newitem_color, with GUI toggles.
 2026-07-17 14:47:22 -05:00
Brues 31ff2773b3 Defer macrotweak conflicts; use SetSize 
Replace the previous RunNextFrame conflict check with per-addon EventUtil.ContinueOnAddOnLoaded calls in modules/macrotweak.lua so macrotweak is disabled as soon as known conflicting addons load. Simplify variable naming and ensure the disabled flag is set correctly. In skins/blizzard/macro.lua replace separate SetHeight/SetWidth calls with a single SetSize(150,22) for MacroEditButton to tidy UI sizing.
 2026-07-15 13:45:06 -05:00
Brues 8176b906df Re-anchor tradeskill merge bar to real craft starts 
EnterTradeskillMerge sized the merged bar as startMs + single*count, a
zero-latency assumption. Each craft boundary actually costs a server
round-trip, so the real chain runs ~(N-1)*lag longer than the bar
assumed. At the clear the overall fill was clamped to full and looked
done, but the fast per-craft spark tracks real time and came up short by
the accumulated lag -- freezing partway on the final craft.

StartTradeskillCraft now re-pins endTime to each craft's real start
(remaining crafts each still take `single`), so on the last craft
remaining==1 and endTime lands on its true completion. The spark and the
overall progress now reach the right edge together.
 2026-07-13 12:34:45 -05:00
Brues 721ecce59d Remove RegisterNewModule call for loothistory 2026-07-13 00:32:21 -05:00
Brues 73b409fb88 Route slash registration through pfUI.api.RegisterSlashCommand 
The RegisterSlashCommand helper in api/api.lua was effectively unused
(only macrotweak called it); every other command hand-rolled the
SLASH_*/SlashCmdList pair. Convert the existing manual registrations to
the helper with force=true, preserving the current always-bind behavior
while centralizing the pattern behind one code path (and its _G. and
conflict-check handling).

Left as-is: pfUI.lua's /rl, /pfui, /gm (registered before api.lua
defines the helper) and the vendored libs' debug commands.
 2026-07-13 00:06:20 -05:00
Brues 0665764610 cleanup 2026-07-12 15:22:57 -05:00
Brues 3faf06141f Skin Arena Frame 2026-07-12 14:49:17 -05:00
Brues 0c06401ec4 Simplify GUI toggle logic 2026-07-12 14:14:38 -05:00
Brues c68e48111d Remove libtooltip 2026-07-12 14:01:25 -05:00
Brues 6936fd894b Replace unusable tooltip scan with C_PlayerInfo.CanUseItem 
The libtipscan approach scanned each bag/bank item's tooltip for red
text, then had to carve out broken (0-durability) items since those also
color red. C_PlayerInfo.CanUseItem checks item requirements directly
(proficiency, level, class/race, skill/spell/rep) and ignores item
state, so broken-but-equippable gear is never flagged and the durability
exclusion drops out entirely. Bank slots resolve through
C_Container.GetContainerItemID(-1, slot) instead of the inventory-slot
workaround the scanner needed.
 2026-07-12 13:48:36 -05:00
Brues b5277ea457 These modules aren't new anymore 2026-07-11 16:04:58 -05:00
Brues 63f0dcbf7a Use GetInventoryItemID instead of parsing link 2026-07-11 13:18:48 -05:00
Brues 0344bff471 cleanup 2026-07-11 12:59:33 -05:00
Brues 1510969105 Unused strings 2026-07-11 12:57:07 -05:00
Brues 6e7361c543 Removed redundant compare.basestats setting 
Just disable the module if you don't want stat comparison
 2026-07-11 12:43:15 -05:00
Brues 2e20a03cbd Restore Inspect UI frame skin 
removed during the tbc purge
 2026-07-11 12:36:03 -05:00
Brues 7389c241a4 using GetSpellInfo with just a spell id is dangerous 
Handful of addons will polyfill their own GetSpellInfo that only accept (bookSlot, bookType) so it's only safe to use C_Spell.GetSpellInfo with just a spell id
 2026-07-11 09:47:46 -05:00
Brues fb5230828c Add Loot History module 
A pfUI-native group-loot roll history window built on ClassicAPI's
C_LootHistory backport, adapted from the anniversary Blizzard reference.

- Movable/scrollable window (ESC-closable, Clear button) listing rolled
  items; each row expands to per-player rolls.
- Item icon/name/quality rendered via the !!!ClassicAPI Item mixin
  (Item:CreateFromItemLink + ContinueOnItemLoad), so uncached items load
  asynchronously and repaint their row.
- Winner shown on the collapsed row (name/roll/roll-type) and marked in the
  expanded list with a checkmark left of the name (matches the reference).
- Expansion state keys on the stable rollID; events (FULL_UPDATE /
  ROLL_CHANGED / ROLL_COMPLETE) drive a rebuild while shown, and re-attach
  the scroll child so a growing list scrolls without a /reload.
- Toggle via /loothistory or /lh; optional auto-show on new rolls behind
  loothistory.autoshow (default off).
 2026-07-11 00:02:31 -05:00
Brues 7aee348a70 Bump min version to 1.6.4 2026-07-10 20:27:16 -05:00
Brues 2a5f480839 Show addon dependencies in tooltip 
Add display of required and optional addon dependencies to the addons tooltip. Introduce AddDependencyLines helper in modules/addons.lua which lists dependencies with color coding: green for loaded, yellow for present but unloaded, and red for missing (uses new T["Missing"]). Store dependency arrays on addon frames (adeps / aoptdeps) using GetAddOnDependencies and C_AddOns.GetAddOnOptionalDependencies. Add translation keys 'Dependencies', 'Optional Dependencies', and 'Missing' to env/translations_enUS.lua.
 2026-07-10 20:26:05 -05:00
Brues 23d1ab840c Show sell value in tooltip when merchant hidden 
When the MerchantFrame is not shown, display the item's total vendor sell value on the tooltip. Adds a guard to call SetTooltipMoney(frame, sell * count) if sell > 0 so stacked items show their combined sell price.
 2026-07-10 13:23:52 -05:00
Brues 13a08b0ea3 Restore hooksecurefunc 2026-07-09 23:01:52 -05:00
Brues a2177fbf49 Restore HookScript 2026-07-09 22:55:26 -05:00
Brues 9cd83e90ad Added GetNoNameObject debugging 2026-07-09 22:31:58 -05:00
Brues 9bcc11e64f removed tbc logic 2026-07-09 22:26:32 -05:00
Brues acab272ec0 Generalize vendor price display across all tooltip types 
Replace the single GameTooltip hook with a comprehensive hooking system that displays vendor prices across 17+ tooltip methods, including loot, quests, bags, mail, auctions, trades, merchants, and crafting. This ensures players see vendor prices consistently regardless of where they view items.
 2026-07-09 22:05:25 -05:00
Brues 61c2f996fa Revert on-swing queue color when the ability is cancelled 
Pressing Esc (or re-pressing) to cancel a queued Heroic Strike / Cleave /
Maul left the swing bar stuck in its queued color. The color is set on the
on-swing press and only cleared on nampower's ON_SWING_QUEUE_POPPED, which
fires solely when a queued-behind on-swing resolves; nampower's cancel path
touches no on-swing state and emits no event, so the flag never cleared.

Reconcile the event flag against the client's IsCurrentAction, which it does
clear on cancel: ReconcileQueued drops the flag once the client has confirmed
the ability as current and then stops showing it (the true->false transition).
It only acts once current has been seen, so a nampower-initiated cast the
client never flags as current keeps its color until its own pop/resolve --
preserving the reason the event-driven path exists.

RebuildQueueSlotCache now caches Maul slots and runs for druids, and no longer
bails in event mode so the caches stay fresh for reconciliation.
 2026-07-09 19:45:17 -05:00
Brues 59ce6d9e74 Use a single shared frame for HookAddonOrVariable 
Every HookAddonOrVariable call created its own lurker frame with three
event registrations. Share one frame across all hooks: they accumulate
in a pending list the single OnEvent handler walks, firing and dropping
each whose addon/variable is available, and unregistering events once the
list empties.

Behavior is preserved and slightly hardened: foundConfig now persists on
the shared frame (set on VARIABLES_LOADED and PLAYER_ENTERING_WORLD, both
of which imply config is ready), so a hook registered after config load
fires immediately if its addon is already loaded rather than waiting for
the next event.
 2026-07-09 17:54:09 -05:00
Brues 967487e283 Utilizing ClassicAPI 1.6.0 
commit d63057474083aa67fda2aa28ee6301334ffc4fdf
Author: Brues <5278969+brues-code@users.noreply.github.com>
Date:   Mon Jul 6 00:59:17 2026 -0500

    Use C_Map.GetMapOverlays instead of hardcoded pfMapOverlayData

    ClassicAPI's C_Map.GetMapOverlays reads WorldMapOverlay.dbc directly and
    returns the full overlay list for a zone (explored + unexplored) — the
    data vanilla's GetMapOverlayInfo withholds. mapreveal now iterates it
    straight (named fields: textureName/texturePath/width/height/offsets),
    dropping unpack_hash and the pfMapOverlayData tables entirely.

    Also fixes the explored-check: it compared the full texture path against
    GetMapOverlayInfo's bare-name keys, so the magnifying glass never
    suppressed on explored overlays. Now matches on the bare name.

    Removes ~870 lines of hand-measured overlay data (base + Turtle).

commit ad12c8209a80cd1211fe08e83f7013d24b5efd2d
Author: Brues <5278969+brues-code@users.noreply.github.com>
Date:   Sun Jul 5 23:45:09 2026 -0500

    utilize HookScript from ClassicAPI
 2026-07-09 00:56:06 -05:00
Brues ab11096b01 Show on-swing queue color on every HS/Cleave/Maul press 
The SPELL_CAST_EVENT hook only called SetQueuedKind, but the queued
color path is gated behind S.useSpellQueueEvent. Nampower fires
SPELL_CAST_EVENT on the actual HS/Cleave/Maul press (not just the
rarer ON_SWING_QUEUED), so flip the event-driven flag there. The
queued color now shows even when the client IsCurrentAction state
does not reflect a natively-queued on-swing ability.
 2026-07-08 10:34:45 -05:00
Brues 0402db380a logically sort Castbar options 2026-07-08 09:47:13 -05:00
Brues 68fe7e22db Split castbar config into General/Player/Target/Focus subcategories 
The castbar options were one long list. Break them into four subentries
under the Castbar parent (matching the Settings/Actionbar layout):
General (fonts, colors, texture, disable-blizzard) plus one page each for
Player, Target, and Focus. Drops the now-redundant per-unit header rows.
 2026-07-07 16:31:56 -05:00
Brues a93e9f530c Add spell name & timer text alignment options for unit frame castbars 
Adds per-unit (player/target/focus) dropdowns to align the castbar
spell name (left text) and cast timer (right text) Left/Center/Right.
Both share a castbaralign dropdown; defaults preserve current behavior
(name LEFT, timer RIGHT). Applied at castbar creation, so takes effect
on /reload like the other castbar options.
 2026-07-07 16:26:48 -05:00
Brues 3be0585039 Don't let the pet bar dodge reposition the stance bar during unlock 
The pet bar force-shows in unlock mode, and its OnShow/OnHide dodge
handlers re-anchor the stance bar above the pet bar. That yanked the
stance bar off its real position while unlocking (dodging a pet bar
that isn't actually active), so it appeared to vanish and only returned
when unlock ended. Skip the dodge re-anchor while unlock is active so
the stance bar stays put and can be positioned.
 2026-07-07 13:02:05 -05:00
Brues ee7c729bcb remove select 2026-07-07 09:16:33 -05:00
Brues 62e0d4eb07 prevent camera from constantly resetting 2026-07-06 17:33:16 -05:00
Brues a4ceb8ba53 utilize HEARTHSTONE_BOUND 2026-07-06 17:07:51 -05:00
Brues 80b677a6f8 utilize UnitIsAFK 2026-07-06 17:07:41 -05:00
Brues f6683b31af Clear castbar unlock preview when leaving unlock mode 
The unlock preview drives the bar via alpha: the OnUpdate forces alpha=1
while the drag handle is shown. On lock, with no active cast (endTime nil)
and no fadeout, the idle branch returned early and left the empty bar
stuck at alpha 1. Reset leftover alpha to 0 in that branch so the preview
clears once the drag handle hides. Fixes #16.
 2026-07-06 03:04:17 -05:00
138 changed files with 10848 additions and 18228 deletions
Expand all files Collapse all files
.github/workflows/release.yml
+3 -3
View File
@@ -23,12 +23,12 @@ jobs:
IFS=. read -r MAJOR MINOR PATCH <<<"$LATEST" IFS=. read -r MAJOR MINOR PATCH <<<"$LATEST"
PACKED=$((MAJOR * 10000 + MINOR * 100 + PATCH)) PACKED=$((MAJOR * 10000 + MINOR * 100 + PATCH))
echo "Pinning PFUI_CLASSIC_API_LATEST to $LATEST ($PACKED)" echo "Pinning PFUI_CLASSIC_API_LATEST to $LATEST ($PACKED)"
sed -i "s/^\([[:space:]]*\)local PFUI_CLASSIC_API_LATEST = .*/\1local PFUI_CLASSIC_API_LATEST = $PACKED/" pfUI.lua sed -i "s/^\([[:space:]]*\)local PFUI_CLASSIC_API_LATEST = .*/\1local PFUI_CLASSIC_API_LATEST = $PACKED/" API_Check.lua
grep 'local PFUI_CLASSIC_API_' pfUI.lua grep 'local PFUI_CLASSIC_API_' API_Check.lua
env: env:
GH_TOKEN: ${{ secrets.GITHUB_TOKEN }} GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
- name: Package and release to GitHub - name: Package and release to GitHub
uses: BigWigsMods/packager@v2 uses: brues-code/packager@vCAPI
env: env:
GITHUB_OAUTH: ${{ secrets.GITHUB_TOKEN }} GITHUB_OAUTH: ${{ secrets.GITHUB_TOKEN }}
.luarc.json
+22
View File
@@ -0,0 +1,22 @@
{
"runtime": {
"version": "Lua 5.1"
},
"diagnostics": {
"disable": ["deprecated"],
"globals": [
"this",
"event",
"arg",
"arg1",
"arg2",
"arg3",
"arg4",
"arg5",
"arg6",
"arg7",
"arg8",
"arg9"
]
}
}
.pkgmeta
+4
View File
@@ -0,0 +1,4 @@
package-as: pfUI
ignore:
- .luarc.json
API_Check.lua
+78
View File
@@ -0,0 +1,78 @@
do
-- ClassicAPI dependency gate.
--
-- Which TOC the client opened already answers "is ClassicAPI here?". Whenever
-- the DLL is loaded it redirects the read of `pfUI\pfUI.toc` to
-- `pfUI_Turtle.toc` (Turtle clients) or `pfUI_ClassicAPI.toc` (everything
-- else). Reaching this file from the plain `pfUI.toc` therefore means
-- ClassicAPI is absent -- and that TOC deliberately loads nothing but this
-- file, so there is nothing to disable, only a notice to show.
--
-- The flavor TOCs still need a version gate of their own: the redirect has
-- existed since ClassicAPI v1.11.0, well below the API surface pfUI relies
-- on. There pfUI does load, and will throw wherever it reaches for something
-- the installed DLL doesn't have yet -- the popup names the cause so those
-- errors aren't a mystery.
local PFUI_CLASSIC_API_MIN = 11500 -- (X*10000 + Y*100 + Z)
local PFUI_CLASSIC_API_LATEST = PFUI_CLASSIC_API_MIN
local PFUI_CLASSIC_API_WEBSITE = "https://github.com/brues-code/ClassicAPI"
local PFUI_CLASSIC_API_LATEST_URL = PFUI_CLASSIC_API_WEBSITE .. "/releases/latest"
local function FormatVersion(packed)
local x = math.floor(packed / 10000)
local y = math.floor(math.mod(packed, 10000) / 100)
local z = math.mod(packed, 100)
return string.format("v%d.%d.%d", x, y, z)
end
local headline, detail
if not CLASSIC_API_VERSION then
headline = "|cff33ffccpf|cffffffffUI|r has been disabled."
detail = "The ClassicAPI DLL isn't loaded. Download the latest release from:"
elseif CLASSIC_API_VERSION < PFUI_CLASSIC_API_MIN then
headline = "|cff33ffccpf|cffffffffUI|r will not work correctly on ClassicAPI " .. FormatVersion(CLASSIC_API_VERSION) .. "."
detail = FormatVersion(PFUI_CLASSIC_API_MIN) .. " or newer is required -- any errors alongside this one are the APIs it is missing. Download the latest release from:"
end
if detail then
local function ShowRequiredPopup()
StaticPopupDialogs["PFUI_CLASSICAPI_REQUIRED"] = {
text = headline .. "\n\n" .. detail,
button1 = OKAY,
hasEditBox = 1,
editBoxWidth = 280,
timeout = 0,
whileDead = 1,
hideOnEscape = 1,
preferredIndex = 3,
OnShow = function()
local editBox = getglobal(this:GetName().."EditBox")
if editBox then
editBox:SetText(PFUI_CLASSIC_API_LATEST_URL)
editBox:HighlightText()
editBox:SetFocus()
end
end,
}
StaticPopup_Show("PFUI_CLASSICAPI_REQUIRED")
DEFAULT_CHAT_FRAME:AddMessage(
headline .. " " .. detail .. " " .. PFUI_CLASSIC_API_LATEST_URL,
1, 0.3, 0.3
)
end
local loginFrame = CreateFrame("Frame")
loginFrame:RegisterEvent("PLAYER_ENTERING_WORLD")
loginFrame:SetScript("OnEvent", function()
loginFrame:UnregisterEvent("PLAYER_ENTERING_WORLD")
ShowRequiredPopup()
end)
elseif CLASSIC_API_VERSION < PFUI_CLASSIC_API_LATEST then
EventUtil.ContinueOnPlayerLogin(function()
C_Timer.After(8, function()
DEFAULT_CHAT_FRAME:AddMessage(
"|cff33ffccpf|rUI: ClassicAPI " .. FormatVersion(PFUI_CLASSIC_API_LATEST) .. " is available — " .. PFUI_CLASSIC_API_LATEST_URL,
1, 0.85, 0.3
)
end)
end)
end
end
README.md
+16 -14
View File
@@ -2,11 +2,11 @@
[![Octo WoW](https://img.shields.io/badge/Octo%20WoW-1.18.1-brightgreen.svg)](https://octowow.st/) [![Octo WoW](https://img.shields.io/badge/Octo%20WoW-1.18.1-brightgreen.svg)](https://octowow.st/)
[![ClassicAPI](https://img.shields.io/badge/ClassicAPI-Required-purple.svg)](https://github.com/brues-code/ClassicAPI) [![ClassicAPI](https://img.shields.io/badge/ClassicAPI-Required-purple.svg)](https://github.com/brues-code/ClassicAPI)
[![SuperWoW](https://img.shields.io/badge/SuperWoW-Required-purple.svg)](https://github.com/balakethelock/SuperWoW)
[![Nampower](https://img.shields.io/badge/Nampower-Required-purple.svg)](https://github.com/brues-code/nampower) [![Nampower](https://img.shields.io/badge/Nampower-Required-purple.svg)](https://github.com/brues-code/nampower)
[![UnitXP](https://img.shields.io/badge/UnitXP__SP3-Optional-yellow.svg)](https://codeberg.org/konaka/UnitXP_SP3) [![SuperWoW](https://img.shields.io/badge/SuperWoW-Optional-yellow.svg)](https://github.com/balakethelock/SuperWoW)
[![UnitXP](https://img.shields.io/badge/UnitXP__SP3-Optional-yellow.svg)](https://github.com/brues-code/UnitXP_SP3)
**A pfUI fork specifically optimized for ClassicAPI on [Octo WoW](https://octowow.st/) which requires Nampower and SuperWoW with optional UnitXP_SP3 DLL integration.** **A pfUI fork specifically optimized for ClassicAPI on [Octo WoW](https://octowow.st/)**
This version includes significant performance improvements and DLL-enhanced features. This version includes significant performance improvements and DLL-enhanced features.
@@ -16,7 +16,7 @@ This version includes significant performance improvements and DLL-enhanced feat
4. Copy "pfUI" into Wow-Directory\Interface\AddOns 4. Copy "pfUI" into Wow-Directory\Interface\AddOns
5. Restart Wow 5. Restart Wow
## Optional DLL Enhancements ## DLL Enhancements
Since pfUI 6.0.0 includes integrations with client-side DLLs for enhanced functionality. These DLLs are permitted on Octo WoW: Since pfUI 6.0.0 includes integrations with client-side DLLs for enhanced functionality. These DLLs are permitted on Octo WoW:
@@ -36,23 +36,24 @@ Provides:
- Faster, safer profile sharing - Engine-side serialize/compress/base64 via C_EncodingUtil - Faster, safer profile sharing - Engine-side serialize/compress/base64 via C_EncodingUtil
- C_Timer - After / NewTicker replacing hand-rolled OnUpdate throttles - C_Timer - After / NewTicker replacing hand-rolled OnUpdate throttles
- Feign death, shapeshift and quest-item detection via real API calls - Feign death, shapeshift and quest-item detection via real API calls
- Mouseover Unit Frames
- Click-casting
- Loot Roll History (/loothistory)
- New item highlighting
- Plenty other functions - Plenty other functions
### [SuperWoW](https://github.com/balakethelock/SuperWoW)
Provides:
- UnitPosition for distance calculations
- SetMouseoverUnit for improved targeting
### [Nampower](https://github.com/brues-code/nampower) ### [Nampower](https://github.com/brues-code/nampower)
Provides: Provides:
- Spell queue indicator - Spell queue indicator
- GCD indicator - GCD indicator
- Reactive spell detection
- Enhanced cast information
### [UnitXP_SP3](https://codeberg.org/konaka/UnitXP_SP3) ### [SuperWoW](https://github.com/balakethelock/SuperWoW)
Provides:
- Tracks party/raid units on the minimap
### [UnitXP_SP3](https://github.com/brues-code/UnitXP_SP3)
Provides: Provides:
- Line of Sight detection - Line of Sight detection
@@ -79,6 +80,7 @@ Use `/pfdll` in-game to check which DLLs are detected.
/swapfocus Toggle Focus and Target-Frame /swapfocus Toggle Focus and Target-Frame
/pftest Toggle pfUI Unitframe Test Mode /pftest Toggle pfUI Unitframe Test Mode
/abp Addon Button Panel /abp Addon Button Panel
/loothistory Show Loot Roll History
## Languages ## Languages
pfUI supports and contains language specific code for the following gameclients. pfUI supports and contains language specific code for the following gameclients.
@@ -91,7 +93,7 @@ pfUI supports and contains language specific code for the following gameclients.
* Russian (ruRU) * Russian (ruRU)
## Recommended Addons ## Recommended Addons
* [pfQuest](https://shagu.org/pfQuest) A simple database and quest helper * [pfQuest](https://github.com/brues-code/pfQuest) A simple database and quest helper
* [SuperCleveRoidMacros](https://github.com/brues-code/SuperCleveRoidMacros) Supports modern macro formats * [SuperCleveRoidMacros](https://github.com/brues-code/SuperCleveRoidMacros) Supports modern macro formats
## Plugins ## Plugins
api/api.lua
+222 -80
View File
@@ -64,6 +64,10 @@ end
-- Requires UnitXP_SP3 -- Requires UnitXP_SP3
function pfUI.api.UnitInLineOfSight(unit1, unit2) function pfUI.api.UnitInLineOfSight(unit1, unit2)
if not pfUI.api.HasUnitXP() then return nil end if not pfUI.api.HasUnitXP() then return nil end
if not unit2 then
unit2 = unit1
unit1 = "player"
end
local success, inSight = pcall(UnitXP, "inSight", unit1, unit2) local success, inSight = pcall(UnitXP, "inSight", unit1, unit2)
if success then return inSight end if success then return inSight end
return nil return nil
@@ -74,6 +78,10 @@ end
-- Requires UnitXP_SP3 -- Requires UnitXP_SP3
function pfUI.api.UnitIsBehind(unit1, unit2) function pfUI.api.UnitIsBehind(unit1, unit2)
if not pfUI.api.HasUnitXP() then return nil end if not pfUI.api.HasUnitXP() then return nil end
if not unit2 then
unit2 = unit1
unit1 = "player"
end
local success, behind = pcall(UnitXP, "behind", unit1, unit2) local success, behind = pcall(UnitXP, "behind", unit1, unit2)
if success then return behind end if success then return behind end
return nil return nil
@@ -84,16 +92,24 @@ gfind = string.gmatch or string.gfind
mod = math.mod or mod mod = math.mod or mod
-- [ strsplit ] -- [ strsplit ]
-- Splits a string using a delimiter. -- Splits a string using a delimiter. Self-contained on purpose: it does NOT
-- delegate to the global strsplit / string.split, because third-party addons
-- clobber those (e.g. BigWigs' SpellRequests redefines string:split to return
-- a table, which would make this return a single table instead of r,g,b,a and
-- break color/version parsing depending on load order). Delimiter chars are
-- treated as a set (any one char splits), and empty fields are preserved
-- ("a,,b" -> "a", "", "b"), matching real strsplit semantics.
-- 'delimiter' [string] characters that will be interpreted as delimiter -- 'delimiter' [string] characters that will be interpreted as delimiter
-- characters (bytes) in the string. -- characters (bytes) in the string.
-- 'subject' [string] String to split. -- 'subject' [string] String to split.
-- return: [list] a list of strings. -- return: [list] a list of strings.
local format, sgsub = string.format, string.gsub
function pfUI.api.strsplit(delimiter, subject) function pfUI.api.strsplit(delimiter, subject)
if not subject then return nil end if not subject then return nil end
local delimiter, fields = delimiter or ":", {} local fields = {}
local pattern = string.format("([^%s]+)", delimiter) delimiter = delimiter or ":"
string.gsub(subject, pattern, function(c) fields[table.getn(fields)+1] = c end) local pattern = format("([^%s]+)", delimiter)
sgsub(subject, pattern, function(c) fields[table.getn(fields)+1] = c end)
return unpack(fields) return unpack(fields)
end end
@@ -102,11 +118,7 @@ end
-- 'tbl' [table] the table that shall be checked -- 'tbl' [table] the table that shall be checked
-- return: [boolean] result of the check. -- return: [boolean] result of the check.
function pfUI.api.isempty(tbl) function pfUI.api.isempty(tbl)
if not tbl then return true end return next(tbl or {}) == nil
for k, v in pairs(tbl) do
return false
end
return true
end end
-- [ checkversion ] -- [ checkversion ]
@@ -135,7 +147,6 @@ end
-- It takes care of the rangecheck module if existing. -- It takes care of the rangecheck module if existing.
-- unit [string] A unit to query (string, unitID) -- unit [string] A unit to query (string, unitID)
-- return: [bool] "1" if in range otherwise "nil" -- return: [bool] "1" if in range otherwise "nil"
local RangeCache = {}
function pfUI.api.UnitInRange(unit) function pfUI.api.UnitInRange(unit)
if not UnitExists(unit) or not UnitIsVisible(unit) then if not UnitExists(unit) or not UnitIsVisible(unit) then
return nil return nil
@@ -143,6 +154,11 @@ function pfUI.api.UnitInRange(unit)
return 1 return 1
end end
-- master switch: with the 40y check off, a visible unit beyond interact
-- range counts as in range (nothing fades). Invisible units already
-- returned nil above, matching the pre-collapse behavior.
if C.unitframes.rangecheck == "0" then return 1 end
-- UnitXP precise mode: skip librange entirely, use direct distance check -- UnitXP precise mode: skip librange entirely, use direct distance check
if C.unitframes.rangecheck_mode == "unitxp" and _G.UnitXP then if C.unitframes.rangecheck_mode == "unitxp" and _G.UnitXP then
local threshold = tonumber(C.unitframes.rangecheck_distance) or 40 local threshold = tonumber(C.unitframes.rangecheck_distance) or 40
@@ -188,6 +204,32 @@ function pfUI.api.UnitHasBuff(unit, name)
return C_UnitAuras.GetAuraDataBySpellName(unit, name, "HELPFUL") ~= nil or nil return C_UnitAuras.GetAuraDataBySpellName(unit, name, "HELPFUL") ~= nil or nil
end end
-- [ ScanAuraSlots ]
-- Fills `buf` with the slot ids of the auras on `unit` that match `filter` and
-- returns how many (buf[1..n]; entries past n are cleared), so a module can
-- keep one buffer and refill it every refresh. Read each aura with
-- C_UnitAuras.UnitAuraBySlot(unit, buf[i]) (positional, no table) or
-- GetAuraDataBySlot. One enumeration walks the aura array once, where a
-- by-index loop (UnitAura(unit, i)) re-walks it from the start for every i.
-- Uses GetAuraSlots' fill-a-table form (table as the 5th argument) instead of
-- its vararg return: Lua 5.0 builds an `arg` table for every vararg call, so
-- collecting the returns in a Lua helper would allocate once per scan.
-- unit [string] unit token
-- filter [string] aura filter ("HELPFUL", "HARMFUL|PLAYER", ...)
-- buf [table] reusable buffer, filled in place
-- max [number] optional cap on the slot count (nil = all)
-- return: [number] count of slot ids written to buf
function pfUI.api.ScanAuraSlots(unit, filter, buf, max)
local _, n = C_UnitAuras.GetAuraSlots(unit, filter, max, nil, buf)
return n
end
-- [ IsPlayerGuid ]
-- Returns whether a GUID or unit token refers to the local player.
-- guid [string] A unit GUID (or unitID) to test.
-- return: [bool] true if it is the player otherwise "false"
pfUI.api.IsPlayerGuid = _G.IsPlayerGuid
-- [ GetUnbuffedRoster ] -- [ GetUnbuffedRoster ]
-- Returns a comma-joined, colored list of group members missing the named aura. -- Returns a comma-joined, colored list of group members missing the named aura.
-- name [string] the localized aura name to check for -- name [string] the localized aura name to check for
@@ -215,11 +257,50 @@ end
-- unit [string] the unitstring -- unit [string] the unitstring
-- return: [table] string, r, g, b -- return: [table] string, r, g, b
function pfUI.api.GetUnitColor(unitstr) function pfUI.api.GetUnitColor(unitstr)
local _, class = UnitClass(unitstr) local class = UnitClassBase(unitstr)
local classColor = PFUI_CLASS_COLORS[class] local classColor = PFUI_CLASS_COLORS[class]
return classColor:GenerateHexColorMarkup(), classColor:GetRGB() return classColor:GenerateHexColorMarkup(), classColor:GetRGB()
end end
-- [ GetRaceIcon ]
-- Builds an inline race icon texture from the shared races atlas.
-- 'raceKey' [string] englishRace key (e.g. "NightElf")
-- 'sex' [int] unit sex (3 = female)
-- return: [string] inline texture escape, or an empty string
function pfUI.api.GetRaceIcon(raceKey, sex)
if not raceKey then return "" end
local gender = sex == 3 and "FEMALE" or "MALE"
local coords = RACE_ICON_TCOORDS[strupper(raceKey) .. "_" .. gender]
if not coords then return "" end
return string.format(
"|TInterface\\Glues\\CharacterCreate\\UI-CharacterCreate-Races:0:0:0:0:512:512:%d:%d:%d:%d|t",
coords[1] * 512, coords[2] * 512, coords[3] * 512, coords[4] * 512)
end
-- inline faction emblems (cropped from the target-frame PvP banners)
local FACTION_ICON = {
Alliance = "|TInterface\\TargetingFrame\\UI-PVP-Alliance:0:0:0:0:64:64:5:37:3:35|t",
Horde = "|TInterface\\TargetingFrame\\UI-PVP-Horde:0:0:0:0:64:64:5:37:3:35|t",
}
-- [ GetFactionIcon ]
-- Resolves an inline faction emblem from the englishRace key stored in L["race"].
-- 'raceKey' [string] englishRace key (e.g. "Orc")
-- return: [string] inline texture escape, or an empty string
function pfUI.api.GetFactionIcon(raceKey)
local info = raceKey and L["race"][raceKey]
if not info then return "" end
return FACTION_ICON[info.faction] or ""
end
-- [ GetPlayerRaceIcons ]
-- Returns the faction and race emblems of the player character.
-- return: [string] both inline textures, or an empty string
function pfUI.api.GetPlayerRaceIcons()
local _, raceKey = UnitRace("player")
return pfUI.api.GetFactionIcon(raceKey) .. pfUI.api.GetRaceIcon(raceKey, UnitSex("player"))
end
-- [ strvertical ] -- [ strvertical ]
-- Creates vertical text using linebreaks. Multibyte char friendly. -- Creates vertical text using linebreaks. Multibyte char friendly.
-- 'str' [string] String to columnize. -- 'str' [string] String to columnize.
@@ -266,11 +347,7 @@ end
-- 'f' [float] the number to breakdown. -- 'f' [float] the number to breakdown.
-- returns: [int],[float] whole and fractional part. -- returns: [int],[float] whole and fractional part.
function pfUI.api.modf(f) function pfUI.api.modf(f)
if modf then return modf(f) end return math.modf(f)
if f > 0 then
return math.floor(f), mod(f,1)
end
return math.ceil(f), mod(f,1)
end end
-- [ GetServerEpoch ] -- [ GetServerEpoch ]
@@ -365,36 +442,53 @@ end
-- 'str' [string] input string that should be matched -- 'str' [string] input string that should be matched
-- 'pat' [string] unformatted pattern -- 'pat' [string] unformatted pattern
-- returns: [strings] matched string in capture order -- returns: [strings] matched string in capture order
local a, b, c, d, e
local _, va, vb, vc, vd, ve
local ra, rb, rc, rd, re
function pfUI.api.cmatch(str, pat) function pfUI.api.cmatch(str, pat)
-- read capture indexes -- idx* = the logical %N index of each physical capture slot (nil when the
a, b, c, d, e = GetCaptures(pat) -- pattern has no %N$ markers); val* = the matched values in physical order.
_, _, va, vb, vc, vd, ve = string.find(str, pfUI.api.SanitizePattern(pat)) local idx1, idx2, idx3, idx4, idx5 = GetCaptures(pat)
local _, _, val1, val2, val3, val4, val5 = string.find(str, pfUI.api.SanitizePattern(pat))
-- put entries into the proper return values -- reorder the physical matches into logical (%1..%5) order
ra = e == 1 and ve or d == 1 and vd or c == 1 and vc or b == 1 and vb or va local out1 = idx5 == 1 and val5 or idx4 == 1 and val4 or idx3 == 1 and val3 or idx2 == 1 and val2 or val1
rb = e == 2 and ve or d == 2 and vd or c == 2 and vc or a == 2 and va or vb local out2 = idx5 == 2 and val5 or idx4 == 2 and val4 or idx3 == 2 and val3 or idx1 == 2 and val1 or val2
rc = e == 3 and ve or d == 3 and vd or a == 3 and va or b == 3 and vb or vc local out3 = idx5 == 3 and val5 or idx4 == 3 and val4 or idx1 == 3 and val1 or idx2 == 3 and val2 or val3
rd = e == 4 and ve or a == 4 and va or c == 4 and vc or b == 4 and vb or vd local out4 = idx5 == 4 and val5 or idx1 == 4 and val1 or idx3 == 4 and val3 or idx2 == 4 and val2 or val4
re = a == 5 and va or d == 5 and vd or c == 5 and vc or b == 5 and vb or ve local out5 = idx1 == 5 and val1 or idx4 == 5 and val4 or idx3 == 5 and val3 or idx2 == 5 and val2 or val5
return ra, rb, rc, rd, re return out1, out2, out3, out4, out5
end end
-- [ GetItemLinkByName ] -- [ GetItemLinkByName ]
-- Returns an itemLink for the given itemname -- Returns an itemLink for the given itemname
-- 'name' [string] name of the item -- 'name' [string] name of the item
-- returns: [string] entire itemLink for the given item -- returns: [string] entire itemLink for the given item
local itemLinkCache = {}
local itemLinkMisses = {}
local ITEMLINK_MAX_SCANS = 2
function pfUI.api.GetItemLinkByName(name) function pfUI.api.GetItemLinkByName(name)
for itemID = 1, 25818 do -- GetInboxItem() hands us a nil name for attachment-less mail
local itemName, hyperLink, itemQuality = GetItemInfo(itemID) if not name then return end
if (itemName and itemName == name) then -- cache successful resolutions so repeated lookups (e.g. per inbox click) are free
local _, _, _, hex = GetItemQualityColor(tonumber(itemQuality)) if itemLinkCache[name] then return itemLinkCache[name] end
return hex.. "|H"..hyperLink.."|h["..itemName.."]|h|r"
-- Failures have to be counted, not just retried. An unresolvable name walks
-- the entire id range and finds nothing -- a visible hitch on every tooltip
-- hover. Allow a couple of attempts (rendering the tooltip caches the item,
-- so the next hover usually resolves), then stop scanning for that name.
local misses = itemLinkMisses[name] or 0
if misses >= ITEMLINK_MAX_SCANS then return end
-- Octo/Turtle custom items live well past the 25818 vanilla ceiling
for itemID = 1, 61000 do
local itemName = C_Item.GetItemNameByID(itemID)
if itemName and itemName == name then
local _, itemLink = C_Item.GetItemInfo(itemID)
itemLinkCache[name] = itemLink
return itemLink
end end
end end
itemLinkMisses[name] = misses + 1
end end
-- [ FindItem ] -- [ FindItem ]
@@ -548,36 +642,54 @@ end
-- 'script' [string] the handler to hook -- 'script' [string] the handler to hook
-- 'func' [function] the function that should be added -- 'func' [function] the function that should be added
function HookScript(f, script, func) function HookScript(f, script, func)
local prev = f:GetScript(script) f:HookScript(script, func)
f:SetScript(script, function(a1,a2,a3,a4,a5,a6,a7,a8,a9) end
if prev then prev(a1,a2,a3,a4,a5,a6,a7,a8,a9) end
func(a1,a2,a3,a4,a5,a6,a7,a8,a9) function hooksecurefunc(tbl, name, func)
end) if type(tbl) == "string" then tbl, name, func = _G, tbl, name end
if not tbl or type(tbl[name]) ~= "function" then return end
return _G.hooksecurefunc(tbl, name, func)
end end
-- [ HookAddonOrVariable ] -- [ HookAddonOrVariable ]
-- Sets a function to be called automatically once an addon gets loaded -- Sets a function to be called automatically once an addon gets loaded
-- 'addon' [string] addon or variable name -- 'addon' [string] addon or variable name
-- 'func' [function] function that should run -- 'func' [function] function that should run
function pfUI.api.HookAddonOrVariable(addon, func) do
local lurker = CreateFrame("Frame", nil) local lurker
lurker.func = func local pending = {}
lurker:RegisterEvent("ADDON_LOADED")
lurker:RegisterEvent("VARIABLES_LOADED") local function ProcessPending()
lurker:RegisterEvent("PLAYER_ENTERING_WORLD") if not lurker.foundConfig then return end
lurker:SetScript("OnEvent",function() for i = table.getn(pending), 1, -1 do
-- only run when config is available local hook = pending[i]
if event == "ADDON_LOADED" and not this.foundConfig then if IsAddOnLoaded(hook.addon) or _G[hook.addon] then
return hook.func()
elseif event == "VARIABLES_LOADED" then table.remove(pending, i)
this.foundConfig = true end
end
if table.getn(pending) == 0 then
lurker:UnregisterAllEvents()
end
end
function pfUI.api.HookAddonOrVariable(addon, func)
if not lurker then
lurker = CreateFrame("Frame", nil)
lurker:SetScript("OnEvent", function()
if event == "VARIABLES_LOADED" or event == "PLAYER_ENTERING_WORLD" then
this.foundConfig = true
end
ProcessPending()
end)
end end
if IsAddOnLoaded(addon) or _G[addon] then table.insert(pending, { addon = addon, func = func })
this:func() lurker:RegisterEvent("ADDON_LOADED")
this:UnregisterAllEvents() lurker:RegisterEvent("VARIABLES_LOADED")
end lurker:RegisterEvent("PLAYER_ENTERING_WORLD")
end) ProcessPending()
end
end end
-- [ QueueFunction ] -- [ QueueFunction ]
@@ -618,6 +730,10 @@ end
function pfUI.api.CreateGoldString(money) function pfUI.api.CreateGoldString(money)
if type(money) ~= "number" then return "-" end if type(money) ~= "number" then return "-" end
if _G.GetCoinTextureString then
return "|cffffffff" .. _G.GetCoinTextureString(money) .. "|r"
end
local gold = floor(money/ 100 / 100) local gold = floor(money/ 100 / 100)
local silver = floor(mod((money/100),100)) local silver = floor(mod((money/100),100))
local copper = floor(mod(money,100)) local copper = floor(mod(money,100))
@@ -701,24 +817,15 @@ function pfUI.api.CopyTable(src)
end end
-- [ Wipe Table ] -- [ Wipe Table ]
-- Empties a table and returns it -- Empties a table and returns it.
-- 'src' [table] the table that should be emptied. -- 'src' [table] the table that should be emptied.
-- return: [table] the emptied table. -- return: [table] the emptied table.
-- Delegates to ClassicAPI's table.wipe, which also resets the Lua 5.0 getn
-- length (luaL_setn(t,0)) so table.insert on a wiped table resumes at [1].
-- Append to wiped arrays with table.insert -- NOT the t[table.getn(t)+1]=v
-- idiom, which needs an unmanaged length counter and won't work here.
function pfUI.api.wipe(src) function pfUI.api.wipe(src)
-- notes: table.insert, table.remove will have undefined behavior return table.wipe(src)
-- when used on tables emptied this way because Lua removes nil
-- entries from tables after an indeterminate time.
-- Instead of table.insert(t,v) use t[table.getn(t)+1]=v as table.getn collapses nil entries.
-- There are no issues with hash tables, t[k]=v where k is not a number behaves as expected.
local mt = getmetatable(src) or {}
if mt.__mode == nil or mt.__mode ~= "kv" then
mt.__mode = "kv"
src=setmetatable(src,mt)
end
for k in pairs(src) do
src[k] = nil
end
return src
end end
-- [ Load Movable ] -- [ Load Movable ]
@@ -976,16 +1083,34 @@ end
-- [ GetStringColor ] -- [ GetStringColor ]
-- Queries the pfUI setting strings and extract its color codes -- Queries the pfUI setting strings and extract its color codes
-- returns r,g,b,a -- returns r,g,b,a as strings
local color_cache = {} local color_cache = setmetatable({}, {
function pfUI.api.GetStringColor(colorstr) __index = function(t, k)
if not color_cache[colorstr] then local color = { pfUI.api.strsplit(",", k) }
local r, g, b, a = pfUI.api.strsplit(",", colorstr) rawset(t, k, color)
color_cache[colorstr] = { r, g, b, a } return color
end end
})
function pfUI.api.GetStringColor(colorstr)
return unpack(color_cache[colorstr]) return unpack(color_cache[colorstr])
end end
-- [ GetStringColorObject ]
-- Like GetStringColor, but returns a cached ColorMixin instead of raw values.
-- The object is a shared per-string singleton, so treat it as read-only.
-- returns a ColorMixin
local color_object_cache = setmetatable({}, {
__index = function(t, k)
local r,g,b,a = pfUI.api.GetStringColor(k)
local color = CreateColor(tonumber(r), tonumber(g), tonumber(b), tonumber(a))
rawset(t, k, color)
return color
end
})
function pfUI.api.GetStringColorObject(colorstr)
return color_object_cache[colorstr]
end
-- [ rgbhex ] -- [ rgbhex ]
-- Returns color format from color info -- Returns color format from color info
-- 'r' [table | number] color table or r color component -- 'r' [table | number] color table or r color component
@@ -993,12 +1118,13 @@ end
-- 'b' [number] optional b color component -- 'b' [number] optional b color component
-- 'a' [number] optional alpha component -- 'a' [number] optional alpha component
-- returns color string in the form of '|caarrggbb' -- returns color string in the form of '|caarrggbb'
local _r, _g, _b, _a local rgbhex_cache = {}
function pfUI.api.rgbhex(r, g, b, a) function pfUI.api.rgbhex(r, g, b, a)
local _r, _g, _b, _a
if type(r) == "table" then if type(r) == "table" then
if r.r then if r.r then
_r, _g, _b, _a = r.r, r.g, r.b, (r.a or 1) _r, _g, _b, _a = r.r, r.g, r.b, (r.a or 1)
elseif table.getn(r) >= 3 then elseif r[3] ~= nil then
_r, _g, _b, _a = r[1], r[2], r[3], (r[4] or 1) _r, _g, _b, _a = r[1], r[2], r[3], (r[4] or 1)
end end
elseif tonumber(r) then elseif tonumber(r) then
@@ -1006,7 +1132,13 @@ function pfUI.api.rgbhex(r, g, b, a)
end end
if _r and _g and _b and _a then if _r and _g and _b and _a then
return CreateColor(_r, _g, _b, _a):GenerateHexColorMarkup() local key = ((Round(_r*255)*256 + Round(_g*255))*256 + Round(_b*255))*256 + Round(_a*255)
local hex = rgbhex_cache[key]
if not hex then
hex = "|c" .. C_ColorUtil.GenerateTextColorCode({ r = _r, g = _g, b = _b, a = _a })
rgbhex_cache[key] = hex
end
return hex
end end
return "" return ""
@@ -1559,6 +1691,16 @@ end
-- 'arg1' [string] -- 'arg1' [string]
-- return object -- return object
function pfUI.api.GetNoNameObject(frame, objtype, layer, arg1, arg2) function pfUI.api.GetNoNameObject(frame, objtype, layer, arg1, arg2)
-- A nil/non-frame parent otherwise dies on frame:GetRegions()/:GetChildren()
-- below, and the traceback stops here — useless, since all callers share this
-- line. pfUI shadows Lua's `error` (dropping the level arg and not throwing),
-- so fold the caller frame in via debugstack to name the offending skin, then
-- bail so we don't fall through and crash on frame:GetRegions() anyway.
if type(frame) ~= "table" or not frame.GetRegions then
error("GetNoNameObject: invalid parent frame\n" .. debugstack(2, 3, 0))
return
end
local arg1 = arg1 and gsub(arg1, "([%+%-%*%(%)%?%[%]%^])", "%%%1") local arg1 = arg1 and gsub(arg1, "([%+%-%*%(%)%?%[%]%^])", "%%%1")
local arg2 = arg2 and gsub(arg2, "([%+%-%*%(%)%?%[%]%^])", "%%%1") local arg2 = arg2 and gsub(arg2, "([%+%-%*%(%)%?%[%]%^])", "%%%1")
api/config.lua
+46 -12
View File
@@ -155,6 +155,7 @@ function pfUI:LoadConfig()
pfUI:UpdateConfig("appearance", "cd", "dynamicsize", "1") pfUI:UpdateConfig("appearance", "cd", "dynamicsize", "1")
pfUI:UpdateConfig("appearance", "castbar", "castbarcolor", ".7,.7,.9,.8") pfUI:UpdateConfig("appearance", "castbar", "castbarcolor", ".7,.7,.9,.8")
pfUI:UpdateConfig("appearance", "castbar", "channelcolor", ".9,.9,.7,.8") pfUI:UpdateConfig("appearance", "castbar", "channelcolor", ".9,.9,.7,.8")
pfUI:UpdateConfig("appearance", "castbar", "failcolor", "1,.2,.2,.8")
pfUI:UpdateConfig("appearance", "castbar", "texture", "Interface\\AddOns\\pfUI\\img\\bar") pfUI:UpdateConfig("appearance", "castbar", "texture", "Interface\\AddOns\\pfUI\\img\\bar")
pfUI:UpdateConfig("appearance", "infight", "screen", "0") pfUI:UpdateConfig("appearance", "infight", "screen", "0")
pfUI:UpdateConfig("appearance", "infight", "aggro", "0") pfUI:UpdateConfig("appearance", "infight", "aggro", "0")
@@ -162,6 +163,8 @@ function pfUI:LoadConfig()
pfUI:UpdateConfig("appearance", "infight", "intensity", "16") pfUI:UpdateConfig("appearance", "infight", "intensity", "16")
pfUI:UpdateConfig("appearance", "bags", "unusable", "1") pfUI:UpdateConfig("appearance", "bags", "unusable", "1")
pfUI:UpdateConfig("appearance", "bags", "unusable_color", ".9,.2,.2,1") pfUI:UpdateConfig("appearance", "bags", "unusable_color", ".9,.2,.2,1")
pfUI:UpdateConfig("appearance", "bags", "newitem", "1")
pfUI:UpdateConfig("appearance", "bags", "newitem_color", "1,1,1,1")
pfUI:UpdateConfig("appearance", "bags", "borderlimit", "1") pfUI:UpdateConfig("appearance", "bags", "borderlimit", "1")
pfUI:UpdateConfig("appearance", "bags", "borderonlygear", "0") pfUI:UpdateConfig("appearance", "bags", "borderonlygear", "0")
pfUI:UpdateConfig("appearance", "bags", "fulltext", "1") pfUI:UpdateConfig("appearance", "bags", "fulltext", "1")
@@ -172,6 +175,8 @@ function pfUI:LoadConfig()
pfUI:UpdateConfig("appearance", "bags", "bagrowlength", "10") pfUI:UpdateConfig("appearance", "bags", "bagrowlength", "10")
pfUI:UpdateConfig("appearance", "bags", "bankrowlength", "10") pfUI:UpdateConfig("appearance", "bags", "bankrowlength", "10")
pfUI:UpdateConfig("appearance", "bags", "autoSortOnOpen", "0") pfUI:UpdateConfig("appearance", "bags", "autoSortOnOpen", "0")
pfUI:UpdateConfig("appearance", "bags", "sortreverse", "0")
pfUI:UpdateConfig("appearance", "bags", "sortprioreverse", "0")
pfUI:UpdateConfig("appearance", "minimap", "size", "140") pfUI:UpdateConfig("appearance", "minimap", "size", "140")
pfUI:UpdateConfig("appearance", "minimap", "arrowscale", "1") pfUI:UpdateConfig("appearance", "minimap", "arrowscale", "1")
pfUI:UpdateConfig("appearance", "minimap", "zonetext", "off") pfUI:UpdateConfig("appearance", "minimap", "zonetext", "off")
@@ -196,6 +201,8 @@ function pfUI:LoadConfig()
pfUI:UpdateConfig("loot", nil, "rollannounce", "0") pfUI:UpdateConfig("loot", nil, "rollannounce", "0")
pfUI:UpdateConfig("loot", nil, "raritytimer", "1") pfUI:UpdateConfig("loot", nil, "raritytimer", "1")
pfUI:UpdateConfig("loothistory", nil, "autoshow", "0")
pfUI:UpdateConfig("unitframes", nil, "disable", "0") pfUI:UpdateConfig("unitframes", nil, "disable", "0")
pfUI:UpdateConfig("unitframes", nil, "pastel", "1") pfUI:UpdateConfig("unitframes", nil, "pastel", "1")
pfUI:UpdateConfig("unitframes", nil, "custom", "0") pfUI:UpdateConfig("unitframes", nil, "custom", "0")
@@ -227,8 +234,8 @@ function pfUI:LoadConfig()
pfUI:UpdateConfig("unitframes", nil, "druidmanaoffy", "0") pfUI:UpdateConfig("unitframes", nil, "druidmanaoffy", "0")
pfUI:UpdateConfig("unitframes", nil, "druidmanaspace", "-3") pfUI:UpdateConfig("unitframes", nil, "druidmanaspace", "-3")
pfUI:UpdateConfig("unitframes", nil, "druidmanatexture", "Interface\\AddOns\\pfUI\\img\\bar") pfUI:UpdateConfig("unitframes", nil, "druidmanatexture", "Interface\\AddOns\\pfUI\\img\\bar")
pfUI:UpdateConfig("unitframes", nil, "druidmanatext", "1")
pfUI:UpdateConfig("unitframes", nil, "rangechecki", "4")
pfUI:UpdateConfig("unitframes", nil, "combowidth", "6") pfUI:UpdateConfig("unitframes", nil, "combowidth", "6")
pfUI:UpdateConfig("unitframes", nil, "comboheight", "6") pfUI:UpdateConfig("unitframes", nil, "comboheight", "6")
pfUI:UpdateConfig("unitframes", nil, "swingtimerwidth", "200") pfUI:UpdateConfig("unitframes", nil, "swingtimerwidth", "200")
@@ -379,6 +386,27 @@ function pfUI:LoadConfig()
pfUI:UpdateConfig("unitframes", "grouppet", "glowcombat", "0") pfUI:UpdateConfig("unitframes", "grouppet", "glowcombat", "0")
pfUI:UpdateConfig("unitframes", "grouppet", "txthpright", "healthperc") pfUI:UpdateConfig("unitframes", "grouppet", "txthpright", "healthperc")
pfUI:UpdateConfig("unitframes", "raidpet", "portrait", "off")
pfUI:UpdateConfig("unitframes", "raidpet", "width", "50")
pfUI:UpdateConfig("unitframes", "raidpet", "height", "14")
pfUI:UpdateConfig("unitframes", "raidpet", "pheight", "0")
pfUI:UpdateConfig("unitframes", "raidpet", "buffs", "off")
pfUI:UpdateConfig("unitframes", "raidpet", "buffsize", "16")
pfUI:UpdateConfig("unitframes", "raidpet", "debuffs", "off")
pfUI:UpdateConfig("unitframes", "raidpet", "debuffsize", "16")
pfUI:UpdateConfig("unitframes", "raidpet", "faderange", "1")
pfUI:UpdateConfig("unitframes", "raidpet", "glowcombat", "0")
pfUI:UpdateConfig("unitframes", "raidpet", "txthpright", "healthperc")
-- off by default; mirrors the raid grid layout when enabled
pfUI:UpdateConfig("unitframes", "raidpet", "visible", "0")
-- collapse: pack only pets that exist (from the roster snapshot) instead
-- of mirroring every raid slot
pfUI:UpdateConfig("unitframes", "raidpet", "collapse", "1")
-- pet block has its own layout, independent of the raid grid
pfUI:UpdateConfig("unitframes", "raidpet", "raidlayout", "8x5")
pfUI:UpdateConfig("unitframes", "raidpet", "raidpadding", "3")
pfUI:UpdateConfig("unitframes", "raidpet", "raidfill", "VERTICAL")
pfUI:UpdateConfig("unitframes", "raid", "portrait", "off") pfUI:UpdateConfig("unitframes", "raid", "portrait", "off")
pfUI:UpdateConfig("unitframes", "raid", "width", "50") pfUI:UpdateConfig("unitframes", "raid", "width", "50")
pfUI:UpdateConfig("unitframes", "raid", "height", "26") pfUI:UpdateConfig("unitframes", "raid", "height", "26")
@@ -397,6 +425,7 @@ function pfUI:LoadConfig()
pfUI:UpdateConfig("unitframes", "raid", "raidlayout", "8x5") pfUI:UpdateConfig("unitframes", "raid", "raidlayout", "8x5")
pfUI:UpdateConfig("unitframes", "raid", "raidpadding", "3") pfUI:UpdateConfig("unitframes", "raid", "raidpadding", "3")
pfUI:UpdateConfig("unitframes", "raid", "raidfill", "VERTICAL") pfUI:UpdateConfig("unitframes", "raid", "raidfill", "VERTICAL")
pfUI:UpdateConfig("unitframes", "raid", "collapse", "0")
pfUI:UpdateConfig("unitframes", "raid", "raidgrouplabel", "0") pfUI:UpdateConfig("unitframes", "raid", "raidgrouplabel", "0")
pfUI:UpdateConfig("unitframes", "raid", "grouplabelxoff", "0") pfUI:UpdateConfig("unitframes", "raid", "grouplabelxoff", "0")
pfUI:UpdateConfig("unitframes", "raid", "grouplabelyoff", "8") pfUI:UpdateConfig("unitframes", "raid", "grouplabelyoff", "8")
@@ -452,7 +481,7 @@ function pfUI:LoadConfig()
pfUI:UpdateConfig("unitframes", "ptarget", "txthpright", "none") pfUI:UpdateConfig("unitframes", "ptarget", "txthpright", "none")
pfUI:UpdateConfig("unitframes", "ptarget", "overhealperc", "10") pfUI:UpdateConfig("unitframes", "ptarget", "overhealperc", "10")
local ufs = { "player", "target", "focus", "focustarget", "group", "grouptarget", "grouppet", "raid", "ttarget", "pet", "ptarget", "fallback", "tttarget" } local ufs = { "player", "target", "focus", "focustarget", "group", "grouptarget", "grouppet", "raid", "raidpet", "ttarget", "pet", "ptarget", "fallback", "tttarget" }
for _, unit in pairs(ufs) do for _, unit in pairs(ufs) do
pfUI:UpdateConfig("unitframes", unit, "selfdebuff", "0") pfUI:UpdateConfig("unitframes", unit, "selfdebuff", "0")
pfUI:UpdateConfig("unitframes", unit, "visible", "1") pfUI:UpdateConfig("unitframes", unit, "visible", "1")
@@ -525,7 +554,6 @@ function pfUI:LoadConfig()
pfUI:UpdateConfig("unitframes", unit, "glowaggro", "1") pfUI:UpdateConfig("unitframes", unit, "glowaggro", "1")
pfUI:UpdateConfig("unitframes", unit, "glowcombat", "1") pfUI:UpdateConfig("unitframes", unit, "glowcombat", "1")
pfUI:UpdateConfig("unitframes", unit, "showtooltip", "1")
pfUI:UpdateConfig("unitframes", unit, "healthcolor", "1") pfUI:UpdateConfig("unitframes", unit, "healthcolor", "1")
pfUI:UpdateConfig("unitframes", unit, "powercolor", "1") pfUI:UpdateConfig("unitframes", unit, "powercolor", "1")
pfUI:UpdateConfig("unitframes", unit, "levelcolor", "1") pfUI:UpdateConfig("unitframes", unit, "levelcolor", "1")
@@ -617,13 +645,13 @@ function pfUI:LoadConfig()
pfUI:UpdateConfig("bars", nil, "animation", "zoomfade") pfUI:UpdateConfig("bars", nil, "animation", "zoomfade")
pfUI:UpdateConfig("bars", nil, "animmode", "keypress") pfUI:UpdateConfig("bars", nil, "animmode", "keypress")
pfUI:UpdateConfig("bars", nil, "animalways", "0") pfUI:UpdateConfig("bars", nil, "animalways", "0")
pfUI:UpdateConfig("bars", nil, "macroscan", "1")
pfUI:UpdateConfig("bars", nil, "reagents", "1") pfUI:UpdateConfig("bars", nil, "reagents", "1")
pfUI:UpdateConfig("bars", nil, "hunterbar", "0") pfUI:UpdateConfig("bars", nil, "hunterbar", "0")
pfUI:UpdateConfig("bars", nil, "pagemasteralt", "0") pfUI:UpdateConfig("bars", nil, "pagemasteralt", "0")
pfUI:UpdateConfig("bars", nil, "pagemastershift", "0") pfUI:UpdateConfig("bars", nil, "pagemastershift", "0")
pfUI:UpdateConfig("bars", nil, "pagemasterctrl", "0") pfUI:UpdateConfig("bars", nil, "pagemasterctrl", "0")
pfUI:UpdateConfig("bars", nil, "druidstealth", "0") pfUI:UpdateConfig("bars", nil, "druidstealth", "0")
pfUI:UpdateConfig("bars", nil, "priestshadow", "0")
pfUI:UpdateConfig("bars", nil, "showcastable", "1") pfUI:UpdateConfig("bars", nil, "showcastable", "1")
pfUI:UpdateConfig("bars", nil, "glowrange", "1") pfUI:UpdateConfig("bars", nil, "glowrange", "1")
pfUI:UpdateConfig("bars", nil, "rangecolor", "1,0.1,0.1,1") pfUI:UpdateConfig("bars", nil, "rangecolor", "1,0.1,0.1,1")
@@ -714,9 +742,11 @@ function pfUI:LoadConfig()
pfUI:UpdateConfig("castbar", "player", "txtleftoffy", "0") pfUI:UpdateConfig("castbar", "player", "txtleftoffy", "0")
pfUI:UpdateConfig("castbar", "player", "showlag", "0") pfUI:UpdateConfig("castbar", "player", "showlag", "0")
pfUI:UpdateConfig("castbar", "player", "showrank", "0") pfUI:UpdateConfig("castbar", "player", "showrank", "0")
pfUI:UpdateConfig("castbar", "player", "mergetradeskill", "1") pfUI:UpdateConfig("castbar", "player", "mergetradeskill", "0")
pfUI:UpdateConfig("castbar", "player", "txtrightoffx", "0") pfUI:UpdateConfig("castbar", "player", "txtrightoffx", "0")
pfUI:UpdateConfig("castbar", "player", "txtrightoffy", "0") pfUI:UpdateConfig("castbar", "player", "txtrightoffy", "0")
pfUI:UpdateConfig("castbar", "player", "namealign", "LEFT")
pfUI:UpdateConfig("castbar", "player", "timealign", "RIGHT")
pfUI:UpdateConfig("castbar", "target", "hide_pfui", "0") pfUI:UpdateConfig("castbar", "target", "hide_pfui", "0")
pfUI:UpdateConfig("castbar", "target", "width", "-1") pfUI:UpdateConfig("castbar", "target", "width", "-1")
pfUI:UpdateConfig("castbar", "target", "height", "-1") pfUI:UpdateConfig("castbar", "target", "height", "-1")
@@ -729,6 +759,8 @@ function pfUI:LoadConfig()
pfUI:UpdateConfig("castbar", "target", "showrank", "0") pfUI:UpdateConfig("castbar", "target", "showrank", "0")
pfUI:UpdateConfig("castbar", "target", "txtrightoffx", "0") pfUI:UpdateConfig("castbar", "target", "txtrightoffx", "0")
pfUI:UpdateConfig("castbar", "target", "txtrightoffy", "0") pfUI:UpdateConfig("castbar", "target", "txtrightoffy", "0")
pfUI:UpdateConfig("castbar", "target", "namealign", "LEFT")
pfUI:UpdateConfig("castbar", "target", "timealign", "RIGHT")
pfUI:UpdateConfig("castbar", "focus", "hide_pfui", "0") pfUI:UpdateConfig("castbar", "focus", "hide_pfui", "0")
pfUI:UpdateConfig("castbar", "focus", "width", "-1") pfUI:UpdateConfig("castbar", "focus", "width", "-1")
pfUI:UpdateConfig("castbar", "focus", "height", "-1") pfUI:UpdateConfig("castbar", "focus", "height", "-1")
@@ -741,6 +773,8 @@ function pfUI:LoadConfig()
pfUI:UpdateConfig("castbar", "focus", "showrank", "0") pfUI:UpdateConfig("castbar", "focus", "showrank", "0")
pfUI:UpdateConfig("castbar", "focus", "txtrightoffx", "0") pfUI:UpdateConfig("castbar", "focus", "txtrightoffx", "0")
pfUI:UpdateConfig("castbar", "focus", "txtrightoffy", "0") pfUI:UpdateConfig("castbar", "focus", "txtrightoffy", "0")
pfUI:UpdateConfig("castbar", "focus", "namealign", "LEFT")
pfUI:UpdateConfig("castbar", "focus", "timealign", "RIGHT")
pfUI:UpdateConfig("castbar", nil, "use_unitfonts", "0") pfUI:UpdateConfig("castbar", nil, "use_unitfonts", "0")
pfUI:UpdateConfig("tooltip", nil, "position", "chat") pfUI:UpdateConfig("tooltip", nil, "position", "chat")
@@ -749,6 +783,10 @@ function pfUI:LoadConfig()
pfUI:UpdateConfig("tooltip", nil, "extguild", "1") pfUI:UpdateConfig("tooltip", nil, "extguild", "1")
pfUI:UpdateConfig("tooltip", nil, "itemid", "0") pfUI:UpdateConfig("tooltip", nil, "itemid", "0")
pfUI:UpdateConfig("tooltip", nil, "movespeed", "0") pfUI:UpdateConfig("tooltip", nil, "movespeed", "0")
pfUI:UpdateConfig("tooltip", nil, "aurasource", "0")
pfUI:UpdateConfig("tooltip", nil, "spellid", "0")
pfUI:UpdateConfig("tooltip", nil, "unitid", "0")
pfUI:UpdateConfig("tooltip", nil, "showbuffs", "0")
pfUI:UpdateConfig("tooltip", nil, "alpha", "0.8") pfUI:UpdateConfig("tooltip", nil, "alpha", "0.8")
pfUI:UpdateConfig("tooltip", nil, "alwaysperc", "0") pfUI:UpdateConfig("tooltip", nil, "alwaysperc", "0")
pfUI:UpdateConfig("tooltip", "compare", "basestats", "1") pfUI:UpdateConfig("tooltip", "compare", "basestats", "1")
@@ -778,6 +816,7 @@ function pfUI:LoadConfig()
pfUI:UpdateConfig("chat", "text", "playerlinks", "1") pfUI:UpdateConfig("chat", "text", "playerlinks", "1")
pfUI:UpdateConfig("chat", "text", "detecturl", "1") pfUI:UpdateConfig("chat", "text", "detecturl", "1")
pfUI:UpdateConfig("chat", "text", "classcolor", "1") pfUI:UpdateConfig("chat", "text", "classcolor", "1")
pfUI:UpdateConfig("chat", "text", "playericons", "0")
pfUI:UpdateConfig("chat", "text", "whosearchunknown", "0") pfUI:UpdateConfig("chat", "text", "whosearchunknown", "0")
pfUI:UpdateConfig("chat", "text", "playerlevel", "0") pfUI:UpdateConfig("chat", "text", "playerlevel", "0")
pfUI:UpdateConfig("chat", "left", "width", "380") pfUI:UpdateConfig("chat", "left", "width", "380")
@@ -919,6 +958,7 @@ function pfUI:LoadConfig()
pfUI:UpdateConfig("questlog", nil, "showQuestLevels", "0") pfUI:UpdateConfig("questlog", nil, "showQuestLevels", "0")
pfUI:UpdateConfig("character", "inventory", "durability", "1") pfUI:UpdateConfig("character", "inventory", "durability", "1")
pfUI:UpdateConfig("character", "inventory", "equipflyout", "0")
pfUI:UpdateConfig("character", "reputation", "repRequired", "1") pfUI:UpdateConfig("character", "reputation", "repRequired", "1")
pfUI:UpdateConfig("thirdparty", nil, "chatbg", "1") pfUI:UpdateConfig("thirdparty", nil, "chatbg", "1")
pfUI:UpdateConfig("thirdparty", nil, "showmeter", "0") pfUI:UpdateConfig("thirdparty", nil, "showmeter", "0")
@@ -926,6 +966,7 @@ function pfUI:LoadConfig()
pfUI:UpdateConfig("thirdparty", "dpsmate", "dock", "0") pfUI:UpdateConfig("thirdparty", "dpsmate", "dock", "0")
pfUI:UpdateConfig("thirdparty", "shagudps", "skin", "0") pfUI:UpdateConfig("thirdparty", "shagudps", "skin", "0")
pfUI:UpdateConfig("thirdparty", "shagudps", "dock", "0") pfUI:UpdateConfig("thirdparty", "shagudps", "dock", "0")
pfUI:UpdateConfig("thirdparty", "greedmeter", "dock", "0")
pfUI:UpdateConfig("thirdparty", "swstats", "skin", "0") pfUI:UpdateConfig("thirdparty", "swstats", "skin", "0")
pfUI:UpdateConfig("thirdparty", "swstats", "dock", "0") pfUI:UpdateConfig("thirdparty", "swstats", "dock", "0")
pfUI:UpdateConfig("thirdparty", "ktm", "skin", "0") pfUI:UpdateConfig("thirdparty", "ktm", "skin", "0")
@@ -1099,13 +1140,6 @@ function pfUI:MigrateConfig()
end end
end end
-- migrating rangecheck interval (> 3.2.2)
if checkversion(3, 2, 2) then
if tonumber(pfUI_config.unitframes.rangechecki) <= 1 then
pfUI_config.unitframes.rangechecki = "2"
end
end
-- migrating legacy buff/debuff naming (> 3.5.0) -- migrating legacy buff/debuff naming (> 3.5.0)
if checkversion(3, 5, 0) then if checkversion(3, 5, 0) then
local unitframes = { "player", "target", "focus", "group", "grouptarget", "grouppet", "raid", "ttarget", "pet", "ptarget", "fallback" } local unitframes = { "player", "target", "focus", "group", "grouptarget", "grouppet", "raid", "ttarget", "pet", "ptarget", "fallback" }
api/ui-widgets.lua
+273 -64
View File
@@ -21,8 +21,7 @@ do -- statusbars
local handlers = { local handlers = {
["DisplayValue"] = function(self, val) ["DisplayValue"] = function(self, val)
val = val > self.max and self.max or val val = Clamp(val, self.min, self.max)
val = val < self.min and self.min or val
-- remove animation queue -- remove animation queue
if val == self.val_ then if val == self.val_ then
@@ -38,8 +37,7 @@ do -- statusbars
point = height / (self.max - self.min) * (val - self.min) point = height / (self.max - self.min) * (val - self.min)
-- keep values in limits -- keep values in limits
point = math.min(height, point) point = Clamp(point, 0, height)
point = math.max(0, point)
-- set point to zero if value and max is zero -- set point to zero if value and max is zero
if val == 0 then point = 0 end if val == 0 then point = 0 end
@@ -57,8 +55,7 @@ do -- statusbars
point = width / (self.max - self.min) * (val - self.min) point = width / (self.max - self.min) * (val - self.min)
-- keep values in limits -- keep values in limits
point = math.min(width, point) point = Clamp(point, 0, width)
point = math.max(0, point)
-- set point to zero if value and max is zero -- set point to zero if value and max is zero
if val == 0 then point = 0 end if val == 0 then point = 0 end
@@ -138,15 +135,8 @@ do -- statusbars
end end
do -- dropdown do -- dropdown
local _, class = UnitClass("player")
local color = PFUI_CLASS_COLORS[class]
local function ListEntryOnShow() local function ListEntryOnShow()
if this.parent.id == this.id then this.icon:SetShown(this.parent.id == this.id)
this.icon:Show()
else
this.icon:Hide()
end
end end
local function ListEntryOnClick() local function ListEntryOnClick()
@@ -288,8 +278,7 @@ do -- dropdown
frame.icon = frame:CreateTexture(nil, "OVERLAY") frame.icon = frame:CreateTexture(nil, "OVERLAY")
frame.icon:SetPoint("RIGHT", frame, "RIGHT", -2, 0) frame.icon:SetPoint("RIGHT", frame, "RIGHT", -2, 0)
frame.icon:SetHeight(16) frame.icon:SetSize(16, 16)
frame.icon:SetWidth(16)
frame.icon:SetTexture("Interface\\Buttons\\UI-CheckBox-Check") frame.icon:SetTexture("Interface\\Buttons\\UI-CheckBox-Check")
frame.text = frame:CreateFontString(nil, "OVERLAY") frame.text = frame:CreateFontString(nil, "OVERLAY")
@@ -329,8 +318,7 @@ do -- dropdown
local button = CreateFrame("Button", nil, frame) local button = CreateFrame("Button", nil, frame)
button:SetPoint("RIGHT", frame, "RIGHT", -2, 0) button:SetPoint("RIGHT", frame, "RIGHT", -2, 0)
button:SetWidth(16) button:SetSize(16, 16)
button:SetHeight(16)
button:SetScript("OnClick", ListButtonOnClick) button:SetScript("OnClick", ListButtonOnClick)
SkinArrowButton(button, "down") SkinArrowButton(button, "down")
button.icon:SetVertexColor(1,.9,.1) button.icon:SetVertexColor(1,.9,.1)
@@ -380,8 +368,7 @@ function pfUI.api.CreateTabChild(self, title, bwidth, bheight, bottom, static)
end end
-- set dimensions -- set dimensions
b:SetHeight(button_height) b:SetSize(button_width, button_height)
b:SetWidth(button_width)
b:SetID(childcount) b:SetID(childcount)
if not self.align or self.align == "LEFT" then if not self.align or self.align == "LEFT" then
@@ -516,13 +503,7 @@ function pfUI.api.CreateScrollFrame(name, parent)
local max = f:GetVerticalScrollRange() local max = f:GetVerticalScrollRange()
local new = current - step local new = current - step
if new >= max then f:SetVerticalScroll(Clamp(new, 0, max))
f:SetVerticalScroll(max)
elseif new <= 0 then
f:SetVerticalScroll(0)
else
f:SetVerticalScroll(new)
end
f:UpdateScrollState() f:UpdateScrollState()
end end
@@ -539,8 +520,7 @@ function pfUI.api.CreateScrollChild(name, parent)
local f = CreateFrame("Frame", name, parent) local f = CreateFrame("Frame", name, parent)
-- dummy values required -- dummy values required
f:SetWidth(1) f:SetSize(1, 1)
f:SetHeight(1)
f:SetAllPoints(parent) f:SetAllPoints(parent)
parent:SetScrollChild(f) parent:SetScrollChild(f)
@@ -569,7 +549,7 @@ end
-- 'frame' [frame] the modelframe that should be used -- 'frame' [frame] the modelframe that should be used
function pfUI.api.EnableClickRotate(frame) function pfUI.api.EnableClickRotate(frame)
frame:EnableMouse(true) frame:EnableMouse(true)
HookScript(frame, "OnUpdate", function() frame:HookScript("OnUpdate", function()
if this.rotate then if this.rotate then
local x,_ = GetCursorPosition() local x,_ = GetCursorPosition()
if this.curx > x then if this.curx > x then
@@ -582,14 +562,14 @@ function pfUI.api.EnableClickRotate(frame)
end end
end) end)
HookScript(frame, "OnMouseDown", function() frame:HookScript("OnMouseDown", function()
if arg1 == "LeftButton" then if arg1 == "LeftButton" then
this.rotate = true this.rotate = true
this.curx, this.cury = GetCursorPosition() this.curx, this.cury = GetCursorPosition()
end end
end) end)
HookScript(frame, "OnMouseUp", function() frame:HookScript("OnMouseUp", function()
this.rotate, this.curx, this.cury = nil, nil, nil this.rotate, this.curx, this.cury = nil, nil, nil
end) end)
end end
@@ -607,15 +587,13 @@ end
function pfUI.api.SetHighlight(frame, cr, cg, cb) function pfUI.api.SetHighlight(frame, cr, cg, cb)
if not frame then return end if not frame then return end
if not cr or not cg or not cb then if not cr or not cg or not cb then
local _, class = UnitClass("player") cr, cg, cb = PFUI_CLASS_COLORS[UnitClassBase('player')]:GetRGB()
cr, cg, cb = GetClassColor(class)
end end
frame.cr, frame.cg, frame.cb = cr, cg, cb, ca frame.cr, frame.cg, frame.cb = cr, cg, cb, ca
frame.rr, frame.rg, frame.rb, frame.ra = GetStringColor(pfUI_config.appearance.border.color) frame.rr, frame.rg, frame.rb, frame.ra = GetStringColor(pfUI_config.appearance.border.color)
if not frame.pfEnterLeave then if not frame.pfEnterLeave then
if not frame.HookScript then frame.HookScript = HookScript end
local enter, leave = frame:GetScript("OnEnter"), frame:GetScript("OnLeave") local enter, leave = frame:GetScript("OnEnter"), frame:GetScript("OnLeave")
if enter then if enter then
@@ -654,8 +632,7 @@ function pfUI.api.SkinButton(button, cr, cg, cb, icon, disableHighlight)
if not b then b = button end if not b then b = button end
if not b then return end if not b then return end
if not cr or not cg or not cb then if not cr or not cg or not cb then
local _, class = UnitClass("player") cr, cg, cb = PFUI_CLASS_COLORS[UnitClassBase('player')]:GetRGB()
cr, cg, cb = GetClassColor(class)
end end
pfUI.api.CreateBackdrop(b, nil, true) pfUI.api.CreateBackdrop(b, nil, true)
b:SetNormalTexture("") b:SetNormalTexture("")
@@ -703,8 +680,7 @@ function pfUI.api.SkinCollapseButton(button, all)
b.icon = _G[name] or CreateFrame("Button", name, b) b.icon = _G[name] or CreateFrame("Button", name, b)
if all then size = 14 end if all then size = 14 end
b.icon:SetWidth(size) b.icon:SetSize(size, size)
b.icon:SetHeight(size)
b.icon:SetPoint("LEFT", 2, 2) b.icon:SetPoint("LEFT", 2, 2)
CreateBackdrop(b.icon) CreateBackdrop(b.icon)
b.icon.text = b.icon:CreateFontString(nil, "OVERLAY") b.icon.text = b.icon:CreateFontString(nil, "OVERLAY")
@@ -733,12 +709,10 @@ end
function pfUI.api.SkinRotateButton(button) function pfUI.api.SkinRotateButton(button)
pfUI.api.CreateBackdrop(button) pfUI.api.CreateBackdrop(button)
local _, class = UnitClass("player") local cr, cg, cb = PFUI_CLASS_COLORS[UnitClassBase('player')]:GetRGB()
local color = PFUI_CLASS_COLORS[class]
local cr, cg, cb = color.r , color.g, color.b
button:SetWidth(button:GetWidth() - 18) local btnW, btnH = button:GetSize()
button:SetHeight(button:GetHeight() - 18) button:SetSize(btnW - 18, btnH - 18)
button:GetNormalTexture():SetTexCoord(0.3, 0.29, 0.3, 0.65, 0.69, 0.29, 0.69, 0.65) button:GetNormalTexture():SetTexCoord(0.3, 0.29, 0.3, 0.65, 0.69, 0.29, 0.69, 0.65)
button:GetPushedTexture():SetTexCoord(0.3, 0.29, 0.3, 0.65, 0.69, 0.29, 0.69, 0.65) button:GetPushedTexture():SetTexCoord(0.3, 0.29, 0.3, 0.65, 0.69, 0.29, 0.69, 0.65)
@@ -760,8 +734,7 @@ function pfUI.api.SkinCloseButton(button, parentFrame, offsetX, offsetY)
SkinButton(button, 1, .25, .25) SkinButton(button, 1, .25, .25)
button:SetWidth(15) button:SetSize(15, 15)
button:SetHeight(15)
if parentFrame then if parentFrame then
button:ClearAllPoints() button:ClearAllPoints()
@@ -788,8 +761,7 @@ function pfUI.api.SkinArrowButton(button, dir, size)
button:SetDisabledTexture(nil) button:SetDisabledTexture(nil)
if size then if size then
button:SetWidth(size) button:SetSize(size, size)
button:SetHeight(size)
end end
if not button.icon then if not button.icon then
@@ -844,7 +816,6 @@ function pfUI.api.SkinScrollbar(frame, always)
-- always show parent frame -- always show parent frame
if always then if always then
RunOOC(function() RunOOC(function()
if not parent.HookScript then parent.HookScript = HookScript end
parent:HookScript("OnHide", function() this:Show() end) parent:HookScript("OnHide", function() this:Show() end)
end) end)
end end
@@ -896,8 +867,7 @@ function pfUI.api.SkinCheckbox(frame, size)
frame:SetPushedTexture("") frame:SetPushedTexture("")
frame:SetHighlightTexture("") frame:SetHighlightTexture("")
if size then if size then
frame:SetWidth(size) frame:SetSize(size, size)
frame:SetHeight(size)
end end
CreateBackdrop(frame) CreateBackdrop(frame)
SetAllPointsOffset(frame.backdrop, frame, 4) SetAllPointsOffset(frame.backdrop, frame, 4)
@@ -925,8 +895,7 @@ function pfUI.api.SkinDropDown(frame, cr, cg, cb, useSmall)
CreateBackdrop(button) CreateBackdrop(button)
button.backdrop:ClearAllPoints() button.backdrop:ClearAllPoints()
button.backdrop:SetWidth(18) button.backdrop:SetSize(18, 18)
button.backdrop:SetHeight(18)
button.backdrop:SetPoint("RIGHT", frame.backdrop, "RIGHT", -2, 0) button.backdrop:SetPoint("RIGHT", frame.backdrop, "RIGHT", -2, 0)
if not button.icon then if not button.icon then
@@ -938,9 +907,7 @@ function pfUI.api.SkinDropDown(frame, cr, cg, cb, useSmall)
end end
if not cr or not cg or not cb then if not cr or not cg or not cb then
local _, class = UnitClass("player") cr, cg, cb = PFUI_CLASS_COLORS[UnitClassBase('player')]:GetRGB()
local color = PFUI_CLASS_COLORS[class]
cr, cg, cb = color.r , color.g, color.b
end end
SetHighlight(button, cr, cg, cb) SetHighlight(button, cr, cg, cb)
@@ -1110,8 +1077,7 @@ function pfUI.api.CreateQuestionDialog(text, yes, no, editbox, onclose)
-- buttons -- buttons
question.yes = CreateFrame("Button", "pfQuestionDialogYes", question, "UIPanelButtonTemplate") question.yes = CreateFrame("Button", "pfQuestionDialogYes", question, "UIPanelButtonTemplate")
pfUI.api.SkinButton(question.yes) pfUI.api.SkinButton(question.yes)
question.yes:SetWidth(100) question.yes:SetSize(100, 22)
question.yes:SetHeight(22)
question.yes:SetText(yescap) question.yes:SetText(yescap)
question.yes:SetScript("OnClick", function() question.yes:SetScript("OnClick", function()
if yes then yes() end if yes then yes() end
@@ -1126,8 +1092,7 @@ function pfUI.api.CreateQuestionDialog(text, yes, no, editbox, onclose)
question.no = CreateFrame("Button", "pfQuestionDialogNo", question, "UIPanelButtonTemplate") question.no = CreateFrame("Button", "pfQuestionDialogNo", question, "UIPanelButtonTemplate")
pfUI.api.SkinButton(question.no) pfUI.api.SkinButton(question.no)
question.no:SetWidth(100) question.no:SetSize(100, 22)
question.no:SetHeight(22)
question.no:SetText(nocap) question.no:SetText(nocap)
question.no:SetScript("OnClick", function() question.no:SetScript("OnClick", function()
if no then no() end if no then no() end
@@ -1143,8 +1108,7 @@ function pfUI.api.CreateQuestionDialog(text, yes, no, editbox, onclose)
question.close = CreateFrame("Button", "pfQuestionDialogClose", question) question.close = CreateFrame("Button", "pfQuestionDialogClose", question)
question.close:SetPoint("TOPRIGHT", -border, -border) question.close:SetPoint("TOPRIGHT", -border, -border)
pfUI.api.CreateBackdrop(question.close) pfUI.api.CreateBackdrop(question.close)
question.close:SetHeight(10) question.close:SetSize(10, 10)
question.close:SetWidth(10)
question.close.texture = question.close:CreateTexture("pfQuestionDialogCloseTex") question.close.texture = question.close:CreateTexture("pfQuestionDialogCloseTex")
question.close.texture:SetTexture(pfUI.media["img:close"]) question.close.texture:SetTexture(pfUI.media["img:close"])
question.close.texture:ClearAllPoints() question.close.texture:ClearAllPoints()
@@ -1246,9 +1210,8 @@ function pfUI.api.CreateInfoBox(text, time, parent, height)
infobox.duration = time infobox.duration = time
infobox.lastshow = GetTime() infobox.lastshow = GetTime()
infobox:SetWidth(infobox.text:GetStringWidth() + 50) infobox:SetSize(infobox.text:GetStringWidth() + 50, height)
infobox:SetParent(parent) infobox:SetParent(parent)
infobox:SetHeight(height)
infobox:SetFrameStrata("FULLSCREEN_DIALOG") infobox:SetFrameStrata("FULLSCREEN_DIALOG")
infobox:Show() infobox:Show()
@@ -1283,3 +1246,249 @@ function pfUI.api.SkinMoneyInputFrame(frame)
copperIcon:ClearAllPoints() copperIcon:ClearAllPoints()
copperIcon:SetPoint("LEFT", copper_editbox, "RIGHT", 2, 0) copperIcon:SetPoint("LEFT", copper_editbox, "RIGHT", 2, 0)
end end
-- Shared icon picker widget. Builds a name field, a "currently selected"
-- preview, and a 10x8 icon grid backed by IconDataProviderMixin with an
-- All/Spells/Items filter and a name search. Used by the macro icon picker
-- and the equipment manager's name/icon popup. The widgets attach to
-- `parent`; the caller owns the surrounding frame, its OK/Cancel buttons,
-- and the save flow. Selection is tracked by texture PATH (not index) so it
-- survives filter changes -- a spell icon you picked still saves after you
-- switch the filter to "Items" and it drops out of the visible grid.
--
-- name global-name prefix for the scroll frame and editboxes
-- parent the popup frame to attach the widgets to
-- extraType IconDataProviderExtraType.* seed (Spellbook / Equipment)
-- nameLabelText header shown above the name field
--
-- Returns a handle:
-- .editbox name EditBox (caller wires enter/escape)
-- .search search EditBox
-- .GetIcon() current selected texture path
-- .SetIcon(path) set selection (nil -> question mark)
-- .Refresh() ensure provider, redraw grid + preview
-- .SetIconAreaShown(shown) show/hide the grid, filter, search, and labels
function pfUI.api.CreateIconPicker(name, parent, extraType, nameLabelText)
local QUESTION_MARK = "INTERFACE\\ICONS\\INV_MISC_QUESTIONMARK"
local ICON_GRID_COLS = 10
local ICON_GRID_ROWS = 8
local ICON_BTN_SIZE = 36
local ICON_BTN_PAD = 6
local provider = nil
local selectedIconPath = QUESTION_MARK
local currentFilter = "all"
local searchText = ""
local filtered = nil -- provider indices matching the search, or nil when empty
local RefreshIconGrid, RebuildFilter
local function EnsureProvider()
if not provider then
provider = CreateAndInitFromMixin(IconDataProviderMixin, extraType)
end
end
-- Normalize a texture to an uppercase basename so matching works across
-- sources: GetMacroInfo / stored set icons return "Interface\Icons\<name>"
-- while provider paths are uppercase-prefixed for base icons and
-- mixed-case for spellbook extras.
local function IconKey(path)
if type(path) ~= "string" then return path end
return string.gsub(string.upper(path), "^.*[\\/]", "")
end
parent.nameLabel = parent:CreateFontString(nil, "OVERLAY", "GameFontNormal")
parent.nameLabel:SetPoint("TOPLEFT", parent, "TOPLEFT", 14, -20)
parent.nameLabel:SetText(nameLabelText)
parent.editbox = CreateFrame("EditBox", name.."Name", parent, "InputBoxTemplate")
parent.editbox:SetSize(280, 20)
parent.editbox:SetPoint("TOPLEFT", parent, "TOPLEFT", 14, -38)
parent.editbox:SetAutoFocus(false)
parent.editbox:SetMaxLetters(16)
CreateBackdrop(parent.editbox)
parent.selectedLabel = parent:CreateFontString(nil, "OVERLAY", "GameFontNormal")
parent.selectedLabel:SetPoint("TOPRIGHT", parent, "TOPRIGHT", -14, -14)
parent.selectedLabel:SetText(ICON_SELECTION_TITLE_CURRENT)
parent.selectedLabel:SetTextColor(1, 0.82, 0)
parent.selectedPreview = CreateFrame("Frame", nil, parent)
parent.selectedPreview:SetSize(42, 42)
parent.selectedPreview:SetPoint("TOPRIGHT", parent, "TOPRIGHT", -14, -30)
CreateBackdrop(parent.selectedPreview)
parent.selectedPreview.tex = parent.selectedPreview:CreateTexture(nil, "ARTWORK")
parent.selectedPreview.tex:SetAllPoints(parent.selectedPreview)
parent.selectedPreview.tex:SetTexCoord(.08, .92, .08, .92)
parent.iconLabel = parent:CreateFontString(nil, "OVERLAY", "GameFontNormal")
parent.iconLabel:SetPoint("TOPLEFT", parent, "TOPLEFT", 14, -86)
parent.iconLabel:SetText(MACRO_POPUP_CHOOSE_ICON)
-- Icon grid + scroll
local iconScroll = CreateFrame("ScrollFrame", name.."Scroll", parent, "FauxScrollFrameTemplate")
iconScroll:SetPoint("TOPLEFT", parent, "TOPLEFT", 14, -116)
iconScroll:SetWidth(ICON_GRID_COLS * (ICON_BTN_SIZE + ICON_BTN_PAD) - ICON_BTN_PAD)
iconScroll:SetHeight(ICON_GRID_ROWS * (ICON_BTN_SIZE + ICON_BTN_PAD) - ICON_BTN_PAD)
local scrollbar = _G[name.."ScrollScrollBar"]
scrollbar:ClearAllPoints()
scrollbar:SetPoint("TOPLEFT", iconScroll, "TOPRIGHT", 8, -16)
scrollbar:SetPoint("BOTTOMLEFT", iconScroll, "BOTTOMRIGHT", 8, 16)
SkinScrollbar(scrollbar)
-- Filter dropdown: All / Spells / Items
local filterDropdown = CreateFrame("Frame", name.."Filter", parent, "UIDropDownMenuTemplate")
filterDropdown:SetPoint("TOPRIGHT", parent, "TOPRIGHT", 0, -80)
local function ApplyFilter(value)
currentFilter = value
UIDropDownMenu_SetSelectedValue(filterDropdown, value)
if provider then
if value == "spells" then provider:SetIconTypes({ IconDataProviderIconType.Spell })
elseif value == "items" then provider:SetIconTypes({ IconDataProviderIconType.Item })
else provider:SetIconTypes(nil) end
RebuildFilter()
RefreshIconGrid()
end
end
UIDropDownMenu_Initialize(filterDropdown, function()
local info
info = {}; info.text = ICON_FILTER_ALL; info.value = "all"
info.func = function() ApplyFilter("all") end
info.checked = currentFilter == "all"
UIDropDownMenu_AddButton(info)
info = {}; info.text = ICON_FILTER_SPELL; info.value = "spells"
info.func = function() ApplyFilter("spells") end
info.checked = currentFilter == "spells"
UIDropDownMenu_AddButton(info)
info = {}; info.text = ICON_FILTER_ITEM; info.value = "items"
info.func = function() ApplyFilter("items") end
info.checked = currentFilter == "items"
UIDropDownMenu_AddButton(info)
end)
UIDropDownMenu_SetWidth(120, filterDropdown)
UIDropDownMenu_SetSelectedValue(filterDropdown, "all")
SkinDropDown(filterDropdown)
local iconButtons = {}
for r = 1, ICON_GRID_ROWS do
for c = 1, ICON_GRID_COLS do
local i = (r - 1) * ICON_GRID_COLS + c
local btn = CreateFrame("Button", nil, parent)
btn:SetSize(ICON_BTN_SIZE, ICON_BTN_SIZE)
btn:SetPoint("TOPLEFT", iconScroll, "TOPLEFT", (c-1) * (ICON_BTN_SIZE + ICON_BTN_PAD), -(r-1) * (ICON_BTN_SIZE + ICON_BTN_PAD))
CreateBackdrop(btn)
btn.texture = btn:CreateTexture(nil, "ARTWORK")
btn.texture:SetAllPoints(btn)
btn.texture:SetTexCoord(.08, .92, .08, .92)
btn:SetScript("OnClick", function()
if this.iconIndex and provider then
local path = provider:GetIconByIndex(this.iconIndex)
if path then selectedIconPath = path end
RefreshIconGrid()
end
end)
btn:SetScript("OnEnter", function()
if not this.iconIndex or not provider then return end
local path = provider:GetIconByIndex(this.iconIndex)
if type(path) == "string" then
GameTooltip:SetOwner(this, "ANCHOR_RIGHT")
GameTooltip:SetText(IconKey(path), 1, 1, 1)
GameTooltip:Show()
end
end)
btn:SetScript("OnLeave", GameTooltip_Hide)
iconButtons[i] = btn
end
end
-- Rebuild the search-filtered index list (provider indices whose icon
-- basename contains the search text); nil when the search box is empty.
function RebuildFilter()
EnsureProvider()
if searchText == "" then
filtered = nil
return
end
filtered = {}
for i = 1, provider:GetNumIcons() do
local path = provider:GetIconByIndex(i)
if type(path) == "string" and string.find(IconKey(path), searchText, 1, true) then
table.insert(filtered, i)
end
end
end
function RefreshIconGrid()
EnsureProvider()
local numIcons = filtered and table.getn(filtered) or provider:GetNumIcons()
local numRows = math.ceil(numIcons / ICON_GRID_COLS)
FauxScrollFrame_Update(iconScroll, numRows, ICON_GRID_ROWS, ICON_BTN_SIZE + ICON_BTN_PAD)
local offset = FauxScrollFrame_GetOffset(iconScroll)
for i = 1, ICON_GRID_ROWS * ICON_GRID_COLS do
local listIdx = i + offset * ICON_GRID_COLS
local btn = iconButtons[i]
if listIdx <= numIcons then
btn:Show()
local providerIdx = filtered and filtered[listIdx] or listIdx
btn.iconIndex = providerIdx
local path = provider:GetIconByIndex(providerIdx)
btn.texture:SetTexture(path)
if IconKey(path) == IconKey(selectedIconPath) then
btn.backdrop:SetBackdropBorderColor(1, 0.82, 0, 1)
else
btn.backdrop:SetBackdropBorderColor(pfUI.cache.er, pfUI.cache.eg, pfUI.cache.eb, pfUI.cache.ea)
end
else
btn:Hide()
btn.iconIndex = nil
end
end
parent.selectedPreview.tex:SetTexture(selectedIconPath)
end
iconScroll:SetScript("OnVerticalScroll", function()
FauxScrollFrame_OnVerticalScroll(ICON_BTN_SIZE + ICON_BTN_PAD, function() RefreshIconGrid() end)
end)
-- Search box (bottom-left) filters the grid by icon name.
parent.searchLabel = parent:CreateFontString(nil, "OVERLAY", "GameFontNormal")
parent.searchLabel:SetPoint("BOTTOMLEFT", parent, "BOTTOMLEFT", 16, 18)
parent.searchLabel:SetText(SEARCH)
parent.search = CreateFrame("EditBox", name.."Search", parent, "InputBoxTemplate")
parent.search:SetSize(180, 20)
parent.search:SetPoint("LEFT", parent.searchLabel, "RIGHT", 10, 0)
parent.search:SetAutoFocus(false)
CreateBackdrop(parent.search)
parent.search:SetScript("OnEscapePressed", function() this:ClearFocus() end)
parent.search:SetScript("OnTextChanged", function()
searchText = strupper(strtrim(this:GetText()))
RebuildFilter()
scrollbar:SetValue(0)
RefreshIconGrid()
end)
-- Release the provider when the popup closes so its icon cache GCs.
parent:HookScript("OnHide", function()
if provider then provider:Release(); provider = nil end
end)
local handle = { editbox = parent.editbox, search = parent.search }
function handle.GetIcon() return selectedIconPath end
function handle.SetIcon(path) selectedIconPath = path or QUESTION_MARK end
function handle.Refresh() RefreshIconGrid() end
function handle.SetIconAreaShown(shown)
local method = shown and "Show" or "Hide"
iconScroll[method](iconScroll)
for _, b in ipairs(iconButtons) do b[method](b) end
parent.iconLabel[method](parent.iconLabel)
parent.selectedLabel[method](parent.selectedLabel)
parent.selectedPreview[method](parent.selectedPreview)
filterDropdown[method](filterDropdown)
parent.searchLabel[method](parent.searchLabel)
parent.search[method](parent.search)
end
return handle
end
api/unitframes.lua
+588 -888
View File
File diff suppressed because it is too large Load Diff
compat/vanilla.lua
-64
View File
@@ -1,64 +0,0 @@
-- load pfUI environment
setfenv(1, pfUI:GetEnvironment())
-- [[ Constants ]]--
EVENTS_MINIMAP_ZONE_UPDATE = {"PLAYER_ENTERING_WORLD", "MINIMAP_ZONE_CHANGED"}
MICRO_BUTTONS = {
'CharacterMicroButton', 'SpellbookMicroButton', 'TalentMicroButton',
'QuestLogMicroButton', 'SocialsMicroButton', 'WorldMapMicroButton',
'MainMenuMicroButton', 'HelpMicroButton',
}
NAMEPLATE_OBJECTORDER = { "border", "glow", "name", "level", "levelicon", "raidicon" }
NAMEPLATE_FRAMETYPE = "Button"
MINIMAP_TRACKING_FRAME = _G.MiniMapTrackingFrame
FRIENDS_NAME_LOCATION = "ButtonTextNameLocation"
COOLDOWN_FRAME_TYPE = "Model"
LOOT_BUTTON_FRAME_TYPE = "LootButton"
PLAYER_BUFF_START_ID = -1
ACTIONBAR_SECURE_TEMPLATE_BAR = nil
ACTIONBAR_SECURE_TEMPLATE_BUTTON = nil
UNITFRAME_SECURE_TEMPLATE = nil
--[[ Vanilla API Extensions ]]--
-- Safe post-hook helper. The global `hooksecurefunc` belongs to ClassicAPI
-- (its C implementation); this wrapper only adds pfUI's missing-target guard:
-- ClassicAPI errors when target[name] isn't a function, whereas a lot of our
-- call sites hook optional/late-loaded frames and rely on a silent no-op.
-- Normalizes the string form, skips when the target is absent, then delegates
-- to the C version (uncapped args, callback-pcall, taint parity).
function pfUI.hooksecurefunc(tbl, name, func)
if type(tbl) == "string" then tbl, name, func = _G, tbl, name end
if not tbl or type(tbl[name]) ~= "function" then return end
return _G.hooksecurefunc(tbl, name, func)
end
do -- GetItemInfo
local name, link, rarity, minlevel, itype, isubtype, stack
function GetItemInfo(item)
if not item then return end
name, link, rarity, minlevel, itype, isubtype, stack = _G.GetItemInfo(item)
return name, link, rarity, nil, minlevel, itype, isubtype, stack
end
end
do -- RunMacroText
local obj = { ["GetText"] = function(self) return self.text end }
obj = setmetatable(obj, {__index = function(tab,key)
local value = function() return end
rawset(tab,key,value)
return value
end})
function RunMacroText(text)
obj.text = text
ChatEdit_ParseText(obj, 1)
end
end
env/locales_deDE.lua
Vendored
-1065
View File
File diff suppressed because it is too large Load Diff
env/locales_enUS.lua
Vendored
-1067
View File
File diff suppressed because it is too large Load Diff
env/locales_esES.lua
Vendored
-1060
View File
File diff suppressed because it is too large Load Diff
env/locales_frFR.lua
Vendored
-1056
View File
File diff suppressed because it is too large Load Diff
env/locales_koKR.lua
Vendored
-1026
View File
File diff suppressed because it is too large Load Diff
env/locales_ruRU.lua
Vendored
-1063
View File
File diff suppressed because it is too large Load Diff
env/locales_zhCN.lua
Vendored
-1080
View File
File diff suppressed because it is too large Load Diff
env/tables.lua
Vendored
-2424
View File
File diff suppressed because it is too large Load Diff
env/tables_stock.lua
Vendored
+2377
View File
File diff suppressed because it is too large Load Diff
env/tables_turtle.lua
Vendored
+2991
View File
File diff suppressed because it is too large Load Diff
env/translations_deDE.lua
Vendored
+11 -6
View File
@@ -27,7 +27,6 @@ pfUI_translation["deDE"] = {
["Always Show Item Comparison"] = nil, ["Always Show Item Comparison"] = nil,
["Always Show On Target Units"] = nil, ["Always Show On Target Units"] = nil,
["Always Show On Units With Missing HP"] = nil, ["Always Show On Units With Missing HP"] = nil,
["Always Show Self In Raid Frames"] = nil,
["Always Use 2D Portraits"] = nil, ["Always Use 2D Portraits"] = nil,
["Ammo Counter"] = nil, ["Ammo Counter"] = nil,
["Anchor Bags Above Chat"] = nil, ["Anchor Bags Above Chat"] = nil,
@@ -52,10 +51,12 @@ pfUI_translation["deDE"] = {
["Auto Sell Grey Items"] = nil, ["Auto Sell Grey Items"] = nil,
["Average Per Hour"] = nil, ["Average Per Hour"] = nil,
["Background Color"] = nil, ["Background Color"] = nil,
["Bags"] = "Taschen",
["Bags & Bank"] = nil, ["Bags & Bank"] = nil,
["Bags Border Size"] = nil, ["Bags Border Size"] = nil,
["Bagslots Per Row"] = nil, ["Bagslots Per Row"] = nil,
["Bagspace"] = nil, ["Bagspace"] = nil,
["Bank"] = "Bank",
["Banker"] = nil, ["Banker"] = nil,
["Bankslots Per Row"] = nil, ["Bankslots Per Row"] = nil,
["Bar Background"] = nil, ["Bar Background"] = nil,
@@ -124,6 +125,7 @@ pfUI_translation["deDE"] = {
["Click Casting"] = nil, ["Click Casting"] = nil,
["Clock"] = nil, ["Clock"] = nil,
["Close"] = nil, ["Close"] = nil,
["Collapse Empty Slots"] = nil,
["Color"] = nil, ["Color"] = nil,
["Color Buff Stacks"] = nil, ["Color Buff Stacks"] = nil,
["Color Debuff Stacks"] = nil, ["Color Debuff Stacks"] = nil,
@@ -138,7 +140,6 @@ pfUI_translation["deDE"] = {
["Combat Timer"] = nil, ["Combat Timer"] = nil,
["Combopoint Height"] = nil, ["Combopoint Height"] = nil,
["Combopoint Width"] = nil, ["Combopoint Width"] = nil,
["Compare Item Base Stats"] = nil,
["Components"] = nil, ["Components"] = nil,
["Config UI Settings"] = nil, ["Config UI Settings"] = nil,
["Configuration"] = nil, ["Configuration"] = nil,
@@ -291,7 +292,6 @@ pfUI_translation["deDE"] = {
["Enable Mana Ticks"] = nil, ["Enable Mana Ticks"] = nil,
["Enable Micro Bar"] = nil, ["Enable Micro Bar"] = nil,
["Enable Mouselook With Right Click"] = nil, ["Enable Mouselook With Right Click"] = nil,
["Enable Mouseover Tooltip"] = nil,
["Enable Movable Bags"] = nil, ["Enable Movable Bags"] = nil,
["Enable Offscreen Frame Positions"] = nil, ["Enable Offscreen Frame Positions"] = nil,
["Enable Overlap"] = nil, ["Enable Overlap"] = nil,
@@ -312,6 +312,7 @@ pfUI_translation["deDE"] = {
["Encode"] = nil, ["Encode"] = nil,
["Ended"] = nil, ["Ended"] = nil,
["Energy Color"] = nil, ["Energy Color"] = nil,
["Equipped"] = "Angelegt",
["Equipped Item Color"] = nil, ["Equipped Item Color"] = nil,
["Estimate Debuffs"] = nil, ["Estimate Debuffs"] = nil,
["Estimate Enemy Health Points"] = nil, ["Estimate Enemy Health Points"] = nil,
@@ -569,6 +570,7 @@ pfUI_translation["deDE"] = {
["Overwrite If Unit Is Attacking Others"] = nil, ["Overwrite If Unit Is Attacking Others"] = nil,
["Overwrite If Unit Is Attacking You"] = nil, ["Overwrite If Unit Is Attacking You"] = nil,
["Overwrite If Unit Is Casting"] = nil, ["Overwrite If Unit Is Casting"] = nil,
["Owner Name"] = nil,
["Pageable"] = nil, ["Pageable"] = nil,
["Paging Actionbar"] = nil, ["Paging Actionbar"] = nil,
["Panel"] = nil, ["Panel"] = nil,
@@ -616,12 +618,13 @@ pfUI_translation["deDE"] = {
["Raid Mark X-Offset"] = nil, ["Raid Mark X-Offset"] = nil,
["Raid Mark Y-Offset"] = nil, ["Raid Mark Y-Offset"] = nil,
["Raid Padding"] = nil, ["Raid Padding"] = nil,
["Raid-Pet"] = nil,
["Random"] = nil, ["Random"] = nil,
["Random Roll Announcement Rarity"] = nil, ["Random Roll Announcement Rarity"] = nil,
["Random Rolling"] = nil, ["Random Rolling"] = nil,
["Range Based Hunter Paging"] = nil, ["Range Based Hunter Paging"] = nil,
["Range Check Interval"] = nil,
["Rank"] = nil, ["Rank"] = nil,
["Recast Totem"] = nil,
["Red Border On Enemy Units"] = nil, ["Red Border On Enemy Units"] = nil,
["Red Name Text On Infight Units"] = nil, ["Red Name Text On Infight Units"] = nil,
["Regional Settings"] = nil, ["Regional Settings"] = nil,
@@ -667,7 +670,6 @@ pfUI_translation["deDE"] = {
["Scale"] = nil, ["Scale"] = nil,
["Scale Border On HiDPI Displays"] = nil, ["Scale Border On HiDPI Displays"] = nil,
["Scaling"] = nil, ["Scaling"] = nil,
["Scan Macros For Spells"] = nil,
["Screen Edge Glow Intensity"] = nil, ["Screen Edge Glow Intensity"] = nil,
["Screen Resolution"] = nil, ["Screen Resolution"] = nil,
["Screenshot"] = nil, ["Screenshot"] = nil,
@@ -703,6 +705,7 @@ pfUI_translation["deDE"] = {
["Show Description"] = nil, ["Show Description"] = nil,
["Show Dispel Indicators"] = nil, ["Show Dispel Indicators"] = nil,
["Show Druid Mana Bar"] = nil, ["Show Druid Mana Bar"] = nil,
["Show Druid Mana Bar Text"] = nil,
["Show Duration Inside Buff"] = nil, ["Show Duration Inside Buff"] = nil,
["Show Empty Buttons"] = nil, ["Show Empty Buttons"] = nil,
["Show FPS and Latency Colors"] = nil, ["Show FPS and Latency Colors"] = nil,
@@ -739,6 +742,7 @@ pfUI_translation["deDE"] = {
["Show Required Questitem Count"] = nil, ["Show Required Questitem Count"] = nil,
["Show Resting"] = nil, ["Show Resting"] = nil,
["Show Self In Group Frames"] = nil, ["Show Self In Group Frames"] = nil,
["Show Self In Raid Frames When Solo"] = nil,
["Show Spell Icon"] = nil, ["Show Spell Icon"] = nil,
["Show Spell Name"] = nil, ["Show Spell Name"] = nil,
["Show Stacks"] = nil, ["Show Stacks"] = nil,
@@ -783,6 +787,7 @@ pfUI_translation["deDE"] = {
["Target Castbar"] = nil, ["Target Castbar"] = nil,
["Target Debuff Bar"] = nil, ["Target Debuff Bar"] = nil,
["Target Nameplate Zoom Factor"] = nil, ["Target Nameplate Zoom Factor"] = nil,
["Target Totem"] = nil,
["Target-Target"] = nil, ["Target-Target"] = nil,
["Target-Target-Target"] = nil, ["Target-Target-Target"] = nil,
["Text"] = nil, ["Text"] = nil,
@@ -815,6 +820,7 @@ pfUI_translation["deDE"] = {
["Top Actionbar"] = nil, ["Top Actionbar"] = nil,
["Top Left"] = nil, ["Top Left"] = nil,
["Top Right"] = nil, ["Top Right"] = nil,
["Total"] = "Gesamt",
["Total Gold"] = nil, ["Total Gold"] = nil,
["Totem Direction"] = nil, ["Totem Direction"] = nil,
["Totem Icons"] = nil, ["Totem Icons"] = nil,
@@ -877,7 +883,6 @@ pfUI_translation["deDE"] = {
["XP Percentage"] = nil, ["XP Percentage"] = nil,
["Yellow Border On Neutral Units"] = nil, ["Yellow Border On Neutral Units"] = nil,
["Yes"] = nil, ["Yes"] = nil,
["You gain (.+) Mana from Totemic Recall"] = nil,
["You got"] = nil, ["You got"] = nil,
["Your interface is now set up.\n\nFor advanced configuration, just open the |cff33ffccpf|rUI settings via the escape menu or type \"|cffffffaa/pfui|r\" into the chat.\n\n Have a nice trip!\n\n|cffaaaaaa- Shagu"] = nil, ["Your interface is now set up.\n\nFor advanced configuration, just open the |cff33ffccpf|rUI settings via the escape menu or type \"|cffffffaa/pfui|r\" into the chat.\n\n Have a nice trip!\n\n|cffaaaaaa- Shagu"] = nil,
["Your items have been repaired for"] = nil, ["Your items have been repaired for"] = nil,
env/translations_enUS.lua
Vendored
+33 -6
View File
@@ -19,6 +19,7 @@ pfUI_translation["enUS"] = {
["Align Chat Windows"] = nil, ["Align Chat Windows"] = nil,
["Aligned Position"] = nil, ["Aligned Position"] = nil,
["All messages will be forwarded to:"] = nil, ["All messages will be forwarded to:"] = nil,
["All players passed"] = nil,
["Alt-Click Action"] = nil, ["Alt-Click Action"] = nil,
["Always Allow Drag Via Shift Key"] = nil, ["Always Allow Drag Via Shift Key"] = nil,
["Always Show"] = nil, ["Always Show"] = nil,
@@ -27,7 +28,6 @@ pfUI_translation["enUS"] = {
["Always Show Item Comparison"] = nil, ["Always Show Item Comparison"] = nil,
["Always Show On Target Units"] = nil, ["Always Show On Target Units"] = nil,
["Always Show On Units With Missing HP"] = nil, ["Always Show On Units With Missing HP"] = nil,
["Always Show Self In Raid Frames"] = nil,
["Always Use 2D Portraits"] = nil, ["Always Use 2D Portraits"] = nil,
["Ammo Counter"] = nil, ["Ammo Counter"] = nil,
["Anchor Bags Above Chat"] = nil, ["Anchor Bags Above Chat"] = nil,
@@ -52,15 +52,19 @@ pfUI_translation["enUS"] = {
["Auto Sell Grey Items"] = nil, ["Auto Sell Grey Items"] = nil,
["Average Per Hour"] = nil, ["Average Per Hour"] = nil,
["Background Color"] = nil, ["Background Color"] = nil,
["Bags"] = nil,
["Bags & Bank"] = nil, ["Bags & Bank"] = nil,
["Bags Border Size"] = nil, ["Bags Border Size"] = nil,
["Bagslots Per Row"] = nil, ["Bagslots Per Row"] = nil,
["Bagspace"] = nil, ["Bagspace"] = nil,
["Bank"] = nil,
["Banker"] = nil, ["Banker"] = nil,
["Bankslots Per Row"] = nil, ["Bankslots Per Row"] = nil,
["Bar Background"] = nil, ["Bar Background"] = nil,
["Bar Texture"] = nil, ["Bar Texture"] = nil,
["Battleground Frames"] = nil,
["Battleground Statistics"] = nil, ["Battleground Statistics"] = nil,
["BEHIND"] = nil,
["Blacklist"] = nil, ["Blacklist"] = nil,
["Blinding Powder"] = nil, ["Blinding Powder"] = nil,
["Blue Border On Friendly Players"] = nil, ["Blue Border On Friendly Players"] = nil,
@@ -119,11 +123,13 @@ pfUI_translation["enUS"] = {
["Chat Bubble Transparency"] = nil, ["Chat Bubble Transparency"] = nil,
["Chat Default Brackets"] = nil, ["Chat Default Brackets"] = nil,
["Class"] = nil, ["Class"] = nil,
["Clear"] = nil,
["Clear Rolls"] = nil, ["Clear Rolls"] = nil,
["Click Action"] = nil, ["Click Action"] = nil,
["Click Casting"] = nil, ["Click Casting"] = nil,
["Clock"] = nil, ["Clock"] = nil,
["Close"] = nil, ["Close"] = nil,
["Collapse Empty Slots"] = nil,
["Color"] = nil, ["Color"] = nil,
["Color Buff Stacks"] = nil, ["Color Buff Stacks"] = nil,
["Color Debuff Stacks"] = nil, ["Color Debuff Stacks"] = nil,
@@ -138,7 +144,6 @@ pfUI_translation["enUS"] = {
["Combat Timer"] = nil, ["Combat Timer"] = nil,
["Combopoint Height"] = nil, ["Combopoint Height"] = nil,
["Combopoint Width"] = nil, ["Combopoint Width"] = nil,
["Compare Item Base Stats"] = nil,
["Components"] = nil, ["Components"] = nil,
["Config UI Settings"] = nil, ["Config UI Settings"] = nil,
["Configuration"] = nil, ["Configuration"] = nil,
@@ -195,6 +200,7 @@ pfUI_translation["enUS"] = {
["Deficit"] = nil, ["Deficit"] = nil,
["Delete profile"] = nil, ["Delete profile"] = nil,
["Delete / Reset"] = nil, ["Delete / Reset"] = nil,
["Dependencies"] = nil,
["Descending"] = nil, ["Descending"] = nil,
["Description Font"] = nil, ["Description Font"] = nil,
["Description Font Size"] = nil, ["Description Font Size"] = nil,
@@ -291,7 +297,6 @@ pfUI_translation["enUS"] = {
["Enable Mana Ticks"] = nil, ["Enable Mana Ticks"] = nil,
["Enable Micro Bar"] = nil, ["Enable Micro Bar"] = nil,
["Enable Mouselook With Right Click"] = nil, ["Enable Mouselook With Right Click"] = nil,
["Enable Mouseover Tooltip"] = nil,
["Enable Movable Bags"] = nil, ["Enable Movable Bags"] = nil,
["Enable Offscreen Frame Positions"] = nil, ["Enable Offscreen Frame Positions"] = nil,
["Enable Overlap"] = nil, ["Enable Overlap"] = nil,
@@ -312,6 +317,7 @@ pfUI_translation["enUS"] = {
["Encode"] = nil, ["Encode"] = nil,
["Ended"] = nil, ["Ended"] = nil,
["Energy Color"] = nil, ["Energy Color"] = nil,
["Equipped"] = nil,
["Equipped Item Color"] = nil, ["Equipped Item Color"] = nil,
["Estimate Debuffs"] = nil, ["Estimate Debuffs"] = nil,
["Estimate Enemy Health Points"] = nil, ["Estimate Enemy Health Points"] = nil,
@@ -324,6 +330,7 @@ pfUI_translation["enUS"] = {
["Export"] = nil, ["Export"] = nil,
["Face"] = nil, ["Face"] = nil,
["Fade To Custom Color"] = nil, ["Fade To Custom Color"] = nil,
["FARM MODE"] = nil,
["Fast"] = nil, ["Fast"] = nil,
["Filter Mode"] = nil, ["Filter Mode"] = nil,
["Finish"] = nil, ["Finish"] = nil,
@@ -409,6 +416,7 @@ pfUI_translation["enUS"] = {
["Highlight Equipped Items"] = nil, ["Highlight Equipped Items"] = nil,
["Highlight Not Usable Spells"] = nil, ["Highlight Not Usable Spells"] = nil,
["Highlight Out Of Mana Spells"] = nil, ["Highlight Out Of Mana Spells"] = nil,
["Highlight New Items"] = nil,
["Highlight Out Of Range Spells"] = nil, ["Highlight Out Of Range Spells"] = nil,
["Highlight Settings That Require Reload"] = nil, ["Highlight Settings That Require Reload"] = nil,
["Highlight Unusable Items"] = nil, ["Highlight Unusable Items"] = nil,
@@ -477,6 +485,7 @@ pfUI_translation["enUS"] = {
["Look & Feel"] = nil, ["Look & Feel"] = nil,
["Loot"] = nil, ["Loot"] = nil,
["Loot & Spam"] = nil, ["Loot & Spam"] = nil,
["Loot History"] = nil,
["Macro Text Color"] = nil, ["Macro Text Color"] = nil,
["Macro Text Size"] = nil, ["Macro Text Size"] = nil,
["Main Actionbar"] = nil, ["Main Actionbar"] = nil,
@@ -499,6 +508,7 @@ pfUI_translation["enUS"] = {
["Menu Font Size"] = nil, ["Menu Font Size"] = nil,
["Messages are no longer forwarded to:"] = nil, ["Messages are no longer forwarded to:"] = nil,
["Middle Mouse Button"] = nil, ["Middle Mouse Button"] = nil,
["Missing"] = nil,
["Minimap"] = nil, ["Minimap"] = nil,
["Minimap Panel"] = nil, ["Minimap Panel"] = nil,
["Minimap Size (|cffffaaaaExperimental|r)"] = nil, ["Minimap Size (|cffffaaaaExperimental|r)"] = nil,
@@ -525,11 +535,13 @@ pfUI_translation["enUS"] = {
["Network Latency"] = nil, ["Network Latency"] = nil,
["Network Up"] = nil, ["Network Up"] = nil,
["New entry:"] = nil, ["New entry:"] = nil,
["New Item Color"] = nil,
["NEW TIMER"] = nil, ["NEW TIMER"] = nil,
["Next"] = nil, ["Next"] = nil,
["Next Memory Cleanup"] = nil, ["Next Memory Cleanup"] = nil,
["No"] = nil, ["No"] = nil,
["No Anchor"] = nil, ["No Anchor"] = nil,
["NO LOS"] = nil,
["None"] = nil, ["None"] = nil,
["Not a valid button!"] = nil, ["Not a valid button!"] = nil,
["No tracking spell active"] = nil, ["No tracking spell active"] = nil,
@@ -552,6 +564,7 @@ pfUI_translation["enUS"] = {
["Only Show Own Debuffs (|cffffaaaaExperimental|r)"] = nil, ["Only Show Own Debuffs (|cffffaaaaExperimental|r)"] = nil,
["Only Show Target Castbar"] = nil, ["Only Show Target Castbar"] = nil,
["On State Change"] = nil, ["On State Change"] = nil,
["Optional Dependencies"] = nil,
["Options"] = nil, ["Options"] = nil,
["Orientation"] = nil, ["Orientation"] = nil,
["Other Panel: Minimap"] = nil, ["Other Panel: Minimap"] = nil,
@@ -569,6 +582,7 @@ pfUI_translation["enUS"] = {
["Overwrite If Unit Is Attacking Others"] = nil, ["Overwrite If Unit Is Attacking Others"] = nil,
["Overwrite If Unit Is Attacking You"] = nil, ["Overwrite If Unit Is Attacking You"] = nil,
["Overwrite If Unit Is Casting"] = nil, ["Overwrite If Unit Is Casting"] = nil,
["Owner Name"] = nil,
["Pageable"] = nil, ["Pageable"] = nil,
["Paging Actionbar"] = nil, ["Paging Actionbar"] = nil,
["Panel"] = nil, ["Panel"] = nil,
@@ -616,12 +630,13 @@ pfUI_translation["enUS"] = {
["Raid Mark X-Offset"] = nil, ["Raid Mark X-Offset"] = nil,
["Raid Mark Y-Offset"] = nil, ["Raid Mark Y-Offset"] = nil,
["Raid Padding"] = nil, ["Raid Padding"] = nil,
["Raid-Pet"] = nil,
["Random"] = nil, ["Random"] = nil,
["Random Roll Announcement Rarity"] = nil, ["Random Roll Announcement Rarity"] = nil,
["Random Rolling"] = nil, ["Random Rolling"] = nil,
["Range Based Hunter Paging"] = nil, ["Range Based Hunter Paging"] = nil,
["Range Check Interval"] = nil,
["Rank"] = nil, ["Rank"] = nil,
["Recast Totem"] = nil,
["Red Border On Enemy Units"] = nil, ["Red Border On Enemy Units"] = nil,
["Red Name Text On Infight Units"] = nil, ["Red Name Text On Infight Units"] = nil,
["Regional Settings"] = nil, ["Regional Settings"] = nil,
@@ -645,6 +660,7 @@ pfUI_translation["enUS"] = {
["Resting"] = nil, ["Resting"] = nil,
["Reveal Unexplored Areas"] = nil, ["Reveal Unexplored Areas"] = nil,
["Switch to current zone"] = nil, ["Switch to current zone"] = nil,
["Retrieving item information..."] = nil,
["Right"] = nil, ["Right"] = nil,
["Right Actionbar"] = nil, ["Right Actionbar"] = nil,
["Right Anchor"] = nil, ["Right Anchor"] = nil,
@@ -667,7 +683,6 @@ pfUI_translation["enUS"] = {
["Scale"] = nil, ["Scale"] = nil,
["Scale Border On HiDPI Displays"] = nil, ["Scale Border On HiDPI Displays"] = nil,
["Scaling"] = nil, ["Scaling"] = nil,
["Scan Macros For Spells"] = nil,
["Screen Edge Glow Intensity"] = nil, ["Screen Edge Glow Intensity"] = nil,
["Screen Resolution"] = nil, ["Screen Resolution"] = nil,
["Screenshot"] = nil, ["Screenshot"] = nil,
@@ -703,6 +718,7 @@ pfUI_translation["enUS"] = {
["Show Description"] = nil, ["Show Description"] = nil,
["Show Dispel Indicators"] = nil, ["Show Dispel Indicators"] = nil,
["Show Druid Mana Bar"] = nil, ["Show Druid Mana Bar"] = nil,
["Show Druid Mana Bar Text"] = nil,
["Show Duration Inside Buff"] = nil, ["Show Duration Inside Buff"] = nil,
["Show Empty Buttons"] = nil, ["Show Empty Buttons"] = nil,
["Show FPS and Latency Colors"] = nil, ["Show FPS and Latency Colors"] = nil,
@@ -739,6 +755,7 @@ pfUI_translation["enUS"] = {
["Show Required Questitem Count"] = nil, ["Show Required Questitem Count"] = nil,
["Show Resting"] = nil, ["Show Resting"] = nil,
["Show Self In Group Frames"] = nil, ["Show Self In Group Frames"] = nil,
["Show Self In Raid Frames When Solo"] = nil,
["Show Spell Icon"] = nil, ["Show Spell Icon"] = nil,
["Show Spell Name"] = nil, ["Show Spell Name"] = nil,
["Show Stacks"] = nil, ["Show Stacks"] = nil,
@@ -750,12 +767,17 @@ pfUI_translation["enUS"] = {
["Show Totems Indicators"] = nil, ["Show Totems Indicators"] = nil,
["Shrink & Return"] = nil, ["Shrink & Return"] = nil,
["Size"] = nil, ["Size"] = nil,
["Spell Name Alignment"] = nil,
["Spell Name X Offset"] = nil,
["Spell Name Y Offset"] = nil,
["Skin"] = nil, ["Skin"] = nil,
["Skins"] = nil, ["Skins"] = nil,
["Slow"] = nil, ["Slow"] = nil,
["Small"] = nil, ["Small"] = nil,
["Some settings need to reload the UI to take effect.\nDo you want to reload now?"] = nil, ["Some settings need to reload the UI to take effect.\nDo you want to reload now?"] = nil,
["Some settings need to reload the UI to take effect.\nDo you want to reloadUI now?"] = nil, ["Some settings need to reload the UI to take effect.\nDo you want to reloadUI now?"] = nil,
["Sort Bags"] = nil,
["Sort Bank"] = nil,
["Sort Order"] = nil, ["Sort Order"] = nil,
["Soul Shard"] = nil, ["Soul Shard"] = nil,
["Soulshard Counter"] = nil, ["Soulshard Counter"] = nil,
@@ -777,12 +799,14 @@ pfUI_translation["enUS"] = {
["Switch Pages On Alt Key Press"] = nil, ["Switch Pages On Alt Key Press"] = nil,
["Switch Pages On Ctrl Key Press"] = nil, ["Switch Pages On Ctrl Key Press"] = nil,
["Switch Pages On Druid Stealth"] = nil, ["Switch Pages On Druid Stealth"] = nil,
["Switch Pages On Priest Shadowform"] = nil,
["Switch Pages On Shift Key Press"] = nil, ["Switch Pages On Shift Key Press"] = nil,
["Systeminfo"] = nil, ["Systeminfo"] = nil,
["Target"] = nil, ["Target"] = nil,
["Target Castbar"] = nil, ["Target Castbar"] = nil,
["Target Debuff Bar"] = nil, ["Target Debuff Bar"] = nil,
["Target Nameplate Zoom Factor"] = nil, ["Target Nameplate Zoom Factor"] = nil,
["Target Totem"] = nil,
["Target-Target"] = nil, ["Target-Target"] = nil,
["Target-Target-Target"] = nil, ["Target-Target-Target"] = nil,
["Text"] = nil, ["Text"] = nil,
@@ -798,6 +822,9 @@ pfUI_translation["enUS"] = {
["Threshold To Trust Health Estimation"] = nil, ["Threshold To Trust Health Estimation"] = nil,
["Time"] = nil, ["Time"] = nil,
["Timer"] = nil, ["Timer"] = nil,
["Timer Alignment"] = nil,
["Timer X Offset"] = nil,
["Timer Y Offset"] = nil,
["Time Remaining"] = nil, ["Time Remaining"] = nil,
["Timer In Minutes"] = nil, ["Timer In Minutes"] = nil,
["Timestamp Brackets"] = nil, ["Timestamp Brackets"] = nil,
@@ -815,6 +842,7 @@ pfUI_translation["enUS"] = {
["Top Actionbar"] = nil, ["Top Actionbar"] = nil,
["Top Left"] = nil, ["Top Left"] = nil,
["Top Right"] = nil, ["Top Right"] = nil,
["Total"] = nil,
["Total Gold"] = nil, ["Total Gold"] = nil,
["Totem Direction"] = nil, ["Totem Direction"] = nil,
["Totem Icons"] = nil, ["Totem Icons"] = nil,
@@ -877,7 +905,6 @@ pfUI_translation["enUS"] = {
["XP Percentage"] = nil, ["XP Percentage"] = nil,
["Yellow Border On Neutral Units"] = nil, ["Yellow Border On Neutral Units"] = nil,
["Yes"] = nil, ["Yes"] = nil,
["You gain (.+) Mana from Totemic Recall"] = nil,
["You got"] = nil, ["You got"] = nil,
["Your interface is now set up.\n\nFor advanced configuration, just open the |cff33ffccpf|rUI settings via the escape menu or type \"|cffffffaa/pfui|r\" into the chat.\n\n Have a nice trip!\n\n|cffaaaaaa- Shagu"] = nil, ["Your interface is now set up.\n\nFor advanced configuration, just open the |cff33ffccpf|rUI settings via the escape menu or type \"|cffffffaa/pfui|r\" into the chat.\n\n Have a nice trip!\n\n|cffaaaaaa- Shagu"] = nil,
["Your items have been repaired for"] = nil, ["Your items have been repaired for"] = nil,
env/translations_esES.lua
Vendored
+11 -6
View File
@@ -27,7 +27,6 @@ pfUI_translation["esES"] = {
["Always Show Item Comparison"] = "Mostrar siempre la comparativa entre objetos", ["Always Show Item Comparison"] = "Mostrar siempre la comparativa entre objetos",
["Always Show On Target Units"] = "Mostrar siempre en el objectivo", ["Always Show On Target Units"] = "Mostrar siempre en el objectivo",
["Always Show On Units With Missing HP"] = "Mostrar siempre en unidades con falta de salud", ["Always Show On Units With Missing HP"] = "Mostrar siempre en unidades con falta de salud",
["Always Show Self In Raid Frames"] = "Mostrarse siempre a sí mismo en los marcos de banda",
["Always Use 2D Portraits"] = "Usar siempre retratos 2D", ["Always Use 2D Portraits"] = "Usar siempre retratos 2D",
["Ammo Counter"] = "Contador de munición", ["Ammo Counter"] = "Contador de munición",
["Anchor Bags Above Chat"] = nil, ["Anchor Bags Above Chat"] = nil,
@@ -52,10 +51,12 @@ pfUI_translation["esES"] = {
["Auto Sell Grey Items"] = "Vender objetos grises automáticamente", ["Auto Sell Grey Items"] = "Vender objetos grises automáticamente",
["Average Per Hour"] = "Promedio por hora", ["Average Per Hour"] = "Promedio por hora",
["Background Color"] = "Color del fondo", ["Background Color"] = "Color del fondo",
["Bags"] = "Bolsas",
["Bags & Bank"] = "Bolsas y banco", ["Bags & Bank"] = "Bolsas y banco",
["Bags Border Size"] = "Tamaño del borde de las bolsas", ["Bags Border Size"] = "Tamaño del borde de las bolsas",
["Bagslots Per Row"] = "Casillas de la bolsa por fila", ["Bagslots Per Row"] = "Casillas de la bolsa por fila",
["Bagspace"] = "Huecos en las bolsas", ["Bagspace"] = "Huecos en las bolsas",
["Bank"] = "Banco",
["Banker"] = "Banquero", ["Banker"] = "Banquero",
["Bankslots Per Row"] = "Casillas del banco por fila", ["Bankslots Per Row"] = "Casillas del banco por fila",
["Bar Background"] = "Fondo de la barra", ["Bar Background"] = "Fondo de la barra",
@@ -124,6 +125,7 @@ pfUI_translation["esES"] = {
["Click Casting"] = "Lanzamiento al hacer click", ["Click Casting"] = "Lanzamiento al hacer click",
["Clock"] = "Reloj", ["Clock"] = "Reloj",
["Close"] = "Cerrar", ["Close"] = "Cerrar",
["Collapse Empty Slots"] = nil,
["Color"] = nil, ["Color"] = nil,
["Color Buff Stacks"] = "Colorear pilas de beneficios", ["Color Buff Stacks"] = "Colorear pilas de beneficios",
["Color Debuff Stacks"] = "Colorear pilas de perjuicios", ["Color Debuff Stacks"] = "Colorear pilas de perjuicios",
@@ -138,7 +140,6 @@ pfUI_translation["esES"] = {
["Combat Timer"] = "Temporizador de combate", ["Combat Timer"] = "Temporizador de combate",
["Combopoint Height"] = nil, ["Combopoint Height"] = nil,
["Combopoint Width"] = nil, ["Combopoint Width"] = nil,
["Compare Item Base Stats"] = "Comparar estadísticas bases de objetos",
["Components"] = "Componentes", ["Components"] = "Componentes",
["Config UI Settings"] = nil, ["Config UI Settings"] = nil,
["Configuration"] = "Configuración", ["Configuration"] = "Configuración",
@@ -291,7 +292,6 @@ pfUI_translation["esES"] = {
["Enable Mana Ticks"] = "Activar el indicador de pulsos del maná", ["Enable Mana Ticks"] = "Activar el indicador de pulsos del maná",
["Enable Micro Bar"] = "Activar microbarra", ["Enable Micro Bar"] = "Activar microbarra",
["Enable Mouselook With Right Click"] = "Mirar usando el puntero con clic derecho", ["Enable Mouselook With Right Click"] = "Mirar usando el puntero con clic derecho",
["Enable Mouseover Tooltip"] = "Activar la descripción emergente al pasar el puntero",
["Enable Movable Bags"] = "Permitir mover las bolsas", ["Enable Movable Bags"] = "Permitir mover las bolsas",
["Enable Offscreen Frame Positions"] = "Permitir mover los marcos fuera de la pantalla", ["Enable Offscreen Frame Positions"] = "Permitir mover los marcos fuera de la pantalla",
["Enable Overlap"] = "Permitir superposición", ["Enable Overlap"] = "Permitir superposición",
@@ -312,6 +312,7 @@ pfUI_translation["esES"] = {
["Encode"] = "Codificar", ["Encode"] = "Codificar",
["Ended"] = "Terminado", ["Ended"] = "Terminado",
["Energy Color"] = "Color de energía", ["Energy Color"] = "Color de energía",
["Equipped"] = "Equipado",
["Equipped Item Color"] = "Color del objeto equipado", ["Equipped Item Color"] = "Color del objeto equipado",
["Estimate Debuffs"] = "Estimar los perjuicios", ["Estimate Debuffs"] = "Estimar los perjuicios",
["Estimate Enemy Health Points"] = "Estimar los puntos de salud del enemigo", ["Estimate Enemy Health Points"] = "Estimar los puntos de salud del enemigo",
@@ -569,6 +570,7 @@ pfUI_translation["esES"] = {
["Overwrite If Unit Is Attacking Others"] = nil, ["Overwrite If Unit Is Attacking Others"] = nil,
["Overwrite If Unit Is Attacking You"] = nil, ["Overwrite If Unit Is Attacking You"] = nil,
["Overwrite If Unit Is Casting"] = nil, ["Overwrite If Unit Is Casting"] = nil,
["Owner Name"] = nil,
["Pageable"] = "Paginable", ["Pageable"] = "Paginable",
["Paging Actionbar"] = "Paginando la barra de acción", ["Paging Actionbar"] = "Paginando la barra de acción",
["Panel"] = "Panel", ["Panel"] = "Panel",
@@ -616,12 +618,13 @@ pfUI_translation["esES"] = {
["Raid Mark X-Offset"] = nil, ["Raid Mark X-Offset"] = nil,
["Raid Mark Y-Offset"] = nil, ["Raid Mark Y-Offset"] = nil,
["Raid Padding"] = "Espaciado del marco de banda", ["Raid Padding"] = "Espaciado del marco de banda",
["Raid-Pet"] = nil,
["Random"] = "Aleatorio", ["Random"] = "Aleatorio",
["Random Roll Announcement Rarity"] = "Anuncio para tirar los dados aleatoriamente", ["Random Roll Announcement Rarity"] = "Anuncio para tirar los dados aleatoriamente",
["Random Rolling"] = "Tirar los dados aleatoriamente", ["Random Rolling"] = "Tirar los dados aleatoriamente",
["Range Based Hunter Paging"] = "Paginado de alcance para cazadores", ["Range Based Hunter Paging"] = "Paginado de alcance para cazadores",
["Range Check Interval"] = "Intervalo de comprobación de alcance",
["Rank"] = "Rango", ["Rank"] = "Rango",
["Recast Totem"] = nil,
["Red Border On Enemy Units"] = "Borde rojo en unidades enemigas", ["Red Border On Enemy Units"] = "Borde rojo en unidades enemigas",
["Red Name Text On Infight Units"] = nil, ["Red Name Text On Infight Units"] = nil,
["Regional Settings"] = nil, ["Regional Settings"] = nil,
@@ -667,7 +670,6 @@ pfUI_translation["esES"] = {
["Scale"] = "Escala", ["Scale"] = "Escala",
["Scale Border On HiDPI Displays"] = "Escalar los bordes en las pantallas con DPI alto", ["Scale Border On HiDPI Displays"] = "Escalar los bordes en las pantallas con DPI alto",
["Scaling"] = "Escalada", ["Scaling"] = "Escalada",
["Scan Macros For Spells"] = nil,
["Screen Edge Glow Intensity"] = "Intensidad de brillo en los bordes de la pantalla", ["Screen Edge Glow Intensity"] = "Intensidad de brillo en los bordes de la pantalla",
["Screen Resolution"] = "Resolución de pantalla", ["Screen Resolution"] = "Resolución de pantalla",
["Screenshot"] = "Captura de pantalla", ["Screenshot"] = "Captura de pantalla",
@@ -703,6 +705,7 @@ pfUI_translation["esES"] = {
["Show Description"] = "Mostrar descripción", ["Show Description"] = "Mostrar descripción",
["Show Dispel Indicators"] = "Mostrar indicadores para disipar", ["Show Dispel Indicators"] = "Mostrar indicadores para disipar",
["Show Druid Mana Bar"] = nil, ["Show Druid Mana Bar"] = nil,
["Show Druid Mana Bar Text"] = nil,
["Show Duration Inside Buff"] = "Mostrar la duración dentro del beneficios", ["Show Duration Inside Buff"] = "Mostrar la duración dentro del beneficios",
["Show Empty Buttons"] = "Mostrar botones vacíos", ["Show Empty Buttons"] = "Mostrar botones vacíos",
["Show FPS and Latency Colors"] = "Mostrar FPS y colores de latencia", ["Show FPS and Latency Colors"] = "Mostrar FPS y colores de latencia",
@@ -739,6 +742,7 @@ pfUI_translation["esES"] = {
["Show Required Questitem Count"] = "Muestra el número requerido de objetos de misión", ["Show Required Questitem Count"] = "Muestra el número requerido de objetos de misión",
["Show Resting"] = "Mostrar descanso", ["Show Resting"] = "Mostrar descanso",
["Show Self In Group Frames"] = "Mostrar a sí mismo en marcos de grupo", ["Show Self In Group Frames"] = "Mostrar a sí mismo en marcos de grupo",
["Show Self In Raid Frames When Solo"] = nil,
["Show Spell Icon"] = "Mostrar icono de hechizo", ["Show Spell Icon"] = "Mostrar icono de hechizo",
["Show Spell Name"] = nil, ["Show Spell Name"] = nil,
["Show Stacks"] = "Mostrar pilas", ["Show Stacks"] = "Mostrar pilas",
@@ -783,6 +787,7 @@ pfUI_translation["esES"] = {
["Target Castbar"] = "Barra de lanzamiento del objetivo", ["Target Castbar"] = "Barra de lanzamiento del objetivo",
["Target Debuff Bar"] = "Barra de perjuicios del objetivo", ["Target Debuff Bar"] = "Barra de perjuicios del objetivo",
["Target Nameplate Zoom Factor"] = "Factor de zoom de la placa de nombre del objetivo", ["Target Nameplate Zoom Factor"] = "Factor de zoom de la placa de nombre del objetivo",
["Target Totem"] = nil,
["Target-Target"] = "Objetivo-Objetivo", ["Target-Target"] = "Objetivo-Objetivo",
["Target-Target-Target"] = "Objetivo-Objetivo-Objetivo", ["Target-Target-Target"] = "Objetivo-Objetivo-Objetivo",
["Text"] = nil, ["Text"] = nil,
@@ -815,6 +820,7 @@ pfUI_translation["esES"] = {
["Top Actionbar"] = "Barra de acción superior", ["Top Actionbar"] = "Barra de acción superior",
["Top Left"] = "Superior derecha", ["Top Left"] = "Superior derecha",
["Top Right"] = "Superior izquierda", ["Top Right"] = "Superior izquierda",
["Total"] = "Total",
["Total Gold"] = "Oro Total", ["Total Gold"] = "Oro Total",
["Totem Direction"] = "Dirección del tótem", ["Totem Direction"] = "Dirección del tótem",
["Totem Icons"] = "Iconos de los tótems", ["Totem Icons"] = "Iconos de los tótems",
@@ -877,7 +883,6 @@ pfUI_translation["esES"] = {
["XP Percentage"] = "Porcentaje de exp.", ["XP Percentage"] = "Porcentaje de exp.",
["Yellow Border On Neutral Units"] = "Borde amarillo en unidades neutrales", ["Yellow Border On Neutral Units"] = "Borde amarillo en unidades neutrales",
["Yes"] = "Sí", ["Yes"] = "Sí",
["You gain (.+) Mana from Totemic Recall"] = nil,
["You got"] = "Obtienes", ["You got"] = "Obtienes",
["Your interface is now set up.\n\nFor advanced configuration, just open the |cff33ffccpf|rUI settings via the escape menu or type \"|cffffffaa/pfui|r\" into the chat.\n\n Have a nice trip!\n\n|cffaaaaaa- Shagu"] = "Ahora su interfaz está configurada.\n\nPara la configuración avanzada, abra la configuración |cff33ffccpf|rUI por el menú de escape o escriba \"|cffffffaa/pfui|r\" en el chat.", ["Your interface is now set up.\n\nFor advanced configuration, just open the |cff33ffccpf|rUI settings via the escape menu or type \"|cffffffaa/pfui|r\" into the chat.\n\n Have a nice trip!\n\n|cffaaaaaa- Shagu"] = "Ahora su interfaz está configurada.\n\nPara la configuración avanzada, abra la configuración |cff33ffccpf|rUI por el menú de escape o escriba \"|cffffffaa/pfui|r\" en el chat.",
["Your items have been repaired for"] = "Tus objetos se han reparado por", ["Your items have been repaired for"] = "Tus objetos se han reparado por",
env/translations_frFR.lua
Vendored
+11 -6
View File
@@ -27,7 +27,6 @@ pfUI_translation["frFR"] = {
["Always Show Item Comparison"] = "Toujours afficher la comparaison d'objet", ["Always Show Item Comparison"] = "Toujours afficher la comparaison d'objet",
["Always Show On Target Units"] = "Toujours montrer sur la cible", ["Always Show On Target Units"] = "Toujours montrer sur la cible",
["Always Show On Units With Missing HP"] = "Toujours montrer sur les cibles avec de la vie manquante", ["Always Show On Units With Missing HP"] = "Toujours montrer sur les cibles avec de la vie manquante",
["Always Show Self In Raid Frames"] = "Toujours montrer soi-même dans le cadre de raid",
["Always Use 2D Portraits"] = "Toujours utiliser les portraits 2D", ["Always Use 2D Portraits"] = "Toujours utiliser les portraits 2D",
["Ammo Counter"] = "Compteur de munitions", ["Ammo Counter"] = "Compteur de munitions",
["Anchor Bags Above Chat"] = nil, ["Anchor Bags Above Chat"] = nil,
@@ -52,10 +51,12 @@ pfUI_translation["frFR"] = {
["Auto Sell Grey Items"] = "Vente automatique des objets gris", ["Auto Sell Grey Items"] = "Vente automatique des objets gris",
["Average Per Hour"] = "Moyenne par heure", ["Average Per Hour"] = "Moyenne par heure",
["Background Color"] = "Couleur de l'arrière-plan", ["Background Color"] = "Couleur de l'arrière-plan",
["Bags"] = "Sacs",
["Bags & Bank"] = "Sacs et Banque", ["Bags & Bank"] = "Sacs et Banque",
["Bags Border Size"] = "Taille de la bordure des Sacs", ["Bags Border Size"] = "Taille de la bordure des Sacs",
["Bagslots Per Row"] = "Emplacements des sacs par rangée", ["Bagslots Per Row"] = "Emplacements des sacs par rangée",
["Bagspace"] = "Place libre des sacs", ["Bagspace"] = "Place libre des sacs",
["Bank"] = "Banque",
["Banker"] = "Banquier", ["Banker"] = "Banquier",
["Bankslots Per Row"] = "Emplacements de la banque par rangée", ["Bankslots Per Row"] = "Emplacements de la banque par rangée",
["Bar Background"] = "Arrière plan de la barre", ["Bar Background"] = "Arrière plan de la barre",
@@ -124,6 +125,7 @@ pfUI_translation["frFR"] = {
["Click Casting"] = "Clique sur le lancement de sort", ["Click Casting"] = "Clique sur le lancement de sort",
["Clock"] = "Horloge", ["Clock"] = "Horloge",
["Close"] = "Fermer", ["Close"] = "Fermer",
["Collapse Empty Slots"] = nil,
["Color"] = nil, ["Color"] = nil,
["Color Buff Stacks"] = "Couleur des l'empilements des Améliorations", ["Color Buff Stacks"] = "Couleur des l'empilements des Améliorations",
["Color Debuff Stacks"] = "Couleur de l'empilements de Affaiblissements", ["Color Debuff Stacks"] = "Couleur de l'empilements de Affaiblissements",
@@ -138,7 +140,6 @@ pfUI_translation["frFR"] = {
["Combat Timer"] = "Chronomètre de combat", ["Combat Timer"] = "Chronomètre de combat",
["Combopoint Height"] = nil, ["Combopoint Height"] = nil,
["Combopoint Width"] = nil, ["Combopoint Width"] = nil,
["Compare Item Base Stats"] = "Compare les stats de base d'un objet",
["Components"] = "Composants", ["Components"] = "Composants",
["Config UI Settings"] = nil, ["Config UI Settings"] = nil,
["Configuration"] = "Configuration", ["Configuration"] = "Configuration",
@@ -291,7 +292,6 @@ pfUI_translation["frFR"] = {
["Enable Mana Ticks"] = "Activer les Ticks de mana", ["Enable Mana Ticks"] = "Activer les Ticks de mana",
["Enable Micro Bar"] = "Activer la barre des menus miniature", ["Enable Micro Bar"] = "Activer la barre des menus miniature",
["Enable Mouselook With Right Click"] = "Activer le déplacement de la caméra avec le clic droit", ["Enable Mouselook With Right Click"] = "Activer le déplacement de la caméra avec le clic droit",
["Enable Mouseover Tooltip"] = "Activer l'infobulle au passage de la souris",
["Enable Movable Bags"] = "Activer les sacs mobiles", ["Enable Movable Bags"] = "Activer les sacs mobiles",
["Enable Offscreen Frame Positions"] = "Activer le positionnement des cadres en dehors de l'écran", ["Enable Offscreen Frame Positions"] = "Activer le positionnement des cadres en dehors de l'écran",
["Enable Overlap"] = "Activer la superposition", ["Enable Overlap"] = "Activer la superposition",
@@ -312,6 +312,7 @@ pfUI_translation["frFR"] = {
["Encode"] = "Encoder", ["Encode"] = "Encoder",
["Ended"] = "Terminé", ["Ended"] = "Terminé",
["Energy Color"] = "Couleur de l'energie", ["Energy Color"] = "Couleur de l'energie",
["Equipped"] = "Équipé",
["Equipped Item Color"] = "Couleur de l'objet équipé", ["Equipped Item Color"] = "Couleur de l'objet équipé",
["Estimate Debuffs"] = "Estimer les Affaiblissements", ["Estimate Debuffs"] = "Estimer les Affaiblissements",
["Estimate Enemy Health Points"] = "Estimer les points de vie ennemis", ["Estimate Enemy Health Points"] = "Estimer les points de vie ennemis",
@@ -569,6 +570,7 @@ pfUI_translation["frFR"] = {
["Overwrite If Unit Is Attacking Others"] = nil, ["Overwrite If Unit Is Attacking Others"] = nil,
["Overwrite If Unit Is Attacking You"] = nil, ["Overwrite If Unit Is Attacking You"] = nil,
["Overwrite If Unit Is Casting"] = nil, ["Overwrite If Unit Is Casting"] = nil,
["Owner Name"] = nil,
["Pageable"] = "Pageable", ["Pageable"] = "Pageable",
["Paging Actionbar"] = "Barre d'action de pagination", ["Paging Actionbar"] = "Barre d'action de pagination",
["Panel"] = "Panneau", ["Panel"] = "Panneau",
@@ -616,12 +618,13 @@ pfUI_translation["frFR"] = {
["Raid Mark X-Offset"] = nil, ["Raid Mark X-Offset"] = nil,
["Raid Mark Y-Offset"] = nil, ["Raid Mark Y-Offset"] = nil,
["Raid Padding"] = "Remplissage du Raid", ["Raid Padding"] = "Remplissage du Raid",
["Raid-Pet"] = nil,
["Random"] = "Aléatoire", ["Random"] = "Aléatoire",
["Random Roll Announcement Rarity"] = "Rareté des annonces des jets de dés aléatoires", ["Random Roll Announcement Rarity"] = "Rareté des annonces des jets de dés aléatoires",
["Random Rolling"] = "Lancer de dés aléatoires", ["Random Rolling"] = "Lancer de dés aléatoires",
["Range Based Hunter Paging"] = "Pagination de distance basée sur le chasseur", ["Range Based Hunter Paging"] = "Pagination de distance basée sur le chasseur",
["Range Check Interval"] = "Intervalle de vérification de la distance",
["Rank"] = nil, ["Rank"] = nil,
["Recast Totem"] = nil,
["Red Border On Enemy Units"] = "Bordure rouge sur les unités ennemies", ["Red Border On Enemy Units"] = "Bordure rouge sur les unités ennemies",
["Red Name Text On Infight Units"] = nil, ["Red Name Text On Infight Units"] = nil,
["Regional Settings"] = nil, ["Regional Settings"] = nil,
@@ -667,7 +670,6 @@ pfUI_translation["frFR"] = {
["Scale"] = "Échelle", ["Scale"] = "Échelle",
["Scale Border On HiDPI Displays"] = "Échelle de bordure sur les écrans HiDPI", ["Scale Border On HiDPI Displays"] = "Échelle de bordure sur les écrans HiDPI",
["Scaling"] = "Mise à l'échelle", ["Scaling"] = "Mise à l'échelle",
["Scan Macros For Spells"] = nil,
["Screen Edge Glow Intensity"] = nil, ["Screen Edge Glow Intensity"] = nil,
["Screen Resolution"] = "Résolution d'écran", ["Screen Resolution"] = "Résolution d'écran",
["Screenshot"] = "Imprime écran", ["Screenshot"] = "Imprime écran",
@@ -703,6 +705,7 @@ pfUI_translation["frFR"] = {
["Show Description"] = "Afficher les descriptions", ["Show Description"] = "Afficher les descriptions",
["Show Dispel Indicators"] = "Afficher les indicateurs de dissipation", ["Show Dispel Indicators"] = "Afficher les indicateurs de dissipation",
["Show Druid Mana Bar"] = nil, ["Show Druid Mana Bar"] = nil,
["Show Druid Mana Bar Text"] = nil,
["Show Duration Inside Buff"] = "Afficher la durée à l'intérieur des améliorations", ["Show Duration Inside Buff"] = "Afficher la durée à l'intérieur des améliorations",
["Show Empty Buttons"] = "Afficher les boutons vides", ["Show Empty Buttons"] = "Afficher les boutons vides",
["Show FPS and Latency Colors"] = nil, ["Show FPS and Latency Colors"] = nil,
@@ -739,6 +742,7 @@ pfUI_translation["frFR"] = {
["Show Required Questitem Count"] = nil, ["Show Required Questitem Count"] = nil,
["Show Resting"] = "Afficher au repos", ["Show Resting"] = "Afficher au repos",
["Show Self In Group Frames"] = "S'afficher dans les cadres de groupe", ["Show Self In Group Frames"] = "S'afficher dans les cadres de groupe",
["Show Self In Raid Frames When Solo"] = nil,
["Show Spell Icon"] = "Afficher l'icone des sorts", ["Show Spell Icon"] = "Afficher l'icone des sorts",
["Show Spell Name"] = nil, ["Show Spell Name"] = nil,
["Show Stacks"] = "Afficher les empilements", ["Show Stacks"] = "Afficher les empilements",
@@ -783,6 +787,7 @@ pfUI_translation["frFR"] = {
["Target Castbar"] = "Barre d'incantation de la cible", ["Target Castbar"] = "Barre d'incantation de la cible",
["Target Debuff Bar"] = "Barre des affaiblissements de la cible", ["Target Debuff Bar"] = "Barre des affaiblissements de la cible",
["Target Nameplate Zoom Factor"] = "Facteur de zoom du Nameplate de la cible", ["Target Nameplate Zoom Factor"] = "Facteur de zoom du Nameplate de la cible",
["Target Totem"] = nil,
["Target-Target"] = "Cible de la cible", ["Target-Target"] = "Cible de la cible",
["Target-Target-Target"] = "Cible de la cible de la cible", ["Target-Target-Target"] = "Cible de la cible de la cible",
["Text"] = nil, ["Text"] = nil,
@@ -815,6 +820,7 @@ pfUI_translation["frFR"] = {
["Top Actionbar"] = "Barre d'action supérieure", ["Top Actionbar"] = "Barre d'action supérieure",
["Top Left"] = "Haut Gauche", ["Top Left"] = "Haut Gauche",
["Top Right"] = "Haut Droit", ["Top Right"] = "Haut Droit",
["Total"] = "Total",
["Total Gold"] = "Or Total", ["Total Gold"] = "Or Total",
["Totem Direction"] = "Direction des totems", ["Totem Direction"] = "Direction des totems",
["Totem Icons"] = "Icones des totems", ["Totem Icons"] = "Icones des totems",
@@ -877,7 +883,6 @@ pfUI_translation["frFR"] = {
["XP Percentage"] = "Pourcentage de la barre d'expérience", ["XP Percentage"] = "Pourcentage de la barre d'expérience",
["Yellow Border On Neutral Units"] = "Bordure jaune sur les unités neutres", ["Yellow Border On Neutral Units"] = "Bordure jaune sur les unités neutres",
["Yes"] = "Oui", ["Yes"] = "Oui",
["You gain (.+) Mana from Totemic Recall"] = nil,
["You got"] = "Vous avez", ["You got"] = "Vous avez",
["Your interface is now set up.\n\nFor advanced configuration, just open the |cff33ffccpf|rUI settings via the escape menu or type \"|cffffffaa/pfui|r\" into the chat.\n\n Have a nice trip!\n\n|cffaaaaaa- Shagu"] = nil, ["Your interface is now set up.\n\nFor advanced configuration, just open the |cff33ffccpf|rUI settings via the escape menu or type \"|cffffffaa/pfui|r\" into the chat.\n\n Have a nice trip!\n\n|cffaaaaaa- Shagu"] = nil,
["Your items have been repaired for"] = "Vos objets ont été réparés pour", ["Your items have been repaired for"] = "Vos objets ont été réparés pour",
env/translations_koKR.lua
Vendored
+11 -6
View File
@@ -27,7 +27,6 @@ pfUI_translation["koKR"] = {
["Always Show Item Comparison"] = "항상 착용 장비와 비교 표시", ["Always Show Item Comparison"] = "항상 착용 장비와 비교 표시",
["Always Show On Target Units"] = nil, ["Always Show On Target Units"] = nil,
["Always Show On Units With Missing HP"] = nil, ["Always Show On Units With Missing HP"] = nil,
["Always Show Self In Raid Frames"] = nil,
["Always Use 2D Portraits"] = "항상 2D초상화 사용", ["Always Use 2D Portraits"] = "항상 2D초상화 사용",
["Ammo Counter"] = "탄약 갯수", ["Ammo Counter"] = "탄약 갯수",
["Anchor Bags Above Chat"] = nil, ["Anchor Bags Above Chat"] = nil,
@@ -52,10 +51,12 @@ pfUI_translation["koKR"] = {
["Auto Sell Grey Items"] = "회색아이템 자동 판매", ["Auto Sell Grey Items"] = "회색아이템 자동 판매",
["Average Per Hour"] = nil, ["Average Per Hour"] = nil,
["Background Color"] = "백그라운드 색상", ["Background Color"] = "백그라운드 색상",
["Bags"] = "가방",
["Bags & Bank"] = "가방&은행", ["Bags & Bank"] = "가방&은행",
["Bags Border Size"] = "가방 테두리 크기", ["Bags Border Size"] = "가방 테두리 크기",
["Bagslots Per Row"] = nil, ["Bagslots Per Row"] = nil,
["Bagspace"] = "가방 공간", ["Bagspace"] = "가방 공간",
["Bank"] = "은행",
["Banker"] = nil, ["Banker"] = nil,
["Bankslots Per Row"] = nil, ["Bankslots Per Row"] = nil,
["Bar Background"] = nil, ["Bar Background"] = nil,
@@ -124,6 +125,7 @@ pfUI_translation["koKR"] = {
["Click Casting"] = nil, ["Click Casting"] = nil,
["Clock"] = "시계", ["Clock"] = "시계",
["Close"] = "닫기", ["Close"] = "닫기",
["Collapse Empty Slots"] = nil,
["Color"] = nil, ["Color"] = nil,
["Color Buff Stacks"] = nil, ["Color Buff Stacks"] = nil,
["Color Debuff Stacks"] = nil, ["Color Debuff Stacks"] = nil,
@@ -138,7 +140,6 @@ pfUI_translation["koKR"] = {
["Combat Timer"] = "전투 타이머", ["Combat Timer"] = "전투 타이머",
["Combopoint Height"] = nil, ["Combopoint Height"] = nil,
["Combopoint Width"] = nil, ["Combopoint Width"] = nil,
["Compare Item Base Stats"] = nil,
["Components"] = nil, ["Components"] = nil,
["Config UI Settings"] = nil, ["Config UI Settings"] = nil,
["Configuration"] = "구성", ["Configuration"] = "구성",
@@ -291,7 +292,6 @@ pfUI_translation["koKR"] = {
["Enable Mana Ticks"] = nil, ["Enable Mana Ticks"] = nil,
["Enable Micro Bar"] = "미니바 보기(블리자드 마이크로바)", ["Enable Micro Bar"] = "미니바 보기(블리자드 마이크로바)",
["Enable Mouselook With Right Click"] = "오른쪽 클릭 Mouselook 사용", ["Enable Mouselook With Right Click"] = "오른쪽 클릭 Mouselook 사용",
["Enable Mouseover Tooltip"] = nil,
["Enable Movable Bags"] = nil, ["Enable Movable Bags"] = nil,
["Enable Offscreen Frame Positions"] = "오프스크린 프레임 위치 활성화", ["Enable Offscreen Frame Positions"] = "오프스크린 프레임 위치 활성화",
["Enable Overlap"] = "겹쳐서 표시", ["Enable Overlap"] = "겹쳐서 표시",
@@ -312,6 +312,7 @@ pfUI_translation["koKR"] = {
["Encode"] = nil, ["Encode"] = nil,
["Ended"] = nil, ["Ended"] = nil,
["Energy Color"] = nil, ["Energy Color"] = nil,
["Equipped"] = "착용 중",
["Equipped Item Color"] = nil, ["Equipped Item Color"] = nil,
["Estimate Debuffs"] = nil, ["Estimate Debuffs"] = nil,
["Estimate Enemy Health Points"] = nil, ["Estimate Enemy Health Points"] = nil,
@@ -569,6 +570,7 @@ pfUI_translation["koKR"] = {
["Overwrite If Unit Is Attacking Others"] = nil, ["Overwrite If Unit Is Attacking Others"] = nil,
["Overwrite If Unit Is Attacking You"] = nil, ["Overwrite If Unit Is Attacking You"] = nil,
["Overwrite If Unit Is Casting"] = nil, ["Overwrite If Unit Is Casting"] = nil,
["Owner Name"] = nil,
["Pageable"] = nil, ["Pageable"] = nil,
["Paging Actionbar"] = nil, ["Paging Actionbar"] = nil,
["Panel"] = "패널", ["Panel"] = "패널",
@@ -616,12 +618,13 @@ pfUI_translation["koKR"] = {
["Raid Mark X-Offset"] = nil, ["Raid Mark X-Offset"] = nil,
["Raid Mark Y-Offset"] = nil, ["Raid Mark Y-Offset"] = nil,
["Raid Padding"] = nil, ["Raid Padding"] = nil,
["Raid-Pet"] = nil,
["Random"] = nil, ["Random"] = nil,
["Random Roll Announcement Rarity"] = nil, ["Random Roll Announcement Rarity"] = nil,
["Random Rolling"] = nil, ["Random Rolling"] = nil,
["Range Based Hunter Paging"] = nil, ["Range Based Hunter Paging"] = nil,
["Range Check Interval"] = nil,
["Rank"] = nil, ["Rank"] = nil,
["Recast Totem"] = nil,
["Red Border On Enemy Units"] = nil, ["Red Border On Enemy Units"] = nil,
["Red Name Text On Infight Units"] = nil, ["Red Name Text On Infight Units"] = nil,
["Regional Settings"] = nil, ["Regional Settings"] = nil,
@@ -667,7 +670,6 @@ pfUI_translation["koKR"] = {
["Scale"] = nil, ["Scale"] = nil,
["Scale Border On HiDPI Displays"] = nil, ["Scale Border On HiDPI Displays"] = nil,
["Scaling"] = nil, ["Scaling"] = nil,
["Scan Macros For Spells"] = nil,
["Screen Edge Glow Intensity"] = nil, ["Screen Edge Glow Intensity"] = nil,
["Screen Resolution"] = "화면 해상도", ["Screen Resolution"] = "화면 해상도",
["Screenshot"] = nil, ["Screenshot"] = nil,
@@ -703,6 +705,7 @@ pfUI_translation["koKR"] = {
["Show Description"] = nil, ["Show Description"] = nil,
["Show Dispel Indicators"] = nil, ["Show Dispel Indicators"] = nil,
["Show Druid Mana Bar"] = nil, ["Show Druid Mana Bar"] = nil,
["Show Druid Mana Bar Text"] = nil,
["Show Duration Inside Buff"] = nil, ["Show Duration Inside Buff"] = nil,
["Show Empty Buttons"] = nil, ["Show Empty Buttons"] = nil,
["Show FPS and Latency Colors"] = nil, ["Show FPS and Latency Colors"] = nil,
@@ -739,6 +742,7 @@ pfUI_translation["koKR"] = {
["Show Required Questitem Count"] = nil, ["Show Required Questitem Count"] = nil,
["Show Resting"] = nil, ["Show Resting"] = nil,
["Show Self In Group Frames"] = nil, ["Show Self In Group Frames"] = nil,
["Show Self In Raid Frames When Solo"] = nil,
["Show Spell Icon"] = nil, ["Show Spell Icon"] = nil,
["Show Spell Name"] = nil, ["Show Spell Name"] = nil,
["Show Stacks"] = nil, ["Show Stacks"] = nil,
@@ -783,6 +787,7 @@ pfUI_translation["koKR"] = {
["Target Castbar"] = nil, ["Target Castbar"] = nil,
["Target Debuff Bar"] = nil, ["Target Debuff Bar"] = nil,
["Target Nameplate Zoom Factor"] = nil, ["Target Nameplate Zoom Factor"] = nil,
["Target Totem"] = nil,
["Target-Target"] = "대상-대상", ["Target-Target"] = "대상-대상",
["Target-Target-Target"] = nil, ["Target-Target-Target"] = nil,
["Text"] = nil, ["Text"] = nil,
@@ -815,6 +820,7 @@ pfUI_translation["koKR"] = {
["Top Actionbar"] = nil, ["Top Actionbar"] = nil,
["Top Left"] = nil, ["Top Left"] = nil,
["Top Right"] = nil, ["Top Right"] = nil,
["Total"] = "총",
["Total Gold"] = "총 금", ["Total Gold"] = "총 금",
["Totem Direction"] = nil, ["Totem Direction"] = nil,
["Totem Icons"] = nil, ["Totem Icons"] = nil,
@@ -877,7 +883,6 @@ pfUI_translation["koKR"] = {
["XP Percentage"] = "경험치 퍼센트", ["XP Percentage"] = "경험치 퍼센트",
["Yellow Border On Neutral Units"] = nil, ["Yellow Border On Neutral Units"] = nil,
["Yes"] = nil, ["Yes"] = nil,
["You gain (.+) Mana from Totemic Recall"] = nil,
["You got"] = nil, ["You got"] = nil,
["Your interface is now set up.\n\nFor advanced configuration, just open the |cff33ffccpf|rUI settings via the escape menu or type \"|cffffffaa/pfui|r\" into the chat.\n\n Have a nice trip!\n\n|cffaaaaaa- Shagu"] = nil, ["Your interface is now set up.\n\nFor advanced configuration, just open the |cff33ffccpf|rUI settings via the escape menu or type \"|cffffffaa/pfui|r\" into the chat.\n\n Have a nice trip!\n\n|cffaaaaaa- Shagu"] = nil,
["Your items have been repaired for"] = nil, ["Your items have been repaired for"] = nil,
env/translations_ruRU.lua
Vendored
+11 -6
View File
@@ -27,7 +27,6 @@ pfUI_translation["ruRU"] = {
["Always Show Item Comparison"] = "Всегда показывать сравнение предметов", ["Always Show Item Comparison"] = "Всегда показывать сравнение предметов",
["Always Show On Target Units"] = "Всегда показывать над выбранной целью", ["Always Show On Target Units"] = "Всегда показывать над выбранной целью",
["Always Show On Units With Missing HP"] = "Всегда показывать над целями с неполным здоровьем", ["Always Show On Units With Missing HP"] = "Всегда показывать над целями с неполным здоровьем",
["Always Show Self In Raid Frames"] = "Всегда показывать себя в рейде",
["Always Use 2D Portraits"] = "Всегда использовать 2D-портреты", ["Always Use 2D Portraits"] = "Всегда использовать 2D-портреты",
["Ammo Counter"] = "Счетчик боеприпасов", ["Ammo Counter"] = "Счетчик боеприпасов",
["Anchor Bags Above Chat"] = nil, ["Anchor Bags Above Chat"] = nil,
@@ -52,10 +51,12 @@ pfUI_translation["ruRU"] = {
["Auto Sell Grey Items"] = "Автоматическая продажа серых предметов", ["Auto Sell Grey Items"] = "Автоматическая продажа серых предметов",
["Average Per Hour"] = "Среднее за час", ["Average Per Hour"] = "Среднее за час",
["Background Color"] = "Цвет фона", ["Background Color"] = "Цвет фона",
["Bags"] = "Сумки",
["Bags & Bank"] = "Сумки & Банк", ["Bags & Bank"] = "Сумки & Банк",
["Bags Border Size"] = "Размер границы сумок", ["Bags Border Size"] = "Размер границы сумок",
["Bagslots Per Row"] = "Количество ячеек в сумке на строку", ["Bagslots Per Row"] = "Количество ячеек в сумке на строку",
["Bagspace"] = "Место в сумках", ["Bagspace"] = "Место в сумках",
["Bank"] = "Банк",
["Banker"] = "Банкир", ["Banker"] = "Банкир",
["Bankslots Per Row"] = "Количество ячеек в банке на строку", ["Bankslots Per Row"] = "Количество ячеек в банке на строку",
["Bar Background"] = "Фон панели", ["Bar Background"] = "Фон панели",
@@ -124,6 +125,7 @@ pfUI_translation["ruRU"] = {
["Click Casting"] = "Каст по нажатию", ["Click Casting"] = "Каст по нажатию",
["Clock"] = "Часы", ["Clock"] = "Часы",
["Close"] = "Закрыть", ["Close"] = "Закрыть",
["Collapse Empty Slots"] = nil,
["Color"] = nil, ["Color"] = nil,
["Color Buff Stacks"] = "Цвет стаков баффа", ["Color Buff Stacks"] = "Цвет стаков баффа",
["Color Debuff Stacks"] = "Цвет стаков дебаффа", ["Color Debuff Stacks"] = "Цвет стаков дебаффа",
@@ -138,7 +140,6 @@ pfUI_translation["ruRU"] = {
["Combat Timer"] = "Таймер боя", ["Combat Timer"] = "Таймер боя",
["Combopoint Height"] = nil, ["Combopoint Height"] = nil,
["Combopoint Width"] = nil, ["Combopoint Width"] = nil,
["Compare Item Base Stats"] = "Сравнивать базовые характеристики предмета",
["Components"] = "Компоненты", ["Components"] = "Компоненты",
["Config UI Settings"] = "Настройка параметров пользовательского интерфейса", ["Config UI Settings"] = "Настройка параметров пользовательского интерфейса",
["Configuration"] = "Конфигурация", ["Configuration"] = "Конфигурация",
@@ -291,7 +292,6 @@ pfUI_translation["ruRU"] = {
["Enable Mana Ticks"] = "Включить восполнение маны", ["Enable Mana Ticks"] = "Включить восполнение маны",
["Enable Micro Bar"] = "Включить панель микро меню", ["Enable Micro Bar"] = "Включить панель микро меню",
["Enable Mouselook With Right Click"] = "Включить нажатие правой кнопки мыши на индикаторе здоровья", ["Enable Mouselook With Right Click"] = "Включить нажатие правой кнопки мыши на индикаторе здоровья",
["Enable Mouseover Tooltip"] = "Включить подсказку при наведении мыши",
["Enable Movable Bags"] = "Включить подвижные сумки", ["Enable Movable Bags"] = "Включить подвижные сумки",
["Enable Offscreen Frame Positions"] = "Включить расположение окон за пределами экрана", ["Enable Offscreen Frame Positions"] = "Включить расположение окон за пределами экрана",
["Enable Overlap"] = "Включить перекрытие", ["Enable Overlap"] = "Включить перекрытие",
@@ -312,6 +312,7 @@ pfUI_translation["ruRU"] = {
["Encode"] = "Кодировать", ["Encode"] = "Кодировать",
["Ended"] = "Окончание", ["Ended"] = "Окончание",
["Energy Color"] = "Цвет энергии", ["Energy Color"] = "Цвет энергии",
["Equipped"] = "Экипировано",
["Equipped Item Color"] = "Цвет экипированных предметов", ["Equipped Item Color"] = "Цвет экипированных предметов",
["Estimate Debuffs"] = "Оценка дебафов", ["Estimate Debuffs"] = "Оценка дебафов",
["Estimate Enemy Health Points"] = "Оценка очков здоровья врага", ["Estimate Enemy Health Points"] = "Оценка очков здоровья врага",
@@ -569,6 +570,7 @@ pfUI_translation["ruRU"] = {
["Overwrite If Unit Is Attacking Others"] = nil, ["Overwrite If Unit Is Attacking Others"] = nil,
["Overwrite If Unit Is Attacking You"] = nil, ["Overwrite If Unit Is Attacking You"] = nil,
["Overwrite If Unit Is Casting"] = nil, ["Overwrite If Unit Is Casting"] = nil,
["Owner Name"] = nil,
["Pageable"] = "Прокрутка страниц", ["Pageable"] = "Прокрутка страниц",
["Paging Actionbar"] = "Прокрутка панелей", ["Paging Actionbar"] = "Прокрутка панелей",
["Panel"] = "Панель", ["Panel"] = "Панель",
@@ -616,12 +618,13 @@ pfUI_translation["ruRU"] = {
["Raid Mark X-Offset"] = nil, ["Raid Mark X-Offset"] = nil,
["Raid Mark Y-Offset"] = nil, ["Raid Mark Y-Offset"] = nil,
["Raid Padding"] = "Отступ рейда", ["Raid Padding"] = "Отступ рейда",
["Raid-Pet"] = nil,
["Random"] = "Случайно", ["Random"] = "Случайно",
["Random Roll Announcement Rarity"] = "Оповещение случайного броска для качества предмета", ["Random Roll Announcement Rarity"] = "Оповещение случайного броска для качества предмета",
["Random Rolling"] = "Случайный бросок костей для", ["Random Rolling"] = "Случайный бросок костей для",
["Range Based Hunter Paging"] = "[|cffA9D271Охотник|r] Переключение страниц на основе диапазона", ["Range Based Hunter Paging"] = "[|cffA9D271Охотник|r] Переключение страниц на основе диапазона",
["Range Check Interval"] = "Интервал проверки диапазона",
["Rank"] = "Ранг", ["Rank"] = "Ранг",
["Recast Totem"] = nil,
["Red Border On Enemy Units"] = "Красные границы вражеских юнитов", ["Red Border On Enemy Units"] = "Красные границы вражеских юнитов",
["Red Name Text On Infight Units"] = nil, ["Red Name Text On Infight Units"] = nil,
["Regional Settings"] = "Региональные настройки", ["Regional Settings"] = "Региональные настройки",
@@ -667,7 +670,6 @@ pfUI_translation["ruRU"] = {
["Scale"] = "Масштаб", ["Scale"] = "Масштаб",
["Scale Border On HiDPI Displays"] = "Масштабировать границы на HiDPI мониторах", ["Scale Border On HiDPI Displays"] = "Масштабировать границы на HiDPI мониторах",
["Scaling"] = "Масштаб интерфейса", ["Scaling"] = "Масштаб интерфейса",
["Scan Macros For Spells"] = nil,
["Screen Edge Glow Intensity"] = "Интенсивность свечения на краях экрана", ["Screen Edge Glow Intensity"] = "Интенсивность свечения на краях экрана",
["Screen Resolution"] = "Разрешение экрана", ["Screen Resolution"] = "Разрешение экрана",
["Screenshot"] = "Снимок экрана", ["Screenshot"] = "Снимок экрана",
@@ -703,6 +705,7 @@ pfUI_translation["ruRU"] = {
["Show Description"] = "Показать описание", ["Show Description"] = "Показать описание",
["Show Dispel Indicators"] = "Показать индикаторы рассеивания", ["Show Dispel Indicators"] = "Показать индикаторы рассеивания",
["Show Druid Mana Bar"] = nil, ["Show Druid Mana Bar"] = nil,
["Show Druid Mana Bar Text"] = nil,
["Show Duration Inside Buff"] = "Показать продолжительность внутри баффа", ["Show Duration Inside Buff"] = "Показать продолжительность внутри баффа",
["Show Empty Buttons"] = "Показать пустые кнопки", ["Show Empty Buttons"] = "Показать пустые кнопки",
["Show FPS and Latency Colors"] = "Показать частоту кадров и задержку в цвете", ["Show FPS and Latency Colors"] = "Показать частоту кадров и задержку в цвете",
@@ -739,6 +742,7 @@ pfUI_translation["ruRU"] = {
["Show Required Questitem Count"] = "Показать необходимое количество предметов для задания", ["Show Required Questitem Count"] = "Показать необходимое количество предметов для задания",
["Show Resting"] = "Показать иконку отдыха", ["Show Resting"] = "Показать иконку отдыха",
["Show Self In Group Frames"] = "Показать себя в окне группы", ["Show Self In Group Frames"] = "Показать себя в окне группы",
["Show Self In Raid Frames When Solo"] = nil,
["Show Spell Icon"] = "Показать иконку заклинания", ["Show Spell Icon"] = "Показать иконку заклинания",
["Show Spell Name"] = "Показать название заклинания", ["Show Spell Name"] = "Показать название заклинания",
["Show Stacks"] = "Показать стаки", ["Show Stacks"] = "Показать стаки",
@@ -783,6 +787,7 @@ pfUI_translation["ruRU"] = {
["Target Castbar"] = "Панель применения цели", ["Target Castbar"] = "Панель применения цели",
["Target Debuff Bar"] = "Панель дебаффов цели", ["Target Debuff Bar"] = "Панель дебаффов цели",
["Target Nameplate Zoom Factor"] = "Коэффициент увеличения индикатора здоровья цели", ["Target Nameplate Zoom Factor"] = "Коэффициент увеличения индикатора здоровья цели",
["Target Totem"] = nil,
["Target-Target"] = "Цель цели", ["Target-Target"] = "Цель цели",
["Target-Target-Target"] = "Цель цели цели", ["Target-Target-Target"] = "Цель цели цели",
["Text"] = nil, ["Text"] = nil,
@@ -815,6 +820,7 @@ pfUI_translation["ruRU"] = {
["Top Actionbar"] = "Верхняя", ["Top Actionbar"] = "Верхняя",
["Top Left"] = "Сверху слева", ["Top Left"] = "Сверху слева",
["Top Right"] = "Сверху справа", ["Top Right"] = "Сверху справа",
["Total"] = "Всего",
["Total Gold"] = "Всего золота", ["Total Gold"] = "Всего золота",
["Totem Direction"] = "Направление тотемов", ["Totem Direction"] = "Направление тотемов",
["Totem Icons"] = "Иконки тотемов", ["Totem Icons"] = "Иконки тотемов",
@@ -877,7 +883,6 @@ pfUI_translation["ruRU"] = {
["XP Percentage"] = "Процент опыта", ["XP Percentage"] = "Процент опыта",
["Yellow Border On Neutral Units"] = "Желтые границы на нейтральных юнитах", ["Yellow Border On Neutral Units"] = "Желтые границы на нейтральных юнитах",
["Yes"] = "Да", ["Yes"] = "Да",
["You gain (.+) Mana from Totemic Recall"] = nil,
["You got"] = "Вы получили", ["You got"] = "Вы получили",
["Your interface is now set up.\n\nFor advanced configuration, just open the |cff33ffccpf|rUI settings via the escape menu or type \"|cffffffaa/pfui|r\" into the chat.\n\n Have a nice trip!\n\n|cffaaaaaa- Shagu"] = "Теперь ваш интерфейс настроен.\n\nДля расширенной настройки откройте \"Настройки |cff33ffccpf|rUI\" с помощью escape меню или введите \"|cffffffaa/pfui|r\" в чат.\n\nЖелаю хорошего путешествия!\n\n|cffaaaaaa- Shagu", ["Your interface is now set up.\n\nFor advanced configuration, just open the |cff33ffccpf|rUI settings via the escape menu or type \"|cffffffaa/pfui|r\" into the chat.\n\n Have a nice trip!\n\n|cffaaaaaa- Shagu"] = "Теперь ваш интерфейс настроен.\n\nДля расширенной настройки откройте \"Настройки |cff33ffccpf|rUI\" с помощью escape меню или введите \"|cffffffaa/pfui|r\" в чат.\n\nЖелаю хорошего путешествия!\n\n|cffaaaaaa- Shagu",
["Your items have been repaired for"] = "Ваши предметы были отремонтированы за", ["Your items have been repaired for"] = "Ваши предметы были отремонтированы за",
env/translations_zhCN.lua
Vendored
+11 -6
View File
@@ -27,7 +27,6 @@ pfUI_translation["zhCN"] = {
["Always Show Item Comparison"] = "始终显示装备比较（或按SHIFT键）", ["Always Show Item Comparison"] = "始终显示装备比较（或按SHIFT键）",
["Always Show On Target Units"] = "始终在目标单位上显示", ["Always Show On Target Units"] = "始终在目标单位上显示",
["Always Show On Units With Missing HP"] = "始终在未满血单位上显示", ["Always Show On Units With Missing HP"] = "始终在未满血单位上显示",
["Always Show Self In Raid Frames"] = "始终在团队框架中显示自己",
["Always Use 2D Portraits"] = "始终使用2D头像", ["Always Use 2D Portraits"] = "始终使用2D头像",
["Ammo Counter"] = "弹药数量", ["Ammo Counter"] = "弹药数量",
["Anchor Bags Above Chat"] = "将背包锚定在聊天框上方", ["Anchor Bags Above Chat"] = "将背包锚定在聊天框上方",
@@ -52,10 +51,12 @@ pfUI_translation["zhCN"] = {
["Auto Sell Grey Items"] = "自动贩卖灰色物品", ["Auto Sell Grey Items"] = "自动贩卖灰色物品",
["Average Per Hour"] = "平均每小时", ["Average Per Hour"] = "平均每小时",
["Background Color"] = "背景颜色", ["Background Color"] = "背景颜色",
["Bags"] = "背包",
["Bags & Bank"] = "背包和银行", ["Bags & Bank"] = "背包和银行",
["Bags Border Size"] = "背包边框大小", ["Bags Border Size"] = "背包边框大小",
["Bagslots Per Row"] = "每行包裹槽数量", ["Bagslots Per Row"] = "每行包裹槽数量",
["Bagspace"] = "背包空间", ["Bagspace"] = "背包空间",
["Bank"] = "银行",
["Banker"] = "工会银行角色", ["Banker"] = "工会银行角色",
["Bankslots Per Row"] = "每行银行槽数量", ["Bankslots Per Row"] = "每行银行槽数量",
["Bar Background"] = "动作条背景", ["Bar Background"] = "动作条背景",
@@ -124,6 +125,7 @@ pfUI_translation["zhCN"] = {
["Click Casting"] = "点击施法", ["Click Casting"] = "点击施法",
["Clock"] = "时间", ["Clock"] = "时间",
["Close"] = "关闭", ["Close"] = "关闭",
["Collapse Empty Slots"] = nil,
["Color"] = "颜色", ["Color"] = "颜色",
["Color Buff Stacks"] = "Buff堆叠颜色", ["Color Buff Stacks"] = "Buff堆叠颜色",
["Color Debuff Stacks"] = "Debuff堆叠颜色", ["Color Debuff Stacks"] = "Debuff堆叠颜色",
@@ -138,7 +140,6 @@ pfUI_translation["zhCN"] = {
["Combat Timer"] = "战斗计时器", ["Combat Timer"] = "战斗计时器",
["Combopoint Height"] = "连击点高度", ["Combopoint Height"] = "连击点高度",
["Combopoint Width"] = "连击点宽度", ["Combopoint Width"] = "连击点宽度",
["Compare Item Base Stats"] = "基于属性的装备对比",
["Components"] = "组件", ["Components"] = "组件",
["Config UI Settings"] = "界面设置", ["Config UI Settings"] = "界面设置",
["Configuration"] = "配置", ["Configuration"] = "配置",
@@ -291,7 +292,6 @@ pfUI_translation["zhCN"] = {
["Enable Mana Ticks"] = "显示法力值刻度", ["Enable Mana Ticks"] = "显示法力值刻度",
["Enable Micro Bar"] = "显示菜单栏", ["Enable Micro Bar"] = "显示菜单栏",
["Enable Mouselook With Right Click"] = "启动右键移动镜头", ["Enable Mouselook With Right Click"] = "启动右键移动镜头",
["Enable Mouseover Tooltip"] = "启用鼠标悬停工具提示",
["Enable Movable Bags"] = "启用可移动包裹", ["Enable Movable Bags"] = "启用可移动包裹",
["Enable Offscreen Frame Positions"] = "允许本插件所有框体移出屏幕边缘", ["Enable Offscreen Frame Positions"] = "允许本插件所有框体移出屏幕边缘",
["Enable Overlap"] = "叠加显示", ["Enable Overlap"] = "叠加显示",
@@ -312,6 +312,7 @@ pfUI_translation["zhCN"] = {
["Encode"] = "编码", ["Encode"] = "编码",
["Ended"] = "结束", ["Ended"] = "结束",
["Energy Color"] = "能量值颜色", ["Energy Color"] = "能量值颜色",
["Equipped"] = "已装备",
["Equipped Item Color"] = "已装备物品颜色", ["Equipped Item Color"] = "已装备物品颜色",
["Estimate Debuffs"] = "预估Debuffs", ["Estimate Debuffs"] = "预估Debuffs",
["Estimate Enemy Health Points"] = "预估敌人的生命值", ["Estimate Enemy Health Points"] = "预估敌人的生命值",
@@ -569,6 +570,7 @@ pfUI_translation["zhCN"] = {
["Overwrite If Unit Is Attacking Others"] = "如果单位正在攻击其它单位则变色", ["Overwrite If Unit Is Attacking Others"] = "如果单位正在攻击其它单位则变色",
["Overwrite If Unit Is Attacking You"] = "如果单位正在攻击你则变色", ["Overwrite If Unit Is Attacking You"] = "如果单位正在攻击你则变色",
["Overwrite If Unit Is Casting"] = "如果单位正在施法则变色", ["Overwrite If Unit Is Casting"] = "如果单位正在施法则变色",
["Owner Name"] = nil,
["Pageable"] = "可分页", ["Pageable"] = "可分页",
["Paging Actionbar"] = "分页动作条", ["Paging Actionbar"] = "分页动作条",
["Panel"] = "面板", ["Panel"] = "面板",
@@ -616,12 +618,13 @@ pfUI_translation["zhCN"] = {
["Raid Mark X-Offset"] = nil, ["Raid Mark X-Offset"] = nil,
["Raid Mark Y-Offset"] = nil, ["Raid Mark Y-Offset"] = nil,
["Raid Padding"] = "团队填充", ["Raid Padding"] = "团队填充",
["Raid-Pet"] = nil,
["Random"] = "给随机玩家", ["Random"] = "给随机玩家",
["Random Roll Announcement Rarity"] = "随机Roll点稀有度", ["Random Roll Announcement Rarity"] = "随机Roll点稀有度",
["Random Rolling"] = "随机Roll点 物品:", ["Random Rolling"] = "随机Roll点 物品:",
["Range Based Hunter Paging"] = "启用基于范围的自动分页[|cff7fff7f猎人|r]", ["Range Based Hunter Paging"] = "启用基于范围的自动分页[|cff7fff7f猎人|r]",
["Range Check Interval"] = "范围检查间隔",
["Rank"] = "军衔", ["Rank"] = "军衔",
["Recast Totem"] = nil,
["Red Border On Enemy Units"] = "显示敌方单位红色边框", ["Red Border On Enemy Units"] = "显示敌方单位红色边框",
["Red Name Text On Infight Units"] = "进战斗的单位显示红色姓名", ["Red Name Text On Infight Units"] = "进战斗的单位显示红色姓名",
["Regional Settings"] = "区域设置", ["Regional Settings"] = "区域设置",
@@ -667,7 +670,6 @@ pfUI_translation["zhCN"] = {
["Scale"] = "比例", ["Scale"] = "比例",
["Scale Border On HiDPI Displays"] = "缩放高DPI显示器上的边框", ["Scale Border On HiDPI Displays"] = "缩放高DPI显示器上的边框",
["Scaling"] = "UI缩放", ["Scaling"] = "UI缩放",
["Scan Macros For Spells"] = "扫描宏命令中的法术",
["Screen Edge Glow Intensity"] = "屏幕边缘发光强度", ["Screen Edge Glow Intensity"] = "屏幕边缘发光强度",
["Screen Resolution"] = "屏幕分辨率", ["Screen Resolution"] = "屏幕分辨率",
["Screenshot"] = "屏幕截图", ["Screenshot"] = "屏幕截图",
@@ -703,6 +705,7 @@ pfUI_translation["zhCN"] = {
["Show Description"] = "显示描述", ["Show Description"] = "显示描述",
["Show Dispel Indicators"] = "显示驱散指示器", ["Show Dispel Indicators"] = "显示驱散指示器",
["Show Druid Mana Bar"] = "显示德鲁伊法力条", ["Show Druid Mana Bar"] = "显示德鲁伊法力条",
["Show Druid Mana Bar Text"] = nil,
["Show Duration Inside Buff"] = "显示持续时间在Buff里面", ["Show Duration Inside Buff"] = "显示持续时间在Buff里面",
["Show Empty Buttons"] = "显示空按钮", ["Show Empty Buttons"] = "显示空按钮",
["Show FPS and Latency Colors"] = "显示帧数以及延迟颜色", ["Show FPS and Latency Colors"] = "显示帧数以及延迟颜色",
@@ -740,6 +743,7 @@ pfUI_translation["zhCN"] = {
["Show Required Questitem Count"] = "显示所需的任务物品计数", ["Show Required Questitem Count"] = "显示所需的任务物品计数",
["Show Resting"] = "显示休息图标", ["Show Resting"] = "显示休息图标",
["Show Self In Group Frames"] = "在队伍框架中显示自己", ["Show Self In Group Frames"] = "在队伍框架中显示自己",
["Show Self In Raid Frames When Solo"] = nil,
["Show Spell Icon"] = "显示技能图标", ["Show Spell Icon"] = "显示技能图标",
["Show Spell Name"] = "显示技能名称", ["Show Spell Name"] = "显示技能名称",
["Show Stacks"] = "显示堆叠", ["Show Stacks"] = "显示堆叠",
@@ -784,6 +788,7 @@ pfUI_translation["zhCN"] = {
["Target Castbar"] = "目标施法条", ["Target Castbar"] = "目标施法条",
["Target Debuff Bar"] = "目标Debuffs条", ["Target Debuff Bar"] = "目标Debuffs条",
["Target Nameplate Zoom Factor"] = "目标姓名板缩放系数", ["Target Nameplate Zoom Factor"] = "目标姓名板缩放系数",
["Target Totem"] = nil,
["Target-Target"] = "目标的目标", ["Target-Target"] = "目标的目标",
["Target-Target-Target"] = "目标的目标的目标", ["Target-Target-Target"] = "目标的目标的目标",
["Text"] = "文本", ["Text"] = "文本",
@@ -816,6 +821,7 @@ pfUI_translation["zhCN"] = {
["Top Actionbar"] = "上方动作条", ["Top Actionbar"] = "上方动作条",
["Top Left"] = "左上方", ["Top Left"] = "左上方",
["Top Right"] = "右上方", ["Top Right"] = "右上方",
["Total"] = "总计",
["Total Gold"] = "总黄金", ["Total Gold"] = "总黄金",
["Totem Direction"] = "图腾方向", ["Totem Direction"] = "图腾方向",
["Totem Icons"] = "图腾图标", ["Totem Icons"] = "图腾图标",
@@ -878,7 +884,6 @@ pfUI_translation["zhCN"] = {
["XP Percentage"] = "经验百分比", ["XP Percentage"] = "经验百分比",
["Yellow Border On Neutral Units"] = "显示中立单位黄色边框", ["Yellow Border On Neutral Units"] = "显示中立单位黄色边框",
["Yes"] = "是", ["Yes"] = "是",
["You gain (.+) Mana from Totemic Recall"] = "你从图腾召回获得了(.+)点法力值",
["You got"] = "你已得到", ["You got"] = "你已得到",
["Your interface is now set up.\n\nFor advanced configuration, just open the |cff33ffccpf|rUI settings via the escape menu or type \"|cffffffaa/pfui|r\" into the chat.\n\n Have a nice trip!\n\n|cffaaaaaa- Shagu"] = "你的界面现在已经完成设置.高级设置请点击游戏菜单或者输入命令/pfui进行设置.祝您游戏愉快", ["Your interface is now set up.\n\nFor advanced configuration, just open the |cff33ffccpf|rUI settings via the escape menu or type \"|cffffffaa/pfui|r\" into the chat.\n\n Have a nice trip!\n\n|cffaaaaaa- Shagu"] = "你的界面现在已经完成设置.高级设置请点击游戏菜单或者输入命令/pfui进行设置.祝您游戏愉快",
["Your items have been repaired for"] = "你的物品已经修好了", ["Your items have been repaired for"] = "你的物品已经修好了",
env/translations_zhTW.lua
Vendored
+11 -6
View File
@@ -27,7 +27,6 @@ pfUI_translation["zhTW"] = {
["Always Show Item Comparison"] = "始終顯示裝備比較", ["Always Show Item Comparison"] = "始終顯示裝備比較",
["Always Show On Target Units"] = nil, ["Always Show On Target Units"] = nil,
["Always Show On Units With Missing HP"] = nil, ["Always Show On Units With Missing HP"] = nil,
["Always Show Self In Raid Frames"] = nil,
["Always Use 2D Portraits"] = "始終使用2D頭像", ["Always Use 2D Portraits"] = "始終使用2D頭像",
["Ammo Counter"] = "彈藥數量", ["Ammo Counter"] = "彈藥數量",
["Anchor Bags Above Chat"] = nil, ["Anchor Bags Above Chat"] = nil,
@@ -52,10 +51,12 @@ pfUI_translation["zhTW"] = {
["Auto Sell Grey Items"] = "自動販賣灰色物品", ["Auto Sell Grey Items"] = "自動販賣灰色物品",
["Average Per Hour"] = "平均每小時", ["Average Per Hour"] = "平均每小時",
["Background Color"] = "背景顏色", ["Background Color"] = "背景顏色",
["Bags"] = "背包",
["Bags & Bank"] = "背包和銀行", ["Bags & Bank"] = "背包和銀行",
["Bags Border Size"] = "背包邊框大小", ["Bags Border Size"] = "背包邊框大小",
["Bagslots Per Row"] = "每行包裹槽數量", ["Bagslots Per Row"] = "每行包裹槽數量",
["Bagspace"] = "背包空間", ["Bagspace"] = "背包空間",
["Bank"] = "銀行",
["Banker"] = "工會銀行角色", ["Banker"] = "工會銀行角色",
["Bankslots Per Row"] = "每行銀行槽數量", ["Bankslots Per Row"] = "每行銀行槽數量",
["Bar Background"] = nil, ["Bar Background"] = nil,
@@ -124,6 +125,7 @@ pfUI_translation["zhTW"] = {
["Click Casting"] = nil, ["Click Casting"] = nil,
["Clock"] = "時間", ["Clock"] = "時間",
["Close"] = "關閉", ["Close"] = "關閉",
["Collapse Empty Slots"] = nil,
["Color"] = nil, ["Color"] = nil,
["Color Buff Stacks"] = nil, ["Color Buff Stacks"] = nil,
["Color Debuff Stacks"] = nil, ["Color Debuff Stacks"] = nil,
@@ -138,7 +140,6 @@ pfUI_translation["zhTW"] = {
["Combat Timer"] = "戰鬥計時器", ["Combat Timer"] = "戰鬥計時器",
["Combopoint Height"] = nil, ["Combopoint Height"] = nil,
["Combopoint Width"] = nil, ["Combopoint Width"] = nil,
["Compare Item Base Stats"] = "基於屬性的裝備對比",
["Components"] = "組件", ["Components"] = "組件",
["Config UI Settings"] = nil, ["Config UI Settings"] = nil,
["Configuration"] = "配置", ["Configuration"] = "配置",
@@ -291,7 +292,6 @@ pfUI_translation["zhTW"] = {
["Enable Mana Ticks"] = nil, ["Enable Mana Ticks"] = nil,
["Enable Micro Bar"] = "顯示功能表列", ["Enable Micro Bar"] = "顯示功能表列",
["Enable Mouselook With Right Click"] = "啟動右鍵移動鏡頭", ["Enable Mouselook With Right Click"] = "啟動右鍵移動鏡頭",
["Enable Mouseover Tooltip"] = "啟用滑鼠懸停工具提示",
["Enable Movable Bags"] = "啟用可移動包裹", ["Enable Movable Bags"] = "啟用可移動包裹",
["Enable Offscreen Frame Positions"] = "啟用螢幕框架固定", ["Enable Offscreen Frame Positions"] = "啟用螢幕框架固定",
["Enable Overlap"] = "疊加顯示", ["Enable Overlap"] = "疊加顯示",
@@ -312,6 +312,7 @@ pfUI_translation["zhTW"] = {
["Encode"] = "編碼", ["Encode"] = "編碼",
["Ended"] = nil, ["Ended"] = nil,
["Energy Color"] = nil, ["Energy Color"] = nil,
["Equipped"] = "已裝備",
["Equipped Item Color"] = nil, ["Equipped Item Color"] = nil,
["Estimate Debuffs"] = nil, ["Estimate Debuffs"] = nil,
["Estimate Enemy Health Points"] = nil, ["Estimate Enemy Health Points"] = nil,
@@ -569,6 +570,7 @@ pfUI_translation["zhTW"] = {
["Overwrite If Unit Is Attacking Others"] = "如果单位正在攻擊其它单位則覆蓋", ["Overwrite If Unit Is Attacking Others"] = "如果单位正在攻擊其它单位則覆蓋",
["Overwrite If Unit Is Attacking You"] = "如果单位正在攻擊你則覆蓋", ["Overwrite If Unit Is Attacking You"] = "如果单位正在攻擊你則覆蓋",
["Overwrite If Unit Is Casting"] = "如果单位正在施法則覆蓋", ["Overwrite If Unit Is Casting"] = "如果单位正在施法則覆蓋",
["Owner Name"] = nil,
["Pageable"] = nil, ["Pageable"] = nil,
["Paging Actionbar"] = nil, ["Paging Actionbar"] = nil,
["Panel"] = "面板", ["Panel"] = "面板",
@@ -616,12 +618,13 @@ pfUI_translation["zhTW"] = {
["Raid Mark X-Offset"] = nil, ["Raid Mark X-Offset"] = nil,
["Raid Mark Y-Offset"] = nil, ["Raid Mark Y-Offset"] = nil,
["Raid Padding"] = nil, ["Raid Padding"] = nil,
["Raid-Pet"] = nil,
["Random"] = "給隨機玩家", ["Random"] = "給隨機玩家",
["Random Roll Announcement Rarity"] = "隨機Roll點公示稀有度", ["Random Roll Announcement Rarity"] = "隨機Roll點公示稀有度",
["Random Rolling"] = "隨機Roll點 物品:", ["Random Rolling"] = "隨機Roll點 物品:",
["Range Based Hunter Paging"] = nil, ["Range Based Hunter Paging"] = nil,
["Range Check Interval"] = "範圍檢查間隔",
["Rank"] = nil, ["Rank"] = nil,
["Recast Totem"] = nil,
["Red Border On Enemy Units"] = nil, ["Red Border On Enemy Units"] = nil,
["Red Name Text On Infight Units"] = nil, ["Red Name Text On Infight Units"] = nil,
["Regional Settings"] = nil, ["Regional Settings"] = nil,
@@ -667,7 +670,6 @@ pfUI_translation["zhTW"] = {
["Scale"] = "比例", ["Scale"] = "比例",
["Scale Border On HiDPI Displays"] = nil, ["Scale Border On HiDPI Displays"] = nil,
["Scaling"] = nil, ["Scaling"] = nil,
["Scan Macros For Spells"] = nil,
["Screen Edge Glow Intensity"] = nil, ["Screen Edge Glow Intensity"] = nil,
["Screen Resolution"] = "螢幕解析度", ["Screen Resolution"] = "螢幕解析度",
["Screenshot"] = nil, ["Screenshot"] = nil,
@@ -703,6 +705,7 @@ pfUI_translation["zhTW"] = {
["Show Description"] = nil, ["Show Description"] = nil,
["Show Dispel Indicators"] = nil, ["Show Dispel Indicators"] = nil,
["Show Druid Mana Bar"] = nil, ["Show Druid Mana Bar"] = nil,
["Show Druid Mana Bar Text"] = nil,
["Show Duration Inside Buff"] = "顯示持續時間在Buff裏面", ["Show Duration Inside Buff"] = "顯示持續時間在Buff裏面",
["Show Empty Buttons"] = nil, ["Show Empty Buttons"] = nil,
["Show FPS and Latency Colors"] = nil, ["Show FPS and Latency Colors"] = nil,
@@ -739,6 +742,7 @@ pfUI_translation["zhTW"] = {
["Show Required Questitem Count"] = nil, ["Show Required Questitem Count"] = nil,
["Show Resting"] = nil, ["Show Resting"] = nil,
["Show Self In Group Frames"] = nil, ["Show Self In Group Frames"] = nil,
["Show Self In Raid Frames When Solo"] = nil,
["Show Spell Icon"] = nil, ["Show Spell Icon"] = nil,
["Show Spell Name"] = nil, ["Show Spell Name"] = nil,
["Show Stacks"] = nil, ["Show Stacks"] = nil,
@@ -783,6 +787,7 @@ pfUI_translation["zhTW"] = {
["Target Castbar"] = nil, ["Target Castbar"] = nil,
["Target Debuff Bar"] = nil, ["Target Debuff Bar"] = nil,
["Target Nameplate Zoom Factor"] = nil, ["Target Nameplate Zoom Factor"] = nil,
["Target Totem"] = nil,
["Target-Target"] = "目標的目標", ["Target-Target"] = "目標的目標",
["Target-Target-Target"] = nil, ["Target-Target-Target"] = nil,
["Text"] = nil, ["Text"] = nil,
@@ -815,6 +820,7 @@ pfUI_translation["zhTW"] = {
["Top Actionbar"] = nil, ["Top Actionbar"] = nil,
["Top Left"] = "左上方", ["Top Left"] = "左上方",
["Top Right"] = "右上方", ["Top Right"] = "右上方",
["Total"] = "全部",
["Total Gold"] = "總金量", ["Total Gold"] = "總金量",
["Totem Direction"] = nil, ["Totem Direction"] = nil,
["Totem Icons"] = nil, ["Totem Icons"] = nil,
@@ -877,7 +883,6 @@ pfUI_translation["zhTW"] = {
["XP Percentage"] = "經驗百分比", ["XP Percentage"] = "經驗百分比",
["Yellow Border On Neutral Units"] = nil, ["Yellow Border On Neutral Units"] = nil,
["Yes"] = nil, ["Yes"] = nil,
["You gain (.+) Mana from Totemic Recall"] = nil,
["You got"] = nil, ["You got"] = nil,
["Your interface is now set up.\n\nFor advanced configuration, just open the |cff33ffccpf|rUI settings via the escape menu or type \"|cffffffaa/pfui|r\" into the chat.\n\n Have a nice trip!\n\n|cffaaaaaa- Shagu"] = "您的UI已經設置完畢.使用遊戲菜單或在聊天窗口輸入\"|cffffffaa/pfui|r\"開啟高級設置.祝您遊戲愉快！\n\n|cffaaaaaa- Shagu", ["Your interface is now set up.\n\nFor advanced configuration, just open the |cff33ffccpf|rUI settings via the escape menu or type \"|cffffffaa/pfui|r\" into the chat.\n\n Have a nice trip!\n\n|cffaaaaaa- Shagu"] = "您的UI已經設置完畢.使用遊戲菜單或在聊天窗口輸入\"|cffffffaa/pfui|r\"開啟高級設置.祝您遊戲愉快！\n\n|cffaaaaaa- Shagu",
["Your items have been repaired for"] = "你的物品已經修好了", ["Your items have been repaired for"] = "你的物品已經修好了",
init/libs.xml
-2
View File
@@ -4,9 +4,7 @@
<Include file="..\libs\libdebuff.lua"/> <Include file="..\libs\libdebuff.lua"/>
<Include file="..\libs\librange.lua"/> <Include file="..\libs\librange.lua"/>
<Include file="..\libs\libunitscan.lua"/> <Include file="..\libs\libunitscan.lua"/>
<Include file="..\libs\libtooltip.lua"/>
<Include file="..\libs\libhealth.lua"/> <Include file="..\libs\libhealth.lua"/>
<Include file="..\libs\libtotem.lua"/>
<Include file="..\libs\libthrottle.lua"/> <Include file="..\libs\libthrottle.lua"/>
<Include file="..\libs\libpredict.lua"/> <Include file="..\libs\libpredict.lua"/>
<Include file="..\libs\libbagsort.lua"/> <Include file="..\libs\libbagsort.lua"/>
init/modules.xml
+4 -2
View File
@@ -70,12 +70,14 @@
<Include file="..\modules\addoncompat.lua"/> <Include file="..\modules\addoncompat.lua"/>
<Include file="..\modules\energytick.lua"/> <Include file="..\modules\energytick.lua"/>
<Include file="..\modules\totems.lua"/> <Include file="..\modules\totems.lua"/>
<Include file="..\modules\macrotweak.lua"/> <Include file="..\modules\macroicons.lua"/>
<Include file="..\modules\turtle-wow.lua"/>
<Include file="..\modules\superwow.lua"/> <Include file="..\modules\superwow.lua"/>
<Include file="..\modules\innervatecall.lua"/> <Include file="..\modules\innervatecall.lua"/>
<Include file="..\modules\nampower.lua"/> <Include file="..\modules\nampower.lua"/>
<Include file="..\modules\unitxp.lua"/> <Include file="..\modules\unitxp.lua"/>
<Include file="..\modules\bgscore.lua"/> <Include file="..\modules\bgscore.lua"/>
<Include file="..\modules\equipmentmanager.lua"/> <Include file="..\modules\equipmentmanager.lua"/>
<Include file="..\modules\loothistory.lua"/>
<Include file="..\modules\newitem.lua"/>
<Include file="..\modules\friendnotes.lua"/>
</Ui> </Ui>
init/skins.xml
+2 -9
View File
@@ -1,5 +1,6 @@
<Ui xmlns="http://www.blizzard.com/wow/ui/"> <Ui xmlns="http://www.blizzard.com/wow/ui/">
<Include file="..\skins\blizzard\character.lua"/> <Include file="..\skins\blizzard\character.lua"/>
<Include file="..\skins\blizzard\inspect.lua"/>
<Include file="..\skins\blizzard\spellbook.lua"/> <Include file="..\skins\blizzard\spellbook.lua"/>
<Include file="..\skins\blizzard\friends.lua"/> <Include file="..\skins\blizzard\friends.lua"/>
<Include file="..\skins\blizzard\talents.lua"/> <Include file="..\skins\blizzard\talents.lua"/>
@@ -34,14 +35,6 @@
<Include file="..\skins\blizzard\tooltips.lua"/> <Include file="..\skins\blizzard\tooltips.lua"/>
<Include file="..\skins\blizzard\tabard.lua"/> <Include file="..\skins\blizzard\tabard.lua"/>
<Include file="..\skins\blizzard\itemtext.lua"/> <Include file="..\skins\blizzard\itemtext.lua"/>
<Include file="..\skins\blizzard\lft.lua"/>
<Include file="..\skins\blizzard\turtle_shop.lua"/>
<!-- Turtle WoW -->
<Include file="..\skins\blizzard\barbershop.lua"/>
<Include file="..\skins\blizzard\transmog.lua"/>
<Include file="..\skins\blizzard\custom_merchant.lua"/>
<Include file="..\skins\blizzard\arena_score.lua"/>
<Include file="..\skins\blizzard\ebc.lua"/>
<!-- Turtle WoW skins live in init\turtle.xml (pfUI_Turtle.toc only). -->
</Ui> </Ui>
init/compat.xml → init/stock.xml
+1 -1
View File
@@ -1,3 +1,3 @@
<Ui xmlns="http://www.blizzard.com/wow/ui/"> <Ui xmlns="http://www.blizzard.com/wow/ui/">
<Include file="..\compat\vanilla.lua"/> <Include file="..\env\tables_stock.lua"/>
</Ui> </Ui>
init/turtle.xml
+14
View File
@@ -0,0 +1,14 @@
<Ui xmlns="http://www.blizzard.com/wow/ui/">
<!-- Turtle WoW only: pulled in by pfUI_Turtle.toc, which ClassicAPI selects
when it detects a Turtle client. Everything in here targets frames that
only a Turtle client ever creates. -->
<Include file="..\env\tables_turtle.lua"/>
<Include file="..\skins\blizzard\lft.lua"/>
<Include file="..\skins\blizzard\turtle_shop.lua"/>
<Include file="..\skins\blizzard\barbershop.lua"/>
<Include file="..\skins\blizzard\transmog.lua"/>
<Include file="..\skins\blizzard\ebc.lua"/>
<Include file="..\modules\turtle-wow.lua"/>
</Ui>
libs/libbagsort.lua
+123 -63
View File
@@ -11,26 +11,27 @@ pfUI.api.libbagsort = libbagsort
libbagsort.itemGrid = {} libbagsort.itemGrid = {}
libbagsort.bagList = nil libbagsort.bagList = nil
local HEARTHSTONE_ITEM_ID = 6948 local ItemClass = Enum.ItemClass
local ItemQuality = Enum.ItemQuality
-- Lower prefix = sorted earlier in the bag. -- Lower prefix = sorted earlier in the bag.
local function SortCategoryPrefix(itemId, itemType, itemSubType, quality) local function SortCategoryPrefix(itemId, classID, quality)
if itemId == HEARTHSTONE_ITEM_ID then return "00" end if itemId == HEARTHSTONE_ITEM_ID then return "00" end
if quality == 0 then return "13" end -- Poor (gray) always last if quality == ItemQuality.Poor then return "13" end -- gray always last
if itemType == "Weapon" or itemType == "Armor" then if classID == ItemClass.Weapon or classID == ItemClass.Armor then
if quality and quality >= 4 then return "01" end -- Epic+ gear if quality and quality >= ItemQuality.Epic then return "01" end -- Epic+ gear
if quality == 3 then return "02" end -- Rare gear if quality == ItemQuality.Rare then return "02" end -- Rare gear
if quality == 2 then return "03" end -- Uncommon gear if quality == ItemQuality.Uncommon then return "03" end -- Uncommon gear
return "04" -- Common/poor gear return "04" -- Common/poor gear
end end
if itemType == "Consumable" then return "05" end if classID == ItemClass.Consumable then return "05" end
if itemType == "Reagent" then return "06" end if classID == ItemClass.Reagent then return "06" end
if itemType == "Trade Goods" then return "07" end if classID == ItemClass.Tradegoods then return "07" end
if itemType == "Quest" then return "08" end if classID == ItemClass.Questitem then return "08" end
-- Non-gear items without a specific type, sorted by quality -- Non-gear items without a specific type, sorted by quality
if quality and quality >= 4 then return "09" end if quality and quality >= ItemQuality.Epic then return "09" end
if quality == 3 then return "10" end if quality == ItemQuality.Rare then return "10" end
if quality == 2 then return "11" end if quality == ItemQuality.Uncommon then return "11" end
return "12" return "12"
end end
@@ -41,18 +42,31 @@ local function SortCountSuffix(count)
return string.sub(s, -6) return string.sub(s, -6)
end end
local function SortKey(itemId, name, itype, subtype, quality, count) local function SortKey(itemId, name, classID, subClassID, quality, count)
return SortCategoryPrefix(itemId, itype, subtype, quality) -- Zero-pad the class/subclass so the secondary grouping sorts numerically
.. (itype or "") .. "|" .. (subtype or "") .. "|" .. (name or "zzz") .. "|" .. SortCountSuffix(count) -- (as a string, "10" would otherwise precede "2").
return SortCategoryPrefix(itemId, classID, quality)
.. string.format("%02d|%02d|", classID or 99, subClassID or 99)
.. (name or "zzz") .. "|" .. SortCountSuffix(count)
end end
local function ClearSortData() local function ClearSortData()
libbagsort.itemGrid = {} libbagsort.itemGrid = {}
libbagsort.bagList = nil libbagsort.bagList = nil
libbagsort.opts = nil
libbagsort:UnregisterEvent("BAG_UPDATE_DELAYED") libbagsort:UnregisterEvent("BAG_UPDATE_DELAYED")
libbagsort:SetScript("OnEvent", nil) libbagsort:SetScript("OnEvent", nil)
end end
local function ReverseArray(t)
local i, j = 1, table.getn(t)
while i < j do
t[i], t[j] = t[j], t[i]
i = i + 1
j = j - 1
end
end
-- Two-pointer consolidation: sorts stacks largest-first, then merges from -- Two-pointer consolidation: sorts stacks largest-first, then merges from
-- both ends toward the middle. n is set explicitly so table.getn / table.sort -- both ends toward the middle. n is set explicitly so table.getn / table.sort
-- work correctly in Lua 5.0. -- work correctly in Lua 5.0.
@@ -112,36 +126,61 @@ local function BuildConsolidateOps(bagList)
return ops return ops
end end
-- Bag family bitmask (1 << (familyID-1)); 0 = general-purpose (holds
-- anything). Backpack (0) and bank (-1) are always general. A specialty
-- bag's family comes from the equipped bag item -- ClassicAPI derives it
-- from the container subclass when the raw field is empty (Turtle leaves
-- bags' m_bagFamily at 0), so quivers/soul/profession bags report properly.
local function BagFamily(bag)
if bag == 0 or bag == -1 then return 0 end
local id = GetInventoryItemID("player", ContainerIDToInventoryID(bag))
return id and C_Item.GetItemFamily(id) or 0
end
local function BuildSortGrid() local function BuildSortGrid()
local bagList = libbagsort.bagList local bagList = libbagsort.bagList
libbagsort.itemGrid = {} libbagsort.itemGrid = {}
local normalItems = {} local normalItems = {}
local poorItems = {} local poorItems = {}
local bagCount = 0
local bagSlots = {} -- Destination cells, split by the family they can accept. A specialty
-- bag's slots only take items of its own family; general slots take
-- anything. Cells are collected in forward order (bag order, slot 1..n).
local generalCells = {} -- { {bag=,slot=}, ... }
local specialtyCells = {} -- family -> { {bag=,slot=}, ... }
for _, bag in ipairs(bagList) do for _, bag in ipairs(bagList) do
bagCount = bagCount + 1 local fam = BagFamily(bag)
local numSlots = GetContainerNumSlots(bag) local numSlots = GetContainerNumSlots(bag)
bagSlots[bagCount] = numSlots
if numSlots > 0 then if numSlots > 0 then
libbagsort.itemGrid[bag] = {} libbagsort.itemGrid[bag] = {}
for slot = 1, numSlots do for slot = 1, numSlots do
if fam == 0 then
tinsert(generalCells, {bag=bag, slot=slot})
else
specialtyCells[fam] = specialtyCells[fam] or {}
tinsert(specialtyCells[fam], {bag=bag, slot=slot})
end
local itemId = C_Container.GetContainerItemID(bag, slot) local itemId = C_Container.GetContainerItemID(bag, slot)
if itemId then if itemId then
-- pfUI's compat layer shims GetItemInfo to the modern 10-field -- C_Item.GetItemInfo is the full 18-field tuple; classID/subClassID
-- signature (inserts nil for itemLevel between quality and -- sit at positions 12/13. We categorize on those numeric class IDs
-- minlevel) — so itype/subtype sit at positions 6/7, not 5/6. -- rather than the localized itemType/itemSubType strings. (pfUI's
local name, _, quality, _, _, itype, subtype = GetItemInfo(itemId) -- shimmed global GetItemInfo is only 10 fields and lacks them.)
local name, _, quality, _, _, _, _, _, _, _, _, classID, subClassID = C_Item.GetItemInfo(itemId)
local _, count = GetContainerItemInfo(bag, slot) local _, count = GetContainerItemInfo(bag, slot)
local item = { local item = {
key = SortKey(itemId, name, itype, subtype, quality, count), key = SortKey(itemId, name, classID, subClassID, quality, count),
-- vanilla items carry at most one family bit, so equality
-- against a bag family suffices (no bit.band needed).
family = C_Item.GetItemFamily(itemId) or 0,
srcBag = bag, srcBag = bag,
srcSlot = slot, srcSlot = slot,
curBag = bag, curBag = bag,
curSlot = slot, curSlot = slot,
} }
if quality == 0 then if quality == ItemQuality.Poor then
tinsert(poorItems, item) tinsert(poorItems, item)
else else
tinsert(normalItems, item) tinsert(normalItems, item)
@@ -152,46 +191,61 @@ local function BuildSortGrid()
end end
end end
table.sort(normalItems, function(a, b) return a.key < b.key end) local opts = libbagsort.opts or {}
-- Sort poor items descending so they read in ascending order when placed local reverse = opts.reverse
-- back-to-front (last poor item lands on the last slot). local reversePrio = opts.reversePrio
table.sort(poorItems, function(a, b) return a.key > b.key end)
-- Forward pass: assign normal items from slot 1 of bag 1 onward if reverse then
local bagIdx, destSlot = 1, 1 ReverseArray(generalCells)
while bagIdx <= bagCount and bagSlots[bagIdx] == 0 do for _, cells in pairs(specialtyCells) do
bagIdx = bagIdx + 1 ReverseArray(cells)
end
end end
if reversePrio then
table.sort(normalItems, function(a, b) return a.key > b.key end)
else
table.sort(normalItems, function(a, b) return a.key < b.key end)
end
if reverse then
table.sort(poorItems, function(a, b) return a.key < b.key end)
else
table.sort(poorItems, function(a, b) return a.key > b.key end)
end
-- Forward pass: route each normal item into the next free cell that
-- accepts it -- a matching specialty bag first, overflowing to general.
local genIdx = 1
local specIdx = {} -- family -> next free index into specialtyCells[family]
for _, item in ipairs(normalItems) do for _, item in ipairs(normalItems) do
while bagIdx <= bagCount do local cell
if destSlot <= bagSlots[bagIdx] then break end local fam = item.family
bagIdx = bagIdx + 1 if fam ~= 0 and specialtyCells[fam] then
destSlot = 1 local i = specIdx[fam] or 1
if i <= table.getn(specialtyCells[fam]) then
cell = specialtyCells[fam][i]
specIdx[fam] = i + 1
end
end end
if bagIdx > bagCount then break end if not cell and genIdx <= table.getn(generalCells) then
local grid = libbagsort.itemGrid[item.srcBag][item.srcSlot] cell = generalCells[genIdx]
grid.destBag = bagList[bagIdx] genIdx = genIdx + 1
grid.destSlot = destSlot end
destSlot = destSlot + 1 if not cell then break end
item.destBag = cell.bag
item.destSlot = cell.slot
end end
-- Reverse pass: assign poor items from the last slot of the last bag backward -- Reverse pass: poor items are general; fill remaining general cells from
local rBagIdx = bagCount -- the back, stopping before the ones the forward pass already claimed.
local rDestSlot = 0 local genBack = table.getn(generalCells)
while rBagIdx >= 1 do
if bagSlots[rBagIdx] > 0 then rDestSlot = bagSlots[rBagIdx]; break end
rBagIdx = rBagIdx - 1
end
for _, item in ipairs(poorItems) do for _, item in ipairs(poorItems) do
while rBagIdx >= 1 and rDestSlot < 1 do if genBack < genIdx then break end
rBagIdx = rBagIdx - 1 local cell = generalCells[genBack]
rDestSlot = rBagIdx >= 1 and bagSlots[rBagIdx] or 0 genBack = genBack - 1
end item.destBag = cell.bag
if rBagIdx < 1 then break end item.destSlot = cell.slot
local grid = libbagsort.itemGrid[item.srcBag][item.srcSlot]
grid.destBag = bagList[rBagIdx]
grid.destSlot = rDestSlot
rDestSlot = rDestSlot - 1
end end
end end
@@ -248,9 +302,15 @@ end
-- BAG_UPDATE_DELAYED cycle), then place items by category/name/quality. -- BAG_UPDATE_DELAYED cycle), then place items by category/name/quality.
-- e.g. `libbagsort:Sort({0, 1, 2, 3, 4})` for the main bags; -- e.g. `libbagsort:Sort({0, 1, 2, 3, 4})` for the main bags;
-- `{-1, 5, 6, 7, 8, 9, 10}` for the bank. -- `{-1, 5, 6, 7, 8, 9, 10}` for the bank.
function libbagsort:Sort(bagList) --
-- opts (optional): { reverse = bool, reversePrio = bool }
-- reverse - place the first-ranked item into the last slot of the last
-- bag (junk fills from the opposite end).
-- reversePrio - flip the category ranking (e.g. hearthstone sorts last).
function libbagsort:Sort(bagList, opts)
ClearSortData() ClearSortData()
self.bagList = bagList self.bagList = bagList
self.opts = opts
-- Phase 1: fire every consolidation op in a single batch. -- Phase 1: fire every consolidation op in a single batch.
local ops = BuildConsolidateOps(bagList) local ops = BuildConsolidateOps(bagList)
libs/libdebuff.lua
+83 -74
View File
@@ -11,12 +11,14 @@ setfenv(1, pfUI:GetEnvironment())
-- This eliminates ~400 lines of error-prone shift logic while maintaining full -- This eliminates ~400 lines of error-prone shift logic while maintaining full
-- multi-caster tracking support. -- multi-caster tracking support.
-- --
-- The public per-aura readers (UnitDebuff, UnitOwnDebuff) were retired in favor -- The internal debuff plumbing now runs on ClassicAPI's C_UnitAuras (which
-- of ClassicAPI's C_UnitAuras (which now provides sourceUnit/sourceGUID and -- provides sourceUnit/sourceGUID and non-player expirationTime). The public
-- non-player expirationTime). What remains in libdebuff is the cast-event -- per-aura readers (UnitDebuff, UnitOwnDebuff) survive only as thin adapters
-- bookkeeping consumed by GetBestAuraCast (libpredict HoT tracking) and the -- over C_UnitAuras for third-party addons (e.g. pfUI-WeakIcons) that still
-- libdebuff_*_hooks broadcast surface (subscribers in actionbar / swingtimer -- expect the legacy multi-return signature. The rest of libdebuff is the
-- / libtotem react to SPELL_GO and SPELL_FAILED). -- cast-event bookkeeping consumed by GetBestAuraCast (libpredict HoT tracking)
-- and the libdebuff_*_hooks broadcast surface (subscribers in actionbar /
-- swingtimer react to SPELL_GO and SPELL_FAILED).
-- return instantly when another libdebuff is already active -- return instantly when another libdebuff is already active
if pfUI.api.libdebuff then return end if pfUI.api.libdebuff then return end
@@ -27,8 +29,7 @@ if GetLocale() == "ruRU" then
end end
local libdebuff = CreateFrame("Frame", "pfdebuffsScanner", UIParent) local libdebuff = CreateFrame("Frame", "pfdebuffsScanner", UIParent)
local _, class = UnitClass("player") local class = UnitClassBase("player")
local lastspell
-- Nampower Support -- Nampower Support
local hasNampower = false local hasNampower = false
@@ -375,11 +376,9 @@ local function GetDebuffSlotMap(guid)
local texture = libdebuff:GetSpellIcon(spellId) local texture = libdebuff:GetSpellIcon(spellId)
local stacks = (auraApps and auraApps[auraSlot] or 0) + 1 local stacks = (auraApps and auraApps[auraSlot] or 0) + 1
local dtype = nil local dtype = nil
if GetSpellRecField then local dispelId = C_Spell.GetSpellDispelType(spellId)
local dispelId = GetSpellRecField(spellId, "dispel") if dispelId and dispelId > 0 then
if dispelId and dispelId > 0 then dtype = dispelTypeMap[dispelId]
dtype = dispelTypeMap[dispelId]
end
end end
map[displaySlot] = { map[displaySlot] = {
auraSlot = auraSlot, auraSlot = auraSlot,
@@ -592,37 +591,13 @@ end
-- DURATION FUNCTIONS -- DURATION FUNCTIONS
-- ============================================================================ -- ============================================================================
-- Report the live, talent-accurate duration of a matching aura on the player.
-- ClassicAPI's C_UnitAuras carries the real (mod-folded) duration straight from
-- the engine, so there's no static duration table to maintain. Returns 0 when
-- the player has no such aura (e.g. a debuff that only ever lands on enemies).
function libdebuff:GetDuration(effect, rank) function libdebuff:GetDuration(effect, rank)
if L["debuffs"][effect] then local aura = C_UnitAuras.GetAuraDataBySpellName("player", effect)
local rank = rank and tonumber((string.gsub(rank, RANK, ""))) or 0 return aura and aura.duration or 0
local rank = L["debuffs"][effect][rank] and rank or libdebuff:GetMaxRank(effect)
local duration = L["debuffs"][effect][rank]
if effect == L["dyndebuffs"]["Demoralizing Shout"] then
local _,_,_,_,count = GetTalentInfo(2,1)
if count and count > 0 then duration = duration + ( duration / 100 * (count*10)) end
elseif effect == L["dyndebuffs"]["Shadow Word: Pain"] then
local _,_,_,_,count = GetTalentInfo(3,4)
if count and count > 0 then duration = duration + count * 3 end
elseif effect == L["dyndebuffs"]["Frostbolt"] then
local _,_,_,_,count = GetTalentInfo(3,7)
if count and count > 0 then duration = duration + count end
elseif effect == L["dyndebuffs"]["Gouge"] then
local _,_,_,_,count = GetTalentInfo(3,3)
if count and count > 0 then duration = duration + (count*.5) end
end
return duration
else
return 0
end
end
function libdebuff:GetMaxRank(effect)
local max = 0
for id in pairs(L["debuffs"][effect]) do
if id > max then max = id end
end
return max
end end
function libdebuff:UpdateDuration(unit, unitlevel, effect, duration) function libdebuff:UpdateDuration(unit, unitlevel, effect, duration)
@@ -648,7 +623,6 @@ libdebuff.objects = {}
function libdebuff:AddPending(unit, unitlevel, effect, duration, caster, rank) function libdebuff:AddPending(unit, unitlevel, effect, duration, caster, rank)
if not unit or duration <= 0 then return end if not unit or duration <= 0 then return end
if not L["debuffs"][effect] then return end
if libdebuff.pending[3] then return end if libdebuff.pending[3] then return end
libdebuff.pending[1] = unit libdebuff.pending[1] = unit
@@ -727,39 +701,74 @@ end
-- API: GetBestAuraCast (for libpredict HoT tracking) -- API: GetBestAuraCast (for libpredict HoT tracking)
-- ============================================================================ -- ============================================================================
-- Report the active aura for spellName on `guid`, read straight from
-- C_UnitAuras. expirationTime is the true, caster-modified remaining time, so
-- no cast-event bookkeeping is needed -- and a unit only ever holds one instance
-- of a given spell, so this is inherently the "best" one.
-- Returns (startTime, duration, timeleft, rank, casterGuid) or nil.
function libdebuff:GetBestAuraCast(guid, spellName) function libdebuff:GetBestAuraCast(guid, spellName)
if not guid or not spellName then return nil end if not guid or not spellName then return nil end
-- Check ownDebuffs first (for our casts) local aura = C_UnitAuras.GetAuraDataBySpellName(guid, spellName)
if ownDebuffs[guid] and ownDebuffs[guid][spellName] then if not aura or not aura.expirationTime or aura.expirationTime == 0 then return nil end
local data = ownDebuffs[guid][spellName]
local timeleft = (data.startTime + data.duration) - GetTime() local timeleft = aura.expirationTime - GetTime()
if timeleft > 0 then if timeleft <= 0 then return nil end
return data.startTime, data.duration, timeleft, data.rank, GetPlayerGuid()
end local duration = (aura.duration and aura.duration > 0) and aura.duration or timeleft
local startTime = aura.expirationTime - duration
local rank = aura.spellId and tonumber((string.gsub(C_Spell.GetSpellSubtext(aura.spellId) or "", RANK, ""))) or nil
return startTime, duration, timeleft, rank, aura.sourceGUID
end
-- ============================================================================
-- API: UnitDebuff / UnitOwnDebuff (C_UnitAuras adapters)
-- ============================================================================
-- Thin readers kept for third-party addons (e.g. pfUI-WeakIcons) that still
-- expect libdebuff's legacy multi-return signature:
-- effect, rank, texture, stacks, dtype, duration, timeleft, caster
-- ClassicAPI's C_UnitAuras already resolves source and expiration, so these
-- just remap its AuraData onto that tuple -- no cast-tracking tables
-- (ownDebuffs/allAuraCasts) or GetUnitField slot mapping involved.
local function AuraToLegacy(aura)
if not aura then return nil end
local duration = aura.duration or 0
local timeleft = -1
-- Only report a timer for genuinely timed auras. ClassicAPI can leave a
-- stale expirationTime on permanent (duration 0) auras, so gate on duration.
if duration > 0 and aura.expirationTime and aura.expirationTime > 0 then
timeleft = aura.expirationTime - GetTime()
if timeleft < 0 then timeleft = 0 end
end end
-- Check allAuraCasts (for any caster) -- Aura spellId is the specific cast rank, so its subtext is the active rank.
if allAuraCasts[guid] and allAuraCasts[guid][spellName] then local rank
local bestData = nil local subtext = aura.spellId and C_Spell.GetSpellSubtext(aura.spellId)
local bestCaster = nil if subtext and subtext ~= "" then
local bestTimeleft = 0 rank = tonumber((string.gsub(subtext, "Rank ", "")))
for casterGuid, data in pairs(allAuraCasts[guid][spellName]) do
local timeleft = (data.startTime + data.duration) - GetTime()
if timeleft > bestTimeleft then
bestTimeleft = timeleft
bestData = data
bestCaster = casterGuid
end
end
if bestData and bestTimeleft > 0 then
return bestData.startTime, bestData.duration, bestTimeleft, bestData.rank, bestCaster
end
end end
return nil local dtype = aura.dispelName
if dtype == "" then dtype = nil end
local caster = aura.isFromPlayerOrPlayerPet and "player" or "other"
return aura.name, rank, aura.icon, aura.applications or 0, dtype, duration, timeleft, caster
end
-- id is a 1-based harmful-aura index, matching C_UnitAuras / Blizzard's
-- compacted debuff slots.
function libdebuff:UnitDebuff(unit, id)
return AuraToLegacy(C_UnitAuras.GetAuraDataByIndex(unit, id, "HARMFUL"))
end
-- Player-cast harmful auras only, via the PLAYER filter -- no manual
-- caster-GUID bookkeeping needed.
function libdebuff:UnitOwnDebuff(unit, id)
return AuraToLegacy(C_UnitAuras.GetAuraDataByIndex(unit, id, "HARMFUL|PLAYER"))
end end
-- ============================================================================ -- ============================================================================
@@ -1125,7 +1134,7 @@ if hasNampower then
-- Rank aus spellId ermitteln -- Rank aus spellId ermitteln
local rankNum = 0 local rankNum = 0
local rankString = GetSpellRecField(spellId, "rank") local rankString = C_Spell.GetSpellSubtext(spellId)
if rankString and rankString ~= "" then if rankString and rankString ~= "" then
rankNum = tonumber((string.gsub(rankString, "Rank ", ""))) or 0 rankNum = tonumber((string.gsub(rankString, "Rank ", ""))) or 0
end end
libs/libhealth.lua
+2 -2
View File
@@ -10,8 +10,8 @@ local libhealth = CreateFrame("Frame")
libhealth.enabled = true libhealth.enabled = true
libhealth.reqhit = 4 libhealth.reqhit = 4
libhealth.reqdmg = 5 libhealth.reqdmg = 5
libhealth:RegisterEvent("UNIT_HEALTH") libhealth:RegisterUnitEvent("UNIT_HEALTH", "target")
libhealth:RegisterEvent("UNIT_COMBAT") libhealth:RegisterUnitEvent("UNIT_COMBAT", "target")
libhealth:RegisterEvent("PLAYER_TARGET_CHANGED") libhealth:RegisterEvent("PLAYER_TARGET_CHANGED")
libhealth:RegisterEvent("PLAYER_ENTERING_WORLD") libhealth:RegisterEvent("PLAYER_ENTERING_WORLD")
libhealth:SetScript("OnEvent", function() libhealth:SetScript("OnEvent", function()
libs/libpredict.lua
+16 -16
View File
@@ -168,6 +168,9 @@ pfUI.libdebuff_spell_start_self_hooks["libpredict"] = function(spellId, casterGu
return return
end end
spell_queue[1] = spellName
spell_queue[2] = spellName .. (C_Spell.GetSpellSubtext(spellId) or "")
if spell_queue[1] == spellName and cache[spell_queue[2]] then if spell_queue[1] == spellName and cache[spell_queue[2]] then
local amount = cache[spell_queue[2]][1] local amount = cache[spell_queue[2]][1]
local casttime = castTime local casttime = castTime
@@ -291,7 +294,7 @@ pfUI.libdebuff_spell_start_other_hooks["libpredict"] = function(spellId, casterG
local targetName = resolveNameFromGuid(targetGuid) local targetName = resolveNameFromGuid(targetGuid)
if not targetName then return end if not targetName then return end
local rankStr = GetSpellRecField and GetSpellRecField(spellId, "rank") or "" local rankStr = C_Spell.GetSpellSubtext(spellId) or ""
local spellKey = spellName .. (rankStr or "") local spellKey = spellName .. (rankStr or "")
local amount = foreignCache[casterName] and foreignCache[casterName][spellKey] local amount = foreignCache[casterName] and foreignCache[casterName][spellKey]
@@ -355,11 +358,9 @@ pfUI.libdebuff_spell_go_hooks["libpredict"] = function(spellId, a1, a2, a3, a4,
elseif hotType == "Renew" then duration = renewDuration or 15 elseif hotType == "Renew" then duration = renewDuration or 15
end end
local rank = 0 local rank = 0
if GetSpellRecField then local rankSub = C_Spell.GetSpellSubtext(spellId)
local rankStr = GetSpellRecField(spellId, "rank") if rankSub and rankSub ~= "" then
if rankStr and rankStr ~= "" then rank = tonumber((string.gsub(rankSub, "Rank ", ""))) or 0
rank = tonumber((string.gsub(rankStr, "Rank ", ""))) or 0
end
end end
local playerName = UnitName("player") local playerName = UnitName("player")
libpredict:Hot(playerName, targetName, hotType, duration, nil, "SPELL_GO_SELF", rank) libpredict:Hot(playerName, targetName, hotType, duration, nil, "SPELL_GO_SELF", rank)
@@ -511,8 +512,7 @@ function libpredict:ParseComm(sender, msg)
local unit = senderUnit() local unit = senderUnit()
if not unit then return end if not unit then return end
local startMs = select(4, C_Spell.UnitCastingInfo(unit)) local _, _, _, startMs, endMs = C_Spell.UnitCastingInfo(unit)
local endMs = select(5, C_Spell.UnitCastingInfo(unit))
if not startMs or not endMs then return end if not startMs or not endMs then return end
time = (endMs - startMs) / 1000 time = (endMs - startMs) / 1000
elseif msgtype == 1 then elseif msgtype == 1 then
@@ -523,8 +523,7 @@ function libpredict:ParseComm(sender, msg)
target = {strsplit(":", string.sub(msg,9, -1))} target = {strsplit(":", string.sub(msg,9, -1))}
local unit = senderUnit() local unit = senderUnit()
if not unit then return end if not unit then return end
local startMs = select(4, C_Spell.UnitCastingInfo(unit)) local _, _, _, startMs, endMs = C_Spell.UnitCastingInfo(unit)
local endMs = select(5, C_Spell.UnitCastingInfo(unit))
if not startMs or not endMs then return end if not startMs or not endMs then return end
time = (endMs - startMs) / 1000 time = (endMs - startMs) / 1000
end end
@@ -899,7 +898,7 @@ local INSTANT_HOT_COOLDOWN = 1.0 -- 1 Sekunde Cooldown (GCD ist 1.5s)
local pendingHots = {} local pendingHots = {}
-- Gather Data by User Actions -- Gather Data by User Actions
pfUI.hooksecurefunc("CastSpell", function(id, bookType) hooksecurefunc("CastSpell", function(id, bookType)
if not libpredict.sender.enabled then return end if not libpredict.sender.enabled then return end
local effect, rank = libspell.GetSpellInfo(id, bookType) local effect, rank = libspell.GetSpellInfo(id, bookType)
if not effect then return end if not effect then return end
@@ -952,7 +951,7 @@ pfUI.hooksecurefunc("CastSpell", function(id, bookType)
end end
end) end)
pfUI.hooksecurefunc("CastSpellByName", function(effect, target) hooksecurefunc("CastSpellByName", function(effect, target)
if not libpredict.sender.enabled then return end if not libpredict.sender.enabled then return end
local effect, rank = libspell.GetSpellInfo(effect) local effect, rank = libspell.GetSpellInfo(effect)
if not effect then return end if not effect then return end
@@ -1016,13 +1015,14 @@ pfUI.hooksecurefunc("CastSpellByName", function(effect, target)
end end
end) end)
pfUI.hooksecurefunc("UseAction", function(slot, target, selfcast) hooksecurefunc("UseAction", function(slot, target, selfcast)
if not libpredict.sender.enabled then return end if not libpredict.sender.enabled then return end
if not IsCurrentAction(slot) then return end if not IsCurrentAction(slot) then return end
local kind, id = GetActionInfo(slot) local kind, id = GetActionInfo(slot)
local effect, rank local effect, rank
if kind == "spell" then if kind == "spell" then
effect, rank = GetSpellInfo(id) local spellInfo = C_Spell.GetSpellInfo(id)
effect, rank = spellInfo.name, spellInfo.rank
elseif kind == "macro" then elseif kind == "macro" then
effect, rank = GetMacroSpell(id) effect, rank = GetMacroSpell(id)
end end
@@ -1134,7 +1134,7 @@ libpredict.sender:RegisterEvent("SPELL_HEAL_BY_SELF")
libpredict.sender:RegisterEvent("SPELL_HEAL_BY_OTHER") -- populates foreignCache for other healers libpredict.sender:RegisterEvent("SPELL_HEAL_BY_OTHER") -- populates foreignCache for other healers
-- force cache updates -- force cache updates
libpredict.sender:RegisterEvent("UNIT_INVENTORY_CHANGED") libpredict.sender:RegisterUnitEvent("UNIT_INVENTORY_CHANGED", "player")
libpredict.sender:RegisterEvent("SKILL_LINES_CHANGED") libpredict.sender:RegisterEvent("SKILL_LINES_CHANGED")
-- Shared cleanup helper for failed/interrupted casts -- Shared cleanup helper for failed/interrupted casts
@@ -1225,7 +1225,7 @@ libpredict.sender:SetScript("OnEvent", function()
end) end)
function libpredict:GetHotDuration(unit, spell) function libpredict:GetHotDuration(unit, spell)
if unit == UNKNOWNOBJECT or unit == UNKOWNBEING then return end if unit == UNKNOWNOBJECT or unit == UKNOWNBEING then return end
-- NEW: Try libdebuff first (Nampower AURA_CAST events) -- NEW: Try libdebuff first (Nampower AURA_CAST events)
if pfUI.api.libdebuff and pfUI.api.libdebuff.GetBestAuraCast then if pfUI.api.libdebuff and pfUI.api.libdebuff.GetBestAuraCast then
libs/librange.lua
+14 -164
View File
@@ -2,178 +2,28 @@
setfenv(1, pfUI:GetEnvironment()) setfenv(1, pfUI:GetEnvironment())
--[[ librange ]]-- --[[ librange ]]--
-- A pfUI library that detects and caches distance to units. -- A thin wrapper over ClassicAPI's UnitInRange: a fixed 40y healing-range
-- check computed C-side from unit positions, valid for any unit. There is
-- no cache or scan loop -- the check is cheap enough to run per query,
-- which also sidesteps the staleness a cached scan hit on zone changes and
-- roster re-indexing.
-- --
-- librange:UnitInSpellRange(unit) -- librange:UnitInSpellRange(unit)
-- Returns `1` if the unit is within range, `nil` otherwise. -- Returns `1` if the unit is within range, `nil` otherwise.
--
-- Requires SuperWoW's UnitPosition for the friendly scan path. Target
-- range still works via IsActionInRange (vanilla-native) for any class
-- with a known 40y healing spell on the action bar.
if pfUI.api.librange then return end if pfUI.api.librange then return end
local _, class = UnitClass("player") local librange = {}
local librange = CreateFrame("Frame", "pfRangecheck", UIParent)
-- 40y spells per class. Only consulted to find an action-bar slot for the
-- IsActionInRange target-range path; the party/raid scan uses UnitPosition.
local spells = {
["PALADIN"] = {
"Interface\\Icons\\Spell_Holy_FlashHeal",
"Interface\\Icons\\Spell_Holy_HolyBolt",
},
["PRIEST"] = {
"Interface\\Icons\\Spell_Holy_FlashHeal",
"Interface\\Icons\\Spell_Holy_LesserHeal",
"Interface\\Icons\\Spell_Holy_Heal",
"Interface\\Icons\\Spell_Holy_GreaterHeal",
"Interface\\Icons\\Spell_Holy_Renew",
},
["DRUID"] = {
"Interface\\Icons\\Spell_Nature_HealingTouch",
"Interface\\Icons\\Spell_Nature_ResistNature",
"Interface\\Icons\\Spell_Nature_Rejuvenation",
},
["SHAMAN"] = {
"Interface\\Icons\\Spell_Nature_MagicImmunity",
"Interface\\Icons\\Spell_Nature_HealingWaveLesser",
"Interface\\Icons\\Spell_Nature_HealingWaveGreater",
},
}
-- friendly units the scan loop iterates
local units = {}
table.insert(units, "pet")
for i=1,4 do table.insert(units, "party" .. i) end
for i=1,4 do table.insert(units, "partypet" .. i) end
for i=1,40 do table.insert(units, "raid" .. i) end
for i=1,40 do table.insert(units, "raidpet" .. i) end
local numunits = table.getn(units)
local unitcache = {}
local unitdata = {}
local librange_isLoggingOut = false
librange.id = 1
librange:Hide()
librange:RegisterEvent("ACTIONBAR_SLOT_CHANGED")
librange:RegisterEvent("PLAYER_ENTERING_WORLD")
librange:RegisterEvent("PLAYER_LOGOUT")
librange:RegisterEvent("PLAYER_LEAVING_WORLD")
librange:SetScript("OnEvent", function()
if event == "PLAYER_LOGOUT" or event == "PLAYER_LEAVING_WORLD" then
librange_isLoggingOut = true
this:SetScript("OnUpdate", nil)
this:Hide()
return
end
if pfUI_config.unitframes.rangecheck == "0" then
this:Hide()
return
end
this.interval = tonumber(C.unitframes.rangechecki)/numunits
if event == "ACTIONBAR_SLOT_CHANGED" or event == "PLAYER_ENTERING_WORLD" then
librange.slot = this:GetRangeSlot()
if UnitPosition then this:Show() end
end
end)
librange:SetScript("OnUpdate", function()
if librange_isLoggingOut then return end
if (this.tick or 1) > GetTime() then return end
this.tick = GetTime() + this.interval
while not this:NeedRangeScan(units[this.id]) and this.id <= numunits do
this.id = this.id + 1
end
if this.id <= numunits then
local unit = units[this.id]
if not UnitIsUnit("target", unit) then
local x1, y1, z1 = UnitPosition("player")
local x2, y2, z2 = UnitPosition(unit)
if x1 and x2 then
local distance = ((x2 - x1)^2 + (y2 - y1)^2 + (z2 - z1)^2)^.5
unitdata[unit] = distance < 45 and 1 or 0
end
end
this.id = this.id + 1
else
this.id = 1
end
end)
function librange:NeedRangeScan(unit)
if not UnitExists(unit) then return nil end
if not UnitIsVisible(unit) then return nil end
if CheckInteractDistance(unit, 4) then return nil end
return true
end
function librange:GetRealUnit(unit)
if unitdata[unit] then return unit end
if unitcache[unit] and UnitIsUnit(unitcache[unit], unit) then
return unitcache[unit]
end
for id, realunit in pairs(units) do
if UnitIsUnit(realunit, unit) then
unitcache[unit] = realunit
return realunit
end
end
return unit
end
function librange:GetRangeSlot()
if not spells[class] then return nil end
for i=1,120 do
-- Resolve the slot to a spellID for both spell and macro actions; the old
-- `not GetActionText` macro-filter missed macros that cast a 40y heal but
-- displayed a non-spell icon. C_Spell.GetSpellTexture(spellID) gives the
-- spell's *intrinsic* icon, which is what we match against.
local kind, id = GetActionInfo(i)
local spellID
if kind == "spell" then
spellID = id
elseif kind == "macro" then
local _, _, sid = GetMacroSpell(id)
spellID = sid
end
if spellID then
local texture = C_Spell.GetSpellTexture(spellID)
if texture then
for _, check in pairs(spells[class]) do
if check == texture then return i end
end
end
end
end
return nil
end
function librange:UnitInSpellRange(unit) function librange:UnitInSpellRange(unit)
if UnitIsUnit("target", unit) then -- _G-qualified: bare `UnitInRange` resolves to pfUI.api.UnitInRange inside
if not librange.slot then return nil end -- the pfUI environment (which calls us), so this must reach ClassicAPI's
return IsActionInRange(librange.slot) == 1 and 1 or nil -- global directly or it recurses.
end local inRange, checked = _G.UnitInRange(unit)
-- position miss (e.g. a unit outside the client's sync range): we can't
local unit = librange:GetRealUnit(unit) -- tell, so default to in-range -- matches the old cache's nil behavior.
if not checked then return 1 end
if unitdata[unit] and unitdata[unit] == 1 then return inRange and 1 or nil
return 1
elseif not unitdata[unit] then
return 1
else
return nil
end
end end
-- add librange to pfUI API -- add librange to pfUI API
libs/libspell.lua
+9 -6
View File
@@ -83,12 +83,13 @@ end
-- [number] Casting time of the spell in milliseconds -- [number] Casting time of the spell in milliseconds
-- [number] Minimum range from the target required to cast the spell -- [number] Minimum range from the target required to cast the spell
-- [number] Maximum range from the target at which you can cast the spell -- [number] Maximum range from the target at which you can cast the spell
-- [number] The numeric spell-id of the spell -- [number] Spell's index in the book
-- [number] The type of the spellbook that the spell is in -- [number] The type of the spellbook that the spell is in
-- [number] The numeric spell-id of the spell
local spellinfo = {} local spellinfo = {}
function libspell.GetSpellInfo(index, bookType) function libspell.GetSpellInfo(index, bookType)
local cache = spellinfo[index] local cache = spellinfo[index]
if cache then return cache[1], cache[2], cache[3], cache[4], cache[5], cache[6], cache[7], cache[8] end if cache then return unpack(cache) end
local slot local slot
if type(index) == "string" then if type(index) == "string" then
@@ -108,17 +109,19 @@ function libspell.GetSpellInfo(index, bookType)
-- ClassicAPI's GetSpellInfo returns: name, rank, icon, cost, isFunnel, powerType, -- ClassicAPI's GetSpellInfo returns: name, rank, icon, cost, isFunnel, powerType,
-- castTime(ms), minRange, maxRange, spellID. Keep libspell's historical positional -- castTime(ms), minRange, maxRange, spellID. Keep libspell's historical positional
-- shape (castingTime at 4, ranges at 5/6, slot+bookType at 7/8). -- shape (castingTime at 4, ranges at 5/6, slot+bookType at 7/8).
local name, rank, icon, _, _, _, castingTime, minRange, maxRange = GetSpellInfo(slot, bookType) local name, rank, icon, _, _, _, castingTime, minRange, maxRange, spellId = GetSpellInfo(slot, bookType)
spellinfo[index] = { name, rank, icon, castingTime, minRange, maxRange, slot, bookType } spellinfo[index] = SafePack(name, rank, icon, castingTime, minRange, maxRange, slot, bookType, spellId)
return name, rank, icon, castingTime, minRange, maxRange, slot, bookType return name, rank, icon, castingTime, minRange, maxRange, slot, bookType, spellId
end end
-- Reset all spell caches whenever new spells are learned/unlearned -- Reset all spell caches whenever new spells are learned/unlearned
local resetcache = CreateFrame("Frame") local resetcache = CreateFrame("Frame")
resetcache:RegisterEvent("LEARNED_SPELL_IN_TAB") resetcache:RegisterEvent("LEARNED_SPELL_IN_TAB")
resetcache:SetScript("OnEvent", function() resetcache:SetScript("OnEvent", function()
spellmaxrank, spellindex, spellinfo = {}, {}, {} table.wipe(spellmaxrank)
table.wipe(spellindex)
table.wipe(spellinfo)
end) end)
-- add libspell to pfUI API -- add libspell to pfUI API
libs/libthrottle.lua
+2 -2
View File
@@ -35,7 +35,7 @@ libthrottle.defaults = {
nameplates_target = "custom", nameplates_target = "custom",
nameplates_castbar = "custom", nameplates_castbar = "custom",
nameplates_mass = "custom", nameplates_mass = "custom",
tooltip_cursor = "custom", tooltip_cursor = "fastest",
chat_tab = "custom", chat_tab = "custom",
swingtimer = "custom", swingtimer = "custom",
} }
@@ -160,7 +160,7 @@ libthrottle:SetScript("OnEvent", function()
-- Set defaults for custom fields if missing -- Set defaults for custom fields if missing
if not _G.pfUI_throttle.nameplates_target_custom then _G.pfUI_throttle.nameplates_target_custom = "50" end if not _G.pfUI_throttle.nameplates_target_custom then _G.pfUI_throttle.nameplates_target_custom = "50" end
if not _G.pfUI_throttle.nameplates_custom then _G.pfUI_throttle.nameplates_custom = "10" end if not _G.pfUI_throttle.nameplates_custom then _G.pfUI_throttle.nameplates_custom = "10" end
if not _G.pfUI_throttle.nameplates_castbar_custom then _G.pfUI_throttle.nameplates_castbar_custom = "50" end if not _G.pfUI_throttle.nameplates_castbar_custom then _G.pfUI_throttle.nameplates_castbar_custom = "100" end
if not _G.pfUI_throttle.nameplates_mass_custom then _G.pfUI_throttle.nameplates_mass_custom = "7" end if not _G.pfUI_throttle.nameplates_mass_custom then _G.pfUI_throttle.nameplates_mass_custom = "7" end
if not _G.pfUI_throttle.tooltip_cursor_custom then _G.pfUI_throttle.tooltip_cursor_custom = "10" end if not _G.pfUI_throttle.tooltip_cursor_custom then _G.pfUI_throttle.tooltip_cursor_custom = "10" end
if not _G.pfUI_throttle.chat_tab_custom then _G.pfUI_throttle.chat_tab_custom = "10" end if not _G.pfUI_throttle.chat_tab_custom then _G.pfUI_throttle.chat_tab_custom = "10" end
libs/libtooltip.lua
-59
View File
@@ -1,59 +0,0 @@
-- load pfUI environment
setfenv(1, pfUI:GetEnvironment())
--[[ libtooltip ]]--
-- A pfUI library that provides additional GameTooltip information.
--
-- libtooltip:GetItemID()
-- returns the itemID of the current GameTooltip
-- `nil` when no item is displayed
--
-- libtooltip:GetItemLink()
-- returns the itemLink of the current GameTooltip
-- `nil` when no item is displayed
--
-- libtooltip:GetItemCount()
-- returns the item count (bags) of the current GameTooltip
-- `nil` when no item is displayed
-- return instantly when another libtooltip is already active
if pfUI.api.libtooltip then return end
local libtooltip = CreateFrame("Frame" , "pfLibTooltip", GameTooltip)
libtooltip:SetScript("OnShow", function()
if this:GetParent():HasItem() then
libtooltip.itemName, libtooltip.itemLink, libtooltip.itemID = this:GetParent():GetItem()
end
end)
libtooltip:SetScript("OnHide", function()
this.itemID = nil
this.itemLink = nil
this.itemCount = nil
this.itemName = nil
end)
-- core functions
libtooltip.GetItemID = function(self)
if not libtooltip.itemLink then return end
if not libtooltip.itemID then
libtooltip.itemID = C_Item.GetItemInfoInstant(libtooltip.itemLink)
end
return libtooltip.itemID
end
libtooltip.GetItemLink = function(self)
return libtooltip.itemLink
end
libtooltip.GetItemCount = function(self)
return libtooltip.itemCount
end
pfUI.api.libtooltip = libtooltip
pfUI.hooksecurefunc(GameTooltip, "SetBagItem", function(self, container, slot)
_, libtooltip.itemCount = GetContainerItemInfo(container, slot)
end)
libs/libtotem.lua
-274
View File
@@ -1,274 +0,0 @@
-- load pfUI environment
setfenv(1, pfUI:GetEnvironment())
--[[ libtotem ]]--
-- A pfUI library that tries to emulate the TotemAPI that was introduced in Patch 2.4.
-- It detects and saves all current totems of the player and returns information based
-- on the totem slot ID. The function GetTotemInfo is supposed to work as it would
-- on later expansions.
--
-- GetTotemInfo(id)
-- Returns totem informations on the givent totem slot
-- active, name, start, duration, icon
-- return instantly when another libtotem is already active
if pfUI.api.libtotem then return end
MAX_TOTEMS = MAX_TOTEMS or 4
FIRE_TOTEM_SLOT = FIRE_TOTEM_SLOT or 1
EARTH_TOTEM_SLOT = EARTH_TOTEM_SLOT or 2
WATER_TOTEM_SLOT = WATER_TOTEM_SLOT or 3
AIR_TOTEM_SLOT = AIR_TOTEM_SLOT or 4
local _, class = UnitClass("player")
local libtotem
local active = { [1] = {}, [2] = {}, [3] = {}, [4] = {} }
-- SpellID -> { slot, duration } mapping
-- rank-specific durations are handled via spellId directly
local spellids = {
-- FIRE (slot 1)
[1535] = { slot = FIRE_TOTEM_SLOT, duration = 5 }, -- Fire Nova Totem R1
[8498] = { slot = FIRE_TOTEM_SLOT, duration = 5 }, -- Fire Nova Totem R2
[8499] = { slot = FIRE_TOTEM_SLOT, duration = 5 }, -- Fire Nova Totem R3
[11314] = { slot = FIRE_TOTEM_SLOT, duration = 5 }, -- Fire Nova Totem R4
[11315] = { slot = FIRE_TOTEM_SLOT, duration = 5 }, -- Fire Nova Totem R5
[8227] = { slot = FIRE_TOTEM_SLOT, duration = 120 }, -- Flametongue Totem R1
[8249] = { slot = FIRE_TOTEM_SLOT, duration = 120 }, -- Flametongue Totem R2
[10526] = { slot = FIRE_TOTEM_SLOT, duration = 120 }, -- Flametongue Totem R3
[16387] = { slot = FIRE_TOTEM_SLOT, duration = 120 }, -- Flametongue Totem R4
[8184] = { slot = FIRE_TOTEM_SLOT, duration = 120 }, -- Frost Resistance Totem R1
[10478] = { slot = FIRE_TOTEM_SLOT, duration = 120 }, -- Frost Resistance Totem R2
[10479] = { slot = FIRE_TOTEM_SLOT, duration = 120 }, -- Frost Resistance Totem R3
[8190] = { slot = FIRE_TOTEM_SLOT, duration = 20 }, -- Magma Totem R1
[10585] = { slot = FIRE_TOTEM_SLOT, duration = 20 }, -- Magma Totem R2
[10586] = { slot = FIRE_TOTEM_SLOT, duration = 20 }, -- Magma Totem R3
[10587] = { slot = FIRE_TOTEM_SLOT, duration = 20 }, -- Magma Totem R4
[3599] = { slot = FIRE_TOTEM_SLOT, duration = 30 }, -- Searing Totem R1
[6363] = { slot = FIRE_TOTEM_SLOT, duration = 35 }, -- Searing Totem R2
[6364] = { slot = FIRE_TOTEM_SLOT, duration = 40 }, -- Searing Totem R3
[6365] = { slot = FIRE_TOTEM_SLOT, duration = 45 }, -- Searing Totem R4
[10437] = { slot = FIRE_TOTEM_SLOT, duration = 50 }, -- Searing Totem R5
[10438] = { slot = FIRE_TOTEM_SLOT, duration = 55 }, -- Searing Totem R6
-- EARTH (slot 2)
[2484] = { slot = EARTH_TOTEM_SLOT, duration = 45 }, -- Earthbind Totem
[5730] = { slot = EARTH_TOTEM_SLOT, duration = 15 }, -- Stoneclaw Totem R1
[6390] = { slot = EARTH_TOTEM_SLOT, duration = 15 }, -- Stoneclaw Totem R2
[6391] = { slot = EARTH_TOTEM_SLOT, duration = 15 }, -- Stoneclaw Totem R3
[6392] = { slot = EARTH_TOTEM_SLOT, duration = 15 }, -- Stoneclaw Totem R4
[10427] = { slot = EARTH_TOTEM_SLOT, duration = 15 }, -- Stoneclaw Totem R5
[10428] = { slot = EARTH_TOTEM_SLOT, duration = 15 }, -- Stoneclaw Totem R6
[8071] = { slot = EARTH_TOTEM_SLOT, duration = 120 }, -- Stoneskin Totem R1
[8154] = { slot = EARTH_TOTEM_SLOT, duration = 120 }, -- Stoneskin Totem R2
[8155] = { slot = EARTH_TOTEM_SLOT, duration = 120 }, -- Stoneskin Totem R3
[10406] = { slot = EARTH_TOTEM_SLOT, duration = 120 }, -- Stoneskin Totem R4
[10407] = { slot = EARTH_TOTEM_SLOT, duration = 120 }, -- Stoneskin Totem R5
[10408] = { slot = EARTH_TOTEM_SLOT, duration = 120 }, -- Stoneskin Totem R6
[8075] = { slot = EARTH_TOTEM_SLOT, duration = 120 }, -- Strength of Earth Totem R1
[8160] = { slot = EARTH_TOTEM_SLOT, duration = 120 }, -- Strength of Earth Totem R2
[8161] = { slot = EARTH_TOTEM_SLOT, duration = 120 }, -- Strength of Earth Totem R3
[10442] = { slot = EARTH_TOTEM_SLOT, duration = 120 }, -- Strength of Earth Totem R4
[25361] = { slot = EARTH_TOTEM_SLOT, duration = 120 }, -- Strength of Earth Totem R5
[8143] = { slot = EARTH_TOTEM_SLOT, duration = 120 }, -- Tremor Totem
-- WATER (slot 3)
[8170] = { slot = WATER_TOTEM_SLOT, duration = 120 }, -- Disease Cleansing Totem
[8185] = { slot = WATER_TOTEM_SLOT, duration = 120 }, -- Fire Resistance Totem R1
[10537] = { slot = WATER_TOTEM_SLOT, duration = 120 }, -- Fire Resistance Totem R2
[10538] = { slot = WATER_TOTEM_SLOT, duration = 120 }, -- Fire Resistance Totem R3
[5394] = { slot = WATER_TOTEM_SLOT, duration = 60 }, -- Healing Stream Totem R1
[6375] = { slot = WATER_TOTEM_SLOT, duration = 60 }, -- Healing Stream Totem R2
[6377] = { slot = WATER_TOTEM_SLOT, duration = 60 }, -- Healing Stream Totem R3
[10462] = { slot = WATER_TOTEM_SLOT, duration = 60 }, -- Healing Stream Totem R4
[10463] = { slot = WATER_TOTEM_SLOT, duration = 60 }, -- Healing Stream Totem R5
[5675] = { slot = WATER_TOTEM_SLOT, duration = 60 }, -- Mana Spring Totem R1
[10495] = { slot = WATER_TOTEM_SLOT, duration = 60 }, -- Mana Spring Totem R2
[10496] = { slot = WATER_TOTEM_SLOT, duration = 60 }, -- Mana Spring Totem R3
[10497] = { slot = WATER_TOTEM_SLOT, duration = 60 }, -- Mana Spring Totem R4
[16190] = { slot = WATER_TOTEM_SLOT, duration = 12 }, -- Mana Tide Totem
[8166] = { slot = WATER_TOTEM_SLOT, duration = 120 }, -- Poison Cleansing Totem
-- AIR (slot 4)
[8835] = { slot = AIR_TOTEM_SLOT, duration = 120 }, -- Grace of Air Totem R1
[10627] = { slot = AIR_TOTEM_SLOT, duration = 120 }, -- Grace of Air Totem R2
[8177] = { slot = AIR_TOTEM_SLOT, duration = 45 }, -- Grounding Totem
[10595] = { slot = AIR_TOTEM_SLOT, duration = 120 }, -- Nature Resistance Totem R1
[10600] = { slot = AIR_TOTEM_SLOT, duration = 120 }, -- Nature Resistance Totem R2
[10601] = { slot = AIR_TOTEM_SLOT, duration = 120 }, -- Nature Resistance Totem R3
[25359] = { slot = AIR_TOTEM_SLOT, duration = 120 }, -- Tranquil Air Totem
[8512] = { slot = AIR_TOTEM_SLOT, duration = 120 }, -- Windfury Totem R1
[10613] = { slot = AIR_TOTEM_SLOT, duration = 120 }, -- Windfury Totem R2
[10614] = { slot = AIR_TOTEM_SLOT, duration = 120 }, -- Windfury Totem R3
[15107] = { slot = AIR_TOTEM_SLOT, duration = 120 }, -- Windwall Totem R1
[15421] = { slot = AIR_TOTEM_SLOT, duration = 120 }, -- Windwall Totem R2
[15422] = { slot = AIR_TOTEM_SLOT, duration = 120 }, -- Windwall Totem R3
}
-- icon-based fallback table (used by CastSpell/UseAction hooks that don't have spellId)
local totems = {
[FIRE_TOTEM_SLOT] = {
["Spell_Fire_SealOfFire"] = {[-1] = 5},
["Spell_Nature_GuardianWard"] = {[-1] = 120},
["Spell_FrostResistanceTotem_01"] = {[-1] = 120},
["Spell_Fire_SelfDestruct"] = {[-1] = 20},
["Spell_Fire_SearingTotem"] = {[-1] = 55,[1] = 30,[2] = 35,[3] = 40,[4] = 45,[5] = 50,[6] = 55},
},
[EARTH_TOTEM_SLOT] = {
["Spell_Nature_StrengthOfEarthTotem02"] = {[-1] = 45},
["Spell_Nature_StoneClawTotem"] = {[-1] = 15},
["Spell_Nature_StoneSkinTotem"] = {[-1] = 120},
["Spell_Nature_EarthBindTotem"] = {[-1] = 120},
["Spell_Nature_TremorTotem"] = {[-1] = 120},
},
[WATER_TOTEM_SLOT] = {
["Spell_Nature_DiseaseCleansingTotem"] = {[-1] = 120},
["Spell_FireResistanceTotem_01"] = {[-1] = 120},
["INV_Spear_04"] = {[-1] = 60},
["Spell_Nature_ManaRegenTotem"] = {[-1] = 60},
["Spell_Frost_SummonWaterElemental"] = {[-1] = 12},
["Spell_Nature_PoisonCleansingTotem"] = {[-1] = 120},
},
[AIR_TOTEM_SLOT] = {
["Spell_Nature_InvisibilityTotem"] = {[-1] = 120},
["Spell_Nature_GroundingTotem"] = {[-1] = 45},
["Spell_Nature_NatureResistanceTotem"] = {[-1] = 120},
["Spell_Nature_Brilliance"] = {[-1] = 120},
["Spell_Nature_Windfury"] = {[-1] = 120},
["Spell_Nature_EarthBind"] = {[-1] = 120},
},
}
GetTotemInfo = function(id)
if not active[id] or not active[id].name then return end
if active[id].start + active[id].duration - GetTime() < 0 then
libtotem:Clean(id)
return nil
end
return 1, active[id].name, active[id].start, active[id].duration, active[id].icon
end
if class ~= "SHAMAN" then return end
libtotem = CreateFrame("Frame")
libtotem:RegisterEvent("PLAYER_DEAD")
libtotem:SetScript("OnEvent", function()
if event == "PLAYER_DEAD" then
for i = 1, 4 do libtotem:Clean(i) end
end
end)
libtotem.totems = totems
libtotem.Clean = function(self, slot)
active[slot].name = nil
active[slot].start = nil
active[slot].duration = nil
active[slot].icon = nil
end
-- Direct SpellID commit (Nampower SPELL_GO_SELF, most accurate)
libtotem.CommitBySpellId = function(spellId, icon)
local data = spellids[spellId]
if not data then return false end
local slot = data.slot
active[slot].name = active[slot].pending_name or active[slot].name
active[slot].duration = data.duration
active[slot].icon = icon or active[slot].pending_icon
active[slot].start = GetTime()
active[slot].pending_name = nil
active[slot].pending_icon = nil
return true
end
-- Fallback: icon-based lookup (for CastSpell/UseAction without spellId)
libtotem.CheckAddQueue = function(self, name, rank, icon, spellId)
-- if we have a spellId, just store the name/icon as pending for SPELL_GO
if spellId and spellids[spellId] then
local slot = spellids[spellId].slot
active[slot].pending_name = name
active[slot].pending_icon = icon
return true
end
-- icon-based fallback
for slot = 1, 4 do
for texture, data in pairs(totems[slot]) do
if string.find(icon, texture, 1) then
if rank then
_, _, rank = string.find(rank, "%s(%d+)")
end
local duration
if rank and tonumber(rank) and data[tonumber(rank)] then
duration = data[tonumber(rank)]
else
duration = data[-1]
end
active[slot].pending_name = name
active[slot].pending_icon = icon
active[slot].pending_duration = duration
return true
end
end
end
return nil
end
-- assign library to global space
pfUI.api.libtotem = libtotem
-- SPELL_GO_SELF from libdebuff: commit directly by SpellID, no queue needed
pfUI.libdebuff_spell_go_hooks = pfUI.libdebuff_spell_go_hooks or {}
pfUI.libdebuff_spell_go_hooks["libtotem"] = function(spellId)
if not spellId then return end
local data = spellids[spellId]
if not data then return end
local slot = data.slot
-- use pending name/icon if available (set by CastSpellByName hook), else GetSpellInfo
local name = active[slot].pending_name
local icon = active[slot].pending_icon
if not name and GetSpellInfo then
name = GetSpellInfo(spellId)
end
active[slot].name = name
active[slot].duration = data.duration
active[slot].icon = icon
active[slot].start = GetTime()
active[slot].pending_name = nil
active[slot].pending_icon = nil
active[slot].pending_duration = nil
end
-- Hook CastSpellByName to store pending name/icon per slot
pfUI.hooksecurefunc("CastSpellByName", function(effect, target)
local name, rank, icon, _, _, _, spellId = libspell.GetSpellInfo(effect)
if not name then return end
libtotem:CheckAddQueue(name, rank, icon, spellId)
end)
-- Hook CastSpell to store pending name/icon per slot
pfUI.hooksecurefunc("CastSpell", function(id, bookType)
if not id or not bookType then return end
if bookType ~= BOOKTYPE_SPELL and bookType ~= BOOKTYPE_PET then return end
local name, rank, icon, _, _, _, spellId = libspell.GetSpellInfo(id, bookType)
if not name then return end
libtotem:CheckAddQueue(name, rank, icon, spellId)
end)
-- Hook UseAction. GetActionInfo + GetMacroSpell give us the spellID
-- directly for both spell-action and macro-action slots, so the
-- tooltip-scan fallback (and the "no spellId available" caveat) goes away.
pfUI.hooksecurefunc("UseAction", function(slot, target, selfcast)
if not IsCurrentAction(slot) then return end
local kind, id = GetActionInfo(slot)
local name, rank, spellID
if kind == "spell" then
spellID = id
name, rank = GetSpellInfo(id)
elseif kind == "macro" then
name, rank, spellID = GetMacroSpell(id)
end
if not name then return end
libtotem:CheckAddQueue(name, rank, GetActionTexture(slot), spellID)
end)
libs/libunitscan.lua
+32 -31
View File
@@ -89,20 +89,19 @@ libunitscan:SetScript("OnEvent", function()
-- update own character details -- update own character details
local name = UnitName("player") local name = UnitName("player")
local _, class = UnitClass("player") local class = UnitClassBase("player")
local level = UnitLevel("player") local level = UnitLevel("player")
local guild = GetGuildInfo("player") local guild = GetGuildInfo("player")
AddData("players", name, class, level, nil, guild) AddData("players", name, class, level, nil, guild)
RememberByUnit("player", name, class) RememberByUnit("player", name, class)
elseif event == "FRIENDLIST_UPDATE" then elseif event == "FRIENDLIST_UPDATE" then
local name, class, level
for i = 1, GetNumFriends() do for i = 1, GetNumFriends() do
name, level, class = GetFriendInfo(i) local info = C_FriendList.GetFriendInfoByIndex(i)
class = L["class"][class] or nil if info then
-- friendlist updates due to friend going off-line return level 0, let's not overwrite good older values local level = info.level > 0 and info.level or nil
level = level > 0 and level or nil AddData("players", info.name, info.classFilename, level)
AddData("players", name, class, level) end
end end
elseif event == "GUILD_ROSTER_UPDATE" then elseif event == "GUILD_ROSTER_UPDATE" then
@@ -128,7 +127,7 @@ libunitscan:SetScript("OnEvent", function()
local name, class, level, unit, _, guild local name, class, level, unit, _, guild
for i = 1, GetNumPartyMembers() do for i = 1, GetNumPartyMembers() do
unit = "party" .. i unit = "party" .. i
_, class = UnitClass(unit) class = UnitClassBase(unit)
name = UnitName(unit) name = UnitName(unit)
level = UnitLevel(unit) level = UnitLevel(unit)
guild = GetGuildInfo(unit) guild = GetGuildInfo(unit)
@@ -137,11 +136,11 @@ libunitscan:SetScript("OnEvent", function()
end end
elseif event == "WHO_LIST_UPDATE" or event == "CHAT_MSG_SYSTEM" then elseif event == "WHO_LIST_UPDATE" or event == "CHAT_MSG_SYSTEM" then
local name, class, level, guild, _ for i = 1, C_FriendList.GetNumWhoResults() do
for i = 1, GetNumWhoResults() do local info = C_FriendList.GetWhoInfo(i)
name, guild, level, _, class, _ = GetWhoInfo(i) if info then
class = L["class"][class] or nil AddData("players", info.fullName, info.filename, info.level, nil, info.fullGuildName)
AddData("players", name, class, level, nil, guild) end
end end
elseif event == "UPDATE_MOUSEOVER_UNIT" or event == "PLAYER_TARGET_CHANGED" or event == "NAME_PLATE_UNIT_ADDED" then elseif event == "UPDATE_MOUSEOVER_UNIT" or event == "PLAYER_TARGET_CHANGED" or event == "NAME_PLATE_UNIT_ADDED" then
@@ -149,24 +148,26 @@ libunitscan:SetScript("OnEvent", function()
or event == "NAME_PLATE_UNIT_ADDED" and arg1 or event == "NAME_PLATE_UNIT_ADDED" and arg1
or "mouseover" or "mouseover"
local name, class, level, elite, guild, _ local name, class, level, elite, guild, _
if UnitIsPlayer(scan) then if UnitExists(scan) then
_, class = UnitClass(scan) if UnitIsPlayer(scan) then
level = UnitLevel(scan) class = UnitClassBase(scan)
-- UnitLevel returns -1 for unknown levels, don't overwrite known values level = UnitLevel(scan)
level = level > 0 and level or nil -- UnitLevel returns -1 for unknown levels, don't overwrite known values
name = UnitName(scan) level = level > 0 and level or nil
guild = GetGuildInfo(scan) name = UnitName(scan)
AddData("players", name, class, level, nil, guild) guild = GetGuildInfo(scan)
RememberByUnit(scan, name, class) AddData("players", name, class, level, nil, guild)
else RememberByUnit(scan, name, class)
_, class = UnitClass(scan) else
elite = UnitClassification(scan) class = UnitClassBase(scan)
level = UnitLevel(scan) elite = UnitClassification(scan)
-- UnitLevel returns -1 for unknown levels, don't overwrite known values level = UnitLevel(scan)
level = level > 0 and level or nil -- UnitLevel returns -1 for unknown levels, don't overwrite known values
name = UnitName(scan) level = level > 0 and level or nil
guild = UnitSubName(scan) name = UnitName(scan)
AddData("mobs", name, class, level, elite, guild) guild = UnitSubName(scan)
AddData("mobs", name, class, level, elite, guild)
end
end end
end end
end) end)
modules/actionbar.lua
+108 -166
View File
@@ -1,5 +1,5 @@
pfUI:RegisterModule("actionbar", function () pfUI:RegisterModule("actionbar", function ()
local _, class = UnitClass("player") local class = UnitClassBase("player")
local _, cr, cg, cb = GetUnitColor('player') local _, cr, cg, cb = GetUnitColor('player')
local er, eg, eb, ea = GetStringColor(pfUI_config.appearance.border.color) local er, eg, eb, ea = GetStringColor(pfUI_config.appearance.border.color)
@@ -168,8 +168,7 @@ pfUI:RegisterModule("actionbar", function ()
["zoomfade"] = function() ["zoomfade"] = function()
if this.active == 0 then if this.active == 0 then
-- init animation -- init animation
this:SetWidth(this.parent:GetWidth()) this:SetSize(this.parent:GetSize())
this:SetHeight(this.parent:GetHeight())
this:SetScale(this.parent:GetScale()) this:SetScale(this.parent:GetScale())
this.tex:SetTexture(this.parent.icon:GetTexture()) this.tex:SetTexture(this.parent.icon:GetTexture())
this.tex:SetVertexColor(this.parent.icon:GetVertexColor()) this.tex:SetVertexColor(this.parent.icon:GetVertexColor())
@@ -191,8 +190,7 @@ pfUI:RegisterModule("actionbar", function ()
["shrinkreturn"] = function() ["shrinkreturn"] = function()
if this.active == 0 then if this.active == 0 then
-- init animation -- init animation
this:SetWidth(this.parent:GetWidth()) this:SetSize(this.parent:GetSize())
this:SetHeight(this.parent:GetHeight())
this:SetScale(this.parent:GetScale()) this:SetScale(this.parent:GetScale())
this.tex:SetTexture(this.parent.icon:GetTexture()) this.tex:SetTexture(this.parent.icon:GetTexture())
this.tex:SetVertexColor(this.parent.icon:GetVertexColor()) this.tex:SetVertexColor(this.parent.icon:GetVertexColor())
@@ -218,8 +216,7 @@ pfUI:RegisterModule("actionbar", function ()
["elasticzoom"] = function() ["elasticzoom"] = function()
if this.active == 0 then if this.active == 0 then
-- init animation -- init animation
this:SetWidth(this.parent:GetWidth()) this:SetSize(this.parent:GetSize())
this:SetHeight(this.parent:GetHeight())
this:SetScale(this.parent:GetScale()) this:SetScale(this.parent:GetScale())
this.tex:SetTexture(this.parent.icon:GetTexture()) this.tex:SetTexture(this.parent.icon:GetTexture())
this.tex:SetVertexColor(this.parent.icon:GetVertexColor()) this.tex:SetVertexColor(this.parent.icon:GetVertexColor())
@@ -245,8 +242,7 @@ pfUI:RegisterModule("actionbar", function ()
["wobblezoom"] = function() ["wobblezoom"] = function()
if this.active == 0 then if this.active == 0 then
-- init animation -- init animation
this:SetWidth(this.parent:GetWidth()) this:SetSize(this.parent:GetSize())
this:SetHeight(this.parent:GetHeight())
this:SetScale(this.parent:GetScale()) this:SetScale(this.parent:GetScale())
this.tex:SetTexture(this.parent.icon:GetTexture()) this.tex:SetTexture(this.parent.icon:GetTexture())
this.tex:SetVertexColor(this.parent.icon:GetVertexColor()) this.tex:SetVertexColor(this.parent.icon:GetVertexColor())
@@ -335,8 +331,7 @@ pfUI:RegisterModule("actionbar", function ()
local slfcast = C.bars.altself == "1" and IsAltKeyDown() and true or self.slfcast local slfcast = C.bars.altself == "1" and IsAltKeyDown() and true or self.slfcast
slfcast = C.bars.rightself == "1" and arg1 and arg1 == "RightButton" and true or slfcast slfcast = C.bars.rightself == "1" and arg1 and arg1 == "RightButton" and true or slfcast
self.slfcast = nil self.slfcast = nil
if ( C.bars.keydown == "1" and keystate == "down" and not drag_active ) or (C.bars.keydown == "0" and keystate == "up" or drag_active ) or self.bar == 11 or mouse then
if ( pfUI_config.bars.keydown == "1" and keystate == "down" and not drag_active ) or (pfUI_config.bars.keydown == "0" and keystate == "up" or drag_active ) or self.bar == 11 or mouse then
if self.bar == 11 then if self.bar == 11 then
CastShapeshiftForm(self.id) CastShapeshiftForm(self.id)
elseif grid == 1 then elseif grid == 1 then
@@ -365,73 +360,8 @@ pfUI:RegisterModule("actionbar", function ()
end end
end end
local function ButtonMacroScan(self)
if self.bar > 10 then return end
if not self.scanmacro then return end
if pfUI.bars.skip_macro then return end
-- SuperCleveRoidMacros: for macros it manages, leave spellslot/booktype unset
-- so the button's icon, cooldown, and tooltip flow through the hooked
-- GetActionTexture / GetActionCooldown / GameTooltip:SetAction and follow the
-- active conditional dynamically, instead of being frozen to the first
-- statically-scanned spell.
if CleveRoids and CleveRoids.IsManagedAction and CleveRoids.IsManagedAction(self.id) then
self.spellslot, self.booktype = nil, nil
return
end
local kind, slot = GetActionInfo(self.id)
self.spellslot, self.booktype = nil, nil
if kind == 'macro' then
local name, _, body = GetMacroInfo(slot)
if name and body then
local match
for line in gfind(body, "[^%\n]+") do
_, _, match = string.find(line, '^#showtooltip (.+)')
-- allow the user to disable the scan
if match and strfind(match, "disable") then
return
end
if not match then
-- add support to specify custom tooltips via:
-- /run --showtooltip SPELLNAME
_, _, match = string.find(line, '%-%-showtooltip (.+)')
end
if not match then
_, _, match = string.find(line, '^/cast (.+)')
end
if not match then
_, _, match = string.find(line, '^/pfcast (.+)')
end
if not match then
_, _, match = string.find(line, '^/pfmouse (.+)')
end
if not match then
_, _, match = string.find(line, 'CastSpellByName%(%"(.+)%"%)')
end
if match then
local _, _, spell, rank = string.find(match, '(.+)%((.+)%)')
spell = spell or match
self.spellslot, self.booktype = libspell.GetSpellIndex(spell, rank)
if self.spellslot and self.spellslot > 0 then return end
end
end
end
end
end
local function ButtonEnter(self) local function ButtonEnter(self)
local self = self or this self = self or this
-- indicate that dragging could get enabled -- indicate that dragging could get enabled
drag_await = true drag_await = true
@@ -449,6 +379,8 @@ pfUI:RegisterModule("actionbar", function ()
else else
GameTooltip:SetPetAction(self.id) GameTooltip:SetPetAction(self.id)
end end
elseif self.spellID then
GameTooltip:SetSpellByID(self.spellID)
elseif self.spellslot and self.booktype then elseif self.spellslot and self.booktype then
GameTooltip:SetSpell(self.spellslot, self.booktype) GameTooltip:SetSpell(self.spellslot, self.booktype)
else else
@@ -459,7 +391,7 @@ pfUI:RegisterModule("actionbar", function ()
end end
local function ButtonLeave(self) local function ButtonLeave(self)
local self = self or this self = self or this
-- no longer wait for a drag event -- no longer wait for a drag event
drag_await = nil drag_await = nil
@@ -472,7 +404,7 @@ pfUI:RegisterModule("actionbar", function ()
local grid, sid, id, bar, active, texture, _ local grid, sid, id, bar, active, texture, _
local function ButtonSlotUpdate(self) local function ButtonSlotUpdate(self)
if not self then return end if not self then return end
local self = self or this self = self or this
sid = self.id -- 1 to 120 sid = self.id -- 1 to 120
-- reset shared variables -- reset shared variables
@@ -591,7 +523,7 @@ pfUI:RegisterModule("actionbar", function ()
local sid, usable, oom, _ local sid, usable, oom, _
local function ButtonUsableUpdate(self) local function ButtonUsableUpdate(self)
local self = self or this self = self or this
sid = self.id -- 1 to 120 sid = self.id -- 1 to 120
if self.bar == 11 then if self.bar == 11 then
@@ -605,17 +537,17 @@ pfUI:RegisterModule("actionbar", function ()
-- update usable [out-of-range = 1, oom = 2, not-usable = 3, default = 0] -- update usable [out-of-range = 1, oom = 2, not-usable = 3, default = 0]
if self.outofrange and C.bars.glowrange == "1" then if self.outofrange and C.bars.glowrange == "1" then
if self.vertexstate ~= 1 then if self.vertexstate ~= 1 then
self.icon:SetVertexColor(self.rangeColor[1], self.rangeColor[2], self.rangeColor[3], self.rangeColor[4]) self.icon:SetVertexColor(self.rangeColor:GetRGBA())
self.vertexstate = 1 self.vertexstate = 1
end end
elseif oom and C.bars.showoom == "1" then elseif oom and C.bars.showoom == "1" then
if self.vertexstate ~= 2 then if self.vertexstate ~= 2 then
self.icon:SetVertexColor(self.oomColor[1], self.oomColor[2], self.oomColor[3], self.oomColor[4]) self.icon:SetVertexColor(self.oomColor:GetRGBA())
self.vertexstate = 2 self.vertexstate = 2
end end
elseif not usable and C.bars.showna == "1" then elseif not usable and C.bars.showna == "1" then
if self.vertexstate ~= 3 then if self.vertexstate ~= 3 then
self.icon:SetVertexColor(self.naColor[1], self.naColor[2], self.naColor[3], self.naColor[4]) self.icon:SetVertexColor(self.naColor:GetRGBA())
self.vertexstate = 3 self.vertexstate = 3
end end
else else
@@ -627,7 +559,7 @@ pfUI:RegisterModule("actionbar", function ()
end end
local function ButtonRangeUpdate(self) local function ButtonRangeUpdate(self)
local self = self or this self = self or this
-- update range display -- update range display
if C.bars.glowrange == "1" and self.bar ~= 11 and self.bar ~= 12 and HasAction(self.id) and ActionHasRange(self.id) and IsActionInRange(self.id) == 0 then if C.bars.glowrange == "1" and self.bar ~= 11 and self.bar ~= 12 and HasAction(self.id) and ActionHasRange(self.id) and IsActionInRange(self.id) == 0 then
@@ -696,7 +628,6 @@ pfUI:RegisterModule("actionbar", function ()
local function ButtonFullUpdate(button) local function ButtonFullUpdate(button)
if not button then return end if not button then return end
ButtonMacroScan(button)
ButtonSlotUpdate(button) ButtonSlotUpdate(button)
ButtonRangeUpdate(button) ButtonRangeUpdate(button)
ButtonUsableUpdate(button) ButtonUsableUpdate(button)
@@ -705,7 +636,7 @@ pfUI:RegisterModule("actionbar", function ()
end end
local function BarsEvent(self) local function BarsEvent(self)
local self = self or this self = self or this
-- refresh only specific slots -- refresh only specific slots
if event == "ACTIONBAR_SLOT_CHANGED" and arg1 and arg1 ~= 0 then if event == "ACTIONBAR_SLOT_CHANGED" and arg1 and arg1 ~= 0 then
@@ -813,10 +744,28 @@ pfUI:RegisterModule("actionbar", function ()
-- create the main event and update handler for pfUI actionbars -- create the main event and update handler for pfUI actionbars
local bars = CreateFrame("Frame", "pfActionBar", UIParent) local bars = CreateFrame("Frame", "pfActionBar", UIParent)
for event in pairs(special_events) do bars:RegisterEvent(event) end
for event in pairs(global_events) do bars:RegisterEvent(event) end -- The only unit events in the tables above; both concern the player alone.
for event in pairs(aura_events) do bars:RegisterEvent(event) end -- A registration keeps its kind, so these have to go in unit-filtered from
for event in pairs(pet_events) do bars:RegisterEvent(event) end -- the start -- RegisterUnitEvent over a plain registration stays plain.
local event_units = {
["UNIT_INVENTORY_CHANGED"] = "player",
["UNIT_PET"] = "player",
}
local function RegisterBarEvent(event)
local unit = event_units[event]
if unit then
bars:RegisterUnitEvent(event, unit)
else
bars:RegisterEvent(event)
end
end
for event in pairs(special_events) do RegisterBarEvent(event) end
for event in pairs(global_events) do RegisterBarEvent(event) end
for event in pairs(aura_events) do RegisterBarEvent(event) end
for event in pairs(pet_events) do RegisterBarEvent(event) end
-- refresh actionbar buttons on event -- refresh actionbar buttons on event
bars:SetScript("OnEvent", BarsEvent) bars:SetScript("OnEvent", BarsEvent)
@@ -854,16 +803,20 @@ pfUI:RegisterModule("actionbar", function ()
end end
end end
local cat, stealth
local inCatForm = nil local inCatForm = nil
local prowlActive = nil local prowlActive = nil
-- Cat Form ID per vanilla 1.12 SpellShapeshiftForm.dbc. -- Form IDs per vanilla 1.12 SpellShapeshiftForm.dbc.
local CAT_FORM = 1 local CAT_FORM = 1
local SHADOWFORM = 28
local function HasCatForm() local function HasCatForm()
return GetShapeshiftFormID() == CAT_FORM and true or nil return GetShapeshiftFormID() == CAT_FORM and true or nil
end end
local function InShadowform()
return GetShapeshiftFormID() == SHADOWFORM and true or nil
end
local function FullScan() local function FullScan()
if class ~= "DRUID" then return nil end if class ~= "DRUID" then return nil end
inCatForm = HasCatForm() inCatForm = HasCatForm()
@@ -873,7 +826,7 @@ pfUI:RegisterModule("actionbar", function ()
-- pagemaster / meta page switch -- pagemaster / meta page switch
do do
local prowl, shift, ctrl, alt, default = 8, 6, 5, 3, 1 local formpage, shift, ctrl, alt, default = 8, 6, 5, 3, 1
-- set temporary pagemaster bindings keybinds -- set temporary pagemaster bindings keybinds
if C.bars.pagemaster == "1" then if C.bars.pagemaster == "1" then
@@ -891,8 +844,10 @@ pfUI:RegisterModule("actionbar", function ()
end) end)
end end
-- setup page switch frame -- setup page switch frame. `formpaging` is the shared "auto-page is
local prowling = nil -- active" flag; druid prowl and priest shadowform each drive it, and
-- no character is ever both, so one flag covers both features.
local formpaging = nil
local pageswitch = CreateFrame("Frame", "pfActionBarPageSwitch", UIParent) local pageswitch = CreateFrame("Frame", "pfActionBarPageSwitch", UIParent)
pageswitch:RegisterEvent("PLAYER_ENTERING_WORLD") pageswitch:RegisterEvent("PLAYER_ENTERING_WORLD")
pageswitch:RegisterEvent("UPDATE_SHAPESHIFT_FORM") pageswitch:RegisterEvent("UPDATE_SHAPESHIFT_FORM")
@@ -906,10 +861,17 @@ pfUI:RegisterModule("actionbar", function ()
return return
end end
if class == "PRIEST" then
if event == "UPDATE_SHAPESHIFT_FORM" or event == "PLAYER_ENTERING_WORLD" then
formpaging = InShadowform()
end
return
end
if class ~= "DRUID" then return end if class ~= "DRUID" then return end
if event == "PLAYER_ENTERING_WORLD" then if event == "PLAYER_ENTERING_WORLD" then
prowling = FullScan() formpaging = FullScan()
return return
end end
@@ -918,7 +880,7 @@ pfUI:RegisterModule("actionbar", function ()
inCatForm = HasCatForm() inCatForm = HasCatForm()
if not inCatForm then if not inCatForm then
prowlActive = nil prowlActive = nil
prowling = nil formpaging = nil
end end
return return
end end
@@ -928,10 +890,10 @@ pfUI:RegisterModule("actionbar", function ()
if inCatForm then if inCatForm then
if IsStealthed() then if IsStealthed() then
prowlActive = true prowlActive = true
prowling = true formpaging = true
else else
prowlActive = nil prowlActive = nil
prowling = nil formpaging = nil
end end
end end
end) end)
@@ -947,7 +909,7 @@ pfUI:RegisterModule("actionbar", function ()
if PROWL_IDS[spellId] then if PROWL_IDS[spellId] then
inCatForm = true inCatForm = true
prowlActive = true prowlActive = true
prowling = true formpaging = true
end end
end end
pageswitch:SetScript("OnUpdate", function() pageswitch:SetScript("OnUpdate", function()
@@ -965,11 +927,12 @@ pfUI:RegisterModule("actionbar", function ()
SwitchBar(default) SwitchBar(default)
end end
-- switch actionbar page if druid stealth is detected -- switch actionbar page while druid stealth / priest shadowform is active
if C.bars.druidstealth == "1" then if (class == "DRUID" and C.bars.druidstealth == "1")
if prowling and _G.CURRENT_ACTIONBAR_PAGE == 1 then or (class == "PRIEST" and C.bars.priestshadow == "1") then
SwitchBar(prowl) if formpaging and _G.CURRENT_ACTIONBAR_PAGE == 1 then
elseif not prowling and _G.CURRENT_ACTIONBAR_PAGE == 8 then SwitchBar(formpage)
elseif not formpaging and _G.CURRENT_ACTIONBAR_PAGE == 8 then
SwitchBar(default) SwitchBar(default)
end end
end end
@@ -983,13 +946,13 @@ pfUI:RegisterModule("actionbar", function ()
local font_offset = tonumber(C.bars.font_offset) local font_offset = tonumber(C.bars.font_offset)
local macro_size = tonumber(C.bars.macro_size) local macro_size = tonumber(C.bars.macro_size)
local macro_color = { strsplit(",", C.bars.macro_color) } local macro_color = { GetStringColor(C.bars.macro_color) }
local count_size = tonumber(C.bars.count_size) local count_size = tonumber(C.bars.count_size)
local count_color = { strsplit(",", C.bars.count_color) } local count_color = { GetStringColor(C.bars.count_color) }
local bind_size = tonumber(C.bars.bind_size) local bind_size = tonumber(C.bars.bind_size)
local bind_color = { strsplit(",", C.bars.bind_color) } local bind_color = { GetStringColor(C.bars.bind_color) }
local cd_size = tonumber(C.bars.cd_size) local cd_size = tonumber(C.bars.cd_size)
@@ -1008,7 +971,7 @@ pfUI:RegisterModule("actionbar", function ()
local id = (bar-1)*12+button local id = (bar-1)*12+button
local exists = _G[button_name] and true or nil local exists = _G[button_name] and true or nil
local f = _G[button_name] or CreateFrame("Button", button_name, parent, ACTIONBAR_SECURE_TEMPLATE_BUTTON) local f = _G[button_name] or CreateFrame("Button", button_name, parent)
-- no button available, create a new one -- no button available, create a new one
if not exists then if not exists then
@@ -1034,7 +997,7 @@ pfUI:RegisterModule("actionbar", function ()
f.slot = id f.slot = id
-- cooldown -- cooldown
f.cd = CreateFrame(COOLDOWN_FRAME_TYPE, f:GetName() .. "Cooldown", f, "CooldownFrameTemplate") f.cd = CreateFrame("Model", f:GetName() .. "Cooldown", f, "CooldownFrameTemplate")
f.cd.pfCooldownStyleAnimation = 1 f.cd.pfCooldownStyleAnimation = 1
f.cd.pfCooldownType = "NOGCD" f.cd.pfCooldownType = "NOGCD"
f.cd.pfCooldownSize = cd_size f.cd.pfCooldownSize = cd_size
@@ -1140,31 +1103,25 @@ pfUI:RegisterModule("actionbar", function ()
f.count:SetJustifyH("RIGHT") f.count:SetJustifyH("RIGHT")
f.count:SetJustifyV("BOTTOM") f.count:SetJustifyV("BOTTOM")
-- macro spell scan (disabled when macro addons are loaded) f.scanmacro, f.spellslot, f.booktype = nil, nil, nil
if C.bars.macroscan == "0" or pfUI:MacroAddonsLoaded() then
f.scanmacro, f.spellslot, f.booktype = nil, nil, nil
else
f.scanmacro = true
end
-- range glow color -- range glow color
f.rangeColor = { strsplit(",", C.bars.rangecolor) } f.rangeColor = GetStringColorObject(C.bars.rangecolor)
-- out of mana color -- out of mana color
f.oomColor = { strsplit(",", C.bars.oomcolor) } f.oomColor = GetStringColorObject(C.bars.oomcolor)
-- not usable color -- not usable color
f.naColor = { strsplit(",", C.bars.nacolor) } f.naColor = GetStringColorObject(C.bars.nacolor)
-- equipped color -- equipped color
if f.equipped then if f.equipped then
f.equipped:SetTexture(strsplit(",", C.bars.eqcolor)) f.equipped:SetTexture(GetStringColor(C.bars.eqcolor))
end end
-- general appearance -- general appearance
f.showempty = showempty == "1" and true or nil f.showempty = showempty == "1" and true or nil
f:SetHeight(size) f:SetSize(size, size)
f:SetWidth(size)
CreateBackdrop(f, border) CreateBackdrop(f, border)
return f return f
@@ -1226,7 +1183,7 @@ pfUI:RegisterModule("actionbar", function ()
-- create frame -- create frame
local init = not bars[i] local init = not bars[i]
bars[i] = bars[i] or CreateFrame("Frame", "pfActionBar" .. barnames[i], UIParent, ACTIONBAR_SECURE_TEMPLATE_BAR) bars[i] = bars[i] or CreateFrame("Frame", "pfActionBar" .. barnames[i], UIParent)
bars[i]:SetID(i) bars[i]:SetID(i)
-- autohide -- autohide
@@ -1336,8 +1293,7 @@ pfUI:RegisterModule("actionbar", function ()
-- adjust actionbar size -- adjust actionbar size
BarLayoutSize(bars[i], buttons, formfactor, size, border, spacing, uneven, fillmode) BarLayoutSize(bars[i], buttons, formfactor, size, border, spacing, uneven, fillmode)
bars[i]:SetWidth(bars[i]._size[1]) bars[i]:SetSize(bars[i]._size[1], bars[i]._size[2])
bars[i]:SetHeight(bars[i]._size[2])
bars[i]:ClearAllPoints() bars[i]:ClearAllPoints()
if i == 1 then -- main if i == 1 then -- main
bars[i]:SetPoint("BOTTOM", 0, 2*border) bars[i]:SetPoint("BOTTOM", 0, 2*border)
@@ -1356,6 +1312,7 @@ pfUI:RegisterModule("actionbar", function ()
-- make stance bar dodge by default -- make stance bar dodge by default
bars[i]:SetScript("OnShow", function() bars[i]:SetScript("OnShow", function()
if pfUI.unlock and pfUI.unlock:IsShown() then return end
if bars[11] and bars[11]:IsShown() then if bars[11] and bars[11]:IsShown() then
bars[11]:ClearAllPoints() bars[11]:ClearAllPoints()
bars[11]:SetPoint("BOTTOM", bars[12], "TOP", 0, 3*border) bars[11]:SetPoint("BOTTOM", bars[12], "TOP", 0, 3*border)
@@ -1365,6 +1322,7 @@ pfUI:RegisterModule("actionbar", function ()
-- restore old stance bar position -- restore old stance bar position
bars[i]:SetScript("OnHide", function() bars[i]:SetScript("OnHide", function()
if pfUI.unlock and pfUI.unlock:IsShown() then return end
if bars[11] and bars[11]:IsShown() then if bars[11] and bars[11]:IsShown() then
bars[11]:ClearAllPoints() bars[11]:ClearAllPoints()
bars[11]:SetPoint("BOTTOM", bars[6], "TOP", 0, 3*border) bars[11]:SetPoint("BOTTOM", bars[6], "TOP", 0, 3*border)
@@ -1537,7 +1495,7 @@ pfUI:RegisterModule("actionbar", function ()
-- via GetActionInfo + C_Spell.GetSpellReagents. Macro actions and -- via GetActionInfo + C_Spell.GetSpellReagents. Macro actions and
-- bag-item actions are skipped (their reagent resolution would need a -- bag-item actions are skipped (their reagent resolution would need a
-- macro-body parse / item-effect lookup that we don't bother with). -- macro-body parse / item-effect lookup that we don't bother with).
local UpdateSlot = function(slot) local function UpdateSlot(slot)
local newID = nil local newID = nil
if HasAction(slot) then if HasAction(slot) then
local kind, spellID = GetActionInfo(slot) local kind, spellID = GetActionInfo(slot)
@@ -1552,60 +1510,44 @@ pfUI:RegisterModule("actionbar", function ()
if reagent_slots[slot] ~= newID then if reagent_slots[slot] ~= newID then
reagent_slots[slot] = newID reagent_slots[slot] = newID
if newID then if newID then
reagent_counts[newID] = reagent_counts[newID] or 0 reagent_counts[newID] = reagent_counts[newID] or C_Item.GetItemCount(newID)
end end
updatecache[slot] = true updatecache[slot] = true
end end
end end
-- Recount every tracked reagent and flag its buttons for a refresh.
local RecountReagents = function()
for itemID in pairs(reagent_counts) do
reagent_counts[itemID] = C_Item.GetItemCount(itemID)
end
for slot in pairs(reagent_slots) do
updatecache[slot] = true
end
end
local reagentcounter = CreateFrame("Frame", "pfReagentCounter", UIParent) local reagentcounter = CreateFrame("Frame", "pfReagentCounter", UIParent)
reagentcounter:RegisterEvent("PLAYER_ENTERING_WORLD") reagentcounter:RegisterEvent("PLAYER_ENTERING_WORLD")
reagentcounter:RegisterEvent("ACTIONBAR_SLOT_CHANGED") reagentcounter:RegisterEvent("ACTIONBAR_SLOT_CHANGED")
reagentcounter:RegisterEvent("BAG_UPDATE_DELAYED") reagentcounter:RegisterEvent("BAG_UPDATE_DELAYED")
reagentcounter:SetScript("OnEvent", function() reagentcounter:SetScript("OnEvent", function()
if event == "BAG_UPDATE_DELAYED" then if event == "ACTIONBAR_SLOT_CHANGED" then
this.event = true -- arg1 is the changed slot; 0 (or nil) means "all slots"
if arg1 and arg1 > 0 then
UpdateSlot(arg1)
else
for slot = 1, 120 do UpdateSlot(slot) end
end
elseif event == "BAG_UPDATE_DELAYED" then
-- inventory changed: refresh the counts we already track
RecountReagents()
else else
this.scan = 1 -- PLAYER_ENTERING_WORLD: seed the full reagent map (UpdateSlot seeds
-- each new reagent's count; a BAG_UPDATE_DELAYED follows during login)
for slot = 1, 120 do UpdateSlot(slot) end
end end
end) end)
-- Reagent counter update with throttle for performance optimization
reagentcounter:SetScript("OnUpdate", function()
-- Throttle entire function to 10 FPS for smooth scanning
if (this.tick_update or 0) > GetTime() then return end
this.tick_update = GetTime() + 0.1
-- scan one action slot per update
if this.scan and this.scan <= 120 then
UpdateSlot(this.scan)
this.scan = this.scan + 1
end
-- trigger reagent count updates after action scans
if this.scan and this.scan >= 120 then
this.event = true
this.scan = nil
end
-- queue events to fire only once per second
if not this.event then return end
if ( this.tick or 1) > GetTime() then return else this.tick = GetTime() + 1 end
-- scan for all reagent item counts
for itemID in pairs(reagent_counts) do
reagent_counts[itemID] = C_Item.GetItemCount(itemID)
end
-- update all actionbar buttons
for slot in pairs(reagent_slots) do
updatecache[slot] = true
end
-- remove event trigger
this.event = nil
end)
function IsReagentAction(slot) function IsReagentAction(slot)
return reagent_slots[slot] and true or nil return reagent_slots[slot] and true or nil
end end
modules/addonbuttons.lua
+27 -33
View File
@@ -37,15 +37,10 @@ pfUI:RegisterModule("addonbuttons", function ()
pfUI.addonbuttons.minimapbutton = CreateFrame("Button", "pfMinimapButton", pfUI.minimap or UIParent) pfUI.addonbuttons.minimapbutton = CreateFrame("Button", "pfMinimapButton", pfUI.minimap or UIParent)
pfUI.addonbuttons.minimapbutton:SetFrameLevel(24) pfUI.addonbuttons.minimapbutton:SetFrameLevel(24)
pfUI.addonbuttons.minimapbutton:SetWidth(12) pfUI.addonbuttons.minimapbutton:SetSize(12, 12)
pfUI.addonbuttons.minimapbutton:SetHeight(12)
pfUI.addonbuttons.minimapbutton:SetScript("OnClick", function() pfUI.addonbuttons.minimapbutton:SetScript("OnClick", function()
if pfUI.addonbuttons:IsShown() then pfUI.addonbuttons:SetShown(not pfUI.addonbuttons:IsShown())
pfUI.addonbuttons:Hide()
else
pfUI.addonbuttons:Show()
end
end) end)
pfUI.addonbuttons.buttons = {} pfUI.addonbuttons.buttons = {}
@@ -163,27 +158,25 @@ pfUI:RegisterModule("addonbuttons", function ()
pfUI.addonbuttons:SetScale(pfUI.minimap:GetScale()) pfUI.addonbuttons:SetScale(pfUI.minimap:GetScale())
pfUI.addonbuttons.minimapbutton:ClearAllPoints() pfUI.addonbuttons.minimapbutton:ClearAllPoints()
local mbtnWidth, mbtnHeight = pfUI.minimap:GetSize()
local dynamicSize = ceil((GetNumButtons() > 0 and GetNumButtons() or 1) / tonumber(C.abuttons.rowsize)) * GetStringSize() + tonumber(C.abuttons.spacing)
if C.abuttons.position == "bottom" then if C.abuttons.position == "bottom" then
pfUI.addonbuttons:SetWidth(pfUI.minimap:GetWidth()) pfUI.addonbuttons:SetSize(mbtnWidth, dynamicSize)
pfUI.addonbuttons:SetHeight(ceil((GetNumButtons() > 0 and GetNumButtons() or 1) / tonumber(C.abuttons.rowsize)) * GetStringSize() + tonumber(C.abuttons.spacing))
pfUI.addonbuttons:SetPoint("TOP", pfUI.minimap, "BOTTOM", 0 , -default_border * 3) pfUI.addonbuttons:SetPoint("TOP", pfUI.minimap, "BOTTOM", 0 , -default_border * 3)
SkinArrowButton(pfUI.addonbuttons.minimapbutton, "down") SkinArrowButton(pfUI.addonbuttons.minimapbutton, "down")
pfUI.addonbuttons.minimapbutton:SetPoint("BOTTOM", pfUI.minimap, "BOTTOM", 0, 4) pfUI.addonbuttons.minimapbutton:SetPoint("BOTTOM", pfUI.minimap, "BOTTOM", 0, 4)
elseif C.abuttons.position == "left" then elseif C.abuttons.position == "left" then
pfUI.addonbuttons:SetWidth(ceil((GetNumButtons() > 0 and GetNumButtons() or 1) / tonumber(C.abuttons.rowsize)) * GetStringSize() + tonumber(C.abuttons.spacing)) pfUI.addonbuttons:SetSize(dynamicSize, mbtnHeight)
pfUI.addonbuttons:SetHeight(pfUI.minimap:GetHeight())
pfUI.addonbuttons:SetPoint("TOPRIGHT", pfUI.minimap, "TOPLEFT", -default_border * 3, 0) pfUI.addonbuttons:SetPoint("TOPRIGHT", pfUI.minimap, "TOPLEFT", -default_border * 3, 0)
SkinArrowButton(pfUI.addonbuttons.minimapbutton, "left") SkinArrowButton(pfUI.addonbuttons.minimapbutton, "left")
pfUI.addonbuttons.minimapbutton:SetPoint("LEFT", pfUI.minimap, "LEFT", 4, 0) pfUI.addonbuttons.minimapbutton:SetPoint("LEFT", pfUI.minimap, "LEFT", 4, 0)
elseif C.abuttons.position == "top" then elseif C.abuttons.position == "top" then
pfUI.addonbuttons:SetWidth(pfUI.minimap:GetWidth()) pfUI.addonbuttons:SetSize(mbtnWidth, dynamicSize)
pfUI.addonbuttons:SetHeight(ceil((GetNumButtons() > 0 and GetNumButtons() or 1) / tonumber(C.abuttons.rowsize)) * GetStringSize() + tonumber(C.abuttons.spacing))
pfUI.addonbuttons:SetPoint("BOTTOM", pfUI.minimap, "TOP", 0 , default_border * 3) pfUI.addonbuttons:SetPoint("BOTTOM", pfUI.minimap, "TOP", 0 , default_border * 3)
SkinArrowButton(pfUI.addonbuttons.minimapbutton, "up") SkinArrowButton(pfUI.addonbuttons.minimapbutton, "up")
pfUI.addonbuttons.minimapbutton:SetPoint("TOP", pfUI.minimap, "TOP", 0, -4) pfUI.addonbuttons.minimapbutton:SetPoint("TOP", pfUI.minimap, "TOP", 0, -4)
elseif C.abuttons.position == "right" then elseif C.abuttons.position == "right" then
pfUI.addonbuttons:SetWidth(ceil((GetNumButtons() > 0 and GetNumButtons() or 1) / tonumber(C.abuttons.rowsize)) * GetStringSize() + tonumber(C.abuttons.spacing)) pfUI.addonbuttons:SetSize(dynamicSize, mbtnHeight)
pfUI.addonbuttons:SetHeight(pfUI.minimap:GetHeight())
pfUI.addonbuttons:SetPoint("TOPLEFT", pfUI.minimap, "TOPRIGHT", default_border * 3, 0) pfUI.addonbuttons:SetPoint("TOPLEFT", pfUI.minimap, "TOPRIGHT", default_border * 3, 0)
SkinArrowButton(pfUI.addonbuttons.minimapbutton, "right") SkinArrowButton(pfUI.addonbuttons.minimapbutton, "right")
pfUI.addonbuttons.minimapbutton:SetPoint("RIGHT", pfUI.minimap, "RIGHT", -4, 0) pfUI.addonbuttons.minimapbutton:SetPoint("RIGHT", pfUI.minimap, "RIGHT", -4, 0)
@@ -231,7 +224,7 @@ pfUI:RegisterModule("addonbuttons", function ()
frame.backup.is_clamped_to_screen = frame:IsClampedToScreen() frame.backup.is_clamped_to_screen = frame:IsClampedToScreen()
frame.backup.is_movable = frame:IsMovable() frame.backup.is_movable = frame:IsMovable()
frame.backup.point = {frame:GetPoint()} frame.backup.point = {frame:GetPoint()}
frame.backup.size = {frame:GetHeight(), frame:GetWidth()} frame.backup.size = {frame:GetSize()}
frame.backup.scale = frame:GetScale() frame.backup.scale = frame:GetScale()
if frame:HasScript("OnDragStart") then if frame:HasScript("OnDragStart") then
frame.backup.on_drag_start = frame:GetScript("OnDragStart") frame.backup.on_drag_start = frame:GetScript("OnDragStart")
@@ -256,8 +249,7 @@ pfUI:RegisterModule("addonbuttons", function ()
frame:SetClampedToScreen(frame.backup.is_clamped_to_screen) frame:SetClampedToScreen(frame.backup.is_clamped_to_screen)
frame:SetMovable(frame.backup.is_movable) frame:SetMovable(frame.backup.is_movable)
frame:SetScale(frame.backup.scale) frame:SetScale(frame.backup.scale)
frame:SetHeight(frame.backup.size[1]) frame:SetSize(frame.backup.size[2], frame.backup.size[1])
frame:SetWidth(frame.backup.size[2])
frame:ClearAllPoints() frame:ClearAllPoints()
frame:SetPoint(frame.backup.point[1], frame.backup.point[2], frame.backup.point[3], frame.backup.point[4], frame.backup.point[5]) frame:SetPoint(frame.backup.point[1], frame.backup.point[2], frame.backup.point[3], frame.backup.point[4], frame.backup.point[5])
if frame.backup.on_drag_start ~= nil then if frame.backup.on_drag_start ~= nil then
@@ -405,22 +397,25 @@ pfUI:RegisterModule("addonbuttons", function ()
pfUI.addonbuttons:ProcessButtons() pfUI.addonbuttons:ProcessButtons()
end) end)
pfUI.addonbuttons:SetScript("OnUpdate", function() -- Initial setup on the next frame, once other addons' minimap buttons exist
RunNextFrame(function()
-- check if the panel should be shown by default -- check if the panel should be shown by default
if not this.initialized then if C.abuttons.showdefault == "1" and GetNumButtons() > 0 then
if C.abuttons.showdefault == "1" and GetNumButtons() > 0 then pfUI.addonbuttons:Show()
pfUI.addonbuttons:Show() else
else pfUI.addonbuttons:Hide()
pfUI.addonbuttons:Hide()
end
-- update all buttons
pfUI.addonbuttons:ProcessButtons()
this.initialized = true
end end
-- throttle updates to once per 5 seconds -- update all buttons and apply workarounds
if ( this.tick or 1) > GetTime() then return else this.tick = GetTime() + 5 end pfUI.addonbuttons:ProcessButtons()
for k, v in pairs(pfUI.addonbuttons.overrides) do
_G[k] = v
end
end)
-- Rescan minimap buttons every 5 seconds while the panel is shown
C_Timer.NewTicker(5, function()
if not pfUI.addonbuttons:IsShown() then return end
-- reload/rescan minimap buttons -- reload/rescan minimap buttons
pfUI.addonbuttons:ProcessButtons() pfUI.addonbuttons:ProcessButtons()
@@ -440,6 +435,5 @@ pfUI:RegisterModule("addonbuttons", function ()
pfUI.addonbuttons:UpdateConfig() pfUI.addonbuttons:UpdateConfig()
_G.SLASH_PFABP1, _G.SLASH_PFABP2 = "/abp", "/pfabp" pfUI.api.RegisterSlashCommand("PFABP", { "/abp", "/pfabp" }, ManualAddOrRemove, true)
_G.SlashCmdList.PFABP = ManualAddOrRemove
end) end)
modules/addons.lua
+26 -14
View File
@@ -18,8 +18,7 @@ pfUI:RegisterModule("addons", function ()
-- addon window -- addon window
pfUI.addons = CreateFrame("Frame", "pfAddons", UIParent) pfUI.addons = CreateFrame("Frame", "pfAddons", UIParent)
pfUI.addons:SetFrameStrata("DIALOG") pfUI.addons:SetFrameStrata("DIALOG")
pfUI.addons:SetHeight(490) pfUI.addons:SetSize(380, 490)
pfUI.addons:SetWidth(380)
pfUI.addons:SetPoint("CENTER", 0,0) pfUI.addons:SetPoint("CENTER", 0,0)
pfUI.addons:EnableMouseWheel(1) pfUI.addons:EnableMouseWheel(1)
pfUI.addons:SetMovable(true) pfUI.addons:SetMovable(true)
@@ -51,8 +50,7 @@ pfUI:RegisterModule("addons", function ()
pfUI.addons.close = CreateFrame("Button", "pfBagClose", pfUI.addons) pfUI.addons.close = CreateFrame("Button", "pfBagClose", pfUI.addons)
pfUI.addons.close:SetPoint("TOPRIGHT", -border*2,-border*2 ) pfUI.addons.close:SetPoint("TOPRIGHT", -border*2,-border*2 )
CreateBackdrop(pfUI.addons.close) CreateBackdrop(pfUI.addons.close)
pfUI.addons.close:SetHeight(15) pfUI.addons.close:SetSize(15, 15)
pfUI.addons.close:SetWidth(15)
pfUI.addons.close.texture = pfUI.addons.close:CreateTexture("pfBagClose") pfUI.addons.close.texture = pfUI.addons.close:CreateTexture("pfBagClose")
pfUI.addons.close.texture:SetTexture(pfUI.media["img:close"]) pfUI.addons.close.texture:SetTexture(pfUI.media["img:close"])
pfUI.addons.close.texture:ClearAllPoints() pfUI.addons.close.texture:ClearAllPoints()
@@ -125,8 +123,7 @@ pfUI:RegisterModule("addons", function ()
end) end)
pfUI.addons.profile:SetPoint("TOP", pfUI.addons, "TOP", 0, -30) pfUI.addons.profile:SetPoint("TOP", pfUI.addons, "TOP", 0, -30)
pfUI.addons.profile:SetHeight(30) pfUI.addons.profile:SetSize(370, 30)
pfUI.addons.profile:SetWidth(370)
CreateBackdrop(pfUI.addons.profile, nil, true) CreateBackdrop(pfUI.addons.profile, nil, true)
-- addon profile: title -- addon profile: title
@@ -139,8 +136,7 @@ pfUI:RegisterModule("addons", function ()
-- addon profile: delete -- addon profile: delete
pfUI.addons.profile.del = CreateFrame("Button", nil, pfUI.addons.profile, "UIPanelButtonTemplate") pfUI.addons.profile.del = CreateFrame("Button", nil, pfUI.addons.profile, "UIPanelButtonTemplate")
SkinButton(pfUI.addons.profile.del) SkinButton(pfUI.addons.profile.del)
pfUI.addons.profile.del:SetWidth(16) pfUI.addons.profile.del:SetSize(16, 16)
pfUI.addons.profile.del:SetHeight(16)
pfUI.addons.profile.del:SetPoint("RIGHT", -10, 0) pfUI.addons.profile.del:SetPoint("RIGHT", -10, 0)
pfUI.addons.profile.del:GetFontString():SetPoint("CENTER", 1, 0) pfUI.addons.profile.del:GetFontString():SetPoint("CENTER", 1, 0)
pfUI.addons.profile.del:SetText("-") pfUI.addons.profile.del:SetText("-")
@@ -157,8 +153,7 @@ pfUI:RegisterModule("addons", function ()
-- addon profile: create -- addon profile: create
pfUI.addons.profile.add = CreateFrame("Button", nil, pfUI.addons.profile, "UIPanelButtonTemplate") pfUI.addons.profile.add = CreateFrame("Button", nil, pfUI.addons.profile, "UIPanelButtonTemplate")
SkinButton(pfUI.addons.profile.add) SkinButton(pfUI.addons.profile.add)
pfUI.addons.profile.add:SetWidth(16) pfUI.addons.profile.add:SetSize(16, 16)
pfUI.addons.profile.add:SetHeight(16)
pfUI.addons.profile.add:SetPoint("RIGHT", pfUI.addons.profile.del, "LEFT", -4, 0) pfUI.addons.profile.add:SetPoint("RIGHT", pfUI.addons.profile.del, "LEFT", -4, 0)
pfUI.addons.profile.add:GetFontString():SetPoint("CENTER", 1, 0) pfUI.addons.profile.add:GetFontString():SetPoint("CENTER", 1, 0)
pfUI.addons.profile.add:SetText("+") pfUI.addons.profile.add:SetText("+")
@@ -201,8 +196,7 @@ pfUI:RegisterModule("addons", function ()
-- addon list: scroll frame -- addon list: scroll frame
pfUI.addons.scroll = CreateScrollFrame("pfAddonListScroll", pfUI.addons) pfUI.addons.scroll = CreateScrollFrame("pfAddonListScroll", pfUI.addons)
pfUI.addons.scroll:SetWidth(360) pfUI.addons.scroll:SetSize(360, 410)
pfUI.addons.scroll:SetHeight(410)
pfUI.addons.scroll:SetPoint("BOTTOM", 0, 10) pfUI.addons.scroll:SetPoint("BOTTOM", 0, 10)
pfUI.addons.scroll.backdrop = CreateFrame("Frame", nil, pfUI.addons.scroll) pfUI.addons.scroll.backdrop = CreateFrame("Frame", nil, pfUI.addons.scroll)
@@ -217,6 +211,21 @@ pfUI:RegisterModule("addons", function ()
pfUI.addons.list:RegisterEvent("PLAYER_ENTERING_WORLD") pfUI.addons.list:RegisterEvent("PLAYER_ENTERING_WORLD")
pfUI.addons.list:SetHeight(GetNumAddOns() * 25 + 26) pfUI.addons.list:SetHeight(GetNumAddOns() * 25 + 26)
local function AddDependencyLines(header, deps)
if not deps or table.getn(deps) == 0 then return end
GameTooltip:AddLine(" ")
GameTooltip:AddLine(header .. ":", .2, 1, .8)
for _, dep in ipairs(deps) do
if IsAddOnLoaded(dep) then
GameTooltip:AddLine(" " .. dep, .5, 1, .5)
elseif C_AddOns.DoesAddOnExist(dep) then
GameTooltip:AddLine(" " .. dep, 1, .82, 0)
else
GameTooltip:AddLine(" " .. dep .. " (" .. T["Missing"] .. ")", 1, .4, .4)
end
end
end
local function AddonOnEnter() local function AddonOnEnter()
this:SetBackdropBorderColor(1,1,1,.08) this:SetBackdropBorderColor(1,1,1,.08)
@@ -231,6 +240,8 @@ pfUI:RegisterModule("addons", function ()
end end
GameTooltip:AddLine(this.anote, .75,.75,.75,1) GameTooltip:AddLine(this.anote, .75,.75,.75,1)
AddDependencyLines(T["Dependencies"], this.adeps)
AddDependencyLines(T["Optional Dependencies"], this.aoptdeps)
GameTooltip:SetWidth(180) GameTooltip:SetWidth(180)
GameTooltip:Show() GameTooltip:Show()
end end
@@ -272,9 +283,10 @@ pfUI:RegisterModule("addons", function ()
frame.anote = anote frame.anote = anote
frame.aauthor = aauthor frame.aauthor = aauthor
frame.aversion = aversion frame.aversion = aversion
frame.adeps = { GetAddOnDependencies(i) } -- required (.toc Dependencies)
frame.aoptdeps = { C_AddOns.GetAddOnOptionalDependencies(i) } -- optional (.toc OptionalDeps)
frame:SetWidth(340) frame:SetSize(340, 25)
frame:SetHeight(25)
frame:SetPoint("TOPLEFT", 5, i * -25 + 20) frame:SetPoint("TOPLEFT", 5, i * -25 + 20)
frame:SetBackdrop(pfUI.backdrop_hover) frame:SetBackdrop(pfUI.backdrop_hover)
modules/afkcam.lua
+5 -7
View File
@@ -1,5 +1,4 @@
pfUI:RegisterModule("afkcam", function () pfUI:RegisterModule("afkcam", function ()
local MARKED_AFK_CAPTURE = SanitizePattern(MARKED_AFK_MESSAGE)
local social_chats = { local social_chats = {
"CHAT_MSG_SAY", "CHAT_MSG_SAY",
"CHAT_MSG_WHISPER", "CHAT_MSG_WHISPER",
@@ -49,8 +48,7 @@ pfUI:RegisterModule("afkcam", function ()
local chat = CreateFrame("ScrollingMessageFrame", "pfAFKCamChat", overlay) local chat = CreateFrame("ScrollingMessageFrame", "pfAFKCamChat", overlay)
chat:EnableMouse(false) chat:EnableMouse(false)
chat:EnableMouseWheel(true) chat:EnableMouseWheel(true)
chat:SetHeight(150) chat:SetSize(500, 150)
chat:SetWidth(500)
chat:SetPoint("BOTTOMLEFT",overlay,"BOTTOMLEFT", 10, 10) chat:SetPoint("BOTTOMLEFT",overlay,"BOTTOMLEFT", 10, 10)
chat:SetTimeVisible(1800.0) chat:SetTimeVisible(1800.0)
chat:SetMaxLines(500) chat:SetMaxLines(500)
@@ -165,10 +163,10 @@ pfUI:RegisterModule("afkcam", function ()
end) end)
afkcam:SetScript("OnEvent", function() afkcam:SetScript("OnEvent", function()
if event == "CHAT_MSG_SYSTEM" then if event == "PLAYER_FLAGS_CHANGED" then
if (arg1 == _G.MARKED_AFK) or strfind(arg1, MARKED_AFK_CAPTURE) then if UnitIsAFK('player') then
delay:Show() delay:Show()
elseif (arg1 == _G.CLEARED_AFK) then elseif delay:IsVisible() then
delay:Hide() delay:Hide()
this:stop() this:stop()
end end
@@ -180,7 +178,7 @@ pfUI:RegisterModule("afkcam", function ()
end end
end) end)
afkcam:RegisterEvent("CHAT_MSG_SYSTEM") afkcam:RegisterEvent("PLAYER_FLAGS_CHANGED")
afkcam:RegisterEvent("PLAYER_REGEN_DISABLED") afkcam:RegisterEvent("PLAYER_REGEN_DISABLED")
afkcam:RegisterEvent("PLAYER_LEAVING_WORLD") -- reseting cvars on PLAYER_LOGOUT crashes the client ¯\_(ツ)_/¯ afkcam:RegisterEvent("PLAYER_LEAVING_WORLD") -- reseting cvars on PLAYER_LOGOUT crashes the client ¯\_(ツ)_/¯
end) end)
modules/autoshift.lua
+5
View File
@@ -2,6 +2,11 @@ pfUI:RegisterModule("autoshift", function ()
pfUI.autoshift = CreateFrame("Frame") pfUI.autoshift = CreateFrame("Frame")
pfUI.autoshift:RegisterEvent("UI_ERROR_MESSAGE") pfUI.autoshift:RegisterEvent("UI_ERROR_MESSAGE")
-- Empty stub kept only so Turtle WoW's pfUI-turtle addon doesn't error when
-- its obsolete moonkin autoshift module iterates pfUI.autoshift.shapeshifts.
-- This fork drives autoshift off GetShapeshiftFormID() and no longer uses it.
pfUI.autoshift.shapeshifts = {}
pfUI.autoshift.scanString = string.gsub(SPELL_FAILED_ONLY_SHAPESHIFT, "%%s", "(.+)") pfUI.autoshift.scanString = string.gsub(SPELL_FAILED_ONLY_SHAPESHIFT, "%%s", "(.+)")
pfUI.autoshift.errors = { SPELL_FAILED_NOT_MOUNTED, ERR_ATTACK_MOUNTED, ERR_TAXIPLAYERALREADYMOUNTED, pfUI.autoshift.errors = { SPELL_FAILED_NOT_MOUNTED, ERR_ATTACK_MOUNTED, ERR_TAXIPLAYERALREADYMOUNTED,
modules/autovendor.lua
+1 -2
View File
@@ -56,8 +56,7 @@ pfUI:RegisterModule("autovendor", function ()
-- Setup Autosell button -- Setup Autosell button
autovendor.button = CreateFrame("Button", "pfMerchantAutoVendorButton", MerchantFrame) autovendor.button = CreateFrame("Button", "pfMerchantAutoVendorButton", MerchantFrame)
autovendor.button:SetWidth(36) autovendor.button:SetSize(36, 36)
autovendor.button:SetHeight(36)
autovendor.button.icon = autovendor.button:CreateTexture("ARTWORK") autovendor.button.icon = autovendor.button:CreateTexture("ARTWORK")
autovendor.button.icon:SetTexture("Interface\\Icons\\Spell_Shadow_SacrificialShield") autovendor.button.icon:SetTexture("Interface\\Icons\\Spell_Shadow_SacrificialShield")
autovendor.button:SetScript("OnEnter", function() autovendor.button:SetScript("OnEnter", function()
modules/bags.lua
+34 -55
View File
@@ -8,6 +8,13 @@ pfUI:RegisterModule("bags", function ()
local scanner = libtipscan:GetScanner("input_search") local scanner = libtipscan:GetScanner("input_search")
local function BagSortOpts()
return {
reverse = C.appearance.bags.sortreverse == "1",
reversePrio = C.appearance.bags.sortprioreverse == "1",
}
end
-- function to detect openable items in inventory -- function to detect openable items in inventory
local openable = { bag = nil, slot = nil, icon = nil } local openable = { bag = nil, slot = nil, icon = nil }
local function GetNextOpenable() local function GetNextOpenable()
@@ -319,8 +326,7 @@ pfUI:RegisterModule("bags", function ()
default_border + x*(frame.button_size+default_border*3), default_border + x*(frame.button_size+default_border*3),
-default_border*2 - y*(frame.button_size+default_border*3) - topspace) -default_border*2 - y*(frame.button_size+default_border*3) - topspace)
pfUI.bags[bag].slots[slot].frame:SetHeight(frame.button_size) pfUI.bags[bag].slots[slot].frame:SetSize(frame.button_size, frame.button_size)
pfUI.bags[bag].slots[slot].frame:SetWidth(frame.button_size)
if x >= rowlength - 1 then if x >= rowlength - 1 then
y = y + 1 y = y + 1
@@ -337,12 +343,13 @@ pfUI:RegisterModule("bags", function ()
local chat = pfUI.chat and ( object == "bank" and pfUI.chat.left or pfUI.chat.right) or nil local chat = pfUI.chat and ( object == "bank" and pfUI.chat.left or pfUI.chat.right) or nil
frame:SetScript("OnShow", function() frame:SetScript("OnShow", function()
frame.opened = true
if C.appearance.bags.hidechat == "1" and chat and chat:IsVisible() then if C.appearance.bags.hidechat == "1" and chat and chat:IsVisible() then
frame.chatWasOpen = true frame.chatWasOpen = true
chat:Hide() chat:Hide()
end end
if C.appearance.bags.autoSortOnOpen == "1" then if C.appearance.bags.autoSortOnOpen == "1" then
libbagsort:Sort({0, 1, 2, 3, 4}) libbagsort:Sort({0, 1, 2, 3, 4}, BagSortOpts())
end end
pfUI.bag:CreateBags(object) pfUI.bag:CreateBags(object)
PlaySound("INTERFACESOUND_BACKPACKOPEN") PlaySound("INTERFACESOUND_BACKPACKOPEN")
@@ -355,6 +362,10 @@ pfUI:RegisterModule("bags", function ()
end end
pfUI.bag:CreateBags(object) pfUI.bag:CreateBags(object)
PlaySound("INTERFACESOUND_BACKPACKCLOSE") PlaySound("INTERFACESOUND_BACKPACKCLOSE")
if frame.opened then
frame.opened = nil
pfUI.events:TriggerEvent("bag:closed", object)
end
end) end)
end end
@@ -385,7 +396,7 @@ pfUI:RegisterModule("bags", function ()
if tpl == "BankItemButtonGenericTemplate" then if tpl == "BankItemButtonGenericTemplate" then
local bankslot = pfUI.bags[bag].slots[slot].frame local bankslot = pfUI.bags[bag].slots[slot].frame
local name = "pfBag" .. bag .. "item" .. slot .. "Cooldown" local name = "pfBag" .. bag .. "item" .. slot .. "Cooldown"
bankslot.cd = CreateFrame(COOLDOWN_FRAME_TYPE, name, bankslot, "CooldownFrameTemplate") bankslot.cd = CreateFrame("Model", name, bankslot, "CooldownFrameTemplate")
bankslot.cd:SetAllPoints(bankslot) bankslot.cd:SetAllPoints(bankslot)
bankslot.cd.pfCooldownStyleAnimation = 1 bankslot.cd.pfCooldownStyleAnimation = 1
bankslot.cd.pfCooldownType = "ALL" bankslot.cd.pfCooldownType = "ALL"
@@ -443,7 +454,7 @@ pfUI:RegisterModule("bags", function ()
end end
end end
local _, _, q, _, _, _, itype = GetItemInfo(itemID) local _, _, q, _, _, _, itype = C_Item.GetItemInfo(itemID)
-- running advanced item color scan -- running advanced item color scan
if C.appearance.bags.borderonlygear == "0" and texture and quality and quality < 1 then if C.appearance.bags.borderonlygear == "0" and texture and quality and quality < 1 then
@@ -533,8 +544,7 @@ pfUI:RegisterModule("bags", function ()
local width = (frame.button_size/5*4 + default_border*2) * (max-min+1+extra) local width = (frame.button_size/5*4 + default_border*2) * (max-min+1+extra)
local height = default_border + (frame.button_size/5*4 + default_border) local height = default_border + (frame.button_size/5*4 + default_border)
frame.bagslots:SetWidth(width) frame.bagslots:SetSize(width, height)
frame.bagslots:SetHeight(height)
for slot=min, max do for slot=min, max do
if not frame.bagslots.slots[slot] then if not frame.bagslots.slots[slot] then
frame.bagslots.slots[slot] = {} frame.bagslots.slots[slot] = {}
@@ -594,8 +604,7 @@ pfUI:RegisterModule("bags", function ()
frame.bagslots.slots[slot].frame:ClearAllPoints() frame.bagslots.slots[slot].frame:ClearAllPoints()
frame.bagslots.slots[slot].frame:SetPoint("TOPLEFT", frame.bagslots, "TOPLEFT", left, top) frame.bagslots.slots[slot].frame:SetPoint("TOPLEFT", frame.bagslots, "TOPLEFT", left, top)
frame.bagslots.slots[slot].frame:SetHeight(frame.button_size/5*4) frame.bagslots.slots[slot].frame:SetSize(frame.button_size/5*4, frame.button_size/5*4)
frame.bagslots.slots[slot].frame:SetWidth(frame.button_size/5*4)
CreateBackdrop(frame.bagslots.slots[slot].frame, default_border) CreateBackdrop(frame.bagslots.slots[slot].frame, default_border)
frame.bagslots.slots[slot].frame:Show() frame.bagslots.slots[slot].frame:Show()
@@ -614,8 +623,7 @@ pfUI:RegisterModule("bags", function ()
end end
frame.bagslots.buy:SetPoint("RIGHT", frame.bagslots, "RIGHT", -default_border, 0) frame.bagslots.buy:SetPoint("RIGHT", frame.bagslots, "RIGHT", -default_border, 0)
CreateBackdrop(frame.bagslots.buy, default_border) CreateBackdrop(frame.bagslots.buy, default_border)
frame.bagslots.buy:SetHeight(frame.button_size/5*4) frame.bagslots.buy:SetSize(frame.button_size/5*4, frame.button_size/5*4)
frame.bagslots.buy:SetWidth(frame.button_size/5*4)
frame.bagslots.buy:SetText("+") frame.bagslots.buy:SetText("+")
frame.bagslots.buy:SetTextColor(.5,.5,1,1) frame.bagslots.buy:SetTextColor(.5,.5,1,1)
frame.bagslots.buy:SetFont(pfUI.font_default, C.global.font_size, "OUTLINE") frame.bagslots.buy:SetFont(pfUI.font_default, C.global.font_size, "OUTLINE")
@@ -707,8 +715,7 @@ pfUI:RegisterModule("bags", function ()
frame.close = CreateFrame("Button", "pfBagClose", frame) frame.close = CreateFrame("Button", "pfBagClose", frame)
frame.close:SetPoint("TOPRIGHT", -default_border*1,-default_border ) frame.close:SetPoint("TOPRIGHT", -default_border*1,-default_border )
CreateBackdrop(frame.close, default_border) CreateBackdrop(frame.close, default_border)
frame.close:SetHeight(12) frame.close:SetSize(12, 12)
frame.close:SetWidth(12)
frame.close.texture = frame.close:CreateTexture("pfBagClose") frame.close.texture = frame.close:CreateTexture("pfBagClose")
frame.close.texture:SetTexture(pfUI.media["img:close"]) frame.close.texture:SetTexture(pfUI.media["img:close"])
frame.close.texture:ClearAllPoints() frame.close.texture:ClearAllPoints()
@@ -733,8 +740,7 @@ pfUI:RegisterModule("bags", function ()
frame.bags = CreateFrame("Button", "pfBagSlotShow", frame) frame.bags = CreateFrame("Button", "pfBagSlotShow", frame)
frame.bags:SetPoint("TOPRIGHT", frame.close, "TOPLEFT", -default_border*3, 0) frame.bags:SetPoint("TOPRIGHT", frame.close, "TOPLEFT", -default_border*3, 0)
CreateBackdrop(frame.bags, default_border) CreateBackdrop(frame.bags, default_border)
frame.bags:SetHeight(12) frame.bags:SetSize(12, 12)
frame.bags:SetWidth(12)
frame.bags:SetTextColor(1,1,.25,1) frame.bags:SetTextColor(1,1,.25,1)
frame.bags:SetFont(pfUI.font_default, C.global.font_size, "OUTLINE") frame.bags:SetFont(pfUI.font_default, C.global.font_size, "OUTLINE")
frame.bags.texture = frame.bags:CreateTexture("pfBagArrowUp") frame.bags.texture = frame.bags:CreateTexture("pfBagArrowUp")
@@ -761,11 +767,7 @@ pfUI:RegisterModule("bags", function ()
end) end)
frame.bags:SetScript("OnClick", function() frame.bags:SetScript("OnClick", function()
if pfUI.bag.right.bagslots:IsShown() then pfUI.bag.right.bagslots:SetShown(not pfUI.bag.right.bagslots:IsShown())
pfUI.bag.right.bagslots:Hide()
else
pfUI.bag.right.bagslots:Show()
end
end) end)
end end
@@ -774,8 +776,7 @@ pfUI:RegisterModule("bags", function ()
frame.open = CreateFrame("Button", "pfBagSlotOpen", frame) frame.open = CreateFrame("Button", "pfBagSlotOpen", frame)
frame.open:SetPoint("TOPRIGHT", frame.bags, "TOPLEFT", -default_border*3, 0) frame.open:SetPoint("TOPRIGHT", frame.bags, "TOPLEFT", -default_border*3, 0)
CreateBackdrop(frame.open, default_border) CreateBackdrop(frame.open, default_border)
frame.open:SetHeight(12) frame.open:SetSize(12, 12)
frame.open:SetWidth(12)
frame.open:SetTextColor(1,1,.25,1) frame.open:SetTextColor(1,1,.25,1)
frame.open:SetFont(pfUI.font_default, C.global.font_size, "OUTLINE") frame.open:SetFont(pfUI.font_default, C.global.font_size, "OUTLINE")
frame.open.texture = frame.open:CreateTexture("pfBagOpenContainer") frame.open.texture = frame.open:CreateTexture("pfBagOpenContainer")
@@ -833,8 +834,7 @@ pfUI:RegisterModule("bags", function ()
frame.disenchant = CreateFrame("Button", "pfBagSlotDisenchant", frame) frame.disenchant = CreateFrame("Button", "pfBagSlotDisenchant", frame)
frame.disenchant:SetPoint("TOPRIGHT", frame.open, "TOPLEFT", -default_border*3, 0) frame.disenchant:SetPoint("TOPRIGHT", frame.open, "TOPLEFT", -default_border*3, 0)
CreateBackdrop(frame.disenchant, default_border) CreateBackdrop(frame.disenchant, default_border)
frame.disenchant:SetHeight(12) frame.disenchant:SetSize(12, 12)
frame.disenchant:SetWidth(12)
frame.disenchant:SetTextColor(1,1,.25,1) frame.disenchant:SetTextColor(1,1,.25,1)
frame.disenchant:SetFont(pfUI.font_default, C.global.font_size, "OUTLINE") frame.disenchant:SetFont(pfUI.font_default, C.global.font_size, "OUTLINE")
frame.disenchant.texture = frame.disenchant:CreateTexture("pfBagDisenchant") frame.disenchant.texture = frame.disenchant:CreateTexture("pfBagDisenchant")
@@ -876,8 +876,7 @@ pfUI:RegisterModule("bags", function ()
frame.picklock = CreateFrame("Button", "pfBagSlotPicklock", frame) frame.picklock = CreateFrame("Button", "pfBagSlotPicklock", frame)
frame.picklock:SetPoint("TOPRIGHT", frame.disenchant, "TOPLEFT", -default_border*3, 0) frame.picklock:SetPoint("TOPRIGHT", frame.disenchant, "TOPLEFT", -default_border*3, 0)
CreateBackdrop(frame.picklock, default_border) CreateBackdrop(frame.picklock, default_border)
frame.picklock:SetHeight(12) frame.picklock:SetSize(12, 12)
frame.picklock:SetWidth(12)
frame.picklock:SetTextColor(1,1,.25,1) frame.picklock:SetTextColor(1,1,.25,1)
frame.picklock:SetFont(pfUI.font_default, C.global.font_size, "OUTLINE") frame.picklock:SetFont(pfUI.font_default, C.global.font_size, "OUTLINE")
frame.picklock.texture = frame.picklock:CreateTexture("pfBagPicklock") frame.picklock.texture = frame.picklock:CreateTexture("pfBagPicklock")
@@ -919,8 +918,7 @@ pfUI:RegisterModule("bags", function ()
frame.keys = CreateFrame("Button", "pfBagSlotShow", frame) frame.keys = CreateFrame("Button", "pfBagSlotShow", frame)
frame.keys:SetPoint("TOPRIGHT", frame.picklock, "TOPLEFT", -default_border*3, 0) frame.keys:SetPoint("TOPRIGHT", frame.picklock, "TOPLEFT", -default_border*3, 0)
CreateBackdrop(frame.keys, default_border) CreateBackdrop(frame.keys, default_border)
frame.keys:SetHeight(12) frame.keys:SetSize(12, 12)
frame.keys:SetWidth(12)
frame.keys:SetTextColor(1,1,.25,1) frame.keys:SetTextColor(1,1,.25,1)
frame.keys:SetFont(pfUI.font_default, C.global.font_size, "OUTLINE") frame.keys:SetFont(pfUI.font_default, C.global.font_size, "OUTLINE")
frame.keys.texture = frame.keys:CreateTexture("pfBagArrowUp") frame.keys.texture = frame.keys:CreateTexture("pfBagArrowUp")
@@ -962,8 +960,7 @@ pfUI:RegisterModule("bags", function ()
frame.sort = CreateFrame("Button", "pfBagSort", frame) frame.sort = CreateFrame("Button", "pfBagSort", frame)
frame.sort:SetPoint("TOPRIGHT", frame.keys, "TOPLEFT", -default_border*3, 0) frame.sort:SetPoint("TOPRIGHT", frame.keys, "TOPLEFT", -default_border*3, 0)
CreateBackdrop(frame.sort, default_border) CreateBackdrop(frame.sort, default_border)
frame.sort:SetHeight(12) frame.sort:SetSize(12, 12)
frame.sort:SetWidth(12)
frame.sort.texture = frame.sort:CreateTexture("pfBagSortIcon") frame.sort.texture = frame.sort:CreateTexture("pfBagSortIcon")
frame.sort.texture:SetTexture(pfUI.media["img:sort"]) frame.sort.texture:SetTexture(pfUI.media["img:sort"])
frame.sort.texture:ClearAllPoints() frame.sort.texture:ClearAllPoints()
@@ -975,7 +972,7 @@ pfUI:RegisterModule("bags", function ()
frame.sort.backdrop:SetBackdropBorderColor(1,1,.25,1) frame.sort.backdrop:SetBackdropBorderColor(1,1,.25,1)
frame.sort.texture:SetVertexColor(1,1,.25,1) frame.sort.texture:SetVertexColor(1,1,.25,1)
GameTooltip:SetOwner(this, "ANCHOR_RIGHT") GameTooltip:SetOwner(this, "ANCHOR_RIGHT")
GameTooltip:SetText("Sort Bags") GameTooltip:SetText(T["Sort Bags"])
GameTooltip:Show() GameTooltip:Show()
end) end)
@@ -988,7 +985,7 @@ pfUI:RegisterModule("bags", function ()
end) end)
frame.sort:SetScript("OnClick", function() frame.sort:SetScript("OnClick", function()
libbagsort:Sort({0, 1, 2, 3, 4}) libbagsort:Sort({0, 1, 2, 3, 4}, BagSortOpts())
end) end)
end end
@@ -996,8 +993,7 @@ pfUI:RegisterModule("bags", function ()
if not frame.gold and (C.appearance.bags.movable == "1" or not pfUI.panel) then if not frame.gold and (C.appearance.bags.movable == "1" or not pfUI.panel) then
frame.gold = CreateFrame("Frame", "pfBagGoldString", frame) frame.gold = CreateFrame("Frame", "pfBagGoldString", frame)
frame.gold:SetPoint("BOTTOMRIGHT", frame, "BOTTOMRIGHT", -4, 1) frame.gold:SetPoint("BOTTOMRIGHT", frame, "BOTTOMRIGHT", -4, 1)
frame.gold:SetWidth(200) frame.gold:SetSize(200, 18)
frame.gold:SetHeight(18)
frame.gold:RegisterEvent("PLAYER_ENTERING_WORLD") frame.gold:RegisterEvent("PLAYER_ENTERING_WORLD")
frame.gold:RegisterEvent("PLAYER_MONEY") frame.gold:RegisterEvent("PLAYER_MONEY")
frame.gold:SetScript("OnEvent", function() frame.gold:SetScript("OnEvent", function()
@@ -1089,21 +1085,6 @@ pfUI:RegisterModule("bags", function ()
frame.search.edit:ClearFocus() frame.search.edit:ClearFocus()
end) end)
frame.search:SetScript("OnHide", function()
frame.search.edit:SetText(T["Search"])
for bag = -2, 11 do
if pfUI.bags[bag] then
local bagsize = GetContainerNumSlots(bag)
if bag == -2 and pfUI.bag.showKeyring == true then bagsize = GetKeyRingSize() end
for slot = 1, bagsize do
if pfUI.bags[bag] and pfUI.bags[bag].slots[slot] then
pfUI.bags[bag].slots[slot].frame:SetAlpha(1)
end
end
end
end
end)
frame.search.edit:SetScript("OnMouseUp", function() frame.search.edit:SetScript("OnMouseUp", function()
if arg1 == "RightButton" then if arg1 == "RightButton" then
this:ClearFocus() this:ClearFocus()
@@ -1133,8 +1114,7 @@ pfUI:RegisterModule("bags", function ()
frame.close = CreateFrame("Button", "pfBagClose", frame) frame.close = CreateFrame("Button", "pfBagClose", frame)
frame.close:SetPoint("TOPRIGHT", -default_border*1,-default_border ) frame.close:SetPoint("TOPRIGHT", -default_border*1,-default_border )
CreateBackdrop(frame.close, default_border) CreateBackdrop(frame.close, default_border)
frame.close:SetHeight(12) frame.close:SetSize(12, 12)
frame.close:SetWidth(12)
frame.close.texture = frame.close:CreateTexture("pfBagClose") frame.close.texture = frame.close:CreateTexture("pfBagClose")
frame.close.texture:SetTexture(pfUI.media["img:close"]) frame.close.texture:SetTexture(pfUI.media["img:close"])
frame.close.texture:ClearAllPoints() frame.close.texture:ClearAllPoints()
@@ -1159,8 +1139,7 @@ pfUI:RegisterModule("bags", function ()
frame.bags = CreateFrame("Button", "pfBagSlotShow", frame) frame.bags = CreateFrame("Button", "pfBagSlotShow", frame)
frame.bags:SetPoint("TOPRIGHT", frame.close, "TOPLEFT", -default_border*3, 0) frame.bags:SetPoint("TOPRIGHT", frame.close, "TOPLEFT", -default_border*3, 0)
CreateBackdrop(frame.bags, default_border) CreateBackdrop(frame.bags, default_border)
frame.bags:SetHeight(12) frame.bags:SetSize(12, 12)
frame.bags:SetWidth(12)
frame.bags:SetTextColor(1,1,.25,1) frame.bags:SetTextColor(1,1,.25,1)
frame.bags:SetFont(pfUI.font_default, C.global.font_size, "OUTLINE") frame.bags:SetFont(pfUI.font_default, C.global.font_size, "OUTLINE")
frame.bags.texture = frame.bags:CreateTexture("pfBagArrowUp") frame.bags.texture = frame.bags:CreateTexture("pfBagArrowUp")
@@ -1213,7 +1192,7 @@ pfUI:RegisterModule("bags", function ()
frame.sort.backdrop:SetBackdropBorderColor(1,1,.25,1) frame.sort.backdrop:SetBackdropBorderColor(1,1,.25,1)
frame.sort.texture:SetVertexColor(1,1,.25,1) frame.sort.texture:SetVertexColor(1,1,.25,1)
GameTooltip:SetOwner(this, "ANCHOR_RIGHT") GameTooltip:SetOwner(this, "ANCHOR_RIGHT")
GameTooltip:SetText("Sort Bank") GameTooltip:SetText(T["Sort Bank"])
GameTooltip:Show() GameTooltip:Show()
end) end)
@@ -1226,7 +1205,7 @@ pfUI:RegisterModule("bags", function ()
end) end)
frame.sort:SetScript("OnClick", function() frame.sort:SetScript("OnClick", function()
libbagsort:Sort({-1, 5, 6, 7, 8, 9, 10}) libbagsort:Sort({-1, 5, 6, 7, 8, 9, 10}, BagSortOpts())
end) end)
end end
end end
modules/bgscore.lua
+3 -5
View File
@@ -2,14 +2,12 @@ pfUI:RegisterModule("bgscore", function ()
local bgframe = WorldStateAlwaysUpFrame local bgframe = WorldStateAlwaysUpFrame
if not bgframe then if not bgframe then
bgframe = CreateFrame("Frame", "WorldStateAlwaysUpFrame", UIParent) bgframe = CreateFrame("Frame", "WorldStateAlwaysUpFrame", UIParent)
bgframe:SetWidth(200) bgframe:SetSize(200, 25)
bgframe:SetHeight(25)
bgframe:SetPoint("TOP", UIParent, "TOP", 0, -100) bgframe:SetPoint("TOP", UIParent, "TOP", 0, -100)
end end
local mover = CreateFrame("Frame", "pfUIBGScoreMover", UIParent) local mover = CreateFrame("Frame", "pfUIBGScoreMover", UIParent)
mover:SetWidth(220) mover:SetSize(220, 30)
mover:SetHeight(30)
mover:SetPoint("TOP", UIParent, "TOP", 0, -100) mover:SetPoint("TOP", UIParent, "TOP", 0, -100)
mover:SetFrameStrata("DIALOG") mover:SetFrameStrata("DIALOG")
mover:SetMovable(true) mover:SetMovable(true)
@@ -34,7 +32,7 @@ pfUI:RegisterModule("bgscore", function ()
-- Title label -- Title label
local title = mover:CreateFontString(nil, "OVERLAY") local title = mover:CreateFontString(nil, "OVERLAY")
title:SetFont("Fonts\\FRIZQT__.TTF", 14, "OUTLINE") title:SetFont("Fonts\\FRIZQT__.TTF", 14, "OUTLINE")
title:SetText("Battleground Frames") title:SetText(T["Battleground Frames"])
title:SetPoint("TOP", mover, "TOP", 0, -2) title:SetPoint("TOP", mover, "TOP", 0, -2)
-- BG score preview text -- BG score preview text
modules/bubbles.lua
+2 -9
View File
@@ -17,12 +17,6 @@ pfUI:RegisterModule("bubbles", function ()
RunNextFrame(function() pfUI.bubbles:ScanBubbles() end) RunNextFrame(function() pfUI.bubbles:ScanBubbles() end)
end) end)
function pfUI.bubbles:IsBubble(f)
if f:GetName() then return end
if not f:GetRegions() then return end
return f:GetRegions().GetTexture and f:GetRegions():GetTexture() == "Interface\\Tooltips\\ChatBubble-Background"
end
function pfUI.bubbles:ProcessBubble(f) function pfUI.bubbles:ProcessBubble(f)
f.text:Hide() f.text:Hide()
f.text:SetFont(pfUI.font_default, tonumber(C.global.font_size) * UIParent:GetScale(), "OUTLINE") f.text:SetFont(pfUI.font_default, tonumber(C.global.font_size) * UIParent:GetScale(), "OUTLINE")
@@ -34,9 +28,8 @@ pfUI:RegisterModule("bubbles", function ()
end end
function pfUI.bubbles:ScanBubbles() function pfUI.bubbles:ScanBubbles()
local childs = { WorldFrame:GetChildren() } for _, f in ipairs(C_ChatBubbles.GetAllChatBubbles()) do
for _, f in pairs(childs) do if not f.frame then
if not f.frame and pfUI.bubbles:IsBubble(f) then
local textures = {f:GetRegions()} local textures = {f:GetRegions()}
for _, object in pairs(textures) do for _, object in pairs(textures) do
if object:GetObjectType() == "Texture" then if object:GetObjectType() == "Texture" then
modules/buff.lua
+46 -32
View File
@@ -7,6 +7,15 @@ pfUI:RegisterModule("buff", function ()
local br, bg, bb, ba = GetStringColor(pfUI_config.appearance.border.color) local br, bg, bb, ba = GetStringColor(pfUI_config.appearance.border.color)
-- Player aura slot ids, enumerated once per refresh pass (ScanPlayerAuraSlots)
-- and read per button by its aura index: one GetAuraSlots walk per range
-- instead of a by-index walk per button.
local helpfulSlots, harmfulSlots = {}, {}
local function ScanPlayerAuraSlots()
ScanAuraSlots("player", "HELPFUL", helpfulSlots, 32)
ScanAuraSlots("player", "HARMFUL", harmfulSlots, 16)
end
local function RefreshBuffButton(buff) local function RefreshBuffButton(buff)
if buff.btype == "HELPFUL" then if buff.btype == "HELPFUL" then
if C.buffs.separateweapons == "1" then if C.buffs.separateweapons == "1" then
@@ -23,7 +32,8 @@ pfUI:RegisterModule("buff", function ()
CreateBackdropShadow(buff) CreateBackdropShadow(buff)
end end
local aura = C_UnitAuras.GetAuraDataByIndex("player", buff.id, buff.btype) local slots = buff.btype == "HELPFUL" and helpfulSlots or harmfulSlots
local name, icon, count, dispelType, _, expirationTime, _, _, _, spellId = C_UnitAuras.UnitAuraBySlot("player", slots[buff.id])
--detect weapon buffs --detect weapon buffs
if buff.btype == "HELPFUL" and ((C.buffs.separateweapons == "0" and buff.gid <= pfUI.buff.wepbuffs.count) or (pfUI.buff.wepbuffs.count > 0 and buff.weapon ~= nil)) then if buff.btype == "HELPFUL" and ((C.buffs.separateweapons == "0" and buff.gid <= pfUI.buff.wepbuffs.count) or (pfUI.buff.wepbuffs.count > 0 and buff.weapon ~= nil)) then
@@ -55,16 +65,16 @@ pfUI:RegisterModule("buff", function ()
buff.texture:SetTexture(GetInventoryItemTexture("player", 17)) buff.texture:SetTexture(GetInventoryItemTexture("player", 17))
buff.backdrop:SetBackdropBorderColor(GetItemQualityColor(GetInventoryItemQuality("player", 17) or 1)) buff.backdrop:SetBackdropBorderColor(GetItemQualityColor(GetInventoryItemQuality("player", 17) or 1))
end end
elseif aura and (( buff.btype == "HARMFUL" and C.buffs.debuffs == "1" ) or ( buff.btype == "HELPFUL" and C.buffs.buffs == "1" )) then elseif name and (( buff.btype == "HARMFUL" and C.buffs.debuffs == "1" ) or ( buff.btype == "HELPFUL" and C.buffs.buffs == "1" )) then
-- Set Buff Texture and Border -- Set Buff Texture and Border
buff.mode = buff.btype buff.mode = buff.btype
buff.expirationTime = aura.expirationTime buff.expirationTime = expirationTime
buff.stackCount = aura.applications buff.stackCount = count
buff.spellId = aura.spellId buff.spellId = spellId
buff.texture:SetTexture(aura.icon) buff.texture:SetTexture(icon)
if buff.btype == "HARMFUL" then if buff.btype == "HARMFUL" then
local dispelColor = C_UnitAuras.GetAuraDispelTypeColor(aura.dispelName) local dispelColor = C_UnitAuras.GetAuraDispelTypeColor(dispelType)
buff.backdrop:SetBackdropBorderColor(dispelColor:GetRGBA()) buff.backdrop:SetBackdropBorderColor(dispelColor:GetRGBA())
else else
buff.backdrop:SetBackdropBorderColor(br,bg,bb,ba) buff.backdrop:SetBackdropBorderColor(br,bg,bb,ba)
@@ -138,16 +148,10 @@ pfUI:RegisterModule("buff", function ()
end end
end) end)
buff:SetScript("OnLeave", function() buff:SetScript("OnLeave", GameTooltip_Hide)
GameTooltip:Hide()
end)
buff:SetScript("OnClick", function() buff:SetScript("OnClick", function()
if CancelItemTempEnchantment and this.mode and this.mode == "MAINHAND" then if this.spellId then
CancelItemTempEnchantment(1)
elseif CancelItemTempEnchantment and this.mode and this.mode == "OFFHAND" then
CancelItemTempEnchantment(2)
elseif this.spellId then
C_Spell.CancelSpellByID(this.spellId) C_Spell.CancelSpellByID(this.spellId)
end end
end) end)
@@ -160,7 +164,7 @@ pfUI:RegisterModule("buff", function ()
pfUI.buff = CreateFrame("Frame", "pfGlobalBuffFrame", UIParent) pfUI.buff = CreateFrame("Frame", "pfGlobalBuffFrame", UIParent)
pfUI.buff:RegisterEvent("PLAYER_AURAS_CHANGED") pfUI.buff:RegisterEvent("PLAYER_AURAS_CHANGED")
pfUI.buff:RegisterEvent("PLAYER_EQUIPMENT_CHANGED") pfUI.buff:RegisterEvent("PLAYER_EQUIPMENT_CHANGED")
pfUI.buff:RegisterEvent("UNIT_MODEL_CHANGED") pfUI.buff:RegisterUnitEvent("UNIT_MODEL_CHANGED", "player")
pfUI.buff:RegisterEvent("BUFF_UPDATE_DURATION_SELF") pfUI.buff:RegisterEvent("BUFF_UPDATE_DURATION_SELF")
pfUI.buff:RegisterEvent("DEBUFF_UPDATE_DURATION_SELF") pfUI.buff:RegisterEvent("DEBUFF_UPDATE_DURATION_SELF")
pfUI.buff:SetScript("OnEvent", function() pfUI.buff:SetScript("OnEvent", function()
@@ -172,6 +176,8 @@ pfUI:RegisterModule("buff", function ()
pfUI.buff.wepbuffs.count = 0 pfUI.buff.wepbuffs.count = 0
end end
ScanPlayerAuraSlots()
for i=1,32 do for i=1,32 do
RefreshBuffButton(pfUI.buff.buffs.buttons[i]) RefreshBuffButton(pfUI.buff.buffs.buttons[i])
end end
@@ -252,6 +258,9 @@ pfUI:RegisterModule("buff", function ()
end end
end) end)
-- CreateBuffButton refreshes each new button from the slot buffers
ScanPlayerAuraSlots()
-- Weapon Buffs -- Weapon Buffs
pfUI.buff.wepbuffs = CreateFrame("Frame", "pfWepBuffFrame", UIParent) pfUI.buff.wepbuffs = CreateFrame("Frame", "pfWepBuffFrame", UIParent)
pfUI.buff.wepbuffs.count = 0 pfUI.buff.wepbuffs.count = 0
@@ -277,28 +286,27 @@ pfUI:RegisterModule("buff", function ()
-- config loading -- config loading
function pfUI.buff:UpdateConfigBuffButton(buff) function pfUI.buff:UpdateConfigBuffButton(buff)
local fontsize = C.buffs.fontsize == "-1" and C.global.font_size or C.buffs.fontsize local fontsize = C.buffs.fontsize == "-1" and C.global.font_size or C.buffs.fontsize
local buffSize, buffSpacing = tonumber(C.buffs.size), tonumber(C.buffs.spacing)
local rowcount, relFrame, offsetX, offsetY local rowcount, relFrame, offsetX, offsetY
if buff.btype == "HELPFUL" then if buff.btype == "HELPFUL" then
if buff.weapon == 1 and C.buffs.separateweapons == "1" then if buff.weapon == 1 and C.buffs.separateweapons == "1" then
rowcount = floor((buff.gid-1) / tonumber(C.buffs.wepbuffrowsize)) rowcount = floor((buff.gid-1) / tonumber(C.buffs.wepbuffrowsize))
relFrame = pfUI.buff.wepbuffs relFrame = pfUI.buff.wepbuffs
offsetX = -(buff.gid-1-rowcount*tonumber(C.buffs.wepbuffrowsize))*(tonumber(C.buffs.size)+2*tonumber(C.buffs.spacing)) offsetX = -(buff.gid-1-rowcount*tonumber(C.buffs.wepbuffrowsize))*(buffSize+2*buffSpacing)
offsetY = -(rowcount) * ((C.buffs.textinside == "1" and 0 or (fontsize*1.5))+tonumber(C.buffs.size)+2*tonumber(C.buffs.spacing)) offsetY = -(rowcount) * ((C.buffs.textinside == "1" and 0 or (fontsize*1.5))+buffSize+2*buffSpacing)
else else
rowcount = floor((buff.gid-1) / tonumber(C.buffs.buffrowsize)) rowcount = floor((buff.gid-1) / tonumber(C.buffs.buffrowsize))
relFrame = pfUI.buff.buffs relFrame = pfUI.buff.buffs
offsetX = -(buff.gid-1-rowcount*tonumber(C.buffs.buffrowsize))*(tonumber(C.buffs.size)+2*tonumber(C.buffs.spacing)) offsetX = -(buff.gid-1-rowcount*tonumber(C.buffs.buffrowsize))*(buffSize+2*buffSpacing)
offsetY = -(rowcount) * ((C.buffs.textinside == "1" and 0 or (fontsize*1.5))+tonumber(C.buffs.size)+2*tonumber(C.buffs.spacing)) offsetY = -(rowcount) * ((C.buffs.textinside == "1" and 0 or (fontsize*1.5))+buffSize+2*buffSpacing)
end end
else else
rowcount = floor((buff.gid-1) / tonumber(C.buffs.debuffrowsize)) rowcount = floor((buff.gid-1) / tonumber(C.buffs.debuffrowsize))
relFrame = pfUI.buff.debuffs relFrame = pfUI.buff.debuffs
offsetX = -(buff.gid-1-rowcount*tonumber(C.buffs.debuffrowsize))*(tonumber(C.buffs.size)+2*tonumber(C.buffs.spacing)) offsetX = -(buff.gid-1-rowcount*tonumber(C.buffs.debuffrowsize))*(buffSize+2*buffSpacing)
offsetY = -(rowcount) * ((C.buffs.textinside == "1" and 0 or (fontsize*1.5))+tonumber(C.buffs.size)+2*tonumber(C.buffs.spacing)) offsetY = -(rowcount) * ((C.buffs.textinside == "1" and 0 or (fontsize*1.5))+buffSize+2*buffSpacing)
end end
buff:SetSize(buffSize, buffSize)
buff:SetWidth(tonumber(C.buffs.size))
buff:SetHeight(tonumber(C.buffs.size))
buff:ClearAllPoints() buff:ClearAllPoints()
buff:SetPoint("TOPRIGHT", relFrame, "TOPRIGHT",offsetX, offsetY) buff:SetPoint("TOPRIGHT", relFrame, "TOPRIGHT",offsetX, offsetY)
@@ -318,20 +326,26 @@ pfUI:RegisterModule("buff", function ()
function pfUI.buff:UpdateConfig() function pfUI.buff:UpdateConfig()
local fontsize = C.buffs.fontsize == "-1" and C.global.font_size or C.buffs.fontsize local fontsize = C.buffs.fontsize == "-1" and C.global.font_size or C.buffs.fontsize
pfUI.buff.buffs:SetWidth(tonumber(C.buffs.buffrowsize) * (tonumber(C.buffs.size)+2*tonumber(C.buffs.spacing))) local spacing = tonumber(C.buffs.spacing)
pfUI.buff.buffs:SetHeight(ceil(32/tonumber(C.buffs.buffrowsize)) * ((C.buffs.textinside == "1" and 0 or (fontsize*1.5))+tonumber(C.buffs.size)+2*tonumber(C.buffs.spacing))) local cell = tonumber(C.buffs.size) + 2 * spacing
pfUI.buff.buffs:SetPoint("TOPRIGHT", pfUI.minimap or UIParent, "TOPLEFT", -4*tonumber(C.buffs.spacing), 0) local rowextra = C.buffs.textinside == "1" and 0 or (fontsize * 1.5)
local function SizeBuffFrame(frame, rowsize, count)
rowsize = tonumber(rowsize)
frame:SetSize(rowsize * cell, ceil(count / rowsize) * (rowextra + cell))
end
SizeBuffFrame(pfUI.buff.buffs, C.buffs.buffrowsize, 32)
pfUI.buff.buffs:SetPoint("TOPRIGHT", pfUI.minimap or UIParent, "TOPLEFT", -4 * spacing, 0)
UpdateMovable(pfUI.buff.buffs) UpdateMovable(pfUI.buff.buffs)
pfUI.buff.debuffs:SetWidth(tonumber(C.buffs.debuffrowsize) * (tonumber(C.buffs.size)+2*tonumber(C.buffs.spacing))) SizeBuffFrame(pfUI.buff.debuffs, C.buffs.debuffrowsize, 16)
pfUI.buff.debuffs:SetHeight(ceil(16/tonumber(C.buffs.debuffrowsize)) * ((C.buffs.textinside == "1" and 0 or (fontsize*1.5))+tonumber(C.buffs.size)+2*tonumber(C.buffs.spacing)))
pfUI.buff.debuffs:SetPoint("TOPRIGHT", pfUI.buff.buffs, "BOTTOMRIGHT", 0, 0) pfUI.buff.debuffs:SetPoint("TOPRIGHT", pfUI.buff.buffs, "BOTTOMRIGHT", 0, 0)
UpdateMovable(pfUI.buff.debuffs) UpdateMovable(pfUI.buff.debuffs)
if C.buffs.separateweapons == "1" then if C.buffs.separateweapons == "1" then
pfUI.buff.wepbuffs:ClearAllPoints() pfUI.buff.wepbuffs:ClearAllPoints()
pfUI.buff.wepbuffs:SetWidth(tonumber(C.buffs.wepbuffrowsize) * (tonumber(C.buffs.size)+2*tonumber(C.buffs.spacing))) SizeBuffFrame(pfUI.buff.wepbuffs, C.buffs.wepbuffrowsize, 2)
pfUI.buff.wepbuffs:SetHeight(ceil(2/tonumber(C.buffs.wepbuffrowsize)) * ((C.buffs.textinside == "1" and 0 or (fontsize*1.5))+tonumber(C.buffs.size)+2*tonumber(C.buffs.spacing)))
pfUI.buff.wepbuffs:SetPoint("TOPRIGHT", pfUI.buff.debuffs, "BOTTOMRIGHT", 0, 0) pfUI.buff.wepbuffs:SetPoint("TOPRIGHT", pfUI.buff.debuffs, "BOTTOMRIGHT", 0, 0)
pfUI.buff.wepbuffs:Show() pfUI.buff.wepbuffs:Show()
UpdateMovable(pfUI.buff.wepbuffs) UpdateMovable(pfUI.buff.wepbuffs)
modules/buffwatch.lua
+51 -44
View File
@@ -73,12 +73,19 @@ pfUI:RegisterModule("buffwatch", function ()
return anchor return anchor
end end
local function GetBuffData(unit, id, type, selfdebuff) -- reusable GetAuraSlots buffer, filled once per RefreshBuffBarFrame
local filter = (selfdebuff and type == "HARMFUL") and "HARMFUL|PLAYER" or type local auraSlots = {}
local aura = C_UnitAuras.GetAuraDataByIndex(unit, id, filter)
if not aura then return end -- Separate buffer for the tooltip handler: OnEnter can fire while a refresh
local remaining = aura.expirationTime > 0 and (aura.expirationTime - GetTime()) or 0 -- is showing/hiding bars under the cursor, so it must not share the above.
return remaining, aura.icon, aura.name, aura.applications local tooltipSlots = {}
-- Reads one aura by the slot id GetAuraSlots returned (nil slot -> nil).
local function GetBuffData(unit, slot)
local name, icon, count, dispelType, _, expirationTime = C_UnitAuras.UnitAuraBySlot(unit, slot)
if not name then return end
local remaining = expirationTime > 0 and (expirationTime - GetTime()) or 0
return remaining, icon, name, count, dispelType
end end
local function StatusBarOnClick() local function StatusBarOnClick()
@@ -90,12 +97,14 @@ pfUI:RegisterModule("buffwatch", function ()
if val == skill then return end if val == skill then return end
end end
config.whitelist = config.whitelist .. "#" .. skill config.whitelist = config.whitelist .. "#" .. skill
fcache[tostring(config)] = nil -- invalidate so the new entry takes effect immediately
DEFAULT_CHAT_FRAME:AddMessage("|cff33ffcc" .. skill .. "|r" .. T["is now whitelisted."]) DEFAULT_CHAT_FRAME:AddMessage("|cff33ffcc" .. skill .. "|r" .. T["is now whitelisted."])
elseif IsShiftKeyDown() then elseif IsShiftKeyDown() then
for _, val in pairs({strsplit("#", config.blacklist)}) do for _, val in pairs({strsplit("#", config.blacklist)}) do
if val == skill then return end if val == skill then return end
end end
config.blacklist = config.blacklist .. "#" .. skill config.blacklist = config.blacklist .. "#" .. skill
fcache[tostring(config)] = nil -- invalidate so the new entry takes effect immediately
DEFAULT_CHAT_FRAME:AddMessage("|cff33ffcc" .. skill .. "|r" .. T["is now blacklisted."]) DEFAULT_CHAT_FRAME:AddMessage("|cff33ffcc" .. skill .. "|r" .. T["is now blacklisted."])
end end
elseif this.parent.unit == "player" then elseif this.parent.unit == "player" then
@@ -111,17 +120,22 @@ pfUI:RegisterModule("buffwatch", function ()
GameTooltip:SetUnitAura("player", this.id, this.type) GameTooltip:SetUnitAura("player", this.id, this.type)
elseif this.type == "HARMFUL" then elseif this.type == "HARMFUL" then
-- selfdebuff filters the displayed list to player-cast harmful auras, but -- selfdebuff filters the displayed list to player-cast harmful auras, but
-- SetUnitAura's index has to be into the engine's full HARMFUL list. Look -- SetUnitAura's index has to be into the unfiltered HARMFUL list. Look up
-- up the displayed aura via the PLAYER filter, then scan engine slots for -- the displayed aura via the PLAYER filter, then find its position in the
-- one whose name + sourceGUID match. -- unfiltered list by name + sourceGUID.
--
-- The unfiltered list is NOT capped at 16: once a unit's 16 debuff slots
-- are full the server parks further debuffs in buff slots, and
-- C_UnitAuras reports those as harmful too. So enumerate what it has.
local config = this.parent and this.parent.config local config = this.parent and this.parent.config
if config and config.selfdebuff == "1" then if config and config.selfdebuff == "1" then
local ownAura = C_UnitAuras.GetAuraDataByIndex(this.unit, this.id, "HARMFUL|PLAYER") local ownAura = C_UnitAuras.GetAuraDataByIndex(this.unit, this.id, "HARMFUL|PLAYER")
if ownAura then if ownAura then
for gameSlot = 1, 16 do local n = ScanAuraSlots(this.unit, "HARMFUL", tooltipSlots)
local check = C_UnitAuras.GetDebuffDataByIndex(this.unit, gameSlot) for i = 1, n do
local check = C_UnitAuras.GetAuraDataBySlot(this.unit, tooltipSlots[i])
if check and check.name == ownAura.name and check.sourceGUID == ownAura.sourceGUID then if check and check.name == ownAura.name and check.sourceGUID == ownAura.sourceGUID then
GameTooltip:SetUnitAura(this.unit, gameSlot, "HARMFUL") GameTooltip:SetUnitAura(this.unit, i, "HARMFUL")
break break
end end
end end
@@ -162,8 +176,7 @@ pfUI:RegisterModule("buffwatch", function ()
local color = parent.color local color = parent.color
local bordercolor = parent.bordercolor local bordercolor = parent.bordercolor
local textcolor = parent.textcolor local textcolor = parent.textcolor
local width = parent:GetWidth() local width, height = parent:GetSize()
local height = parent:GetHeight()
local framename = "pf" .. parent.unit .. ( parent.type == "HARMFUL" and "Debuff" or "Buff" ) .. "Bar" .. bar local framename = "pf" .. parent.unit .. ( parent.type == "HARMFUL" and "Debuff" or "Buff" ) .. "Bar" .. bar
local font = parent.config.use_unitfonts == "1" and pfUI.font_unit or pfUI.font_default local font = parent.config.use_unitfonts == "1" and pfUI.font_unit or pfUI.font_default
@@ -172,8 +185,7 @@ pfUI:RegisterModule("buffwatch", function ()
frame:EnableMouse(1) frame:EnableMouse(1)
frame:Hide() frame:Hide()
frame:SetPoint("BOTTOM", 0, (bar-1)*(height+2*border+1)) frame:SetPoint("BOTTOM", 0, (bar-1)*(height+2*border+1))
frame:SetWidth(width) frame:SetSize(width, height)
frame:SetHeight(height)
frame.bar = CreateFrame("StatusBar", "pfBuffBar" .. bar, frame) frame.bar = CreateFrame("StatusBar", "pfBuffBar" .. bar, frame)
frame.bar:SetPoint("TOPLEFT", frame, "TOPLEFT", height+1, 0) frame.bar:SetPoint("TOPLEFT", frame, "TOPLEFT", height+1, 0)
@@ -202,8 +214,7 @@ pfUI:RegisterModule("buffwatch", function ()
frame.time:SetJustifyH("RIGHT") frame.time:SetJustifyH("RIGHT")
frame.icon = frame:CreateTexture(nil, "OVERLAY") frame.icon = frame:CreateTexture(nil, "OVERLAY")
frame.icon:SetWidth(height) frame.icon:SetSize(height, height)
frame.icon:SetHeight(height)
frame.icon:SetPoint("LEFT", frame, "LEFT", 0, 0) frame.icon:SetPoint("LEFT", frame, "LEFT", 0, 0)
frame.icon:SetTexCoord(.07,.93,.07,.93) frame.icon:SetTexCoord(.07,.93,.07,.93)
@@ -225,7 +236,7 @@ pfUI:RegisterModule("buffwatch", function ()
CreateBackdrop(frame) CreateBackdrop(frame)
CreateBackdropShadow(frame) CreateBackdropShadow(frame)
if bordercolor.r ~= "0" and bordercolor.g ~= "0" and bordercolor.b ~= "0" and bordercolor.a ~= "0" then if bordercolor.r ~= 0 and bordercolor.g ~= 0 and bordercolor.b ~= 0 and bordercolor.a ~= 0 then
frame.backdrop:SetBackdropBorderColor(bordercolor.r,bordercolor.g,bordercolor.b,1) frame.backdrop:SetBackdropBorderColor(bordercolor.r,bordercolor.g,bordercolor.b,1)
end end
@@ -235,9 +246,15 @@ pfUI:RegisterModule("buffwatch", function ()
local function RefreshBuffBarFrame(frame) local function RefreshBuffBarFrame(frame)
-- reinitialize all active buffs -- reinitialize all active buffs
local selfdebuff = frame.config.selfdebuff == "1" local selfdebuff = frame.config.selfdebuff == "1"
local filter = (selfdebuff and frame.type == "HARMFUL") and "HARMFUL|PLAYER" or frame.type
-- one GetAuraSlots enumeration per refresh instead of a by-index walk per
-- bar; the i-th slot is the i-th aura of the filtered list, so `i` stays
-- the index the tooltip / cancel handlers pass to the by-index API
ScanAuraSlots(frame.unit, filter, auraSlots, 32)
for i=1,32 do for i=1,32 do
local timeleft, texture, name, stacks = GetBuffData(frame.unit, i, frame.type, selfdebuff) local timeleft, texture, name, stacks, dtype = GetBuffData(frame.unit, auraSlots[i])
timeleft = timeleft or 0 timeleft = timeleft or 0
if texture and name and name ~= "" and BuffIsVisible(frame.config, name) then if texture and name and name ~= "" and BuffIsVisible(frame.config, name) then
@@ -246,12 +263,14 @@ pfUI:RegisterModule("buffwatch", function ()
frame.buffs[i][3] = name frame.buffs[i][3] = name
frame.buffs[i][4] = texture frame.buffs[i][4] = texture
frame.buffs[i][5] = stacks frame.buffs[i][5] = stacks
frame.buffs[i][6] = dtype
else else
frame.buffs[i][1] = 0 frame.buffs[i][1] = 0
frame.buffs[i][2] = nil frame.buffs[i][2] = nil
frame.buffs[i][3] = nil frame.buffs[i][3] = nil
frame.buffs[i][4] = nil frame.buffs[i][4] = nil
frame.buffs[i][5] = 0 frame.buffs[i][5] = 0
frame.buffs[i][6] = nil
end end
end end
@@ -295,12 +314,9 @@ pfUI:RegisterModule("buffwatch", function ()
-- calculate dynamic auto color -- calculate dynamic auto color
local r, g, b local r, g, b
if frame.type == "HARMFUL" then if frame.type == "HARMFUL" then
r, g, b = 1, .2, .2 -- official Blizzard dispel-type colors (matches unitframes/buff);
local a = C_UnitAuras.GetDebuffDataByIndex(frame.unit, data[2]) -- nil/unknown type falls back to the DEBUFF_TYPE_NONE colour
local dtype = a and a.dispelName r, g, b = C_UnitAuras.GetAuraDispelTypeColor(data[6] or ""):GetRGBA()
if dtype and DebuffTypeColor[dtype] then
r,g,b = DebuffTypeColor[dtype].r,DebuffTypeColor[dtype].g,DebuffTypeColor[dtype].b
end
else else
r,g,b = str2rgb(data[3]) r,g,b = str2rgb(data[3])
end end
@@ -422,18 +438,15 @@ pfUI:RegisterModule("buffwatch", function ()
if pfUI.uf.player and C.buffbar.pbuff.enable == "1" then if pfUI.uf.player and C.buffbar.pbuff.enable == "1" then
pfUI.uf.player.buffbar = CreateBuffBarFrame("Player", "HELPFUL") pfUI.uf.player.buffbar = CreateBuffBarFrame("Player", "HELPFUL")
local config = C.buffbar.pbuff local config = C.buffbar.pbuff
local r, g, b, a = strsplit(",", config.color)
local br, bg, bb, ba = strsplit(",", config.bordercolor)
local tr, tg, tb, ta = strsplit(",", config.textcolor)
pfUI.uf.player.buffbar:SetWidth(config.width == "-1" and pfUI.uf.player:GetWidth() or config.width) pfUI.uf.player.buffbar:SetWidth(config.width == "-1" and pfUI.uf.player:GetWidth() or config.width)
pfUI.uf.player.buffbar:SetHeight(config.height) pfUI.uf.player.buffbar:SetHeight(config.height)
pfUI.uf.player.buffbar.threshold = tonumber(config.threshold) pfUI.uf.player.buffbar.threshold = tonumber(config.threshold)
pfUI.uf.player.buffbar.config = config pfUI.uf.player.buffbar.config = config
pfUI.uf.player.buffbar.buffcmp = config.sort == "asc" and asc or desc pfUI.uf.player.buffbar.buffcmp = config.sort == "asc" and asc or desc
pfUI.uf.player.buffbar.color = { r = r, g = g, b = b, a = a } pfUI.uf.player.buffbar.color = GetStringColorObject(config.color)
pfUI.uf.player.buffbar.bordercolor = { r = br, g = bg, b = bb, a = ba } pfUI.uf.player.buffbar.bordercolor = GetStringColorObject(config.bordercolor)
pfUI.uf.player.buffbar.textcolor = { r = tr, g = tg, b = tb, a = ta } pfUI.uf.player.buffbar.textcolor = GetStringColorObject(config.textcolor)
pfUI.uf.player.buffbar.anchors = { pfUI.uf.player.buffbar.anchors = {
pfUI.uf.player, pfUI.uf.player,
pfUI.uf.player and pfUI.uf.player.debuffs, pfUI.uf.player and pfUI.uf.player.debuffs,
@@ -448,9 +461,6 @@ pfUI:RegisterModule("buffwatch", function ()
-- create player debuffbars -- create player debuffbars
if pfUI.uf.player and C.buffbar.pdebuff.enable == "1" then if pfUI.uf.player and C.buffbar.pdebuff.enable == "1" then
local config = C.buffbar.pdebuff local config = C.buffbar.pdebuff
local r, g, b, a = strsplit(",", config.color)
local br, bg, bb, ba = strsplit(",", config.bordercolor)
local tr, tg, tb, ta = strsplit(",", config.textcolor)
pfUI.uf.player.debuffbar = CreateBuffBarFrame("Player", "HARMFUL") pfUI.uf.player.debuffbar = CreateBuffBarFrame("Player", "HARMFUL")
pfUI.uf.player.debuffbar:SetWidth(config.width == "-1" and pfUI.uf.player:GetWidth() or config.width) pfUI.uf.player.debuffbar:SetWidth(config.width == "-1" and pfUI.uf.player:GetWidth() or config.width)
@@ -458,9 +468,9 @@ pfUI:RegisterModule("buffwatch", function ()
pfUI.uf.player.debuffbar.threshold = tonumber(config.threshold) pfUI.uf.player.debuffbar.threshold = tonumber(config.threshold)
pfUI.uf.player.debuffbar.config = config pfUI.uf.player.debuffbar.config = config
pfUI.uf.player.debuffbar.buffcmp = config.sort == "asc" and asc or desc pfUI.uf.player.debuffbar.buffcmp = config.sort == "asc" and asc or desc
pfUI.uf.player.debuffbar.color = { r = r, g = g, b = b, a = a } pfUI.uf.player.debuffbar.color = GetStringColorObject(config.color)
pfUI.uf.player.debuffbar.bordercolor = { r = br, g = bg, b = bb, a = ba } pfUI.uf.player.debuffbar.bordercolor = GetStringColorObject(config.bordercolor)
pfUI.uf.player.debuffbar.textcolor = { r = tr, g = tg, b = tb, a = ta } pfUI.uf.player.debuffbar.textcolor = GetStringColorObject(config.textcolor)
pfUI.uf.player.debuffbar.anchors = { pfUI.uf.player.debuffbar.anchors = {
pfUI.uf.player, pfUI.uf.player,
pfUI.uf.player and pfUI.uf.player.buffbar and pfUI.uf.player.buffbar.bars, pfUI.uf.player and pfUI.uf.player.buffbar and pfUI.uf.player.buffbar.bars,
@@ -476,18 +486,15 @@ pfUI:RegisterModule("buffwatch", function ()
-- create target debuffbars -- create target debuffbars
if pfUI.uf.target and C.buffbar.tdebuff.enable == "1" then if pfUI.uf.target and C.buffbar.tdebuff.enable == "1" then
local config = C.buffbar.tdebuff local config = C.buffbar.tdebuff
local r, g, b, a = strsplit(",", config.color)
local br, bg, bb, ba = strsplit(",", config.bordercolor)
local tr, tg, tb, ta = strsplit(",", config.textcolor)
pfUI.uf.target.debuffbar = CreateBuffBarFrame("Target", "HARMFUL") pfUI.uf.target.debuffbar = CreateBuffBarFrame("Target", "HARMFUL")
pfUI.uf.target.debuffbar:SetWidth(config.width == "-1" and pfUI.uf.target:GetWidth() or config.width) pfUI.uf.target.debuffbar:SetWidth(config.width == "-1" and pfUI.uf.target:GetWidth() or config.width)
pfUI.uf.target.debuffbar:SetHeight(config.height) pfUI.uf.target.debuffbar:SetHeight(config.height)
pfUI.uf.target.debuffbar.config = config pfUI.uf.target.debuffbar.config = config
pfUI.uf.target.debuffbar.buffcmp = config.sort == "asc" and asc or desc pfUI.uf.target.debuffbar.buffcmp = config.sort == "asc" and asc or desc
pfUI.uf.target.debuffbar.color = { r = r, g = g, b = b, a = a } pfUI.uf.target.debuffbar.color = GetStringColorObject(config.color)
pfUI.uf.target.debuffbar.bordercolor = { r = br, g = bg, b = bb, a = ba } pfUI.uf.target.debuffbar.bordercolor = GetStringColorObject(config.bordercolor)
pfUI.uf.target.debuffbar.textcolor = { r = tr, g = tg, b = tb, a = ta } pfUI.uf.target.debuffbar.textcolor = GetStringColorObject(config.textcolor)
pfUI.uf.target.debuffbar.threshold = tonumber(config.threshold) pfUI.uf.target.debuffbar.threshold = tonumber(config.threshold)
pfUI.uf.target.debuffbar.anchors = { pfUI.uf.target.debuffbar.anchors = {
pfUI.uf.target, pfUI.uf.target,
modules/castbar.lua
+135 -148
View File
@@ -16,9 +16,13 @@ pfUI:RegisterModule("castbar", function ()
end end
end end
-- Clear cast state on the bar. Shows the bar full for one frame, then -- Clear cast state on the bar and start the fade-out. On a normal end the bar
-- OnUpdate fades it out. -- is left at its current fill (a completed cast is already ~full; nothing
local function ClearBar(cb) -- snaps to full, which used to flash for a frame when the next cast stamped
-- the bar). When `failed` is set for a cast that was actually in progress, the
-- bar flashes full red before fading — the cancelled-cast indicator.
local function ClearBar(cb, failed)
local wasActive = cb.endTime ~= nil
cb.startTime, cb.endTime, cb.isChannel = nil, nil, nil cb.startTime, cb.endTime, cb.isChannel = nil, nil, nil
cb.activeName, cb.spellID = nil, nil cb.activeName, cb.spellID = nil, nil
cb.isTradeskill = nil cb.isTradeskill = nil
@@ -26,8 +30,11 @@ pfUI:RegisterModule("castbar", function ()
cb.tradeskillSingleMs, cb.currentCraftStart = nil, nil cb.tradeskillSingleMs, cb.currentCraftStart = nil, nil
cb.lastMax = nil cb.lastMax = nil
cb.delay = 0 cb.delay = 0
cb.bar:SetMinMaxValues(1, 100) if failed and wasActive then
cb.bar:SetValue(100) cb.bar:SetStatusBarColor(GetStringColor(C.appearance.castbar.failcolor))
cb.bar:SetMinMaxValues(0, 1)
cb.bar:SetValue(1)
end
if cb.bar.spark then cb.bar.spark:Hide() end if cb.bar.spark then cb.bar.spark:Hide() end
cb.fadeout = 1 cb.fadeout = 1
end end
@@ -38,7 +45,7 @@ pfUI:RegisterModule("castbar", function ()
if not cb.tradeskillTotal or not cb.activeName or not cb.showname then return end if not cb.tradeskillTotal or not cb.activeName or not cb.showname then return end
local remaining = cb.tradeskillTotal - (cb.tradeskillCompleted or 0) local remaining = cb.tradeskillTotal - (cb.tradeskillCompleted or 0)
if remaining > 1 then if remaining > 1 then
cb.bar.left:SetText(string.format("%s (%d)", cb.activeName, remaining)) cb.bar.left:SetFormattedText("%s (%d)", cb.activeName, remaining)
else else
cb.bar.left:SetText(cb.activeName) cb.bar.left:SetText(cb.activeName)
end end
@@ -65,16 +72,21 @@ pfUI:RegisterModule("castbar", function ()
end end
-- Mark the start of craft 2..N within an active merge (called from the -- Mark the start of craft 2..N within an active merge (called from the
-- SPELLCAST_START / SPELL_START_SELF handlers). Resets the per-craft -- UNIT_SPELLCAST_START handler). Resets the per-craft spark to the left
-- spark to the left edge of the bar. -- edge of the bar.
local function StartTradeskillCraft(cb) local function StartTradeskillCraft(cb)
cb.currentCraftStart = GetTime() * 1000 cb.currentCraftStart = GetTime() * 1000
local remaining = cb.tradeskillTotal - (cb.tradeskillCompleted or 0)
cb.endTime = cb.currentCraftStart + cb.tradeskillSingleMs * remaining
local duration = (cb.endTime - cb.startTime) / 1000
cb.bar:SetMinMaxValues(0, duration)
cb.lastMax = duration
UpdateTradeskillLabel(cb) UpdateTradeskillLabel(cb)
end end
-- Stamp the bar with cast data and render text/icon/lag once. OnUpdate -- Stamp the bar with cast data and render text/icon/lag once. OnUpdate
-- then animates the fill from this state without touching C_Spell. -- then animates the fill from this state without touching C_Spell.
local function StampBar(cb, name, tex, startMs, endMs, spellID, isChannel, delayMs, isTradeskill) local function StampBar(cb, name, tex, startMs, endMs, spellID, isChannel, delayMs, isTradeskill, rank)
cb.startTime = startMs cb.startTime = startMs
cb.endTime = endMs cb.endTime = endMs
cb.isChannel = isChannel cb.isChannel = isChannel
@@ -85,12 +97,15 @@ pfUI:RegisterModule("castbar", function ()
cb:SetAlpha(1) cb:SetAlpha(1)
cb.fadeout = nil cb.fadeout = nil
cb.bar:SetStatusBarColor(strsplit(",", C.appearance.castbar[isChannel and "channelcolor" or "castbarcolor"])) cb.bar:SetStatusBarColor(GetStringColor(C.appearance.castbar[isChannel and "channelcolor" or "castbarcolor"]))
local rank = "" -- Rank: prefer the value the UNIT_SPELLCAST_* event delivered (arg5, passed
if spellID and GetSpellRecField then -- through by RefreshBar). Only the retarget re-poll has no event in hand, so
rank = GetSpellRecField(spellID, "rank") or "" -- it falls back to a lookup.
if not rank and spellID then
rank = C_Spell.GetSpellSubtext(spellID) or ""
end end
rank = rank or ""
local spellname = (cb.showname and name) and (name .. " ") or "" local spellname = (cb.showname and name) and (name .. " ") or ""
local rankstr = (cb.showrank and rank ~= "") and string.format("|cffaaffcc[%s]|r", rank) or "" local rankstr = (cb.showrank and rank ~= "") and string.format("|cffaaffcc[%s]|r", rank) or ""
cb.bar.left:SetText(spellname .. rankstr) cb.bar.left:SetText(spellname .. rankstr)
@@ -98,8 +113,7 @@ pfUI:RegisterModule("castbar", function ()
if tex and cb.showicon then if tex and cb.showicon then
local size = cb:GetHeight() local size = cb:GetHeight()
cb.icon:Show() cb.icon:Show()
cb.icon:SetHeight(size) cb.icon:SetSize(size, size)
cb.icon:SetWidth(size)
cb.icon.texture:SetTexture(tex) cb.icon.texture:SetTexture(tex)
cb.bar:SetPoint("TOPLEFT", cb.icon, "TOPRIGHT", cb.spacing, 0) cb.bar:SetPoint("TOPLEFT", cb.icon, "TOPRIGHT", cb.spacing, 0)
else else
@@ -118,11 +132,21 @@ pfUI:RegisterModule("castbar", function ()
cb.bar:SetMinMaxValues(0, duration) cb.bar:SetMinMaxValues(0, duration)
cb.lastMax = duration cb.lastMax = duration
-- Prime the fill on this frame. StampBar otherwise leaves the previous
-- value in place (ClearBar, run on the prior cast's STOP, leaves it full),
-- so the bar would flash full for the frame between here and the next
-- OnUpdate tick. Reset the throttle too so the timer text updates promptly.
local nowSec = GetTime()
local cur = isChannel and (endMs / 1000 - nowSec) or (nowSec - startMs / 1000)
if cur < 0 then cur = 0 elseif cur > duration then cur = duration end
cb.bar:SetValue(cur)
cb.tick = 0
end end
-- One-shot poll: read C_Spell for the bar's unit, stamp or clear. Called -- One-shot poll: read C_Spell for the bar's unit, stamp or clear. Called
-- from event handlers (cast start, target/focus change), never per-frame. -- from event handlers (cast start, target/focus change), never per-frame.
local function RefreshBar(cb) local function RefreshBar(cb, rank)
local query = cb.unitstr ~= "" and cb.unitstr or cb.unitname local query = cb.unitstr ~= "" and cb.unitstr or cb.unitname
if not query or (cb.unitstr ~= "" and not UnitExists(cb.unitstr)) then if not query or (cb.unitstr ~= "" and not UnitExists(cb.unitstr)) then
ClearBar(cb) ClearBar(cb)
@@ -145,7 +169,7 @@ pfUI:RegisterModule("castbar", function ()
end end
end end
if name and startMs and endMs then if name and startMs and endMs then
StampBar(cb, name, tex, startMs, endMs, spellID, isChan, delayMs, isTradeskill) StampBar(cb, name, tex, startMs, endMs, spellID, isChan, delayMs, isTradeskill, rank)
else else
ClearBar(cb) ClearBar(cb)
end end
@@ -164,8 +188,7 @@ pfUI:RegisterModule("castbar", function ()
-- icon -- icon
cb.icon = CreateFrame("Frame", nil, cb) cb.icon = CreateFrame("Frame", nil, cb)
cb.icon:SetPoint("TOPLEFT", 0, 0) cb.icon:SetPoint("TOPLEFT", 0, 0)
cb.icon:SetHeight(16) cb.icon:SetSize(16, 16)
cb.icon:SetWidth(16)
cb.icon.texture = cb.icon:CreateTexture(nil, "OVERLAY") cb.icon.texture = cb.icon:CreateTexture(nil, "OVERLAY")
cb.icon.texture:SetAllPoints() cb.icon.texture:SetAllPoints()
@@ -193,7 +216,7 @@ pfUI:RegisterModule("castbar", function ()
cb.bar.left:SetFontObject(GameFontWhite) cb.bar.left:SetFontObject(GameFontWhite)
cb.bar.left:SetTextColor(1,1,1,1) cb.bar.left:SetTextColor(1,1,1,1)
cb.bar.left:SetFont(font, font_size, "OUTLINE") cb.bar.left:SetFont(font, font_size, "OUTLINE")
cb.bar.left:SetJustifyH("left") cb.bar.left:SetJustifyH(C.castbar[unitstr].namealign or "LEFT")
-- text right -- text right
cb.bar.right = cb.bar:CreateFontString("Status", "DIALOG", "GameFontNormal") cb.bar.right = cb.bar:CreateFontString("Status", "DIALOG", "GameFontNormal")
@@ -204,7 +227,7 @@ pfUI:RegisterModule("castbar", function ()
cb.bar.right:SetFontObject(GameFontWhite) cb.bar.right:SetFontObject(GameFontWhite)
cb.bar.right:SetTextColor(1,1,1,1) cb.bar.right:SetTextColor(1,1,1,1)
cb.bar.right:SetFont(font, font_size, "OUTLINE") cb.bar.right:SetFont(font, font_size, "OUTLINE")
cb.bar.right:SetJustifyH("right") cb.bar.right:SetJustifyH(C.castbar[unitstr].timealign or "RIGHT")
cb.bar.lag = cb.bar:CreateTexture(nil, "OVERLAY") cb.bar.lag = cb.bar:CreateTexture(nil, "OVERLAY")
cb.bar.lag:SetPoint("TOPRIGHT", cb.bar, "TOPRIGHT", 0, 0) cb.bar.lag:SetPoint("TOPRIGHT", cb.bar, "TOPRIGHT", 0, 0)
@@ -241,7 +264,10 @@ pfUI:RegisterModule("castbar", function ()
return return
end end
if not this.endTime then return end if not this.endTime then
if this:GetAlpha() ~= 0 then this:SetAlpha(0) end
return
end
-- Non-player bars: if the unit disappears (target died / detarget), -- Non-player bars: if the unit disappears (target died / detarget),
-- drop the bar immediately. -- drop the bar immediately.
@@ -288,35 +314,33 @@ pfUI:RegisterModule("castbar", function ()
end end
end) end)
-- Cast lifecycle events. Player bars react to vanilla SPELLCAST_*; non- -- Cast lifecycle, entirely on ClassicAPI's UNIT_SPELLCAST_* events. They
-- player bars also react to Nampower SPELL_*_OTHER (gated by the -- fire per unit token: arg1=="player" for the player's own casts, and the
-- NP_EnableSpell{Start,Go}Events CVars, enabled by libdebuff) plus the -- remote token(s) ("target", "focus", ...) for other units -- so one set of
-- retarget event. Player events also feed non-player bars for the -- events drives every bar with no Nampower dependency. The handler routes an
-- target=self case. -- event to this bar when arg1 matches its unit, or -- since the player's own
cb:RegisterEvent("SPELLCAST_START") -- casts only ever fire arg1=="player" -- when the bar's unit resolves to the
cb:RegisterEvent("SPELLCAST_STOP") -- player (target=self). PLAYER_TARGET/FOCUS_CHANGED re-polls so a unit
cb:RegisterEvent("SPELLCAST_FAILED") -- already mid-cast when it becomes the target/focus still shows.
cb:RegisterEvent("SPELLCAST_INTERRUPTED") -- Filter to this bar's unit, plus "player" for the target/focus bars: the
cb:RegisterEvent("SPELLCAST_CHANNEL_START") -- player's own casts only ever fire arg1=="player", so a self-targeted cast
cb:RegisterEvent("SPELLCAST_CHANNEL_STOP") -- has to reach them too (nil for the player bar itself, which the filter
cb:RegisterEvent("SPELLCAST_CHANNEL_UPDATE") -- skips). This only narrows what arrives -- the arg1/UnitIsUnit test below
cb:RegisterEvent("SPELL_DELAYED_SELF") -- still decides whether the bar acts on it.
-- Chained same-spell recasts never run the client cast path (the 1.12 local selfunit = unitstr ~= "player" and "player" or nil
-- engine short-circuits at spellID == current-cast), so vanilla cb:RegisterUnitEvent("UNIT_SPELLCAST_START", unitstr, selfunit)
-- SPELLCAST_START never fires for them. nampower's SPELL_START_SELF cb:RegisterUnitEvent("UNIT_SPELLCAST_STOP", unitstr, selfunit)
-- (server-driven) is the only signal that shows them. cb:RegisterUnitEvent("UNIT_SPELLCAST_FAILED", unitstr, selfunit)
cb:RegisterEvent("SPELL_START_SELF") cb:RegisterUnitEvent("UNIT_SPELLCAST_INTERRUPTED", unitstr, selfunit)
if unitstr == "player" then cb:RegisterUnitEvent("UNIT_SPELLCAST_DELAYED", unitstr, selfunit)
cb:RegisterEvent("SPELL_GO_SELF") cb:RegisterUnitEvent("UNIT_SPELLCAST_SUCCEEDED", unitstr, selfunit)
end cb:RegisterUnitEvent("UNIT_SPELLCAST_CHANNEL_START", unitstr, selfunit)
if unitstr ~= "player" and unitstr ~= "" then cb:RegisterUnitEvent("UNIT_SPELLCAST_CHANNEL_STOP", unitstr, selfunit)
cb:RegisterEvent("SPELL_START_OTHER") cb:RegisterUnitEvent("UNIT_SPELLCAST_CHANNEL_UPDATE", unitstr, selfunit)
cb:RegisterEvent("SPELL_FAILED_OTHER") if unitstr == "target" then
if unitstr == "target" then cb:RegisterEvent("PLAYER_TARGET_CHANGED")
cb:RegisterEvent("PLAYER_TARGET_CHANGED") elseif unitstr == "focus" then
elseif unitstr == "focus" then cb:RegisterEvent("PLAYER_FOCUS_CHANGED")
cb:RegisterEvent("PLAYER_FOCUS_CHANGED")
end
end end
cb:SetScript("OnEvent", function() cb:SetScript("OnEvent", function()
@@ -327,83 +351,33 @@ pfUI:RegisterModule("castbar", function ()
return return
end end
if event == "SPELL_START_OTHER" then -- UNIT_SPELLCAST_* fire per unit token (arg1). Handle an event when it's
-- arg3=casterGuid. Defer one frame so ClassicAPI's UnitChannelInfo -- for this bar's unit, or -- since the player's own casts only ever fire
-- can see the engine's +0x228 broadcast for remote-unit channels -- arg1=="player" -- when this bar's unit currently resolves to the player
-- (the cohook+packet handler runs in the same frame; the broadcast -- (target=self / focus=self).
-- propagates after). -- Args: arg1=unit, arg2=castGUID, arg3=spellID, arg4=name, arg5=rank.
if arg3 == UnitGUID(unit) then if arg1 ~= unit and not (arg1 == "player" and UnitIsUnit(unit, "player")) then
local target = this
RunNextFrame(function() RefreshBar(target) end)
end
return return
end end
if event == "SPELL_FAILED_OTHER" then if event == "UNIT_SPELLCAST_START" or event == "UNIT_SPELLCAST_CHANNEL_START" then
if arg1 == UnitGUID(unit) then ClearBar(this) end -- START also fires per craft in a same-spell chain, so an active merge
return -- just resyncs the current craft's spark/label instead of restamping.
end
-- Vanilla SPELLCAST_* + SPELL_DELAYED_SELF fire only for the local
-- player. Non-player bars handle them only when their unit currently
-- resolves to the player (target=self / focus=self).
if not UnitIsUnit(unit, 'player') then return end
if event == "SPELLCAST_START" or event == "SPELLCAST_CHANNEL_START" then
if this.tradeskillTotal then if this.tradeskillTotal then
-- Mid-chain craft N+1 of N. Keep the merged bar; resync the spark
-- to the new craft's start and refresh the "(N)" count label.
StartTradeskillCraft(this) StartTradeskillCraft(this)
else else
RefreshBar(this) RefreshBar(this, arg5)
if this.isTradeskill and (this.pendingTradeskillCount or 0) > 1 if this.isTradeskill and (this.pendingTradeskillCount or 0) > 1
and C.castbar.player.mergetradeskill == "1" then and C.castbar.player.mergetradeskill == "1" then
EnterTradeskillMerge(this, this.startTime, this.endTime, this.pendingTradeskillCount) EnterTradeskillMerge(this, this.startTime, this.endTime, this.pendingTradeskillCount)
end end
this.pendingTradeskillCount = nil this.pendingTradeskillCount = nil
end end
elseif event == "SPELL_START_SELF" then elseif event == "UNIT_SPELLCAST_SUCCEEDED" then
-- Catches chained same-spell recasts (no SPELLCAST_START fires) — -- Per-craft completion during a tradeskill merge (arg3 = spellID):
-- including tradeskill chaining where craft 2..N reuse one spell. -- count and clear when the chain is done. A no-op for normal casts,
-- Defer one frame so ClassicAPI's SMSG_SPELL_START co-hook has -- which are cleared by UNIT_SPELLCAST_STOP.
-- stamped g_cast before we poll, regardless of co-hook order. if this.tradeskillTotal and arg3 == this.tradeskillSpellID then
if this.tradeskillTotal then
StartTradeskillCraft(this)
else
local target = this
RunNextFrame(function()
-- Re-check: SPELL_START_SELF (nampower co-hook) fires before vanilla
-- SPELLCAST_START on the same packet, so SPELLCAST_START may have
-- entered merge in this same frame. Don't restamp over it.
if target.tradeskillTotal then
StartTradeskillCraft(target)
return
end
RefreshBar(target)
if target.unitstr == "player" and target.isTradeskill
and (target.pendingTradeskillCount or 0) > 1
and C.castbar.player.mergetradeskill == "1" then
EnterTradeskillMerge(target, target.startTime, target.endTime, target.pendingTradeskillCount)
end
target.pendingTradeskillCount = nil
end)
end
elseif event == "SPELLCAST_CHANNEL_STOP" then
-- A channel's stop can arrive after a following cast already claimed
-- the bar (channel->cast transition); only clear if a channel is
-- actually being shown, so it doesn't wipe an active cast bar.
if this.isChannel then ClearBar(this) end
elseif event == "SPELLCAST_STOP" then
-- During a tradeskill chain, SPELL_GO_SELF already counted this craft
-- and either cleared the bar (chain done) or kept it running. Only a
-- non-merge cast clears here.
if not this.tradeskillTotal then ClearBar(this) end
elseif event == "SPELLCAST_FAILED" or event == "SPELLCAST_INTERRUPTED" then
ClearBar(this)
elseif event == "SPELL_GO_SELF" then
-- arg2 = spellId. In a tradeskill merge, count each successful craft
-- and clear when the chain is done.
if this.tradeskillTotal and arg2 == this.tradeskillSpellID then
this.tradeskillCompleted = (this.tradeskillCompleted or 0) + 1 this.tradeskillCompleted = (this.tradeskillCompleted or 0) + 1
if this.tradeskillCompleted >= this.tradeskillTotal then if this.tradeskillCompleted >= this.tradeskillTotal then
ClearBar(this) ClearBar(this)
@@ -411,33 +385,46 @@ pfUI:RegisterModule("castbar", function ()
UpdateTradeskillLabel(this) UpdateTradeskillLabel(this)
end end
end end
elseif event == "SPELL_DELAYED_SELF" then elseif event == "UNIT_SPELLCAST_CHANNEL_STOP" then
-- Cast pushback. nampower's event carries the delay (arg2); apply it -- A channel's stop can arrive after a following cast already claimed
-- locally rather than re-polling, so the bar doesn't depend on -- the bar (channel->cast transition); only clear if a channel is
-- ClassicAPI's SMSG_SPELL_DELAYED co-hook having bumped g_cast before -- actually being shown, so it doesn't wipe an active cast bar.
-- this fires (co-hook order vs nampower is not guaranteed). if this.isChannel then ClearBar(this) end
if not this.endTime or not arg2 then return end elseif event == "UNIT_SPELLCAST_STOP" then
local delayMs = tonumber(arg2) or 0 -- STOP fires between crafts in a merge too (each craft is a new cast);
if delayMs > 0 then -- UNIT_SPELLCAST_SUCCEEDED owns the count, so only a non-merge cast
this.delay = (this.delay or 0) + delayMs / 1000 -- clears here.
this.endTime = this.endTime + delayMs if not this.tradeskillTotal then ClearBar(this) end
local newDuration = (this.endTime - this.startTime) / 1000 elseif event == "UNIT_SPELLCAST_FAILED" or event == "UNIT_SPELLCAST_INTERRUPTED" then
this.bar:SetMinMaxValues(0, newDuration) ClearBar(this, true)
this.lastMax = newDuration elseif event == "UNIT_SPELLCAST_DELAYED" or event == "UNIT_SPELLCAST_CHANNEL_UPDATE" then
end -- Pushback: a cast delayed later or a channel shortened. Following
elseif event == "SPELLCAST_CHANNEL_UPDATE" then -- Quartz, re-poll just the times and accumulate the shift into a running
-- Channel pushback. ClassicAPI doesn't track channel delay in -- this.delay for the +/- indicator, rather than a full restamp (which
-- g_channel, so we adjust endTime + delay locally and resize the -- would reset that total and re-render icon/text). ClassicAPI moves
-- bar so OnUpdate animates against the new total. -- endMs (SpellDelayed_h bumps g_cast.endMs; the MSG_CHANNEL_UPDATE
if not this.endTime or not arg1 then return end -- co-hook rewrites g_channel.endMs) while startMs stays put, so we diff
local newEndMs = GetTime() * 1000 + arg1 -- endMs. delay is a positive magnitude; OnUpdate signs it "+" for casts
local diff = this.endTime - newEndMs -- and "-" for channels. Skipped during a tradeskill merge.
if diff > 50 then if this.endTime and not this.tradeskillTotal then
this.delay = (this.delay or 0) + diff / 1000 local query = this.unitstr ~= "" and this.unitstr or this.unitname
this.endTime = newEndMs local startMs, endMs
local newDuration = (this.endTime - this.startTime) / 1000 if this.isChannel then
this.bar:SetMinMaxValues(0, newDuration) local _, _, _, s, e = C_Spell.UnitChannelInfo(query)
this.lastMax = newDuration startMs, endMs = s, e
else
local _, _, _, s, e = C_Spell.UnitCastingInfo(query)
startMs, endMs = s, e
end
if startMs and endMs then
local shift = this.isChannel and (this.endTime - endMs) or (endMs - this.endTime)
this.delay = (this.delay or 0) + shift / 1000
this.startTime = startMs
this.endTime = endMs
local newDuration = (endMs - startMs) / 1000
this.bar:SetMinMaxValues(0, newDuration)
this.lastMax = newDuration
end
end end
end end
end) end)
@@ -483,11 +470,11 @@ pfUI:RegisterModule("castbar", function ()
UpdateMovable(pfUI.castbar.player) UpdateMovable(pfUI.castbar.player)
-- Tradeskill merge: hook DoTradeSkill so the player castbar knows the -- Tradeskill merge: hook DoTradeSkill so the player castbar knows the
-- requested count before the first SPELLCAST_START fires. Always-on hook -- requested count before the first UNIT_SPELLCAST_START fires. Always-on
-- (the config knob is read at event time so toggling takes effect on the -- hook (the config knob is read at event time so toggling takes effect on
-- next craft without a /reload). DoTradeSkill is synchronous; the server -- the next craft without a /reload). DoTradeSkill is synchronous; the
-- roundtrip to SPELLCAST_START gives us plenty of time after this hook. -- server roundtrip to UNIT_SPELLCAST_START gives us plenty of time.
pfUI.hooksecurefunc("DoTradeSkill", function(index, num) hooksecurefunc("DoTradeSkill", function(index, num)
if pfUI.castbar.player then if pfUI.castbar.player then
pfUI.castbar.player.pendingTradeskillCount = tonumber(num) or 1 pfUI.castbar.player.pendingTradeskillCount = tonumber(num) or 1
end end
modules/chat.lua
+110 -34
View File
@@ -24,7 +24,7 @@ pfUI:RegisterModule("chat", function ()
end end
end end
pfUI.hooksecurefunc("UnitPopup_OnClick", function(self) hooksecurefunc("UnitPopup_OnClick", function(self)
if this.value == "IGNORE_PLAYER" then if this.value == "IGNORE_PLAYER" then
AddIgnore(_G[UIDROPDOWNMENU_INIT_MENU].name) AddIgnore(_G[UIDROPDOWNMENU_INIT_MENU].name)
end end
@@ -63,6 +63,23 @@ pfUI:RegisterModule("chat", function ()
return pfUI_cache["chathistory"][realm][player][id] return pfUI_cache["chathistory"][realm][player][id]
end end
-- [ Chat Panel Colors ]
-- The panels normally inherit pfUI's global appearance theme; custom colors let chat
-- deviate from it. CreateBackdrop is re-run first to restore the theme, so toggling
-- custom colors back off doesn't leave the previous override behind.
local function ApplyPanelColors(panel)
if not panel then return end
CreateBackdrop(panel, default_border, nil, .8)
if C.chat.global.custombg ~= "1" then return end
local r, g, b, a = GetStringColor(C.chat.global.background)
panel.backdrop:SetBackdropColor(tonumber(r), tonumber(g), tonumber(b), tonumber(a))
local r, g, b, a = GetStringColor(C.chat.global.border)
panel.backdrop:SetBackdropBorderColor(tonumber(r), tonumber(g), tonumber(b), tonumber(a))
end
pfUI.chat = CreateFrame("Frame",nil,UIParent) pfUI.chat = CreateFrame("Frame",nil,UIParent)
pfUI.chat.left = CreateFrame("Frame", "pfChatLeft", UIParent) pfUI.chat.left = CreateFrame("Frame", "pfChatLeft", UIParent)
@@ -76,19 +93,11 @@ pfUI:RegisterModule("chat", function ()
pfUI.chat.left:SetPoint("BOTTOMLEFT", 2*default_border,2*default_border) pfUI.chat.left:SetPoint("BOTTOMLEFT", 2*default_border,2*default_border)
pfUI.chat.left:SetScript("OnShow", function() pfUI.chat:RefreshChat() end) pfUI.chat.left:SetScript("OnShow", function() pfUI.chat:RefreshChat() end)
UpdateMovable(pfUI.chat.left) UpdateMovable(pfUI.chat.left)
CreateBackdrop(pfUI.chat.left, default_border, nil, .8) ApplyPanelColors(pfUI.chat.left)
if C.chat.global.frameshadow == "1" then if C.chat.global.frameshadow == "1" then
CreateBackdropShadow(pfUI.chat.left) CreateBackdropShadow(pfUI.chat.left)
end end
if C.chat.global.custombg == "1" then
local r, g, b, a = strsplit(",", C.chat.global.background)
pfUI.chat.left.backdrop:SetBackdropColor(tonumber(r), tonumber(g), tonumber(b), tonumber(a))
local r, g, b, a = strsplit(",", C.chat.global.border)
pfUI.chat.left.backdrop:SetBackdropBorderColor(tonumber(r), tonumber(g), tonumber(b), tonumber(a))
end
pfUI.chat.left.panelTop = CreateFrame("Frame", "leftChatPanelTop", pfUI.chat.left) pfUI.chat.left.panelTop = CreateFrame("Frame", "leftChatPanelTop", pfUI.chat.left)
pfUI.chat.left.panelTop:ClearAllPoints() pfUI.chat.left.panelTop:ClearAllPoints()
pfUI.chat.left.panelTop:SetHeight(C.global.font_size+default_border*2) pfUI.chat.left.panelTop:SetHeight(C.global.font_size+default_border*2)
@@ -251,19 +260,11 @@ pfUI:RegisterModule("chat", function ()
pfUI.chat.right:SetPoint("BOTTOMRIGHT", -2*default_border,2*default_border) pfUI.chat.right:SetPoint("BOTTOMRIGHT", -2*default_border,2*default_border)
pfUI.chat.right:SetScript("OnShow", function() pfUI.chat:RefreshChat() end) pfUI.chat.right:SetScript("OnShow", function() pfUI.chat:RefreshChat() end)
UpdateMovable(pfUI.chat.right) UpdateMovable(pfUI.chat.right)
CreateBackdrop(pfUI.chat.right, default_border, nil, .8) ApplyPanelColors(pfUI.chat.right)
if C.chat.global.frameshadow == "1" then if C.chat.global.frameshadow == "1" then
CreateBackdropShadow(pfUI.chat.right) CreateBackdropShadow(pfUI.chat.right)
end end
if C.chat.global.custombg == "1" then
local r, g, b, a = strsplit(",", C.chat.global.background)
pfUI.chat.right.backdrop:SetBackdropColor(tonumber(r), tonumber(g), tonumber(b), tonumber(a))
local r, g, b, a = strsplit(",", C.chat.global.border)
pfUI.chat.right.backdrop:SetBackdropBorderColor(tonumber(r), tonumber(g), tonumber(b), tonumber(a))
end
pfUI.chat.right.panelTop = CreateFrame("Frame", "rightChatPanelTop", pfUI.chat.right) pfUI.chat.right.panelTop = CreateFrame("Frame", "rightChatPanelTop", pfUI.chat.right)
pfUI.chat.right.panelTop:ClearAllPoints() pfUI.chat.right.panelTop:ClearAllPoints()
pfUI.chat.right.panelTop:SetHeight(C.global.font_size+default_border*2) pfUI.chat.right.panelTop:SetHeight(C.global.font_size+default_border*2)
@@ -296,6 +297,68 @@ pfUI:RegisterModule("chat", function ()
end end
end end
-- [ Chat Background Alpha ]
-- Blizzard's per-window transparency slider drives FCF_SetWindowAlpha, which only
-- touches the ChatFrame*Background textures that pfUI hides on docked frames. Mirror
-- the window's stored alpha onto the visible pfUI backdrop so the native slider
-- controls it directly.
local function ApplyChatBackgroundAlpha(panel, frame)
if not (panel and panel.backdrop and frame) then return end
local _, _, _, _, _, alpha = GetChatWindowInfo(frame:GetID())
alpha = tonumber(alpha)
if not alpha then return end
local r, g, b = panel.backdrop:GetBackdropColor()
panel.backdrop:SetBackdropColor(r, g, b, alpha)
end
function pfUI.chat:RefreshBackgroundAlpha()
-- Custom colors own the alpha. C.chat.global.background carries its own alpha, is
-- set by profiles and is shared with the meter skins, so the native slider must not
-- overwrite it -- doing so reverted the configured opacity on every refresh. The
-- slider only drives the panel when the user hasn't opted into pfUI's chat colors.
if C.chat.global.custombg == "1" then return end
-- left panel follows the currently selected docked tab
local selected = SELECTED_CHAT_FRAME
if not (selected and selected:GetParent() == pfUI.chat.left) then
selected = ChatFrame1
end
ApplyChatBackgroundAlpha(pfUI.chat.left, selected)
if C.chat.right.enable == "1" then
ApplyChatBackgroundAlpha(pfUI.chat.right, ChatFrame3)
end
end
-- live config apply, resolved by the gui as U["chat"]. Lets the color pickers
-- take effect on the spot instead of waiting for a /reload.
function pfUI.chat:UpdateConfig()
ApplyPanelColors(pfUI.chat.left)
ApplyPanelColors(pfUI.chat.right)
pfUI.chat:RefreshBackgroundAlpha()
end
function pfUI.chat:MigrateBackgroundAlpha()
-- Runs once per character. The previous SetupPositions default stored a hard 0 window
-- alpha, which now renders the pfUI backdrop fully transparent. Restore the historical
-- 0.8 look for any pfUI-managed window still sitting at 0. Only existing installs that
-- already ran chat setup carry that legacy 0; fresh installs get 0.8 from SetupPositions.
if pfUI_init.chatbgalpha then return end
if not pfUI_init["chat_position"] then return end
pfUI_init.chatbgalpha = true
local frames = { ChatFrame1, ChatFrame2 }
if C.chat.right.enable == "1" then table.insert(frames, ChatFrame3) end
for _, frame in ipairs(frames) do
local _, _, _, _, _, alpha = GetChatWindowInfo(frame:GetID())
alpha = tonumber(alpha)
if alpha and alpha <= 0 then
FCF_SetWindowAlpha(frame, 0.8)
end
end
end
function pfUI.chat:RefreshChat() function pfUI.chat:RefreshChat()
local panelheight = C.global.font_size*1.5 + default_border*2 + 2 local panelheight = C.global.font_size*1.5 + default_border*2 + 2
@@ -429,7 +492,7 @@ pfUI:RegisterModule("chat", function ()
_G["ChatFrame" .. i .. "TabFlash"].Show = function() return end _G["ChatFrame" .. i .. "TabFlash"].Show = function() return end
end end
local _, class = UnitClass("player") local class = UnitClassBase("player")
local classColor = PFUI_CLASS_COLORS[class] local classColor = PFUI_CLASS_COLORS[class]
_G["ChatFrame" .. i .. "TabText"]:SetTextColor((classColor.r + .3) * .5, (classColor.g + .3) * .5, (classColor.b + .3) * .5, 1) _G["ChatFrame" .. i .. "TabText"]:SetTextColor((classColor.r + .3) * .5, (classColor.g + .3) * .5, (classColor.b + .3) * .5, 1)
_G["ChatFrame" .. i .. "TabText"]:SetFont(panelfont,panelfont_size, "OUTLINE") _G["ChatFrame" .. i .. "TabText"]:SetFont(panelfont,panelfont_size, "OUTLINE")
@@ -447,9 +510,13 @@ pfUI:RegisterModule("chat", function ()
for index, value in pairs(DOCKED_CHAT_FRAMES) do for index, value in pairs(DOCKED_CHAT_FRAMES) do
FCF_UpdateButtonSide(value) FCF_UpdateButtonSide(value)
end end
pfUI.chat:RefreshBackgroundAlpha()
end end
pfUI.hooksecurefunc("FCF_SaveDock", pfUI.chat.RefreshChat) hooksecurefunc("FCF_SaveDock", pfUI.chat.RefreshChat)
hooksecurefunc("FCF_SetWindowAlpha", function() pfUI.chat:RefreshBackgroundAlpha() end)
hooksecurefunc("FCF_SelectDockFrame", function() pfUI.chat:RefreshBackgroundAlpha() end)
if C.chat.global.tabmouse == "1" then if C.chat.global.tabmouse == "1" then
pfUI.chat.mouseovertab = CreateFrame("Frame") pfUI.chat.mouseovertab = CreateFrame("Frame")
@@ -500,7 +567,7 @@ pfUI:RegisterModule("chat", function ()
FCF_SetLocked(ChatFrame1, 1) FCF_SetLocked(ChatFrame1, 1)
FCF_SetWindowName(ChatFrame1, GENERAL) FCF_SetWindowName(ChatFrame1, GENERAL)
FCF_SetWindowColor(ChatFrame1, 0, 0, 0) FCF_SetWindowColor(ChatFrame1, 0, 0, 0)
FCF_SetWindowAlpha(ChatFrame1, 0) FCF_SetWindowAlpha(ChatFrame1, 0.8)
FCF_SetChatWindowFontSize(ChatFrame1, 12) FCF_SetChatWindowFontSize(ChatFrame1, 12)
ChatFrame1:SetUserPlaced(1) ChatFrame1:SetUserPlaced(1)
@@ -508,7 +575,7 @@ pfUI:RegisterModule("chat", function ()
FCF_SetLocked(ChatFrame2, 1) FCF_SetLocked(ChatFrame2, 1)
FCF_SetWindowName(ChatFrame2, COMBAT_LOG) FCF_SetWindowName(ChatFrame2, COMBAT_LOG)
FCF_SetWindowColor(ChatFrame2, 0, 0, 0) FCF_SetWindowColor(ChatFrame2, 0, 0, 0)
FCF_SetWindowAlpha(ChatFrame2, 0) FCF_SetWindowAlpha(ChatFrame2, 0.8)
FCF_SetChatWindowFontSize(ChatFrame2, 12) FCF_SetChatWindowFontSize(ChatFrame2, 12)
ChatFrame2:SetUserPlaced(1) ChatFrame2:SetUserPlaced(1)
@@ -518,7 +585,7 @@ pfUI:RegisterModule("chat", function ()
FCF_SetLocked(ChatFrame3, 1) FCF_SetLocked(ChatFrame3, 1)
FCF_SetWindowName(ChatFrame3, T["Loot & Spam"]) FCF_SetWindowName(ChatFrame3, T["Loot & Spam"])
FCF_SetWindowColor(ChatFrame3, 0, 0, 0) FCF_SetWindowColor(ChatFrame3, 0, 0, 0)
FCF_SetWindowAlpha(ChatFrame3, 0) FCF_SetWindowAlpha(ChatFrame3, 0.8)
FCF_SetChatWindowFontSize(ChatFrame3, 12) FCF_SetChatWindowFontSize(ChatFrame3, 12)
FCF_UnDockFrame(ChatFrame3) FCF_UnDockFrame(ChatFrame3)
FCF_SetTabPosition(ChatFrame3, 0) FCF_SetTabPosition(ChatFrame3, 0)
@@ -566,6 +633,9 @@ pfUI:RegisterModule("chat", function ()
end end
pfUI.chat:SetScript("OnEvent", function() pfUI.chat:SetScript("OnEvent", function()
-- restore legacy chat windows stuck at 0 alpha before anything reads it
pfUI.chat:MigrateBackgroundAlpha()
-- set the default chat -- set the default chat
FCF_SelectDockFrame(SELECTED_CHAT_FRAME) FCF_SelectDockFrame(SELECTED_CHAT_FRAME)
@@ -675,7 +745,7 @@ pfUI:RegisterModule("chat", function ()
end end
-- read and parse whisper color settings -- read and parse whisper color settings
local cr, cg, cb, ca = strsplit(",", C.chat.global.whisper) local cr, cg, cb, ca = GetStringColor(C.chat.global.whisper)
cr, cg, cb = tonumber(cr), tonumber(cg), tonumber(cb) cr, cg, cb = tonumber(cr), tonumber(cg), tonumber(cb)
local wcol = rgbhex(cr, cg, cb) local wcol = rgbhex(cr, cg, cb)
@@ -706,10 +776,10 @@ pfUI:RegisterModule("chat", function ()
_G.CHAT_WHISPER_INFORM_GET = '[W]' .. default _G.CHAT_WHISPER_INFORM_GET = '[W]' .. default
end end
local r,g,b,a = strsplit(",", C.chat.text.timecolor) local r,g,b,a = GetStringColor(C.chat.text.timecolor)
local timecolorhex = rgbhex(r,g,b,a) local timecolorhex = rgbhex(r,g,b,a)
local r,g,b = strsplit(",", C.chat.text.unknowncolor) local r,g,b = GetStringColor(C.chat.text.unknowncolor)
local unknowncolorhex = rgbhex(r,g,b) local unknowncolorhex = rgbhex(r,g,b)
-- Suppress FriendsFrame's WHO_LIST_UPDATE handling for our DLL-issued -- Suppress FriendsFrame's WHO_LIST_UPDATE handling for our DLL-issued
@@ -757,7 +827,7 @@ pfUI:RegisterModule("chat", function ()
local real, _ = strsplit(":", name) local real, _ = strsplit(":", name)
local color = unknowncolorhex local color = unknowncolorhex
local match = false local match = false
local _, class = C_PlayerCache.GetPlayerInfoByName(real) local _, class, _, raceKey, sex = C_PlayerCache.GetPlayerInfoByName(real)
-- local guid = GetCurrentChatGUID() -- local guid = GetCurrentChatGUID()
-- if guid then -- if guid then
-- _, class = GetPlayerInfoByGUID(guid) -- _, class = GetPlayerInfoByGUID(guid)
@@ -775,8 +845,12 @@ pfUI:RegisterModule("chat", function ()
end end
if C.chat.text.tintunknown == "1" or match then if C.chat.text.tintunknown == "1" or match then
local icon = ""
if match and C.chat.text.playericons == "1" then
icon = GetFactionIcon(raceKey) .. GetRaceIcon(raceKey, sex)
end
text = string.gsub(text, "|Hplayer:"..name.."|h%["..real.."%]|h(.-:-)", text = string.gsub(text, "|Hplayer:"..name.."|h%["..real.."%]|h(.-:-)",
left..color.."|Hplayer:"..name.."|h" .. color .. real .. "|h|r"..right.."%1") left..icon..color.."|Hplayer:"..name.."|h" .. color .. real .. "|h|r"..right.."%1")
end end
end end
end end
@@ -810,23 +884,25 @@ pfUI:RegisterModule("chat", function ()
end end
end end
-- detect the whisper prefix BEFORE prepending a timestamp; the timestamp
-- pushes the whisper colour code off position 1 and the find below fails
local isWhisper = C.chat.global.whispermod == "1" and string.find(text, wcol, 1) == 1
-- show timestamp in chat -- show timestamp in chat
if C.chat.text.time == "1" then if C.chat.text.time == "1" then
text = timecolorhex .. tleft .. date(C.chat.text.timeformat) .. tright .. "|r " .. text text = timecolorhex .. tleft .. date(C.chat.text.timeformat) .. tright .. "|r " .. text
end end
-- save chat history -- save chat history
if C.chat.global.whispermod == "1" and string.find(text, wcol, 1) == 1 then if isWhisper then
SaveChatHistory(frame:GetID(), string.gsub(text, wcol, ""), cr, cg, cb) SaveChatHistory(frame:GetID(), string.gsub(text, wcol, ""), cr, cg, cb)
else else
SaveChatHistory(frame:GetID(), text, a1, a2, a3) SaveChatHistory(frame:GetID(), text, a1, a2, a3)
end end
if C.chat.global.whispermod == "1" then if isWhisper then
-- patch incoming whisper string to match the colors -- patch incoming whisper string to match the colors
if string.find(text, wcol, 1) == 1 then text = string.gsub(text, "|r", "|r" .. wcol)
text = string.gsub(text, "|r", "|r" .. wcol)
end
end end
frame:HookAddMessage(text, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17) frame:HookAddMessage(text, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17)
modules/chatcopy.lua
+1 -2
View File
@@ -96,8 +96,7 @@ pfUI:RegisterModule("chatcopy", function ()
scroll:Hide() scroll:Hide()
local editbox = CreateFrame("EditBox", "pfChatCopyBox" .. i, scroll) local editbox = CreateFrame("EditBox", "pfChatCopyBox" .. i, scroll)
editbox:SetHeight(frame:GetHeight()) editbox:SetSize(frame:GetSize())
editbox:SetWidth(frame:GetWidth())
editbox:SetAllPoints(scroll) editbox:SetAllPoints(scroll)
editbox:SetTextColor(1,1,1,1) editbox:SetTextColor(1,1,1,1)
editbox:SetFontObject(ChatFontNormal) editbox:SetFontObject(ChatFontNormal)
modules/combopoints.lua
+2 -2
View File
@@ -5,7 +5,7 @@ pfUI:RegisterModule("combopoints", function ()
ComboFrame:Hide() ComboFrame:Hide()
ComboFrame:UnregisterAllEvents() ComboFrame:UnregisterAllEvents()
local _, class = UnitClass("player") local class = UnitClassBase("player")
local combo_width = C["unitframes"]["combowidth"] local combo_width = C["unitframes"]["combowidth"]
local combo_height = C["unitframes"]["comboheight"] local combo_height = C["unitframes"]["comboheight"]
pfUI.combopoints = {} pfUI.combopoints = {}
@@ -52,7 +52,7 @@ pfUI:RegisterModule("combopoints", function ()
-- combo -- combo
if class == "DRUID" or class == "ROGUE" then if class == "DRUID" or class == "ROGUE" then
local combo = CreateFrame("Frame") local combo = CreateFrame("Frame")
combo:RegisterEvent("UNIT_COMBO_POINTS") combo:RegisterUnitEvent("UNIT_COMBO_POINTS", "player")
combo:RegisterEvent("PLAYER_COMBO_POINTS") combo:RegisterEvent("PLAYER_COMBO_POINTS")
combo:RegisterEvent("PLAYER_TARGET_CHANGED") combo:RegisterEvent("PLAYER_TARGET_CHANGED")
combo:RegisterEvent("PLAYER_ENTERING_WORLD") combo:RegisterEvent("PLAYER_ENTERING_WORLD")
modules/cooldown.lua
+35 -25
View File
@@ -1,35 +1,40 @@
pfUI:RegisterModule("cooldown", function () pfUI:RegisterModule("cooldown", function ()
-- cache values -- cache values
local lowcolor = {strsplit(",", C.appearance.cd.lowcolor)} -- local lowcolor = {strsplit(",", C.appearance.cd.lowcolor)}
local normalcolor = {strsplit(",", C.appearance.cd.normalcolor)} -- local normalcolor = {strsplit(",", C.appearance.cd.normalcolor)}
local minutecolor = {strsplit(",", C.appearance.cd.minutecolor)} -- local minutecolor = {strsplit(",", C.appearance.cd.minutecolor)}
local hourcolor = {strsplit(",", C.appearance.cd.hourcolor)} -- local hourcolor = {strsplit(",", C.appearance.cd.hourcolor)}
local daycolor = {strsplit(",", C.appearance.cd.daycolor)} -- local daycolor = {strsplit(",", C.appearance.cd.daycolor)}
local parent, parent_name
local function pfCooldownOnUpdate() local function pfCooldownOnUpdate()
parent = this:GetParent() -- Throttle FIRST. One of these runs per visible cooldown text, every frame,
if not parent then this:Hide() end -- so anything above this gate is multiplied by the frame rate and by how
parent_name = parent:GetName() -- many cooldowns are ticking.
local now = GetTime()
if (this.tick or 0) > now then return end
this.tick = now + .1
-- avoid to set cooldowns on invalid frames local parent = this:GetParent()
if parent_name and _G[parent_name .. "Cooldown"] then if not parent then this:Hide() return end
if not _G[parent_name .. "Cooldown"]:IsShown() then
this:Hide() -- avoid to set cooldowns on invalid frames. The cooldown frame is stashed
end -- at creation: resolving it as _G[parent:GetName() .. "Cooldown"] built and
-- interned that string twice per call, and this is the hottest path in the
-- UI. The stashed reference is also the frame itself rather than a guess
-- from its parent's name, so it holds for cooldowns named anything else.
if this.cooldown and not this.cooldown:IsShown() then
this:Hide()
return
end end
-- only run every 0.1 seconds from here on
if ( this.tick or .1) > GetTime() then return else this.tick = GetTime() + .1 end
-- fix own alpha value (should be inherited, but somehow isn't always) -- fix own alpha value (should be inherited, but somehow isn't always)
if this:GetAlpha() ~= parent:GetAlpha() then if this:GetAlpha() ~= parent:GetAlpha() then
this:SetAlpha(parent:GetAlpha()) this:SetAlpha(parent:GetAlpha())
end end
if this.start < GetTime() then if this.start < now then
-- calculating remaining time as it should be -- calculating remaining time as it should be
local remaining = this.duration - (GetTime() - this.start) local remaining = this.duration - (now - this.start)
if remaining >= 0 then if remaining >= 0 then
this.text:SetText(GetColoredTimeString(remaining)) this.text:SetText(GetColoredTimeString(remaining))
else else
@@ -38,13 +43,13 @@ pfUI:RegisterModule("cooldown", function ()
else else
-- I have absolutely no idea, but it works: -- I have absolutely no idea, but it works:
-- https://github.com/Stanzilla/WoWUIBugs/issues/47 -- https://github.com/Stanzilla/WoWUIBugs/issues/47
local time = time() local currentTime = time()
local startupTime = time - GetTime() local startupTime = currentTime - now
-- just a simplification of: ((2^32) - (start * 1000)) / 1000 -- just a simplification of: ((2^32) - (start * 1000)) / 1000
local cdTime = (2 ^ 32) / 1000 - this.start local cdTime = (2 ^ 32) / 1000 - this.start
local cdStartTime = startupTime - cdTime local cdStartTime = startupTime - cdTime
local cdEndTime = cdStartTime + this.duration local cdEndTime = cdStartTime + this.duration
local remaining = cdEndTime - time local remaining = cdEndTime - currentTime
if remaining >= 0 then if remaining >= 0 then
this.text:SetText(GetColoredTimeString(remaining)) this.text:SetText(GetColoredTimeString(remaining))
@@ -55,11 +60,16 @@ pfUI:RegisterModule("cooldown", function ()
end end
local height, size local height, size
local textcount = 0
local function pfCreateCoolDown(cooldown, start, duration) local function pfCreateCoolDown(cooldown, start, duration)
cooldown.pfCooldownText = CreateFrame("Frame", "pfCooldownFrame", cooldown:GetParent()) textcount = textcount + 1
local name = cooldown.GetName and cooldown:GetName() or "pfCooldown" .. textcount
cooldown.pfCooldownText = CreateFrame("Frame", name .. "Text", cooldown:GetParent())
cooldown.pfCooldownText.cooldown = cooldown
cooldown.pfCooldownText:SetAllPoints(cooldown) cooldown.pfCooldownText:SetAllPoints(cooldown)
cooldown.pfCooldownText:SetFrameLevel(cooldown:GetParent():GetFrameLevel() + 2) cooldown.pfCooldownText:SetFrameLevel(cooldown:GetParent():GetFrameLevel() + 2)
cooldown.pfCooldownText.text = cooldown.pfCooldownText:CreateFontString("pfCooldownFrameText", "OVERLAY") cooldown.pfCooldownText.text = cooldown.pfCooldownText:CreateFontString(name .. "TextString", "OVERLAY")
if not cooldown.pfCooldownType then if not cooldown.pfCooldownType then
size = tonumber(C.appearance.cd.font_size_foreign) size = tonumber(C.appearance.cd.font_size_foreign)
@@ -136,5 +146,5 @@ pfUI:RegisterModule("cooldown", function ()
-- vanilla does not have a cooldown frame type, so we hook the -- vanilla does not have a cooldown frame type, so we hook the
-- regular SetTimer function that each one is calling. -- regular SetTimer function that each one is calling.
pfUI.hooksecurefunc("CooldownFrame_SetTimer", SetCooldown) hooksecurefunc("CooldownFrame_SetTimer", SetCooldown)
end) end)
modules/easteregg.lua
+8 -11
View File
@@ -8,9 +8,9 @@ pfUI:RegisterModule("easteregg", function ()
local pvpking = CreateFrame("Frame", "pfPvPKing", UIParent) local pvpking = CreateFrame("Frame", "pfPvPKing", UIParent)
pvpking:Hide() pvpking:Hide()
pvpking:RegisterEvent("CHAT_MSG_SYSTEM") pvpking:RegisterEvent("PLAYER_FLAGS_CHANGED")
pvpking:SetScript("OnEvent", function() pvpking:SetScript("OnEvent", function()
if strfind(arg1, "You are now", 1) and strfind(arg1, "(AFK)", 1) then if UnitIsAFK('player') then
_G.CHAT_FLAG_AFK = title .. " " _G.CHAT_FLAG_AFK = title .. " "
this.time = GetTime() this.time = GetTime()
this:Show() this:Show()
@@ -61,14 +61,13 @@ pfUI:RegisterModule("easteregg", function ()
end) end)
-- trigger fireworks when being AFK -- trigger fireworks when being AFK
fireworks:RegisterEvent("CHAT_MSG_SYSTEM") fireworks:RegisterEvent("PLAYER_FLAGS_CHANGED")
fireworks:SetScript("OnEvent", function() fireworks:SetScript("OnEvent", function()
if strfind(arg1, _G.MARKED_AFK) or strfind(arg1, _G.MARKED_AFK_MESSAGE) then local isAFK = UnitIsAFK('player')
if isAFK then
this:SetAlpha(0) this:SetAlpha(0)
this:Show()
elseif strfind(arg1, _G.CLEARED_AFK) then
this:Hide()
end end
this:SetShown(isAFK)
end) end)
-- basic explosion animation -- basic explosion animation
@@ -124,8 +123,7 @@ pfUI:RegisterModule("easteregg", function ()
local f = GetExplosion() local f = GetExplosion()
f:ClearAllPoints() f:ClearAllPoints()
f:SetPoint("CENTER", fireworks, "TOPLEFT", x, y) f:SetPoint("CENTER", fireworks, "TOPLEFT", x, y)
f:SetWidth(25) f:SetSize(25, 25)
f:SetHeight(25)
f.tex:SetTexture(1,1,1,.5) f.tex:SetTexture(1,1,1,.5)
f:SetAlpha(1) f:SetAlpha(1)
f:Show() f:Show()
@@ -135,8 +133,7 @@ pfUI:RegisterModule("easteregg", function ()
local f = GetExplosion() local f = GetExplosion()
f:ClearAllPoints() f:ClearAllPoints()
f:SetPoint("CENTER", fireworks, "TOPLEFT", x+(math.random(0,100)-50), y+(math.random(0,100)-50)) f:SetPoint("CENTER", fireworks, "TOPLEFT", x+(math.random(0,100)-50), y+(math.random(0,100)-50))
f:SetWidth(2) f:SetSize(2, 2)
f:SetHeight(2)
f.tex:SetTexture(math.random(),math.random(),math.random(),1) f.tex:SetTexture(math.random(),math.random(),math.random(),1)
f:SetAlpha(1) f:SetAlpha(1)
f:Show() f:Show()
modules/energytick.lua
+187 -62
View File
@@ -1,20 +1,82 @@
local function getAdjustedTickTimer() -- One server clock drives every power: Player::RegenerateAll fires every
local adjustedEnergyTick = 2 -- REGEN_TIME_FULL (2s), re-arms with `+=`, and is never reset by casting. The
-- five-second rule (SetLastManaUse on any mana-costing cast) changes what a tick
-- pays, never when it lands; mp5 and the player's MOD_MANA_REGEN_INTERRUPT share
-- still come in. That share can't be computed here -- item sources are equip
-- auras absent from the buff list and m_modManaRegenInterrupt is never sent --
-- so the spark shows it instead: dim through the window until a tick lands.
--
-- The sweep free-runs on that clock and phase-locks to observed gains. A gain
-- mid-sweep (Illumination, Judgement of Wisdom, potions, a Mana Spring totem on
-- its own phase) is not the tick and never moves it.
-- Check rogue talents and compute energy tick timing reduction for Combat spec (1.18.0 Blade Rush Talent) local FIVE_SECOND_RULE = 5
if UnitClass("player") == "Rogue" then
local _, _, _, _, currRank = GetTalentInfo(2, 16)
local bladeRushRank = currRank or 0
if bladeRushRank > 0 then -- gains farther than this from the predicted boundary are not the tick
local agility = UnitStat("player", 2) -- 2 is agility stat index local TICK_TOLERANCE = .25
local reductionPerAgi = 0.0006 * bladeRushRank -- 0.0006 for rank 1, 0.0012 for rank 2
local totalReduction = agility * reductionPerAgi -- arrival jitter; a tick inside this band confirms the sweep rather than
adjustedEnergyTick = adjustedEnergyTick - totalReduction -- re-anchoring it, or the spark hitches at every wrap
local TICK_JITTER = .08
-- Player::RegenerateAll:
-- mod = GetTotalAuraModifier(SPELL_AURA_MOD_ENERGY_REGEN_TIME)
-- if mod > 0 then mod = mod * agility / 10 end
-- m_regenTimer += max(1, REGEN_TIME_FULL - mod) -- milliseconds
local REGEN_TIME_FULL = 2
local ENERGY_REGEN_TIME_AURA = 217 -- SPELL_AURA_MOD_ENERGY_REGEN_TIME
-- fixed magnitude is basePoints + baseDice (stored 11 -> 12); a die above 1 is
-- a roll the client can't know, so it counts as nothing rather than a guess
local amountCache = {}
local function auraAmount(spellID)
local amount = amountCache[spellID]
if amount then return amount end
amount = 0
local effects = C_Spell.GetSpellEffectInfo(spellID) -- nil for an id with no record
if effects then
for i = 1, 3 do
local fx = effects[i]
if fx.auraName == ENERGY_REGEN_TIME_AURA and fx.dieSides <= 1 then
amount = fx.basePoints + fx.baseDice
break
end
end end
end end
amountCache[spellID] = amount
return amount
end
return adjustedEnergyTick -- A passive is in effect exactly while known (current rank only, never in the
-- buff list); anything castable or cast on us counts only while it is up.
local function getEnergyRegenTimeMod()
local sum = 0
for _, spellID in ipairs(C_SpellBook.GetPlayerSpellsByAura(ENERGY_REGEN_TIME_AURA)) do
if C_Spell.IsSpellPassive(spellID) then
sum = sum + auraAmount(spellID)
end
end
for i = 1, 32 do
local spellID = select(10, C_UnitAuras.UnitAura("player", i, "HELPFUL"))
if not spellID then break end
sum = sum + auraAmount(spellID)
end
return sum
end
-- cleared on SPELLS_CHANGED (passives) and PLAYER_AURAS_CHANGED (buffs), and
-- recomputed by the next tick that asks. Agility stays live: it's one call.
local energyRegenTimeMod
local function getAdjustedTickTimer()
if not energyRegenTimeMod then
energyRegenTimeMod = getEnergyRegenTimeMod()
end
if energyRegenTimeMod == 0 then return REGEN_TIME_FULL end
-- ms on the server, seconds here; the 1ms floor is the server's and this is a divisor
local reduction = energyRegenTimeMod * UnitStat("player", 2) / 10000
return math.max(0.001, REGEN_TIME_FULL - reduction)
end end
pfUI:RegisterModule("energytick", function() pfUI:RegisterModule("energytick", function()
@@ -22,64 +84,111 @@ pfUI:RegisterModule("energytick", function()
return return
end end
-- inside the module body on purpose: C is on pfUI.env, not _G
local function getBarWidth()
return C.unitframes.player.pwidth ~= "-1" and C.unitframes.player.pwidth or C.unitframes.player.width
end
-- was this gain the regen tick? if so, re-anchor the sweep on it
local function lockTick(frame)
local now, period = GetTime(), getAdjustedTickTimer()
if frame.start then
-- signed distance to the nearest predicted boundary
local err = mod(now - frame.start, period)
if err > period / 2 then err = err - period end
if math.abs(err) <= TICK_TOLERANCE then
-- correct only what lies beyond normal jitter
if err > TICK_JITTER then
frame.start = frame.start + (err - TICK_JITTER)
elseif err < -TICK_JITTER then
frame.start = frame.start + (err + TICK_JITTER)
end
frame.max, frame.rejected = period, nil
return true
end
-- two rejected gains one period apart are the real clock: relock to it
local periodic = frame.rejected and math.abs(now - frame.rejected - period) <= TICK_TOLERANCE
if not periodic then
frame.rejected = now
return false
end
end
frame.start, frame.max, frame.rejected = now, period, nil
return true
end
local energytick = CreateFrame("Frame", nil, pfUI.uf.player.power.bar) local energytick = CreateFrame("Frame", nil, pfUI.uf.player.power.bar)
energytick:SetAllPoints(pfUI.uf.player.power.bar) energytick:SetAllPoints(pfUI.uf.player.power.bar)
energytick:RegisterEvent("PLAYER_ENTERING_WORLD") energytick:RegisterEvent("PLAYER_ENTERING_WORLD")
energytick:RegisterEvent("UNIT_DISPLAYPOWER") energytick:RegisterUnitEvent("UNIT_DISPLAYPOWER", "player")
energytick:RegisterEvent("UNIT_ENERGY") energytick:RegisterUnitEvent("UNIT_ENERGY", "player")
energytick:RegisterEvent("UNIT_MANA") energytick:RegisterUnitEvent("UNIT_MANA", "player")
energytick:RegisterEvent("CHAT_MSG_SPELL_SELF_BUFF") energytick:RegisterUnitEvent("UNIT_SPELLCAST_SUCCEEDED", "player")
energytick:RegisterEvent("CHAT_MSG_SPELL_PERIODIC_SELF_BUFFS") energytick:RegisterUnitEvent("UNIT_SPELLCAST_CHANNEL_STOP", "player")
energytick:RegisterEvent("SPELLS_CHANGED")
energytick:RegisterEvent("PLAYER_AURAS_CHANGED")
energytick:SetScript("OnEvent", function() energytick:SetScript("OnEvent", function()
if UnitPowerType("player") == 0 and C.unitframes.player.manatick == "1" then if UnitPowerType("player") == Enum.PowerType.Mana and C.unitframes.player.manatick == "1" then
this.mode = "MANA" this.mode = "MANA"
this:Show() this:Show()
elseif UnitPowerType("player") == 3 and C.unitframes.player.energy == "1" then elseif UnitPowerType("player") == Enum.PowerType.Energy and C.unitframes.player.energy == "1" then
this.mode = "ENERGY" this.mode = "ENERGY"
this:Show() this:Show()
else else
this:Hide() this:Hide()
end end
-- Filter nur eigene Energy-Gewinne von Talents/Buffs if event == "SPELLS_CHANGED" or event == "PLAYER_AURAS_CHANGED" then
if event == "CHAT_MSG_SPELL_SELF_BUFF" or event == "CHAT_MSG_SPELL_PERIODIC_SELF_BUFFS" then energyRegenTimeMod = nil
if string.find(arg1, "You gain") and string.find(arg1, "Energy from") then
this.ignoreNextGain = true
end
return return
end end
if event == "PLAYER_ENTERING_WORLD" then if event == "PLAYER_ENTERING_WORLD" then
this.lastMana = UnitMana("player") this.lastPower = UnitPower("player")
end
-- the rule arms on the cast (Spell::TakePower: mana powerType, cost > 0),
-- not on a mana drop -- Mana Burn lowers mana without arming it
if event == "UNIT_SPELLCAST_SUCCEEDED" and arg1 == "player" then
local cost = C_Spell.GetSpellPowerCost(arg3)
cost = cost and cost[1]
if cost and cost.type == Enum.PowerType.Mana and cost.cost > 0 then
this.fsrSpell, this.fsrEnd = arg3, GetTime() + FIVE_SECOND_RULE
this.fsrGain = nil
end
return
end
-- Unit::Update won't expire the rule while the spending spell still channels
if event == "UNIT_SPELLCAST_CHANNEL_STOP" and arg1 == "player" then
if this.fsrSpell and this.fsrSpell == arg3 then
this.fsrEnd, this.fsrGain = GetTime() + FIVE_SECOND_RULE, nil
end
return
end end
if (event == "UNIT_MANA" or event == "UNIT_ENERGY") and arg1 == "player" then if (event == "UNIT_MANA" or event == "UNIT_ENERGY") and arg1 == "player" then
this.currentMana = UnitMana("player") local power = UnitPower("player")
local diff = 0 local diff = this.lastPower and (power - this.lastPower) or 0
if this.lastMana then this.lastPower = power
diff = this.currentMana - this.lastMana
-- only a gain can be the tick; a spend never touches the phase
if diff > 0 and lockTick(this) then
-- a tick inside the window proves regen continues through it
if this.fsrEnd and this.fsrEnd > GetTime() then
this.fsrGain = true
end
end end
if this.mode == "MANA" and diff < 0 then -- phase is kept while hidden; OnUpdate catches up by whole periods
this.target = 5 if this.mode == "MANA" and power >= UnitPowerMax("player") then
elseif this.mode == "MANA" and diff > 0 then this:Hide()
if UnitMana("player") >= UnitManaMax("player") then
this.start = nil
this.spark:SetAlpha(0)
this:Hide()
elseif this.max ~= 5 and diff > (this.badtick and this.badtick * 1.2 or 5) then
this.target = 2
else
this.badtick = diff
end
elseif this.mode == "ENERGY" and diff >= 0 then
if not this.ignoreNextGain then
this.target = getAdjustedTickTimer()
end
this.ignoreNextGain = false
end end
this.lastMana = this.currentMana
end end
end) end)
@@ -90,37 +199,53 @@ pfUI:RegisterModule("energytick", function()
end end
this.tick = GetTime() + 0.020 -- ~50 FPS this.tick = GetTime() + 0.020 -- ~50 FPS
if this.target then -- five-second rule drains to nothing
this.start, this.max = GetTime(), this.target local remaining = this.fsrEnd and (this.fsrEnd - GetTime()) or 0
this.target = nil if this.mode == "MANA" and remaining > 0 then
this.spark:SetAlpha(1) this.fsrbar:SetWidth(getBarWidth() * remaining / FIVE_SECOND_RULE)
this:Show() this.fsrbar:Show()
else
this.fsrSpell, this.fsrEnd, this.fsrGain = nil, nil, nil
this.fsrbar:Hide()
end end
if not this.start then if not this.start then
this.spark:SetAlpha(0)
return
end
if this.mode == "MANA" and UnitPower("player") >= UnitPowerMax("player") then
this.spark:SetAlpha(0)
return return
end end
this.current = GetTime() - this.start this.current = GetTime() - this.start
-- roll over by whole periods, not from now: restarting bakes frame
-- overshoot into the phase as drift the lock then has to chase
if this.current > this.max then if this.current > this.max then
-- Don't restart tick timer if mana is full this.start = this.start + this.max * math.floor(this.current / this.max)
if this.mode == "MANA" and UnitMana("player") >= UnitManaMax("player") then this.max = getAdjustedTickTimer()
this.start = nil this.current = GetTime() - this.start
this.spark:SetAlpha(0)
return
end
this.start, this.max, this.current = GetTime(), getAdjustedTickTimer(), 0
end end
local pos = (C.unitframes.player.pwidth ~= "-1" and C.unitframes.player.pwidth or C.unitframes.player.width) -- dim while the rule is up and nothing has ticked inside it yet
* (this.current / this.max) this.spark:SetAlpha((remaining > 0 and not this.fsrGain) and .4 or 1)
if not C.unitframes.player.pheight then if not C.unitframes.player.pheight then
return return
end end
local pos = getBarWidth() * (this.current / this.max)
this.spark:SetPoint("LEFT", pos - ((C.unitframes.player.pheight + 5) / 2), 0) this.spark:SetPoint("LEFT", pos - ((C.unitframes.player.pheight + 5) / 2), 0)
end) end)
energytick.fsrbar = energytick:CreateTexture(nil, "ARTWORK")
energytick.fsrbar:SetTexture(1, 1, 1, .15)
energytick.fsrbar:SetPoint("TOPLEFT", 0, 0)
energytick.fsrbar:SetPoint("BOTTOMLEFT", 0, 0)
energytick.fsrbar:Hide()
energytick.spark = energytick:CreateTexture(nil, "OVERLAY") energytick.spark = energytick:CreateTexture(nil, "OVERLAY")
energytick.spark:SetTexture("Interface\\CastingBar\\UI-CastingBar-Spark") energytick.spark:SetTexture("Interface\\CastingBar\\UI-CastingBar-Spark")
energytick.spark:SetHeight(C.unitframes.player.pheight + 15) energytick.spark:SetHeight(C.unitframes.player.pheight + 15)
@@ -133,4 +258,4 @@ pfUI:RegisterModule("energytick", function()
energytick.spark:SetWidth(C.unitframes.player.pheight + 5) energytick.spark:SetWidth(C.unitframes.player.pheight + 5)
hookUpdateConfig(pfUI.uf.player) hookUpdateConfig(pfUI.uf.player)
end end
end) end)
modules/eqcompare.lua
+22 -5
View File
@@ -88,7 +88,7 @@ pfUI:RegisterModule("eqcompare", function ()
local prevMerchant = ShoppingTooltip1.SetMerchantCompareItem local prevMerchant = ShoppingTooltip1.SetMerchantCompareItem
local function SetMerchantCompareItem(self, index, compareItem) local function SetMerchantCompareItem(self, index, compareItem)
if C.tooltip.compare.basestats == "1" and compareItem == 1 then if compareItem == 1 then
ShowCompareItem(nil, GetMerchantItemLink(index), 1) ShowCompareItem(nil, GetMerchantItemLink(index), 1)
return false return false
end end
@@ -97,7 +97,7 @@ pfUI:RegisterModule("eqcompare", function ()
local prevAuction = ShoppingTooltip1.SetAuctionCompareItem local prevAuction = ShoppingTooltip1.SetAuctionCompareItem
local function SetAuctionCompareItem(self, type, index, compareItem) local function SetAuctionCompareItem(self, type, index, compareItem)
if C.tooltip.compare.basestats == "1" and compareItem == 1 then if compareItem == 1 then
ShowCompareItem(nil, GetAuctionItemLink(type, index), 1) ShowCompareItem(nil, GetAuctionItemLink(type, index), 1)
return false return false
end end
@@ -130,17 +130,34 @@ pfUI:RegisterModule("eqcompare", function ()
SetTradeTargetItem = GetTradeTargetItemLink SetTradeTargetItem = GetTradeTargetItemLink
} }
-- Guda anchors its item tooltips with ANCHOR_NONE and its own SetPoint, and
-- the tooltip module then moves every ANCHOR_NONE tooltip to its configured
-- spot. Reading the rect inside the Set* call picks the side against the
-- position the tooltip is about to leave, so place the compare a frame later.
local deferred
if C_AddOns.DoesAddOnExist("Guda") then
EventUtil.ContinueOnAddOnLoaded("Guda", function()
deferred = true
end)
end
local function makeHook(getter) local function makeHook(getter)
return function(tooltip, arg1, arg2, arg3) return function(tooltip, arg1, arg2, arg3)
if C.tooltip.compare.basestats == "1" then local link = getter(arg1, arg2, arg3)
ShowCompareItem(tooltip, getter(arg1, arg2, arg3)) if not deferred then
return ShowCompareItem(tooltip, link)
end end
RunNextFrame(function()
if tooltip:IsShown() then
ShowCompareItem(tooltip, link)
end
end)
end end
end end
local function HookTooltip(tooltip) local function HookTooltip(tooltip)
for setter, getter in pairs(TooltipHooks) do for setter, getter in pairs(TooltipHooks) do
pfUI.hooksecurefunc(tooltip, setter, makeHook(getter)) hooksecurefunc(tooltip, setter, makeHook(getter))
end end
end end
modules/equipmentmanager.lua
+94 -270
View File
@@ -1,11 +1,10 @@
-- Equipment Manager module -- Equipment Manager module
-- Backport of the 4.3.4 GearManagerDialog UI on top of ClassicAPI's -- Backport of the 4.3.4 GearManagerDialog UI on top of ClassicAPI's C_EquipmentSet.* API.
-- C_EquipmentSet.* API. Adds a 6th tab to CharacterFrame.
pfUI:RegisterModule("equipmentmanager", function() pfUI:RegisterModule("equipmentmanager", function()
if not C_EquipmentSet or not C_EquipmentSet.CanUseEquipmentSets() then return end if not C_EquipmentSet or not C_EquipmentSet.CanUseEquipmentSets() then return end
pfUI.equipmentmanager = pfUI.equipmentmanager or {} pfUI.equipmentmanager = {}
local SET_ROW_HEIGHT = 36 local SET_ROW_HEIGHT = 36
@@ -14,6 +13,7 @@ pfUI:RegisterModule("equipmentmanager", function()
local pendingAction = nil -- "new" | "save" | "rename" — what the popups apply to local pendingAction = nil -- "new" | "save" | "rename" — what the popups apply to
local slotOverlays = {} -- [invSlotID] = ignored-overlay texture on the character slot local slotOverlays = {} -- [invSlotID] = ignored-overlay texture on the character slot
local popoutButtons = {} -- popout arrow buttons; toggled with the EM frame local popoutButtons = {} -- popout arrow buttons; toggled with the EM frame
local UpdatePopouts -- forward decl; assigned once popouts + flyout exist
-- Pending ignored-slot toggles per set: a slotID here means the -- Pending ignored-slot toggles per set: a slotID here means the
-- effective state is flipped from what's persisted. Committed on -- effective state is flipped from what's persisted. Committed on
@@ -55,7 +55,7 @@ pfUI:RegisterModule("equipmentmanager", function()
local function EquipSet(setID) local function EquipSet(setID)
if not setID then return end if not setID then return end
if C_EquipmentSet.EquipmentSetContainsLockedItems(setID) then if C_EquipmentSet.EquipmentSetContainsLockedItems(setID) then
UIErrorsFrame:AddMessage(ERR_CLIENT_LOCKED_OUT or "Locked items in set", 1, .1, .1, 1) UIErrorsFrame:AddMessage(ERR_CLIENT_LOCKED_OUT, 1, .1, .1, 1)
return return
end end
ClearCursor() ClearCursor()
@@ -68,8 +68,7 @@ pfUI:RegisterModule("equipmentmanager", function()
-- ============================================================ -- ============================================================
local frame = CreateFrame("Frame", "pfEquipmentManagerFrame", CharacterFrame) local frame = CreateFrame("Frame", "pfEquipmentManagerFrame", CharacterFrame)
frame:SetWidth(220) frame:SetSize(220, 350)
frame:SetHeight(350)
frame:SetFrameStrata("HIGH") frame:SetFrameStrata("HIGH")
frame:SetScript("OnShow", function() frame:SetScript("OnShow", function()
this:ClearAllPoints() this:ClearAllPoints()
@@ -78,7 +77,7 @@ pfUI:RegisterModule("equipmentmanager", function()
else else
frame:SetPoint("TOPLEFT", CharacterFrame, "TOPRIGHT", 0, 0) frame:SetPoint("TOPLEFT", CharacterFrame, "TOPRIGHT", 0, 0)
end end
for _, b in ipairs(popoutButtons) do b:Show() end UpdatePopouts()
end) end)
CreateBackdrop(frame, nil, nil, .9) CreateBackdrop(frame, nil, nil, .9)
CreateBackdropShadow(frame) CreateBackdropShadow(frame)
@@ -86,7 +85,7 @@ pfUI:RegisterModule("equipmentmanager", function()
frame.title = frame:CreateFontString(nil, "OVERLAY", "GameFontNormal") frame.title = frame:CreateFontString(nil, "OVERLAY", "GameFontNormal")
frame.title:SetPoint("TOP", frame, "TOP", 0, -10) frame.title:SetPoint("TOP", frame, "TOP", 0, -10)
frame.title:SetText(T["Equipment Manager"] or "Equipment Manager") frame.title:SetText(EQUIPMENT_MANAGER)
local closeBtn = CreateFrame("Button", nil, frame, "UIPanelCloseButton") local closeBtn = CreateFrame("Button", nil, frame, "UIPanelCloseButton")
closeBtn:SetPoint("TOPRIGHT", frame, "TOPRIGHT", -4, -4) closeBtn:SetPoint("TOPRIGHT", frame, "TOPRIGHT", -4, -4)
@@ -98,15 +97,14 @@ pfUI:RegisterModule("equipmentmanager", function()
-- ============================================================ -- ============================================================
local toggleBtn = CreateFrame("Button", "pfEqMgrToggleButton", PaperDollFrame) local toggleBtn = CreateFrame("Button", "pfEqMgrToggleButton", PaperDollFrame)
toggleBtn:SetWidth(28) toggleBtn:SetSize(28, 28)
toggleBtn:SetHeight(28)
toggleBtn:SetPoint("BOTTOM", CharacterHandsSlot, "TOP", 0, 4) toggleBtn:SetPoint("BOTTOM", CharacterHandsSlot, "TOP", 0, 4)
toggleBtn:SetNormalTexture(pfUI.path.."\\img\\UI-GearManager-Button") toggleBtn:SetNormalTexture(pfUI.path.."\\img\\UI-GearManager-Button")
toggleBtn:SetPushedTexture(pfUI.path.."\\img\\UI-GearManager-Button-Pushed") toggleBtn:SetPushedTexture(pfUI.path.."\\img\\UI-GearManager-Button-Pushed")
toggleBtn:SetHighlightTexture("Interface\\Buttons\\ButtonHilight-Square", "ADD") toggleBtn:SetHighlightTexture("Interface\\Buttons\\ButtonHilight-Square", "ADD")
toggleBtn:SetScript("OnEnter", function() toggleBtn:SetScript("OnEnter", function()
GameTooltip:SetOwner(this, "ANCHOR_RIGHT") GameTooltip:SetOwner(this, "ANCHOR_RIGHT")
GameTooltip:SetText(T["Equipment Manager"] or "Equipment Manager") GameTooltip:SetText(PAPERDOLL_EQUIPMENTMANAGER)
GameTooltip:Show() GameTooltip:Show()
end) end)
toggleBtn:SetScript("OnLeave", function() GameTooltip:Hide() end) toggleBtn:SetScript("OnLeave", function() GameTooltip:Hide() end)
@@ -126,13 +124,13 @@ pfUI:RegisterModule("equipmentmanager", function()
-- ============================================================ -- ============================================================
local btnEquip = CreateFrame("Button", "pfEqMgrEquip", frame, "UIPanelButtonTemplate") local btnEquip = CreateFrame("Button", "pfEqMgrEquip", frame, "UIPanelButtonTemplate")
btnEquip:SetWidth(86); btnEquip:SetHeight(22); btnEquip:SetText(T["Equip"] or "Equip") btnEquip:SetSize(86, 22); btnEquip:SetText(EQUIPSET_EQUIP)
btnEquip:SetPoint("TOPLEFT", frame, "TOPLEFT", 16, -30) btnEquip:SetPoint("TOPLEFT", frame, "TOPLEFT", 16, -30)
SkinButton(btnEquip) SkinButton(btnEquip)
btnEquip:SetScript("OnClick", function() EquipSet(selectedSetID) end) btnEquip:SetScript("OnClick", function() EquipSet(selectedSetID) end)
local btnSave = CreateFrame("Button", "pfEqMgrSave", frame, "UIPanelButtonTemplate") local btnSave = CreateFrame("Button", "pfEqMgrSave", frame, "UIPanelButtonTemplate")
btnSave:SetWidth(86); btnSave:SetHeight(22); btnSave:SetText(T["Save"] or "Save") btnSave:SetSize(86, 22); btnSave:SetText(SAVE)
btnSave:SetPoint("LEFT", btnEquip, "RIGHT", 6, 0) btnSave:SetPoint("LEFT", btnEquip, "RIGHT", 6, 0)
SkinButton(btnSave) SkinButton(btnSave)
btnSave:SetScript("OnClick", function() btnSave:SetScript("OnClick", function()
@@ -141,7 +139,7 @@ pfUI:RegisterModule("equipmentmanager", function()
if not name then return end if not name then return end
local targetID = selectedSetID local targetID = selectedSetID
StaticPopupDialogs["PFUI_EQMGR_SAVE_CONFIRM"] = { StaticPopupDialogs["PFUI_EQMGR_SAVE_CONFIRM"] = {
text = string.format(T["Would you like to save the equipment set '%s'?"] or "Would you like to save the equipment set '%s'?", name), text = string.format(CONFIRM_SAVE_EQUIPMENT_SET, name),
button1 = YES, button2 = NO, button1 = YES, button2 = NO,
OnAccept = function() OnAccept = function()
C_EquipmentSet.ClearIgnoredSlotsForSave() C_EquipmentSet.ClearIgnoredSlotsForSave()
@@ -166,7 +164,7 @@ pfUI:RegisterModule("equipmentmanager", function()
local rowMenu = CreateFrame("Frame", "pfEqMgrRowMenu", UIParent) local rowMenu = CreateFrame("Frame", "pfEqMgrRowMenu", UIParent)
rowMenu:SetFrameStrata("DIALOG") rowMenu:SetFrameStrata("DIALOG")
rowMenu:SetWidth(140); rowMenu:SetHeight(50) rowMenu:SetSize(140, 50);
rowMenu:Hide() rowMenu:Hide()
CreateBackdrop(rowMenu, nil, nil, .95) CreateBackdrop(rowMenu, nil, nil, .95)
CreateBackdropShadow(rowMenu) CreateBackdropShadow(rowMenu)
@@ -185,9 +183,9 @@ pfUI:RegisterModule("equipmentmanager", function()
tinsert(UISpecialFrames, "pfEqMgrRowMenu") -- Escape closes it tinsert(UISpecialFrames, "pfEqMgrRowMenu") -- Escape closes it
rowMenu.changeBtn = CreateFrame("Button", nil, rowMenu, "UIPanelButtonTemplate") rowMenu.changeBtn = CreateFrame("Button", nil, rowMenu, "UIPanelButtonTemplate")
rowMenu.changeBtn:SetWidth(130); rowMenu.changeBtn:SetHeight(20) rowMenu.changeBtn:SetSize(130, 20);
rowMenu.changeBtn:SetPoint("TOPLEFT", rowMenu, "TOPLEFT", 5, -3) rowMenu.changeBtn:SetPoint("TOPLEFT", rowMenu, "TOPLEFT", 5, -3)
rowMenu.changeBtn:SetText(T["Change Name/Icon"] or "Change Name/Icon") rowMenu.changeBtn:SetText(EQUIPMENT_SET_EDIT)
SkinButton(rowMenu.changeBtn) SkinButton(rowMenu.changeBtn)
rowMenu.changeBtn:SetScript("OnClick", function() rowMenu.changeBtn:SetScript("OnClick", function()
rowMenu:Hide() rowMenu:Hide()
@@ -198,9 +196,9 @@ pfUI:RegisterModule("equipmentmanager", function()
end) end)
rowMenu.deleteBtn = CreateFrame("Button", nil, rowMenu, "UIPanelButtonTemplate") rowMenu.deleteBtn = CreateFrame("Button", nil, rowMenu, "UIPanelButtonTemplate")
rowMenu.deleteBtn:SetWidth(130); rowMenu.deleteBtn:SetHeight(20) rowMenu.deleteBtn:SetSize(130, 20);
rowMenu.deleteBtn:SetPoint("TOP", rowMenu.changeBtn, "BOTTOM", 0, -2) rowMenu.deleteBtn:SetPoint("TOP", rowMenu.changeBtn, "BOTTOM", 0, -2)
rowMenu.deleteBtn:SetText(T["Delete"] or "Delete") rowMenu.deleteBtn:SetText(DELETE)
SkinButton(rowMenu.deleteBtn) SkinButton(rowMenu.deleteBtn)
rowMenu.deleteBtn:SetScript("OnClick", function() rowMenu.deleteBtn:SetScript("OnClick", function()
rowMenu:Hide() rowMenu:Hide()
@@ -208,7 +206,7 @@ pfUI:RegisterModule("equipmentmanager", function()
local targetID = rowMenu.targetSetID local targetID = rowMenu.targetSetID
local name = C_EquipmentSet.GetEquipmentSetInfo(targetID) local name = C_EquipmentSet.GetEquipmentSetInfo(targetID)
StaticPopupDialogs["PFUI_EQMGR_DELETE"] = { StaticPopupDialogs["PFUI_EQMGR_DELETE"] = {
text = string.format(T["Delete equipment set '%s'?"] or "Delete equipment set '%s'?", name or "?"), text = string.format(CONFIRM_DELETE_EQUIPMENT_SET, name or "?"),
button1 = YES, button2 = NO, button1 = YES, button2 = NO,
OnAccept = function() OnAccept = function()
pendingIgnoredToggles[targetID] = nil pendingIgnoredToggles[targetID] = nil
@@ -229,9 +227,8 @@ pfUI:RegisterModule("equipmentmanager", function()
local LIST_ROW_STRIDE = SET_ROW_HEIGHT + 2 local LIST_ROW_STRIDE = SET_ROW_HEIGHT + 2
local listFrame = CreateFrame("Frame", nil, frame) local listFrame = CreateFrame("Frame", nil, frame)
listFrame:SetPoint("TOPLEFT", frame, "TOPLEFT", 16, -58) listFrame:SetPoint("TOPLEFT", frame, "TOPLEFT", 16, -58)
listFrame:SetWidth(180)
-- Height fits N rows + (N-1) inter-row gaps + 3px top/bottom padding. -- Height fits N rows + (N-1) inter-row gaps + 3px top/bottom padding.
listFrame:SetHeight(LIST_VISIBLE_ROWS * LIST_ROW_STRIDE + 4) listFrame:SetSize(180, LIST_VISIBLE_ROWS * LIST_ROW_STRIDE + 4)
CreateBackdrop(listFrame, nil, nil, .75) CreateBackdrop(listFrame, nil, nil, .75)
-- Mouse-wheel scroll: list of [sets..., newSetRow] is virtualized -- Mouse-wheel scroll: list of [sets..., newSetRow] is virtualized
@@ -247,15 +244,13 @@ pfUI:RegisterModule("equipmentmanager", function()
local setRows = {} local setRows = {}
local function CreateSetRow() local function CreateSetRow()
local row = CreateFrame("Button", nil, listFrame) local row = CreateFrame("Button", nil, listFrame)
row:SetWidth(170) row:SetSize(170, SET_ROW_HEIGHT)
row:SetHeight(SET_ROW_HEIGHT)
-- Position is set per-Refresh based on the row's visible slot; -- Position is set per-Refresh based on the row's visible slot;
-- start anchored to avoid uninitialized geometry before first Refresh. -- start anchored to avoid uninitialized geometry before first Refresh.
row:SetPoint("TOPLEFT", listFrame, "TOPLEFT", 5, -3) row:SetPoint("TOPLEFT", listFrame, "TOPLEFT", 5, -3)
row.icon = row:CreateTexture(nil, "ARTWORK") row.icon = row:CreateTexture(nil, "ARTWORK")
row.icon:SetWidth(30) row.icon:SetSize(30, 30)
row.icon:SetHeight(30)
row.icon:SetPoint("LEFT", row, "LEFT", 2, 0) row.icon:SetPoint("LEFT", row, "LEFT", 2, 0)
row.icon:SetTexCoord(.08, .92, .08, .92) row.icon:SetTexCoord(.08, .92, .08, .92)
@@ -270,7 +265,7 @@ pfUI:RegisterModule("equipmentmanager", function()
row.highlight:Hide() row.highlight:Hide()
row.gear = CreateFrame("Button", nil, row) row.gear = CreateFrame("Button", nil, row)
row.gear:SetWidth(16); row.gear:SetHeight(16) row.gear:SetSize(16, 16);
row.gear:SetPoint("RIGHT", row, "RIGHT", -4, 0) row.gear:SetPoint("RIGHT", row, "RIGHT", -4, 0)
row.gear.tex = row.gear:CreateTexture(nil, "ARTWORK") row.gear.tex = row.gear:CreateTexture(nil, "ARTWORK")
row.gear.tex:SetAllPoints(row.gear) row.gear.tex:SetAllPoints(row.gear)
@@ -306,27 +301,27 @@ pfUI:RegisterModule("equipmentmanager", function()
pfUI.equipmentmanager.Refresh() pfUI.equipmentmanager.Refresh()
end) end)
-- Hover handling: OnLeave fires when the cursor moves onto a child -- Show the gear and tooltip while the cursor is over the row or its
-- (the gear button becomes the topmost mouse target). Use an -- gear child. The gear sits inside the row's rectangle, so a single
-- OnUpdate poll so the gear stays shown while the cursor is over -- MouseIsOver(row) check covers both. OnLeave on the row and the gear
-- the row OR the gear itself. -- catches every exit path, so no OnUpdate poll is needed.
local function HideRowHover()
if MouseIsOver(row) then return end
GameTooltip:Hide()
row.gear:Hide()
end
row:SetScript("OnEnter", function() row:SetScript("OnEnter", function()
if not this.setID then return end if not row.setID then return end
local name = C_EquipmentSet.GetEquipmentSetInfo(this.setID) local name = C_EquipmentSet.GetEquipmentSetInfo(row.setID)
if name then if name then
GameTooltip:SetOwner(this, "ANCHOR_RIGHT") GameTooltip:SetOwner(row, "ANCHOR_RIGHT")
GameTooltip:SetEquipmentSet(name) GameTooltip:SetEquipmentSet(name)
GameTooltip:Show() GameTooltip:Show()
end end
row.gear:Show() row.gear:Show()
this:SetScript("OnUpdate", function()
if not MouseIsOver(this) and not MouseIsOver(row.gear) then
this:SetScript("OnUpdate", nil)
GameTooltip:Hide()
row.gear:Hide()
end
end)
end) end)
row:SetScript("OnLeave", HideRowHover)
row.gear:SetScript("OnLeave", HideRowHover)
return row return row
end end
@@ -338,10 +333,10 @@ pfUI:RegisterModule("equipmentmanager", function()
-- specific set index (row[i] always shows ids[i]). -- specific set index (row[i] always shows ids[i]).
local newSetRow = CreateFrame("Button", nil, listFrame) local newSetRow = CreateFrame("Button", nil, listFrame)
newSetRow:SetWidth(170); newSetRow:SetHeight(SET_ROW_HEIGHT) newSetRow:SetSize(170, SET_ROW_HEIGHT);
newSetRow.icon = newSetRow:CreateTexture(nil, "ARTWORK") newSetRow.icon = newSetRow:CreateTexture(nil, "ARTWORK")
newSetRow.icon:SetWidth(24); newSetRow.icon:SetHeight(24) newSetRow.icon:SetSize(24, 24);
newSetRow.icon:SetPoint("LEFT", newSetRow, "LEFT", 5, 0) newSetRow.icon:SetPoint("LEFT", newSetRow, "LEFT", 5, 0)
newSetRow.icon:SetTexture(pfUI.path.."\\img\\Character-Plus") newSetRow.icon:SetTexture(pfUI.path.."\\img\\Character-Plus")
@@ -349,7 +344,7 @@ pfUI:RegisterModule("equipmentmanager", function()
newSetRow.text:SetPoint("LEFT", newSetRow.icon, "RIGHT", 8, 0) newSetRow.text:SetPoint("LEFT", newSetRow.icon, "RIGHT", 8, 0)
newSetRow.text:SetPoint("RIGHT", newSetRow, "RIGHT", -4, 0) newSetRow.text:SetPoint("RIGHT", newSetRow, "RIGHT", -4, 0)
newSetRow.text:SetJustifyH("LEFT") newSetRow.text:SetJustifyH("LEFT")
newSetRow.text:SetText(T["New Set"] or "New Set") newSetRow.text:SetText(PAPERDOLL_NEWEQUIPMENTSET)
newSetRow.text:SetTextColor(0.2, 1, 0.2) newSetRow.text:SetTextColor(0.2, 1, 0.2)
newSetRow.highlight = newSetRow:CreateTexture(nil, "BACKGROUND") newSetRow.highlight = newSetRow:CreateTexture(nil, "BACKGROUND")
@@ -362,8 +357,7 @@ pfUI:RegisterModule("equipmentmanager", function()
local function MakeButton(name, label, parent, anchor, ax, ay, width) local function MakeButton(name, label, parent, anchor, ax, ay, width)
local b = CreateFrame("Button", name, parent, "UIPanelButtonTemplate") local b = CreateFrame("Button", name, parent, "UIPanelButtonTemplate")
b:SetWidth(width or 70) b:SetSize(width or 70, 22)
b:SetHeight(22)
b:SetText(label) b:SetText(label)
b:SetPoint("TOPLEFT", anchor, "BOTTOMLEFT", ax, ay) b:SetPoint("TOPLEFT", anchor, "BOTTOMLEFT", ax, ay)
SkinButton(b) SkinButton(b)
@@ -376,8 +370,7 @@ pfUI:RegisterModule("equipmentmanager", function()
local namePopup = CreateFrame("Frame", "pfEqMgrNamePopup", UIParent) local namePopup = CreateFrame("Frame", "pfEqMgrNamePopup", UIParent)
namePopup:SetFrameStrata("DIALOG") namePopup:SetFrameStrata("DIALOG")
namePopup:SetWidth(472) namePopup:SetSize(472, 484)
namePopup:SetHeight(498)
namePopup:SetPoint("CENTER", UIParent, "CENTER") namePopup:SetPoint("CENTER", UIParent, "CENTER")
namePopup:Hide() namePopup:Hide()
CreateBackdrop(namePopup, nil, nil, .9) CreateBackdrop(namePopup, nil, nil, .9)
@@ -388,200 +381,28 @@ pfUI:RegisterModule("equipmentmanager", function()
namePopup:SetScript("OnDragStart", function() this:StartMoving() end) namePopup:SetScript("OnDragStart", function() this:StartMoving() end)
namePopup:SetScript("OnDragStop", function() this:StopMovingOrSizing() end) namePopup:SetScript("OnDragStop", function() this:StopMovingOrSizing() end)
namePopup.title = namePopup:CreateFontString(nil, "OVERLAY", "GameFontNormal") -- Equipment seed leads the grid with gear-relevant item icons. The widget
namePopup.title:SetPoint("TOP", namePopup, "TOP", 0, -10) -- owns the name field, preview, grid, filter, and search; this module keeps
namePopup.title:SetText(T["Save Set"] or "Save Set") -- the OK/Cancel buttons and the create/save/rename flow below.
local iconPicker = CreateIconPicker("pfEqMgrIcon", namePopup,
IconDataProviderExtraType.Equipment, GEARSETS_POPUP_TEXT)
namePopup.nameLabel = namePopup:CreateFontString(nil, "OVERLAY", "GameFontNormal") local btnPopupOK = MakeButton("pfEqMgrPopupOK", OKAY, namePopup, namePopup, 14, -340, 80)
namePopup.nameLabel:SetPoint("TOPLEFT", namePopup, "TOPLEFT", 14, -34)
namePopup.nameLabel:SetText(T["Enter Set Name (Max 16 Characters):"] or "Enter Set Name (Max 16 Characters):")
namePopup.editbox = CreateFrame("EditBox", "pfEqMgrNameEdit", namePopup, "InputBoxTemplate") local btnPopupCancel = MakeButton("pfEqMgrPopupCancel", CANCEL, namePopup, namePopup, 0, 0, 80)
namePopup.editbox:SetWidth(280)
namePopup.editbox:SetHeight(20)
namePopup.editbox:SetPoint("TOPLEFT", namePopup, "TOPLEFT", 14, -52)
namePopup.editbox:SetAutoFocus(false)
namePopup.editbox:SetMaxLetters(16)
CreateBackdrop(namePopup.editbox)
namePopup.selectedLabel = namePopup:CreateFontString(nil, "OVERLAY", "GameFontNormal")
namePopup.selectedLabel:SetPoint("TOPRIGHT", namePopup, "TOPRIGHT", -14, -28)
namePopup.selectedLabel:SetText(T["Currently Selected"] or "Currently Selected")
namePopup.selectedLabel:SetTextColor(1, 0.82, 0)
namePopup.selectedPreview = CreateFrame("Frame", nil, namePopup)
namePopup.selectedPreview:SetWidth(42)
namePopup.selectedPreview:SetHeight(42)
namePopup.selectedPreview:SetPoint("TOPRIGHT", namePopup, "TOPRIGHT", -14, -44)
CreateBackdrop(namePopup.selectedPreview)
namePopup.selectedPreview.tex = namePopup.selectedPreview:CreateTexture(nil, "ARTWORK")
namePopup.selectedPreview.tex:SetAllPoints(namePopup.selectedPreview)
namePopup.selectedPreview.tex:SetTexCoord(.08, .92, .08, .92)
namePopup.iconLabel = namePopup:CreateFontString(nil, "OVERLAY", "GameFontNormal")
namePopup.iconLabel:SetPoint("TOPLEFT", namePopup, "TOPLEFT", 14, -100)
namePopup.iconLabel:SetText(T["Choose an Icon:"] or "Choose an Icon:")
-- Icon picker: 10×8 grid of buttons + scroll
local ICON_GRID_COLS = 10
local ICON_GRID_ROWS = 8
local ICON_BTN_SIZE = 36
local ICON_BTN_PAD = 6
local iconScroll = CreateFrame("ScrollFrame", "pfEqMgrIconScroll", namePopup, "FauxScrollFrameTemplate")
iconScroll:SetPoint("TOPLEFT", namePopup, "TOPLEFT", 14, -130)
iconScroll:SetWidth(ICON_GRID_COLS * (ICON_BTN_SIZE + ICON_BTN_PAD) - ICON_BTN_PAD)
iconScroll:SetHeight(ICON_GRID_ROWS * (ICON_BTN_SIZE + ICON_BTN_PAD) - ICON_BTN_PAD)
-- IconDataProviderMixin owns the icon DB, dedup, and lazy load.
-- Init on first picker open; release on hide so the cache GCs.
local provider = nil
-- Selection is tracked by PATH (not index) so it survives filter
-- changes: a spell icon you picked still saves correctly even after
-- you switch the filter to "Items" and it's no longer in the visible list.
local QUESTION_MARK = "INTERFACE\\ICONS\\INV_MISC_QUESTIONMARK"
local selectedIconPath = QUESTION_MARK
local function EnsureProvider()
if not provider then
provider = CreateAndInitFromMixin(IconDataProviderMixin,
IconDataProviderExtraType.Equipment)
end
end
-- Anchor scrollbar to iconScroll's right edge so its position tracks
-- the icon grid rather than the popup. -16/+16 vertical insets are the
-- standard up/down arrow spacing for UIPanelScrollBarTemplate.
local scrollbar = _G["pfEqMgrIconScrollScrollBar"]
if scrollbar then
scrollbar:ClearAllPoints()
scrollbar:SetPoint("TOPLEFT", iconScroll, "TOPRIGHT", 8, -16)
scrollbar:SetPoint("BOTTOMLEFT", iconScroll, "BOTTOMRIGHT", 8, 16)
SkinScrollbar(scrollbar)
end
-- Filter dropdown: "All Icons" / "Spells" / "Items" (top right of icon area).
local filterDropdown = CreateFrame("Frame", "pfEqMgrIconFilter", namePopup, "UIDropDownMenuTemplate")
filterDropdown:SetPoint("TOPRIGHT", namePopup, "TOPRIGHT", 0, -94)
local currentFilter = "all"
local function ApplyFilter(value)
currentFilter = value
UIDropDownMenu_SetSelectedValue(filterDropdown, value)
if provider then
if value == "spells" then provider:SetIconTypes({ IconDataProviderIconType.Spell })
elseif value == "items" then provider:SetIconTypes({ IconDataProviderIconType.Item })
else provider:SetIconTypes(nil) end
-- Don't reset selection — selectedIconPath persists. If the
-- selected icon isn't in the new filter, no grid entry will be
-- highlighted but Save will still write the chosen icon.
pfUI.equipmentmanager.RefreshIconGrid()
end
end
UIDropDownMenu_Initialize(filterDropdown, function()
local info
info = {}; info.text = T["All Icons"] or "All Icons"; info.value = "all"
info.func = function() ApplyFilter("all") end
info.checked = currentFilter == "all"
UIDropDownMenu_AddButton(info)
info = {}; info.text = T["Spells"] or "Spells"; info.value = "spells"
info.func = function() ApplyFilter("spells") end
info.checked = currentFilter == "spells"
UIDropDownMenu_AddButton(info)
info = {}; info.text = T["Items"] or "Items"; info.value = "items"
info.func = function() ApplyFilter("items") end
info.checked = currentFilter == "items"
UIDropDownMenu_AddButton(info)
end)
UIDropDownMenu_SetWidth(120, filterDropdown)
UIDropDownMenu_SetSelectedValue(filterDropdown, "all")
SkinDropDown(filterDropdown)
local iconButtons = {}
for r = 1, ICON_GRID_ROWS do
for c = 1, ICON_GRID_COLS do
local i = (r - 1) * ICON_GRID_COLS + c
local btn = CreateFrame("Button", nil, namePopup)
btn:SetWidth(ICON_BTN_SIZE)
btn:SetHeight(ICON_BTN_SIZE)
btn:SetPoint("TOPLEFT", iconScroll, "TOPLEFT", (c-1) * (ICON_BTN_SIZE + ICON_BTN_PAD), -(r-1) * (ICON_BTN_SIZE + ICON_BTN_PAD))
CreateBackdrop(btn)
btn.texture = btn:CreateTexture(nil, "ARTWORK")
btn.texture:SetAllPoints(btn)
btn.texture:SetTexCoord(.08, .92, .08, .92)
btn.gridIndex = i
btn:SetScript("OnClick", function()
if this.iconIndex and provider then
local path = provider:GetIconByIndex(this.iconIndex)
if path then selectedIconPath = path end
pfUI.equipmentmanager.RefreshIconGrid()
end
end)
btn:SetScript("OnEnter", function()
if not this.iconIndex or not provider then return end
local path = provider:GetIconByIndex(this.iconIndex)
if type(path) == "string" then
local name = string.gsub(path, "^.-INTERFACE\\\\ICONS\\\\", "")
GameTooltip:SetOwner(this, "ANCHOR_RIGHT")
GameTooltip:SetText(name)
GameTooltip:Show()
end
end)
btn:SetScript("OnLeave", GameTooltip_Hide)
iconButtons[i] = btn
end
end
function pfUI.equipmentmanager.RefreshIconGrid()
EnsureProvider()
local numIcons = provider:GetNumIcons()
local numRows = math.ceil(numIcons / ICON_GRID_COLS)
FauxScrollFrame_Update(iconScroll, numRows, ICON_GRID_ROWS, ICON_BTN_SIZE + ICON_BTN_PAD)
local offset = FauxScrollFrame_GetOffset(iconScroll)
for i = 1, ICON_GRID_ROWS * ICON_GRID_COLS do
local listIdx = i + offset * ICON_GRID_COLS
local btn = iconButtons[i]
if listIdx <= numIcons then
btn:Show()
btn.iconIndex = listIdx
local path = provider:GetIconByIndex(listIdx)
btn.texture:SetTexture(path)
if path == selectedIconPath then
btn.backdrop:SetBackdropBorderColor(1, 0.82, 0, 1)
else
btn.backdrop:SetBackdropBorderColor(pfUI.cache.er, pfUI.cache.eg, pfUI.cache.eb, pfUI.cache.ea)
end
else
btn:Hide()
btn.iconIndex = nil
end
end
-- Sync the "Currently Selected" preview from the path directly so it
-- still shows the chosen icon when filtered out of the grid.
namePopup.selectedPreview.tex:SetTexture(selectedIconPath)
end
iconScroll:SetScript("OnVerticalScroll", function()
FauxScrollFrame_OnVerticalScroll(ICON_BTN_SIZE + ICON_BTN_PAD, function() pfUI.equipmentmanager.RefreshIconGrid() end)
end)
namePopup:SetScript("OnHide", function()
if provider then provider:Release(); provider = nil end
end)
local btnPopupOK = MakeButton("pfEqMgrPopupOK", T["OK"] or "OK", namePopup, namePopup, 14, -340, 80)
btnPopupOK:ClearAllPoints()
btnPopupOK:SetPoint("BOTTOMLEFT", namePopup, "BOTTOMLEFT", 14, 12)
local btnPopupCancel = MakeButton("pfEqMgrPopupCancel", T["Cancel"] or "Cancel", namePopup, namePopup, 0, 0, 80)
btnPopupCancel:ClearAllPoints() btnPopupCancel:ClearAllPoints()
btnPopupCancel:SetPoint("BOTTOMRIGHT", namePopup, "BOTTOMRIGHT", -14, 12) btnPopupCancel:SetPoint("BOTTOMRIGHT", namePopup, "BOTTOMRIGHT", -14, 12)
btnPopupCancel:SetScript("OnClick", function() namePopup:Hide() end) btnPopupCancel:SetScript("OnClick", function() namePopup:Hide() end)
-- Okay | Cancel, both anchored to the bottom-right corner.
btnPopupOK:ClearAllPoints()
btnPopupOK:SetPoint("BOTTOMRIGHT", btnPopupCancel, "BOTTOMLEFT", -6, 0)
btnPopupOK:SetScript("OnClick", function() btnPopupOK:SetScript("OnClick", function()
local name = namePopup.editbox:GetText() local name = namePopup.editbox:GetText()
if not name or name == "" then return end if not name or name == "" then return end
-- Strip the prefix to match ClassicAPI's persisted short-form basenames. -- Strip the prefix to match ClassicAPI's persisted short-form basenames.
local iconForSave = string.gsub(selectedIconPath, "INTERFACE\\ICONS\\", "") local iconForSave = string.gsub(iconPicker.GetIcon(), "INTERFACE\\ICONS\\", "")
if pendingAction == "new" then if pendingAction == "new" then
C_EquipmentSet.CreateEquipmentSet(name, iconForSave) C_EquipmentSet.CreateEquipmentSet(name, iconForSave)
C_EquipmentSet.ClearIgnoredSlotsForSave() C_EquipmentSet.ClearIgnoredSlotsForSave()
@@ -610,31 +431,20 @@ pfUI:RegisterModule("equipmentmanager", function()
function OpenNamePopup(action, prefillName, prefillIcon) function OpenNamePopup(action, prefillName, prefillIcon)
pendingAction = action pendingAction = action
namePopup.editbox:SetText(prefillName or "") namePopup.editbox:SetText(prefillName or "")
EnsureProvider()
if prefillIcon then if prefillIcon then
local short = string.gsub(prefillIcon, "INTERFACE\\ICONS\\", "") -- Stored icons come back either as a full path or a bare basename
selectedIconPath = "INTERFACE\\ICONS\\" .. strupper(short) -- (see the row rendering in Refresh). Only prepend the prefix when
-- there's no path separator, so a full path isn't double-prefixed.
iconPicker.SetIcon(string.find(prefillIcon, "\\") and prefillIcon
or ("INTERFACE\\ICONS\\" .. prefillIcon))
else else
selectedIconPath = QUESTION_MARK iconPicker.SetIcon(nil)
end
if action == "rename" then
namePopup.title:SetText(T["Rename Set"] or "Rename Set")
iconScroll:Hide()
for _, b in ipairs(iconButtons) do b:Hide() end
namePopup.iconLabel:Hide()
namePopup.selectedLabel:Hide()
namePopup.selectedPreview:Hide()
filterDropdown:Hide()
else
namePopup.title:SetText(action == "new" and (T["Name Set"] or "Name Set") or (T["Save Set"] or "Save Set"))
iconScroll:Show()
namePopup.iconLabel:Show()
namePopup.selectedLabel:Show()
namePopup.selectedPreview:Show()
filterDropdown:Show()
end end
namePopup.search:SetText("")
-- Rename only changes the name, so hide the whole icon-picking area.
iconPicker.SetIconAreaShown(action ~= "rename")
namePopup:Show() namePopup:Show()
if action ~= "rename" then pfUI.equipmentmanager.RefreshIconGrid() end if action ~= "rename" then iconPicker.Refresh() end
namePopup.editbox:SetFocus() namePopup.editbox:SetFocus()
end end
@@ -643,9 +453,13 @@ pfUI:RegisterModule("equipmentmanager", function()
-- ============================================================ -- ============================================================
local flyout = CreateFrame("Frame", "pfEqMgrFlyout", UIParent) local flyout = CreateFrame("Frame", "pfEqMgrFlyout", UIParent)
-- The name/icon popup is sidecar-only, so it closes with the sidecar.
-- Popout arrows and the flyout are reconciled by UpdatePopouts: by
-- default they follow the sidecar, but with the "Always Show Equipment
-- Slot Flyouts" option they stay while the paperdoll is open.
frame:SetScript("OnHide", function() frame:SetScript("OnHide", function()
for _, b in ipairs(popoutButtons) do b:Hide() end namePopup:Hide()
flyout:Hide() UpdatePopouts()
end) end)
flyout:SetFrameStrata("DIALOG") flyout:SetFrameStrata("DIALOG")
flyout:Hide() flyout:Hide()
@@ -676,7 +490,7 @@ pfUI:RegisterModule("equipmentmanager", function()
end end
end end
ClearCursor() ClearCursor()
UIErrorsFrame:AddMessage(EQUIPMENT_MANAGER_BAGS_FULL or "Your bags are full.", 1, .1, .1, 1) UIErrorsFrame:AddMessage(ERR_EQUIPMENT_MANAGER_BAGS_FULL, 1, .1, .1, 1)
end end
local function MakeFlyoutButton(i) local function MakeFlyoutButton(i)
@@ -692,11 +506,11 @@ pfUI:RegisterModule("equipmentmanager", function()
b:SetScript("OnEnter", function() b:SetScript("OnEnter", function()
GameTooltip:SetOwner(this, "ANCHOR_RIGHT") GameTooltip:SetOwner(this, "ANCHOR_RIGHT")
if this.specialAction == "placeInBags" then if this.specialAction == "placeInBags" then
GameTooltip:SetText(EQUIPMENT_MANAGER_PLACE_IN_BAGS or "Place in Bags", 1, 1, 1) GameTooltip:SetText(EQUIPMENT_MANAGER_PLACE_IN_BAGS, 1, 1, 1)
elseif this.specialAction == "ignore" then elseif this.specialAction == "ignore" then
GameTooltip:SetText(EQUIPMENT_MANAGER_IGNORE_SLOT or "Ignore this slot", 1, 1, 1) GameTooltip:SetText(EQUIPMENT_MANAGER_IGNORE_SLOT, 1, 1, 1)
elseif this.specialAction == "unignore" then elseif this.specialAction == "unignore" then
GameTooltip:SetText(EQUIPMENT_MANAGER_UNIGNORE_SLOT or "Stop ignoring this slot", 1, 1, 1) GameTooltip:SetText(EQUIPMENT_MANAGER_UNIGNORE_SLOT, 1, 1, 1)
elseif this.bag then elseif this.bag then
GameTooltip:SetBagItem(this.bag, this.slot) GameTooltip:SetBagItem(this.bag, this.slot)
elseif this.invSlot then elseif this.invSlot then
@@ -704,7 +518,7 @@ pfUI:RegisterModule("equipmentmanager", function()
end end
GameTooltip:Show() GameTooltip:Show()
end) end)
b:SetScript("OnLeave", function() GameTooltip:Hide() end) b:SetScript("OnLeave", GameTooltip_Hide)
b:SetScript("OnClick", function() b:SetScript("OnClick", function()
if this.specialAction == "placeInBags" then if this.specialAction == "placeInBags" then
UnequipToBags(flyout.targetInvSlot) UnequipToBags(flyout.targetInvSlot)
@@ -809,7 +623,6 @@ pfUI:RegisterModule("equipmentmanager", function()
if num == 0 then if num == 0 then
flyout:Hide() flyout:Hide()
UIErrorsFrame:AddMessage(T["No matching items in bags"] or "No matching items in bags", 1, 1, 0, 1)
return return
end end
@@ -938,15 +751,26 @@ pfUI:RegisterModule("equipmentmanager", function()
end end
end end
-- Tie popout visibility to the EM sidecar. They appear when the -- Popout arrows follow the EM sidecar by default. With the
-- sidecar opens, hide when it closes, and the flyout closes too. -- "Always Show Equipment Slot Flyouts" option they follow the paperdoll
HookScript(frame, "OnShow", function() -- instead, so gear can be swapped without opening the equipment manager.
for _, b in ipairs(popoutButtons) do b:Show() end local function PopoutsActive()
end) if C.character.inventory.equipflyout == "1" then
HookScript(frame, "OnHide", function() return PaperDollFrame:IsShown()
for _, b in ipairs(popoutButtons) do b:Hide() end end
if flyout then flyout:Hide() end return frame:IsShown()
end) end
function UpdatePopouts()
local show = PopoutsActive()
for _, b in ipairs(popoutButtons) do
if show then b:Show() else b:Hide() end
end
if not show then flyout:Hide() end
end
PaperDollFrame:HookScript("OnShow", UpdatePopouts)
PaperDollFrame:HookScript("OnHide", UpdatePopouts)
-- ============================================================ -- ============================================================
-- Refresh -- Refresh
modules/farmmode.lua
+5 -5
View File
@@ -25,8 +25,7 @@ pfUI:RegisterModule("farmmode", function ()
Minimap_ZoomOut() Minimap_ZoomOut()
end end
_G.SLASH_PFFARMMAP1, _G.SLASH_PFFARMMAP2 = "/farm", "/farmmode" pfUI.api.RegisterSlashCommand("PFFARMMAP", { "/farm", "/farmmode" }, ToggleFarmMode, true)
_G.SlashCmdList.PFFARMMAP = ToggleFarmMode
pfUI.farmmap = CreateFrame("Minimap", "pfFarmMap", UIParent) pfUI.farmmap = CreateFrame("Minimap", "pfFarmMap", UIParent)
pfUI.farmmap:Hide() pfUI.farmmap:Hide()
@@ -42,8 +41,9 @@ pfUI:RegisterModule("farmmode", function ()
pfUI.farmmap:RegisterForDrag("LeftButton") pfUI.farmmap:RegisterForDrag("LeftButton")
pfUI.farmmap:SetScript("OnMouseWheel", function() pfUI.farmmap:SetScript("OnMouseWheel", function()
if IsControlKeyDown() then if IsControlKeyDown() then
this:SetWidth(this:GetWidth() + (arg1 > 0 and 10 or -10)) local adjust = (arg1 > 0 and 10 or -10)
this:SetHeight(this:GetHeight() + (arg1 > 0 and 10 or -10)) local width, height = this:GetSize()
this:SetSize(width + adjust, height + adjust)
Minimap_ZoomIn() Minimap_ZoomIn()
Minimap_ZoomOut() Minimap_ZoomOut()
elseif IsShiftKeyDown() then elseif IsShiftKeyDown() then
@@ -136,7 +136,7 @@ pfUI:RegisterModule("farmmode", function ()
pfUI.farmmap.button.txt = pfUI.farmmap.button:CreateFontString("pfFarmMapText", "LOW", "GameFontWhite") pfUI.farmmap.button.txt = pfUI.farmmap.button:CreateFontString("pfFarmMapText", "LOW", "GameFontWhite")
pfUI.farmmap.button.txt:SetFont(pfUI.font_default, C.global.font_size, "OUTLINE") pfUI.farmmap.button.txt:SetFont(pfUI.font_default, C.global.font_size, "OUTLINE")
pfUI.farmmap.button.txt:SetPoint("CENTER", 0, 0) pfUI.farmmap.button.txt:SetPoint("CENTER", 0, 0)
pfUI.farmmap.button.txt:SetText("|cff33ffcc FARM MODE") pfUI.farmmap.button.txt:SetText("|cff33ffcc " .. T["FARM MODE"])
end end
CreateBackdrop(pfUI.farmmap) CreateBackdrop(pfUI.farmmap)
modules/feigndeath.lua
+2 -2
View File
@@ -1,6 +1,6 @@
pfUI:RegisterModule("feigndeath", function () pfUI:RegisterModule("feigndeath", function ()
local oldUnitHealth = UnitHealth local oldUnitHealth = _G.UnitHealth
function UnitHealth(unit) _G.UnitHealth = function(unit)
if UnitIsFeignDeath(unit) then if UnitIsFeignDeath(unit) then
local hp = GetUnitField(unit, "health") local hp = GetUnitField(unit, "health")
if hp and hp > 0 then return hp end if hp and hp > 0 then return hp end
modules/firstrun.lua
+9 -14
View File
@@ -127,7 +127,7 @@ pfUI:RegisterModule("firstrun", function ()
-- welcome dialog -- welcome dialog
pfUI.firstrun:AddStep("init", function() pfUI.firstrun:AddStep("init", function()
local f = CreateFirstRunPage() local f = CreateFirstRunPage()
f.text:SetText(string.format(T["Welcome to |cff33ffccpf|cffffffffUI|r!\n\nI'm the first run wizard that will guide you through some basic configuration. If you're lazy, feel free to hit the \"Defaults\" button. If you wish to run this dialog again, go to the settings and hit the \"Reset Firstrun\" button.\n\nVisit |cff33ffcc%s|r to check for the latest version."], GetAddOnMetadata(pfUI.name, "X-Website"))) f.text:SetFormattedText(T["Welcome to |cff33ffccpf|cffffffffUI|r!\n\nI'm the first run wizard that will guide you through some basic configuration. If you're lazy, feel free to hit the \"Defaults\" button. If you wish to run this dialog again, go to the settings and hit the \"Reset Firstrun\" button.\n\nVisit |cff33ffcc%s|r to check for the latest version."], GetAddOnMetadata(pfUI.name, "X-Website"))
return f return f
end) end)
@@ -137,8 +137,7 @@ pfUI:RegisterModule("firstrun", function ()
f.text:SetText(T["A new installation of |cff33ffccpf|rUI ships with 4 prebuilt design profiles. Click below if you wish to load one of these profiles."]) f.text:SetText(T["A new installation of |cff33ffccpf|rUI ships with 4 prebuilt design profiles. Click below if you wish to load one of these profiles."])
f.Modern = CreateFrame("Button", nil, f, "UIPanelButtonTemplate") f.Modern = CreateFrame("Button", nil, f, "UIPanelButtonTemplate")
f.Modern:SetWidth(120) f.Modern:SetSize(120, 20)
f.Modern:SetHeight(20)
f.Modern:SetPoint("BOTTOM", -65, 100) f.Modern:SetPoint("BOTTOM", -65, 100)
f.Modern:SetTextColor(1,1,1) f.Modern:SetTextColor(1,1,1)
f.Modern:SetText("Modern") f.Modern:SetText("Modern")
@@ -151,8 +150,7 @@ pfUI:RegisterModule("firstrun", function ()
SkinButton(f.Modern) SkinButton(f.Modern)
f.Nostalgia = CreateFrame("Button", nil, f, "UIPanelButtonTemplate") f.Nostalgia = CreateFrame("Button", nil, f, "UIPanelButtonTemplate")
f.Nostalgia:SetWidth(120) f.Nostalgia:SetSize(120, 20)
f.Nostalgia:SetHeight(20)
f.Nostalgia:SetPoint("BOTTOM", 65, 100) f.Nostalgia:SetPoint("BOTTOM", 65, 100)
f.Nostalgia:SetTextColor(1,1,1) f.Nostalgia:SetTextColor(1,1,1)
f.Nostalgia:SetText("Nostalgia") f.Nostalgia:SetText("Nostalgia")
@@ -165,8 +163,7 @@ pfUI:RegisterModule("firstrun", function ()
SkinButton(f.Nostalgia) SkinButton(f.Nostalgia)
f.Legacy = CreateFrame("Button", nil, f, "UIPanelButtonTemplate") f.Legacy = CreateFrame("Button", nil, f, "UIPanelButtonTemplate")
f.Legacy:SetWidth(120) f.Legacy:SetSize(120, 20)
f.Legacy:SetHeight(20)
f.Legacy:SetPoint("BOTTOM", 65, 75) f.Legacy:SetPoint("BOTTOM", 65, 75)
f.Legacy:SetTextColor(1,1,1) f.Legacy:SetTextColor(1,1,1)
f.Legacy:SetText("Legacy") f.Legacy:SetText("Legacy")
@@ -179,8 +176,7 @@ pfUI:RegisterModule("firstrun", function ()
SkinButton(f.Legacy) SkinButton(f.Legacy)
f.Slim = CreateFrame("Button", nil, f, "UIPanelButtonTemplate") f.Slim = CreateFrame("Button", nil, f, "UIPanelButtonTemplate")
f.Slim:SetWidth(120) f.Slim:SetSize(120, 20)
f.Slim:SetHeight(20)
f.Slim:SetPoint("BOTTOM", -65, 75) f.Slim:SetPoint("BOTTOM", -65, 75)
f.Slim:SetTextColor(1,1,1) f.Slim:SetTextColor(1,1,1)
f.Slim:SetText("Slim") f.Slim:SetText("Slim")
@@ -197,8 +193,7 @@ pfUI:RegisterModule("firstrun", function ()
f.Slider.text:SetPoint("TOP", f.Slider, "BOTTOM", 0, 2) f.Slider.text:SetPoint("TOP", f.Slider, "BOTTOM", 0, 2)
f.Slider.text:SetText(T["Scale"]) f.Slider.text:SetText(T["Scale"])
f.Slider:SetWidth(240) f.Slider:SetSize(240, 20)
f.Slider:SetHeight(20)
f.Slider:SetPoint("BOTTOM", 0, 50) f.Slider:SetPoint("BOTTOM", 0, 50)
f.Slider:SetOrientation('HORIZONTAL') f.Slider:SetOrientation('HORIZONTAL')
f.Slider:SetMinMaxValues(0.5, 2.0) f.Slider:SetMinMaxValues(0.5, 2.0)
@@ -263,7 +258,7 @@ pfUI:RegisterModule("firstrun", function ()
SkinCheckbox(f.checkbox, 18) SkinCheckbox(f.checkbox, 18)
f.NextScript = function() f.NextScript = function()
if not pfUI.chat then message("Couldn't apply settings. Chat module is disabled.") end if not pfUI.chat then message("Couldn't apply settings. Chat module is disabled.") return end
pfUI.chat.SetupRightChat(f.checkbox:GetChecked()) pfUI.chat.SetupRightChat(f.checkbox:GetChecked())
end end
@@ -283,7 +278,7 @@ pfUI:RegisterModule("firstrun", function ()
SkinCheckbox(f.checkbox, 18) SkinCheckbox(f.checkbox, 18)
f.NextScript = function() f.NextScript = function()
if not pfUI.chat then message("Couldn't apply settings. Chat module is disabled.") end if not pfUI.chat then message("Couldn't apply settings. Chat module is disabled.") return end
if f.checkbox:GetChecked() then if f.checkbox:GetChecked() then
pfUI.chat.SetupPositions() pfUI.chat.SetupPositions()
end end
@@ -305,7 +300,7 @@ pfUI:RegisterModule("firstrun", function ()
SkinCheckbox(f.checkbox, 18) SkinCheckbox(f.checkbox, 18)
f.NextScript = function() f.NextScript = function()
if not pfUI.chat then message("Couldn't apply settings. Chat module is disabled.") end if not pfUI.chat then message("Couldn't apply settings. Chat module is disabled.") return end
if f.checkbox:GetChecked() then if f.checkbox:GetChecked() then
pfUI.chat.SetupChannels() pfUI.chat.SetupChannels()
end end
modules/focus.lua
+11 -12
View File
@@ -2,20 +2,22 @@ pfUI:RegisterModule("focus", function ()
-- do not go further on disabled UFs -- do not go further on disabled UFs
if C.unitframes.disable == "1" then return end if C.unitframes.disable == "1" then return end
pfUI.uf.focus = pfUI.uf:CreateUnitFrame("Focus", nil, C.unitframes.focus, .2) pfUI.uf.focus = pfUI.uf:CreateUnitFrame("Focus", nil, C.unitframes.focus)
pfUI.uf.focus:UpdateFrameSize() pfUI.uf.focus:UpdateFrameSize()
pfUI.uf.focus:SetPoint("BOTTOMLEFT", UIParent, "BOTTOM", 220, 220) pfUI.uf.focus:SetPoint("BOTTOMLEFT", UIParent, "BOTTOM", 220, 220)
UpdateMovable(pfUI.uf.focus) UpdateMovable(pfUI.uf.focus)
pfUI.uf.focus:Hide() pfUI.uf.focus:Hide()
pfUI.uf.focustarget = pfUI.uf:CreateUnitFrame("FocusTarget", nil, C.unitframes.focustarget, .2) pfUI.uf.focustarget = pfUI.uf:CreateUnitFrame("FocusTarget", nil, C.unitframes.focustarget)
pfUI.uf.focustarget:UpdateFrameSize() pfUI.uf.focustarget:UpdateFrameSize()
pfUI.uf.focustarget:SetPoint("BOTTOMLEFT", pfUI.uf.focus, "TOP", 0, 10) pfUI.uf.focustarget:SetPoint("BOTTOMLEFT", pfUI.uf.focus, "TOP", 0, 10)
UpdateMovable(pfUI.uf.focustarget) UpdateMovable(pfUI.uf.focustarget)
pfUI.uf.focustarget:Hide() pfUI.uf.focustarget:Hide()
-- PLAYER_FOCUS_CHANGED drives immediate refresh on focus assign / clear. -- PLAYER_FOCUS_CHANGED drives immediate refresh on focus assign / clear.
-- The frame's 0.2s tick keeps health/power/aura data fresh between events. -- Between events, ClassicAPI fires UNIT_* (health/mana/aura/...) with
-- arg1 == "focus" and arg1 == "focustarget", so both frames update
-- event-driven like target and need no polling tick.
local refresher = CreateFrame("Frame") local refresher = CreateFrame("Frame")
refresher:RegisterEvent("PLAYER_FOCUS_CHANGED") refresher:RegisterEvent("PLAYER_FOCUS_CHANGED")
refresher:SetScript("OnEvent", function() refresher:SetScript("OnEvent", function()
@@ -30,8 +32,7 @@ end)
-- /focusname is pfUI-specific because the engine has no name→GUID -- /focusname is pfUI-specific because the engine has no name→GUID
-- lookup for off-screen units — we resolve via a short target-swap. -- lookup for off-screen units — we resolve via a short target-swap.
SLASH_PFFOCUSNAME1, SLASH_PFFOCUSNAME2 = '/focusname', '/pffocusname' pfUI.api.RegisterSlashCommand("PFFOCUSNAME", { '/focusname', '/pffocusname' }, function(msg)
function SlashCmdList.PFFOCUSNAME(msg)
if msg == "" then return end if msg == "" then return end
local prevGUID = UnitGUID("target") local prevGUID = UnitGUID("target")
@@ -61,10 +62,9 @@ function SlashCmdList.PFFOCUSNAME(msg)
else else
ClearTarget() ClearTarget()
end end
end end, true)
SLASH_PFCASTFOCUS1, SLASH_PFCASTFOCUS2 = '/castfocus', '/pfcastfocus' pfUI.api.RegisterSlashCommand("PFCASTFOCUS", { '/castfocus', '/pfcastfocus' }, function(msg)
function SlashCmdList.PFCASTFOCUS(msg)
local focusGUID = UnitGUID("focus") local focusGUID = UnitGUID("focus")
if not focusGUID or focusGUID == "0x0000000000000000" then if not focusGUID or focusGUID == "0x0000000000000000" then
UIErrorsFrame:AddMessage(SPELL_FAILED_BAD_TARGETS, 1, 0, 0) UIErrorsFrame:AddMessage(SPELL_FAILED_BAD_TARGETS, 1, 0, 0)
@@ -105,10 +105,9 @@ function SlashCmdList.PFCASTFOCUS(msg)
else else
TargetLastTarget() TargetLastTarget()
end end
end end, true)
SLASH_PFSWAPFOCUS1, SLASH_PFSWAPFOCUS2 = '/swapfocus', '/pfswapfocus' pfUI.api.RegisterSlashCommand("PFSWAPFOCUS", { '/swapfocus', '/pfswapfocus' }, function(msg)
function SlashCmdList.PFSWAPFOCUS(msg)
local targetGUID = UnitGUID("target") local targetGUID = UnitGUID("target")
local oldFocusGUID = UnitGUID("focus") local oldFocusGUID = UnitGUID("focus")
@@ -118,4 +117,4 @@ function SlashCmdList.PFSWAPFOCUS(msg)
TargetUnit(oldFocusGUID) TargetUnit(oldFocusGUID)
end end
end end
end end, true)
modules/friendnotes.lua
+93
View File
@@ -0,0 +1,93 @@
-- Friend notes
-- Client-side notes for friends via ClassicAPI's C_FriendList note API
-- (SetFriendNotes / GetFriendInfo(.notes)). Adds an "Edit Note" entry to the
-- friend right-click menu (the "FRIEND" UnitPopup) and shows the note in a
-- tooltip when you hover a friend in the list.
pfUI:RegisterModule("friendnotes", function ()
local EDIT_TOKEN = "PFUI_FRIEND_NOTE"
-- Note editor. In 1.12 StaticPopup, OnAccept runs with `this` = the OK
-- button (the dialog is this:GetParent()); the friend name arrives as the
-- data argument passed to StaticPopup_Show.
StaticPopupDialogs["PFUI_FRIEND_NOTE_EDIT"] = {
text = SET_FRIENDNOTE_LABEL,
button1 = SAVE,
button2 = CANCEL,
hasEditBox = 1,
maxLetters = 128,
OnAccept = function(name)
C_FriendList.SetFriendNotes(name, _G[this:GetParent():GetName().."EditBox"]:GetText())
end,
EditBoxOnEnterPressed = function(name)
C_FriendList.SetFriendNotes(name, this:GetText())
this:GetParent():Hide()
end,
EditBoxOnEscapePressed = function() this:GetParent():Hide() end,
timeout = 0, whileDead = 1, hideOnEscape = 1,
}
local function OpenNoteEditor(name)
if not name or name == "" then return end
local info = C_FriendList.GetFriendInfo(name)
local dialog = StaticPopup_Show("PFUI_FRIEND_NOTE_EDIT", name, nil, name)
if not dialog then return end
local editbox = _G[dialog:GetName().."EditBox"]
editbox:SetText((info and info.notes) or "")
editbox:HighlightText()
editbox:SetFocus()
end
-- Add "Edit Note" to the friend right-click menu, just before Cancel.
UnitPopupButtons[EDIT_TOKEN] = { text = SET_NOTE, dist = 0 }
local friendMenu = UnitPopupMenus["FRIEND"]
table.insert(friendMenu, table.getn(friendMenu), EDIT_TOKEN)
UnitPopupMenus["PFUI_FRIENDNOTE"] = { EDIT_TOKEN, "CANCEL" }
local function OfflineNoteDropDown_Initialize()
UnitPopup_ShowMenu(_G[UIDROPDOWNMENU_OPEN_MENU], "PFUI_FRIENDNOTE", nil, FriendsDropDown.name)
end
local FriendsFrame_ShowDropdown_orig = FriendsFrame_ShowDropdown
_G.FriendsFrame_ShowDropdown = function(name, connected)
if connected then return FriendsFrame_ShowDropdown_orig(name, connected) end
HideDropDownMenu(1)
FriendsDropDown.initialize = OfflineNoteDropDown_Initialize
FriendsDropDown.displayMode = "MENU"
FriendsDropDown.name = name
ToggleDropDownMenu(1, nil, FriendsDropDown, "cursor")
end
-- Route our entry to the editor and close the menu; delegate the rest. A
-- bare assignment lands on pfUI.env, so set the global explicitly.
local UnitPopup_OnClick_orig = UnitPopup_OnClick
_G.UnitPopup_OnClick = function()
if this and this.value == EDIT_TOKEN then
local dropdown = _G[UIDROPDOWNMENU_INIT_MENU]
local name = dropdown and dropdown.name
CloseDropDownMenus()
OpenNoteEditor(name)
return
end
return UnitPopup_OnClick_orig()
end
-- Show the note in a tooltip while hovering a friend in the list. Friend
-- buttons carry their friend index via SetID (see FriendsFrame_Update).
local function FriendButton_OnEnter()
local index = this:GetID()
if not index or index < 1 then return end
local info = C_FriendList.GetFriendInfoByIndex(index)
if not info or not info.notes or info.notes == "" then return end
GameTooltip:SetOwner(this, "ANCHOR_RIGHT")
GameTooltip:SetText(info.name or "")
GameTooltip:AddLine(info.notes, 1, 1, 1, 1)
GameTooltip:Show()
end
for i = 1, FRIENDS_TO_DISPLAY do
local button = _G["FriendsFrameFriendButton"..i]
if button then
button:HookScript("OnEnter", FriendButton_OnEnter)
button:HookScript("OnLeave", GameTooltip_Hide)
end
end
end)
modules/friends.lua
+2 -2
View File
@@ -150,7 +150,7 @@ pfUI:RegisterSkin("Friends", function ()
end end
-- set positions -- set positions
pfUI.hooksecurefunc("WhoList_Update", function() hooksecurefunc("WhoList_Update", function()
for i = 1, WHOS_TO_DISPLAY do for i = 1, WHOS_TO_DISPLAY do
local level = _G["WhoFrameButton"..i.."Level"] local level = _G["WhoFrameButton"..i.."Level"]
level:ClearAllPoints() level:ClearAllPoints()
@@ -231,7 +231,7 @@ pfUI:RegisterSkin("Friends", function ()
end end
-- set positions -- set positions
pfUI.hooksecurefunc("GuildStatus_Update", function() hooksecurefunc("GuildStatus_Update", function()
for i = 1, GUILDMEMBERS_TO_DISPLAY do for i = 1, GUILDMEMBERS_TO_DISPLAY do
local level = _G["GuildFrameButton"..i.."Level"] local level = _G["GuildFrameButton"..i.."Level"]
level:ClearAllPoints() level:ClearAllPoints()
modules/gm.lua
+1 -1
View File
@@ -86,7 +86,7 @@ pfUI:RegisterModule("gm", function ()
-- pet dropdown -- pet dropdown
-- table.insert(UnitPopupMenus["PET"], "GM_HEADER") -- table.insert(UnitPopupMenus["PET"], "GM_HEADER")
pfUI.hooksecurefunc("UnitPopup_OnClick", function() hooksecurefunc("UnitPopup_OnClick", function()
local dropdownFrame = _G[UIDROPDOWNMENU_INIT_MENU] local dropdownFrame = _G[UIDROPDOWNMENU_INIT_MENU]
local button = this.value local button = this.value
local unit = dropdownFrame.unit local unit = dropdownFrame.unit
modules/gui.lua
+72 -49
View File
@@ -912,6 +912,11 @@ pfUI:RegisterModule("gui", function ()
"1:" .. T["1 Decimal (2.1)"], "1:" .. T["1 Decimal (2.1)"],
"2:" .. T["2 Decimals (2.14)"], "2:" .. T["2 Decimals (2.14)"],
}, },
["castbaralign"] = {
"LEFT:" .. T["Left"],
"CENTER:" .. T["Center"],
"RIGHT:" .. T["Right"],
},
["orientation"] = { ["orientation"] = {
"HORIZONTAL:" .. T["Horizontal"], "HORIZONTAL:" .. T["Horizontal"],
"VERTICAL:" .. T["Vertical"], "VERTICAL:" .. T["Vertical"],
@@ -956,7 +961,7 @@ pfUI:RegisterModule("gui", function ()
"16:" .. T["Very Slow"], "16:" .. T["Very Slow"],
}, },
["uf_rangecheck_mode"] = { ["uf_rangecheck_mode"] = {
"vanilla:" .. T["Vanilla (Spellbook)"], "vanilla:" .. T["ClassicAPI (UnitInRange)"],
"unitxp:" .. T["UnitXP (Precise)"], "unitxp:" .. T["UnitXP (Precise)"],
}, },
["uf_raidlayout"] = { ["uf_raidlayout"] = {
@@ -1063,6 +1068,7 @@ pfUI:RegisterModule("gui", function ()
"unitrev:" .. T["Unit String (Reverse)"], "unitrev:" .. T["Unit String (Reverse)"],
"name:" .. T["Name"], "name:" .. T["Name"],
"nameshort:" .. T["Name (Short)"], "nameshort:" .. T["Name (Short)"],
"ownername:" .. T["Owner Name"],
"level:" .. T["Level"], "level:" .. T["Level"],
"class:" .. T["Class"], "class:" .. T["Class"],
"namehealth:" .. T["Name | Health Missing"], "namehealth:" .. T["Name | Health Missing"],
@@ -2114,10 +2120,9 @@ pfUI:RegisterModule("gui", function ()
CreateConfig(nil, T["Enable 40y-Range Check"], C.unitframes, "rangecheck", "checkbox", nil, nil, nil, nil) CreateConfig(nil, T["Enable 40y-Range Check"], C.unitframes, "rangecheck", "checkbox", nil, nil, nil, nil)
CreateConfig(nil, T["Range Check Mode"], C.unitframes, "rangecheck_mode", "dropdown", pfUI.gui.dropdowns.uf_rangecheck_mode, nil, nil, nil) CreateConfig(nil, T["Range Check Mode"], C.unitframes, "rangecheck_mode", "dropdown", pfUI.gui.dropdowns.uf_rangecheck_mode, nil, nil, nil)
CreateConfig(nil, T["UnitXP Range Threshold (yards)"], C.unitframes, "rangecheck_distance", nil, nil, nil, nil, nil) CreateConfig(nil, T["UnitXP Range Threshold (yards)"], C.unitframes, "rangecheck_distance", nil, nil, nil, nil, nil)
CreateConfig(nil, T["Range Check Interval"], C.unitframes, "rangechecki", "dropdown", pfUI.gui.dropdowns.uf_rangecheckinterval, nil, nil, nil) CreateConfig(nil, T["Show Self In Raid Frames When Solo"], C.unitframes, "selfinraid", "checkbox")
CreateConfig(nil, T["Use Raid Frames To Display Group Members"], C.unitframes, "raidforgroup", "checkbox")
CreateConfig(nil, T["Always Show Self In Raid Frames"], C.unitframes, "selfinraid", "checkbox")
CreateConfig(nil, T["Show Self In Group Frames"], C.unitframes, "selfingroup", "checkbox") CreateConfig(nil, T["Show Self In Group Frames"], C.unitframes, "selfingroup", "checkbox")
CreateConfig(nil, T["Use Raid Frames To Display Group Members"], C.unitframes, "raidforgroup", "checkbox")
CreateConfig(nil, T["Hide Group Frames While In Raid"], C.unitframes.group, "hide_in_raid", "checkbox") CreateConfig(nil, T["Hide Group Frames While In Raid"], C.unitframes.group, "hide_in_raid", "checkbox")
CreateConfig(nil, T["Max Amount Of Raid Frames"], C.unitframes, "maxraid", "dropdown", pfUI.gui.dropdowns.maxraid) CreateConfig(nil, T["Max Amount Of Raid Frames"], C.unitframes, "maxraid", "dropdown", pfUI.gui.dropdowns.maxraid)
@@ -2138,6 +2143,7 @@ pfUI:RegisterModule("gui", function ()
CreateConfig(nil, T["Druid Settings"], nil, nil, "header") CreateConfig(nil, T["Druid Settings"], nil, nil, "header")
CreateConfig(nil, T["Show Druid Mana Bar"], C.unitframes, "druidmanabar", "checkbox", nil, nil, nil, nil) CreateConfig(nil, T["Show Druid Mana Bar"], C.unitframes, "druidmanabar", "checkbox", nil, nil, nil, nil)
CreateConfig(nil, T["Show Druid Mana Bar Text"], C.unitframes, "druidmanatext", "checkbox", nil, nil, nil, nil)
CreateConfig(nil, T["Druid Mana Bar Height"], C.unitframes, "druidmanaheight", nil, nil, nil, nil, nil) CreateConfig(nil, T["Druid Mana Bar Height"], C.unitframes, "druidmanaheight", nil, nil, nil, nil, nil)
CreateConfig(nil, T["Druid Mana Bar Width (-1 = auto)"], C.unitframes, "druidmanawidth", nil, nil, nil, nil, nil) CreateConfig(nil, T["Druid Mana Bar Width (-1 = auto)"], C.unitframes, "druidmanawidth", nil, nil, nil, nil, nil)
CreateConfig(nil, T["Druid Mana Bar X-Offset"], C.unitframes, "druidmanaoffx", nil, nil, nil, nil, nil) CreateConfig(nil, T["Druid Mana Bar X-Offset"], C.unitframes, "druidmanaoffx", nil, nil, nil, nil, nil)
@@ -2180,6 +2186,7 @@ pfUI:RegisterModule("gui", function ()
[10] = { "grouptarget", T["Group-Target"]}, [10] = { "grouptarget", T["Group-Target"]},
[11] = { "grouppet", T["Group-Pet"] }, [11] = { "grouppet", T["Group-Pet"] },
[12] = { "raid", T["Raid"] }, [12] = { "raid", T["Raid"] },
[13] = { "raidpet", T["Raid-Pet"] },
} }
CreateGUIEntry(T["Unit Frames"], T["Click Casting"], function() CreateGUIEntry(T["Unit Frames"], T["Click Casting"], function()
@@ -2229,10 +2236,10 @@ pfUI:RegisterModule("gui", function ()
U.ptarget = U["pettarget"] U.ptarget = U["pettarget"]
U.grouptarget = U["group"] U.grouptarget = U["group"]
U.grouppet = U["group"] U.grouppet = U["group"]
U.raidpet = U["raid"]
-- build config entries -- build config entries
CreateConfig(U[c], T["Display Frame"] .. ": " .. t, C.unitframes[c], "visible", "checkbox") CreateConfig(U[c], T["Display Frame"] .. ": " .. t, C.unitframes[c], "visible", "checkbox")
CreateConfig(U[c], T["Enable Mouseover Tooltip"], C.unitframes[c], "showtooltip", "checkbox")
CreateConfig(U[c], T["Default Transparency"], C.unitframes[c], "alpha_visible", "dropdown", pfUI.gui.dropdowns.percent_small) CreateConfig(U[c], T["Default Transparency"], C.unitframes[c], "alpha_visible", "dropdown", pfUI.gui.dropdowns.percent_small)
CreateConfig(U[c], T["Out Of Range Transparency"], C.unitframes[c], "alpha_outrange", "dropdown", pfUI.gui.dropdowns.percent_small) CreateConfig(U[c], T["Out Of Range Transparency"], C.unitframes[c], "alpha_outrange", "dropdown", pfUI.gui.dropdowns.percent_small)
CreateConfig(U[c], T["Offline Transparency"], C.unitframes[c], "alpha_offline", "dropdown", pfUI.gui.dropdowns.percent_small) CreateConfig(U[c], T["Offline Transparency"], C.unitframes[c], "alpha_offline", "dropdown", pfUI.gui.dropdowns.percent_small)
@@ -2273,6 +2280,13 @@ pfUI:RegisterModule("gui", function ()
CreateConfig(U["raid"], T["Raid Padding"], C.unitframes[c], "raidpadding") CreateConfig(U["raid"], T["Raid Padding"], C.unitframes[c], "raidpadding")
CreateConfig(U["raid"], T["Raid Layout"], C.unitframes[c], "raidlayout", "dropdown", pfUI.gui.dropdowns.uf_raidlayout) CreateConfig(U["raid"], T["Raid Layout"], C.unitframes[c], "raidlayout", "dropdown", pfUI.gui.dropdowns.uf_raidlayout)
CreateConfig(U["raid"], T["Raid Fill Direction"], C.unitframes[c], "raidfill", "dropdown", pfUI.gui.dropdowns.orientation) CreateConfig(U["raid"], T["Raid Fill Direction"], C.unitframes[c], "raidfill", "dropdown", pfUI.gui.dropdowns.orientation)
CreateConfig(U["raid"], T["Collapse Empty Slots"], C.unitframes[c], "collapse", "checkbox")
elseif c == "raidpet" then
CreateConfig(U[c], T["Layout"], nil, nil, "header")
CreateConfig(U["raid"], T["Raid Padding"], C.unitframes[c], "raidpadding")
CreateConfig(U["raid"], T["Raid Layout"], C.unitframes[c], "raidlayout", "dropdown", pfUI.gui.dropdowns.uf_raidlayout)
CreateConfig(U["raid"], T["Raid Fill Direction"], C.unitframes[c], "raidfill", "dropdown", pfUI.gui.dropdowns.orientation)
CreateConfig(U["raid"], T["Collapse Empty Slots"], C.unitframes[c], "collapse", "checkbox")
end end
CreateConfig(U[c], T["Healthbar"], nil, nil, "header") CreateConfig(U[c], T["Healthbar"], nil, nil, "header")
@@ -2397,6 +2411,7 @@ pfUI:RegisterModule("gui", function ()
CreateGUIEntry(T["Character"], T["Inventory"], function() CreateGUIEntry(T["Character"], T["Inventory"], function()
CreateConfig(nil, T["Show Durability"], C.character.inventory, "durability", "checkbox") CreateConfig(nil, T["Show Durability"], C.character.inventory, "durability", "checkbox")
CreateConfig(nil, T["Always Show Equipment Slot Flyouts"], C.character.inventory, "equipflyout", "checkbox")
end) end)
CreateGUIEntry(T["Character"], T["Reputation"], function() CreateGUIEntry(T["Character"], T["Reputation"], function()
@@ -2408,6 +2423,8 @@ pfUI:RegisterModule("gui", function ()
CreateConfig(nil, T["Enable Item Quality Color For Equipment Only"], C.appearance.bags, "borderonlygear", "checkbox") CreateConfig(nil, T["Enable Item Quality Color For Equipment Only"], C.appearance.bags, "borderonlygear", "checkbox")
CreateConfig(nil, T["Highlight Unusable Items"], C.appearance.bags, "unusable", "checkbox") CreateConfig(nil, T["Highlight Unusable Items"], C.appearance.bags, "unusable", "checkbox")
CreateConfig(nil, T["Unusable Item Color"], C.appearance.bags, "unusable_color", "color") CreateConfig(nil, T["Unusable Item Color"], C.appearance.bags, "unusable_color", "color")
CreateConfig(nil, T["Highlight New Items"], C.appearance.bags, "newitem", "checkbox")
CreateConfig(nil, T["New Item Color"], C.appearance.bags, "newitem_color", "color")
CreateConfig(nil, T["Enable Movable Bags"], C.appearance.bags, "movable", "checkbox") CreateConfig(nil, T["Enable Movable Bags"], C.appearance.bags, "movable", "checkbox")
CreateConfig(nil, T["Anchor Bags Above Chat"], C.appearance.bags, "abovechat", "checkbox") CreateConfig(nil, T["Anchor Bags Above Chat"], C.appearance.bags, "abovechat", "checkbox")
CreateConfig(nil, T["Hide Chat When Bags Are Opened"], C.appearance.bags, "hidechat", "checkbox") CreateConfig(nil, T["Hide Chat When Bags Are Opened"], C.appearance.bags, "hidechat", "checkbox")
@@ -2418,6 +2435,8 @@ pfUI:RegisterModule("gui", function ()
CreateConfig(nil, T["Auto Sell Grey Items"], C.global, "autosell", "checkbox") CreateConfig(nil, T["Auto Sell Grey Items"], C.global, "autosell", "checkbox")
CreateConfig(nil, T["Auto Repair Items"], C.global, "autorepair", "checkbox") CreateConfig(nil, T["Auto Repair Items"], C.global, "autorepair", "checkbox")
CreateConfig(nil, T["Auto Sort When Opening Bags"], C.appearance.bags, "autoSortOnOpen", "checkbox") CreateConfig(nil, T["Auto Sort When Opening Bags"], C.appearance.bags, "autoSortOnOpen", "checkbox")
CreateConfig(nil, T["Reverse Sort Direction (Last Bag First)"], C.appearance.bags, "sortreverse", "checkbox")
CreateConfig(nil, T["Reverse Sort Priority (Hearthstone Last)"], C.appearance.bags, "sortprioreverse", "checkbox")
end) end)
CreateGUIEntry(T["Loot"], nil, function() CreateGUIEntry(T["Loot"], nil, function()
@@ -2537,9 +2556,6 @@ pfUI:RegisterModule("gui", function ()
CreateConfig(U["bars"], T["Button Animation"], C.bars, "animation", "dropdown", pfUI.gui.dropdowns.actionbuttonanimations) CreateConfig(U["bars"], T["Button Animation"], C.bars, "animation", "dropdown", pfUI.gui.dropdowns.actionbuttonanimations)
CreateConfig(U["bars"], T["Button Animation Trigger"], C.bars, "animmode", "dropdown", pfUI.gui.dropdowns.animationmode) CreateConfig(U["bars"], T["Button Animation Trigger"], C.bars, "animmode", "dropdown", pfUI.gui.dropdowns.animationmode)
CreateConfig(U["bars"], T["Show Animation On Hidden Bars"], C.bars, "animalways", "checkbox") CreateConfig(U["bars"], T["Show Animation On Hidden Bars"], C.bars, "animalways", "checkbox")
if not pfUI:MacroAddonsLoaded() then
CreateConfig(U["bars"], T["Scan Macros For Spells"], C.bars, "macroscan", "checkbox", nil, nil, nil, nil)
end
CreateConfig(U["bars"], T["Show Reagent Count"], C.bars, "reagents", "checkbox") CreateConfig(U["bars"], T["Show Reagent Count"], C.bars, "reagents", "checkbox")
CreateConfig(U["bars"], T["Highlight Equipped Items"], C.bars, "showequipped", "checkbox") CreateConfig(U["bars"], T["Highlight Equipped Items"], C.bars, "showequipped", "checkbox")
CreateConfig(U["bars"], T["Equipped Item Color"], C.bars, "eqcolor", "color") CreateConfig(U["bars"], T["Equipped Item Color"], C.bars, "eqcolor", "color")
@@ -2568,6 +2584,7 @@ pfUI:RegisterModule("gui", function ()
CreateConfig(U["bars"], T["Switch Pages On Shift Key Press"], C.bars, "pagemastershift", "checkbox") CreateConfig(U["bars"], T["Switch Pages On Shift Key Press"], C.bars, "pagemastershift", "checkbox")
CreateConfig(U["bars"], T["Switch Pages On Ctrl Key Press"], C.bars, "pagemasterctrl", "checkbox") CreateConfig(U["bars"], T["Switch Pages On Ctrl Key Press"], C.bars, "pagemasterctrl", "checkbox")
CreateConfig(U["bars"], T["Switch Pages On Druid Stealth"], C.bars, "druidstealth", "checkbox") CreateConfig(U["bars"], T["Switch Pages On Druid Stealth"], C.bars, "druidstealth", "checkbox")
CreateConfig(U["bars"], T["Switch Pages On Priest Shadowform"], C.bars, "priestshadow", "checkbox")
CreateConfig(nil, T["Range Based Hunter Paging"], C.bars, "hunterbar", "checkbox", nil, nil, nil, nil) CreateConfig(nil, T["Range Based Hunter Paging"], C.bars, "hunterbar", "checkbox", nil, nil, nil, nil)
end) end)
@@ -2743,87 +2760,92 @@ pfUI:RegisterModule("gui", function ()
end) end)
CreateGUIEntry(T["Tooltip"], nil, function() CreateGUIEntry(T["Tooltip"], nil, function()
CreateConfig(nil, T["General"], nil, nil, "header")
CreateConfig(nil, T["Tooltip Position"], C.tooltip, "position", "dropdown", pfUI.gui.dropdowns.tooltip_position) CreateConfig(nil, T["Tooltip Position"], C.tooltip, "position", "dropdown", pfUI.gui.dropdowns.tooltip_position)
CreateConfig(nil, T["Tooltip Text Font"], C.tooltip, "font_tooltip", "dropdown", pfUI.gui.dropdowns.fonts) CreateConfig(nil, T["Tooltip Text Font"], C.tooltip, "font_tooltip", "dropdown", pfUI.gui.dropdowns.fonts)
CreateConfig(nil, T["Tooltip Text Font Size"], C.tooltip, "font_tooltip_size") CreateConfig(nil, T["Tooltip Text Font Size"], C.tooltip, "font_tooltip_size")
CreateConfig(nil, T["Cursor Tooltip Align"], C.tooltip, "cursoralign", "dropdown", pfUI.gui.dropdowns.tooltip_align) CreateConfig(nil, T["Cursor Tooltip Align"], C.tooltip, "cursoralign", "dropdown", pfUI.gui.dropdowns.tooltip_align)
CreateConfig(nil, T["Cursor Tooltip Offset"], C.tooltip, "cursoroffset") CreateConfig(nil, T["Cursor Tooltip Offset"], C.tooltip, "cursoroffset")
CreateConfig(nil, T["Enable Extended Guild Information"], C.tooltip, "extguild", "checkbox")
CreateConfig(nil, T["Always Show Health In Percent"], C.tooltip, "alwaysperc", "checkbox")
CreateConfig(nil, T["Show Item IDs"], C.tooltip, "itemid", "checkbox")
CreateConfig(nil, T["Show Movement Speed"], C.tooltip, "movespeed", "checkbox")
CreateConfig(nil, T["Custom Transparency"], C.tooltip, "alpha") CreateConfig(nil, T["Custom Transparency"], C.tooltip, "alpha")
CreateConfig(nil, T["Status Bar Texture"], C.tooltip.statusbar, "texture", "dropdown", pfUI.gui.dropdowns.uf_bartexture) CreateConfig(nil, T["Status Bar Texture"], C.tooltip.statusbar, "texture", "dropdown", pfUI.gui.dropdowns.uf_bartexture)
CreateConfig(nil, T["Compare Item Base Stats"], C.tooltip.compare, "basestats", "checkbox")
local showAlways = CreateConfig(nil, T["Always Show Item Comparison"], C.tooltip.compare, "showalways", "checkbox") CreateConfig(nil, T["Items"], nil, nil, "header")
local function gate() CreateConfig(nil, T["Always Show Item Comparison"], C.tooltip.compare, "showalways", "checkbox")
local on = C.tooltip.compare.basestats == "1"
if on then
showAlways.input:Enable()
showAlways.caption:SetTextColor(1, 1, 1)
else
showAlways.input:Disable()
showAlways.caption:SetTextColor(0.5, 0.5, 0.5)
end
end
gate()
pfUI.events:RegisterCallback("config:changed", function(_, cat, key)
if cat == C.tooltip.compare and key == "basestats" then gate() end
end, "eqcompare-showalways-gate")
CreateConfig(nil, T["Always Show Extended Vendor Values"], C.tooltip.vendor, "showalways", "checkbox") CreateConfig(nil, T["Always Show Extended Vendor Values"], C.tooltip.vendor, "showalways", "checkbox")
CreateConfig(U["questitem"], T["Show Related Quest On Questitems"], C.tooltip.questitem, "showquest", "checkbox") CreateConfig(U["questitem"], T["Show Related Quest On Questitems"], C.tooltip.questitem, "showquest", "checkbox")
CreateConfig(U["questitem"], T["Show Required Questitem Count"], C.tooltip.questitem, "showcount", "checkbox") CreateConfig(U["questitem"], T["Show Required Questitem Count"], C.tooltip.questitem, "showcount", "checkbox")
CreateConfig(nil, T["Show Item IDs"], C.tooltip, "itemid", "checkbox")
CreateConfig(nil, T["Spells"], nil, nil, "header")
CreateConfig(nil, T["Show Aura Caster"], C.tooltip, "aurasource", "checkbox")
CreateConfig(nil, T["Show Spell IDs"], C.tooltip, "spellid", "checkbox")
CreateConfig(nil, T["Units"], nil, nil, "header")
CreateConfig(nil, T["Enable Extended Guild Information"], C.tooltip, "extguild", "checkbox")
CreateConfig(nil, T["Always Show Health In Percent"], C.tooltip, "alwaysperc", "checkbox")
CreateConfig(nil, T["Show Movement Speed"], C.tooltip, "movespeed", "checkbox")
CreateConfig(nil, T["Show Unit Buffs"], C.tooltip, "showbuffs", "checkbox")
CreateConfig(nil, T["Show Unit IDs"], C.tooltip, "unitid", "checkbox")
end) end)
CreateGUIEntry(T["Castbar"], nil, function() CreateGUIEntry(T["Castbar"], T["General"], function()
CreateConfig(nil, T["Use Unit Fonts"], C.castbar, "use_unitfonts", "checkbox") CreateConfig(nil, T["Use Unit Fonts"], C.castbar, "use_unitfonts", "checkbox")
CreateConfig(nil, T["Casting Color"], C.appearance.castbar, "castbarcolor", "color") CreateConfig(nil, T["Casting Color"], C.appearance.castbar, "castbarcolor", "color")
CreateConfig(nil, T["Channeling Color"], C.appearance.castbar, "channelcolor", "color") CreateConfig(nil, T["Channeling Color"], C.appearance.castbar, "channelcolor", "color")
CreateConfig(nil, T["Castbar Texture"], C.appearance.castbar, "texture", "dropdown", pfUI.gui.dropdowns.uf_bartexture) CreateConfig(nil, T["Castbar Texture"], C.appearance.castbar, "texture", "dropdown", pfUI.gui.dropdowns.uf_bartexture)
CreateConfig(nil, T["Disable Blizzard Castbar"], C.castbar.player, "hide_blizz", "checkbox") CreateConfig(nil, T["Disable Blizzard Castbar"], C.castbar.player, "hide_blizz", "checkbox")
end)
CreateConfig(nil, T["Player Castbar"], nil, nil, "header") CreateGUIEntry(T["Castbar"], T["Player"], function()
CreateConfig(nil, T["Disable Player Castbar"], C.castbar.player, "hide_pfui", "checkbox") CreateConfig(nil, T["Disable Player Castbar"], C.castbar.player, "hide_pfui", "checkbox")
CreateConfig(nil, T["Castbar Width"], C.castbar.player, "width") CreateConfig(nil, T["Castbar Width"], C.castbar.player, "width")
CreateConfig(nil, T["Castbar Height"], C.castbar.player, "height") CreateConfig(nil, T["Castbar Height"], C.castbar.player, "height")
CreateConfig(nil, T["Show Spell Icon"], C.castbar.player, "showicon", "checkbox") CreateConfig(nil, T["Show Spell Icon"], C.castbar.player, "showicon", "checkbox")
CreateConfig(nil, T["Show Spell Name"], C.castbar.player, "showname", "checkbox") CreateConfig(nil, T["Show Spell Name"], C.castbar.player, "showname", "checkbox")
CreateConfig(nil, T["Spell Name Alignment"], C.castbar.player, "namealign", "dropdown", pfUI.gui.dropdowns.castbaralign)
CreateConfig(nil, T["Spell Name X Offset"], C.castbar.player, "txtleftoffx")
CreateConfig(nil, T["Spell Name Y Offset"], C.castbar.player, "txtleftoffy")
CreateConfig(nil, T["Show Timer"], C.castbar.player, "showtimer", "checkbox") CreateConfig(nil, T["Show Timer"], C.castbar.player, "showtimer", "checkbox")
CreateConfig(nil, T["Left Text X Offset"], C.castbar.player, "txtleftoffx") CreateConfig(nil, T["Timer Alignment"], C.castbar.player, "timealign", "dropdown", pfUI.gui.dropdowns.castbaralign)
CreateConfig(nil, T["Left Text Y Offset"], C.castbar.player, "txtleftoffy") CreateConfig(nil, T["Timer X Offset"], C.castbar.player, "txtrightoffx")
CreateConfig(nil, T["Timer Y Offset"], C.castbar.player, "txtrightoffy")
CreateConfig(nil, T["Show Lag"], C.castbar.player, "showlag", "checkbox") CreateConfig(nil, T["Show Lag"], C.castbar.player, "showlag", "checkbox")
CreateConfig(nil, T["Show Rank"], C.castbar.player, "showrank", "checkbox") CreateConfig(nil, T["Show Rank"], C.castbar.player, "showrank", "checkbox")
CreateConfig(nil, T["Merge Tradeskill Casts"], C.castbar.player, "mergetradeskill", "checkbox") CreateConfig(nil, T["Merge Tradeskill Casts"], C.castbar.player, "mergetradeskill", "checkbox")
CreateConfig(nil, T["Right Text X Offset"], C.castbar.player, "txtrightoffx") end)
CreateConfig(nil, T["Right Text Y Offset"], C.castbar.player, "txtrightoffy")
CreateConfig(nil, T["Target Castbar"], nil, nil, "header") CreateGUIEntry(T["Castbar"], T["Target"], function()
CreateConfig(nil, T["Disable Target Castbar"], C.castbar.target, "hide_pfui", "checkbox") CreateConfig(nil, T["Disable Target Castbar"], C.castbar.target, "hide_pfui", "checkbox")
CreateConfig(nil, T["Castbar Width"], C.castbar.target, "width") CreateConfig(nil, T["Castbar Width"], C.castbar.target, "width")
CreateConfig(nil, T["Castbar Height"], C.castbar.target, "height") CreateConfig(nil, T["Castbar Height"], C.castbar.target, "height")
CreateConfig(nil, T["Show Spell Icon"], C.castbar.target, "showicon", "checkbox") CreateConfig(nil, T["Show Spell Icon"], C.castbar.target, "showicon", "checkbox")
CreateConfig(nil, T["Show Spell Name"], C.castbar.target, "showname", "checkbox") CreateConfig(nil, T["Show Spell Name"], C.castbar.target, "showname", "checkbox")
CreateConfig(nil, T["Spell Name Alignment"], C.castbar.target, "namealign", "dropdown", pfUI.gui.dropdowns.castbaralign)
CreateConfig(nil, T["Spell Name X Offset"], C.castbar.target, "txtleftoffx")
CreateConfig(nil, T["Spell Name Y Offset"], C.castbar.target, "txtleftoffy")
CreateConfig(nil, T["Show Timer"], C.castbar.target, "showtimer", "checkbox") CreateConfig(nil, T["Show Timer"], C.castbar.target, "showtimer", "checkbox")
CreateConfig(nil, T["Left Text X Offset"], C.castbar.target, "txtleftoffx") CreateConfig(nil, T["Timer Alignment"], C.castbar.target, "timealign", "dropdown", pfUI.gui.dropdowns.castbaralign)
CreateConfig(nil, T["Left Text Y Offset"], C.castbar.target, "txtleftoffy") CreateConfig(nil, T["Timer X Offset"], C.castbar.target, "txtrightoffx")
CreateConfig(nil, T["Timer Y Offset"], C.castbar.target, "txtrightoffy")
CreateConfig(nil, T["Show Lag"], C.castbar.target, "showlag", "checkbox") CreateConfig(nil, T["Show Lag"], C.castbar.target, "showlag", "checkbox")
CreateConfig(nil, T["Show Rank"], C.castbar.target, "showrank", "checkbox") CreateConfig(nil, T["Show Rank"], C.castbar.target, "showrank", "checkbox")
CreateConfig(nil, T["Right Text X Offset"], C.castbar.target, "txtrightoffx") end)
CreateConfig(nil, T["Right Text Y Offset"], C.castbar.target, "txtrightoffy")
CreateConfig(nil, T["Focus Castbar"], nil, nil, "header") CreateGUIEntry(T["Castbar"], T["Focus"], function()
CreateConfig(nil, T["Disable Focus Castbar"], C.castbar.focus, "hide_pfui", "checkbox") CreateConfig(nil, T["Disable Focus Castbar"], C.castbar.focus, "hide_pfui", "checkbox")
CreateConfig(nil, T["Castbar Width"], C.castbar.focus, "width") CreateConfig(nil, T["Castbar Width"], C.castbar.focus, "width")
CreateConfig(nil, T["Castbar Height"], C.castbar.focus, "height") CreateConfig(nil, T["Castbar Height"], C.castbar.focus, "height")
CreateConfig(nil, T["Show Spell Icon"], C.castbar.focus, "showicon", "checkbox") CreateConfig(nil, T["Show Spell Icon"], C.castbar.focus, "showicon", "checkbox")
CreateConfig(nil, T["Show Spell Name"], C.castbar.focus, "showname", "checkbox") CreateConfig(nil, T["Show Spell Name"], C.castbar.focus, "showname", "checkbox")
CreateConfig(nil, T["Spell Name Alignment"], C.castbar.focus, "namealign", "dropdown", pfUI.gui.dropdowns.castbaralign)
CreateConfig(nil, T["Spell Name X Offset"], C.castbar.focus, "txtleftoffx")
CreateConfig(nil, T["Spell Name Y Offset"], C.castbar.focus, "txtleftoffy")
CreateConfig(nil, T["Show Timer"], C.castbar.focus, "showtimer", "checkbox") CreateConfig(nil, T["Show Timer"], C.castbar.focus, "showtimer", "checkbox")
CreateConfig(nil, T["Left Text X Offset"], C.castbar.focus, "txtleftoffx") CreateConfig(nil, T["Timer Alignment"], C.castbar.focus, "timealign", "dropdown", pfUI.gui.dropdowns.castbaralign)
CreateConfig(nil, T["Left Text Y Offset"], C.castbar.focus, "txtleftoffy") CreateConfig(nil, T["Timer X Offset"], C.castbar.focus, "txtrightoffx")
CreateConfig(nil, T["Timer Y Offset"], C.castbar.focus, "txtrightoffy")
CreateConfig(nil, T["Show Lag"], C.castbar.focus, "showlag", "checkbox") CreateConfig(nil, T["Show Lag"], C.castbar.focus, "showlag", "checkbox")
CreateConfig(nil, T["Show Rank"], C.castbar.focus, "showrank", "checkbox") CreateConfig(nil, T["Show Rank"], C.castbar.focus, "showrank", "checkbox")
CreateConfig(nil, T["Right Text X Offset"], C.castbar.focus, "txtrightoffx")
CreateConfig(nil, T["Right Text Y Offset"], C.castbar.focus, "txtrightoffy")
end) end)
CreateGUIEntry(T["Chat"], nil, function() CreateGUIEntry(T["Chat"], nil, function()
@@ -2842,6 +2864,7 @@ pfUI:RegisterModule("gui", function ()
CreateConfig(nil, T["Generate Playerlinks"], C.chat.text, "playerlinks", "checkbox") CreateConfig(nil, T["Generate Playerlinks"], C.chat.text, "playerlinks", "checkbox")
CreateConfig(nil, T["Enable URL Detection"], C.chat.text, "detecturl", "checkbox") CreateConfig(nil, T["Enable URL Detection"], C.chat.text, "detecturl", "checkbox")
CreateConfig(nil, T["Enable Class Colors"], C.chat.text, "classcolor", "checkbox") CreateConfig(nil, T["Enable Class Colors"], C.chat.text, "classcolor", "checkbox")
CreateConfig(nil, T["Show Faction & Race Icons"] .. " " .. GetPlayerRaceIcons(), C.chat.text, "playericons", "checkbox")
CreateConfig(nil, T["Enable Player Levels"], C.chat.text, "playerlevel", "checkbox") CreateConfig(nil, T["Enable Player Levels"], C.chat.text, "playerlevel", "checkbox")
CreateConfig(nil, T["Who Search Unknown Classes (|cffffaaaaExperimental|r)"], C.chat.text, "whosearchunknown", "checkbox") CreateConfig(nil, T["Who Search Unknown Classes (|cffffaaaaExperimental|r)"], C.chat.text, "whosearchunknown", "checkbox")
CreateConfig(nil, T["Colorize Unknown Classes"], C.chat.text, "tintunknown", "checkbox") CreateConfig(nil, T["Colorize Unknown Classes"], C.chat.text, "tintunknown", "checkbox")
@@ -2855,9 +2878,9 @@ pfUI:RegisterModule("gui", function ()
CreateConfig(nil, T["Only Show Chat Dock On Mouseover"], C.chat.global, "tabmouse", "checkbox") CreateConfig(nil, T["Only Show Chat Dock On Mouseover"], C.chat.global, "tabmouse", "checkbox")
CreateConfig(nil, T["Enable Chat Tab Flashing"], C.chat.global, "chatflash", "checkbox") CreateConfig(nil, T["Enable Chat Tab Flashing"], C.chat.global, "chatflash", "checkbox")
CreateConfig(nil, T["Enable Frame Shadow"], C.chat.global, "frameshadow", "checkbox") CreateConfig(nil, T["Enable Frame Shadow"], C.chat.global, "frameshadow", "checkbox")
CreateConfig(nil, T["Enable Custom Colors"], C.chat.global, "custombg", "checkbox") CreateConfig(U["chat"], T["Enable Custom Colors"], C.chat.global, "custombg", "checkbox")
CreateConfig(nil, T["Chat Background Color"], C.chat.global, "background", "color") CreateConfig(U["chat"], T["Chat Background Color"], C.chat.global, "background", "color")
CreateConfig(nil, T["Chat Border Color"], C.chat.global, "border", "color") CreateConfig(U["chat"], T["Chat Border Color"], C.chat.global, "border", "color")
CreateConfig(nil, T["Enable Custom Incoming Whispers Layout"], C.chat.global, "whispermod", "checkbox") CreateConfig(nil, T["Enable Custom Incoming Whispers Layout"], C.chat.global, "whispermod", "checkbox")
CreateConfig(nil, T["Incoming Whispers Color"], C.chat.global, "whisper", "color") CreateConfig(nil, T["Incoming Whispers Color"], C.chat.global, "whisper", "color")
CreateConfig(nil, T["Enable Sticky Chat"], C.chat.global, "sticky", "checkbox") CreateConfig(nil, T["Enable Sticky Chat"], C.chat.global, "sticky", "checkbox")
@@ -2974,6 +2997,7 @@ pfUI:RegisterModule("gui", function ()
CreateConfig(nil, T["Use Chat Colors for Meters"], C.thirdparty, "chatbg", "checkbox") CreateConfig(nil, T["Use Chat Colors for Meters"], C.thirdparty, "chatbg", "checkbox")
CreateConfig(nil, "ShaguDPS (" .. T["Skin"] .. ")", C.thirdparty.shagudps, "skin", "checkbox") CreateConfig(nil, "ShaguDPS (" .. T["Skin"] .. ")", C.thirdparty.shagudps, "skin", "checkbox")
CreateConfig(nil, "ShaguDPS (" .. T["Dock"] .. ")", C.thirdparty.shagudps, "dock", "checkbox") CreateConfig(nil, "ShaguDPS (" .. T["Dock"] .. ")", C.thirdparty.shagudps, "dock", "checkbox")
CreateConfig(nil, "GreedMeter (" .. T["Dock"] .. ")", C.thirdparty.greedmeter, "dock", "checkbox")
CreateConfig(nil, "DPSMate (" .. T["Skin"] .. ")", C.thirdparty.dpsmate, "skin", "checkbox") CreateConfig(nil, "DPSMate (" .. T["Skin"] .. ")", C.thirdparty.dpsmate, "skin", "checkbox")
CreateConfig(nil, "DPSMate (" .. T["Dock"] .. ")", C.thirdparty.dpsmate, "dock", "checkbox") CreateConfig(nil, "DPSMate (" .. T["Dock"] .. ")", C.thirdparty.dpsmate, "dock", "checkbox")
CreateConfig(nil, "SWStats (" .. T["Skin"] .. ")", C.thirdparty.swstats, "skin", "checkbox") CreateConfig(nil, "SWStats (" .. T["Skin"] .. ")", C.thirdparty.swstats, "skin", "checkbox")
@@ -3002,8 +3026,7 @@ pfUI:RegisterModule("gui", function ()
CreateGUIEntry(T["Components"], T["Modules"], function() CreateGUIEntry(T["Components"], T["Modules"], function()
table.sort(pfUI.modules) table.sort(pfUI.modules)
for i,m in pairs(pfUI.modules) do for i,m in pairs(pfUI.modules) do
-- skip gui and macrotweak when macro addons are loaded if m ~= "gui" then
if m ~= "gui" and not (m == "macrotweak" and pfUI:MacroAddonsLoaded()) then
-- create disabled entry if not existing and display -- create disabled entry if not existing and display
pfUI:UpdateConfig("disabled", nil, m, "0") pfUI:UpdateConfig("disabled", nil, m, "0")
CreateConfig(nil, T["Disable Module"] .. " " .. m, C.disabled, m, "checkbox") CreateConfig(nil, T["Disable Module"] .. " " .. m, C.disabled, m, "checkbox")
modules/hunterbar.lua
+34 -9
View File
@@ -1,10 +1,8 @@
pfUI:RegisterModule("hunterbar", function () pfUI:RegisterModule("hunterbar", function ()
local _,class = UnitClass("player") if UnitClassBase("player") ~= "HUNTER" or C.bars.hunterbar == "0" then return end
if class ~= "HUNTER" or C.bars.hunterbar == "0" then return end
-- Wing Clip (any rank) and Arcane Shot (any rank) spell IDs. -- Wing Clip (any rank) and Arcane Shot (any rank) spell IDs.
-- IsSpellInRange(spellId) works with any spell ID via Nampower, -- C_Spell.IsSpellInRange works with any spell ID, no actionbar slot needed.
-- no actionbar slot needed.
local WINGCLIP_ID = 2974 -- melee range indicator (~5 yd) local WINGCLIP_ID = 2974 -- melee range indicator (~5 yd)
local ARCANESHOT_ID = 3044 -- ranged range indicator (~35 yd) local ARCANESHOT_ID = 3044 -- ranged range indicator (~35 yd)
@@ -12,22 +10,37 @@ pfUI:RegisterModule("hunterbar", function ()
-- Only swap BACK to melee bar when Wing Clip is actually in range. -- Only swap BACK to melee bar when Wing Clip is actually in range.
-- This prevents rapid bar-flipping in the transition zone. -- This prevents rapid bar-flipping in the transition zone.
local THROTTLE = 0.02 -- seconds between range checks (was every frame)
pfUI.hunterbar = CreateFrame("Frame", "pfHunterBar", UIParent) pfUI.hunterbar = CreateFrame("Frame", "pfHunterBar", UIParent)
-- track which page we last forced so we don't spam ChangeActionBarPage() -- track which page we last forced so we don't spam ChangeActionBarPage()
pfUI.hunterbar.lastPage = nil pfUI.hunterbar.lastPage = nil
pfUI.hunterbar.elapsed = 0
-- Idle until there's a live, attackable target. A hidden frame runs no
-- OnUpdate, so the range polling only ticks while it can matter.
pfUI.hunterbar:Hide()
pfUI.hunterbar:SetScript("OnUpdate", function() pfUI.hunterbar:SetScript("OnUpdate", function()
-- only act when there is a live, attackable target this.elapsed = this.elapsed + arg1
if this.elapsed < THROTTLE then return end
this.elapsed = 0
-- Target died or turned unattackable without a target-change event
-- (it dropped to a corpse); stop ticking until the next target.
if not UnitExists("target") or not UnitCanAttack("player", "target") then if not UnitExists("target") or not UnitCanAttack("player", "target") then
this:Hide()
return return
end end
local wingclipInRange = IsSpellInRange(WINGCLIP_ID, "target") -- C_Spell.IsSpellInRange returns true / false / nil (rangeless). The
local arcaneshotInRange = IsSpellInRange(ARCANESHOT_ID, "target") -- explicit == true / == false tests leave the bar unchanged on nil.
local wingclipInRange = C_Spell.IsSpellInRange(WINGCLIP_ID, "target")
local arcaneshotInRange = C_Spell.IsSpellInRange(ARCANESHOT_ID, "target")
-- swap to ranged bar: out of melee range AND arcane shot (8yd) in range -- swap to ranged bar: out of melee range AND arcane shot (8yd) in range
if wingclipInRange == 0 and arcaneshotInRange == 1 then if wingclipInRange == false and arcaneshotInRange == true then
if this.lastPage ~= 2 then if this.lastPage ~= 2 then
this.lastPage = 2 this.lastPage = 2
_G.CURRENT_ACTIONBAR_PAGE = 2 _G.CURRENT_ACTIONBAR_PAGE = 2
@@ -35,7 +48,7 @@ pfUI:RegisterModule("hunterbar", function ()
end end
-- swap to melee bar: in melee range AND arcane shot (8yd) out of range -- swap to melee bar: in melee range AND arcane shot (8yd) out of range
elseif wingclipInRange == 1 and arcaneshotInRange == 0 then elseif wingclipInRange == true and arcaneshotInRange == false then
if this.lastPage ~= 1 then if this.lastPage ~= 1 then
this.lastPage = 1 this.lastPage = 1
_G.CURRENT_ACTIONBAR_PAGE = 1 _G.CURRENT_ACTIONBAR_PAGE = 1
@@ -43,4 +56,16 @@ pfUI:RegisterModule("hunterbar", function ()
end end
end end
end) end)
-- Start ticking only when we gain an attackable target.
pfUI.hunterbar:RegisterEvent("PLAYER_TARGET_CHANGED")
pfUI.hunterbar:RegisterEvent("PLAYER_ENTERING_WORLD")
pfUI.hunterbar:SetScript("OnEvent", function()
if UnitExists("target") and UnitCanAttack("player", "target") then
this.elapsed = THROTTLE -- run the first check on the next frame
this:Show()
else
this:Hide()
end
end)
end) end)
modules/innervatecall.lua
+8 -10
View File
@@ -2,14 +2,12 @@
-- Announces Innervate casts via raid/party/battleground chat -- Announces Innervate casts via raid/party/battleground chat
-- Registers AURA_CAST events directly - zero polling, pure event-driven -- Registers AURA_CAST events directly - zero polling, pure event-driven
pfUI:RegisterNewModule("innervatecall", "Innervate Callout", "DRUID")
pfUI:RegisterModule("innervatecall", function () pfUI:RegisterModule("innervatecall", function ()
-- Requires Nampower for AURA_CAST events -- Requires Nampower for AURA_CAST events
if not GetNampowerVersion then return end if not GetNampowerVersion then return end
-- Only load for druids -- Only load for druids
local _, playerClass = UnitClass("player") if UnitClassBase("player") ~= "DRUID" then return end
if playerClass ~= "DRUID" then return end
local INNERVATE_SPELLID = 29166 local INNERVATE_SPELLID = 29166
@@ -77,14 +75,14 @@ pfUI:RegisterModule("innervatecall", function ()
SendChatMessage(">> Innervate casted on " .. targetName .. " <<", channel) SendChatMessage(">> Innervate casted on " .. targetName .. " <<", channel)
-- Schedule "ready" announcement when cooldown expires -- Schedule "ready" announcement when the cooldown expires. Read the
-- Use GetSpellIdCooldown for precise remaining time, fallback to 360s -- precise remaining time from C_Spell.GetSpellCooldown (startTime and
-- duration are seconds from the GetTime epoch); fall back to 360s.
local cdRemaining = 360 local cdRemaining = 360
if GetSpellIdCooldown then local cd = C_Spell.GetSpellCooldown(INNERVATE_SPELLID)
local cd = GetSpellIdCooldown(INNERVATE_SPELLID) if cd and cd.duration and cd.duration > 0 then
if cd and cd.cooldownRemainingMs and cd.cooldownRemainingMs > 0 then local remaining = cd.startTime + cd.duration - GetTime()
cdRemaining = cd.cooldownRemainingMs / 1000 if remaining > 0 then cdRemaining = remaining end
end
end end
C_Timer.After(cdRemaining, function() C_Timer.After(cdRemaining, function()
modules/itemcount.lua
+9 -5
View File
@@ -26,10 +26,14 @@ pfUI:RegisterModule("itemcount", function ()
if bank < 0 then bank = 0 end if bank < 0 then bank = 0 end
frame:AddLine(" ") frame:AddLine(" ")
if bags > 0 then frame:AddDoubleLine("Bags:", bags, 1, 1, 1, 1, 1, 1) end if bags > 0 then frame:AddDoubleLine(T["Bags"] .. ":", bags, 1, 1, 1, 1, 1, 1) end
if bank > 0 then frame:AddDoubleLine("Bank:", bank, 1, 1, 1, 1, 1, 1) end if bank > 0 then frame:AddDoubleLine(T["Bank"] .. ":", bank, 1, 1, 1, 1, 1, 1) end
if equipped > 0 then frame:AddDoubleLine("Equipped:", equipped, 1, 1, 1, 1, 1, 1) end if equipped > 0 then frame:AddDoubleLine(T["Equipped"] .. ":", equipped, 1, 1, 1, 1, 1, 1) end
frame:AddDoubleLine("Total:", total, 1, 1, 1, 1, 1, 1)
local sources = (bags > 0 and 1 or 0) + (bank > 0 and 1 or 0) + (equipped > 0 and 1 or 0)
if sources > 1 then
frame:AddDoubleLine(T["Total"] .. ":", total, 1, 1, 1, 1, 1, 1)
end
frame:Show() frame:Show()
end end
@@ -41,7 +45,7 @@ pfUI:RegisterModule("itemcount", function ()
end end
end) end)
pfUI.hooksecurefunc("SetItemRef", function() hooksecurefunc("SetItemRef", function()
if ItemRefTooltip:HasItem() then if ItemRefTooltip:HasItem() then
local _, _, id = ItemRefTooltip:GetItem() local _, _, id = ItemRefTooltip:GetItem()
if id then AddCounts(ItemRefTooltip, id) end if id then AddCounts(ItemRefTooltip, id) end
modules/loot.lua
+10 -20
View File
@@ -77,9 +77,7 @@ pfUI:RegisterModule("loot", function ()
if pfUI.loot.my_index or pfUI.loot.disenchanter_index or pfUI.loot.banker_index then if pfUI.loot.my_index or pfUI.loot.disenchanter_index or pfUI.loot.banker_index then
info = wipe(info) info = wipe(info)
info.text = T["Special Recipient"] info.text = T["Special Recipient"]
info.textR = NORMAL_FONT_COLOR.r info.textR, info.textG, info.textB = NORMAL_FONT_COLOR:GetRGB()
info.textG = NORMAL_FONT_COLOR.g
info.textB = NORMAL_FONT_COLOR.b
info.textHeight = 12 info.textHeight = 12
info.hasArrow = 1 info.hasArrow = 1
info.notCheckable = 1 info.notCheckable = 1
@@ -158,9 +156,7 @@ pfUI:RegisterModule("loot", function ()
if level == 1 then if level == 1 then
info = wipe(info) info = wipe(info)
info.text = T["Random"] info.text = T["Random"]
info.textR = NORMAL_FONT_COLOR.r info.textR, info.textG, info.textB = NORMAL_FONT_COLOR:GetRGB()
info.textG = NORMAL_FONT_COLOR.g
info.textB = NORMAL_FONT_COLOR.b
info.value = "PFRANDOM" info.value = "PFRANDOM"
info.textHeight = 12 info.textHeight = 12
info.notCheckable = 1 info.notCheckable = 1
@@ -170,9 +166,7 @@ pfUI:RegisterModule("loot", function ()
info = wipe(info) info = wipe(info)
info.text = T["Request Rolls"] info.text = T["Request Rolls"]
info.textR = NORMAL_FONT_COLOR.r info.textR, info.textG, info.textB = NORMAL_FONT_COLOR:GetRGB()
info.textG = NORMAL_FONT_COLOR.g
info.textB = NORMAL_FONT_COLOR.b
info.value = "PFROLLS" info.value = "PFROLLS"
info.textHeight = 12 info.textHeight = 12
info.hasArrow = 1 info.hasArrow = 1
@@ -183,9 +177,7 @@ pfUI:RegisterModule("loot", function ()
if UIDROPDOWNMENU_MENU_VALUE == "PFROLLS" then if UIDROPDOWNMENU_MENU_VALUE == "PFROLLS" then
info = wipe(info) info = wipe(info)
info.text = T["Clear Rolls"] info.text = T["Clear Rolls"]
info.textR = NORMAL_FONT_COLOR.r info.textR, info.textG, info.textB = NORMAL_FONT_COLOR:GetRGB()
info.textG = NORMAL_FONT_COLOR.g
info.textB = NORMAL_FONT_COLOR.b
info.value = "PFCLEARROLLS" info.value = "PFCLEARROLLS"
info.notCheckable = 1 info.notCheckable = 1
info.func = pfUI.loot.ClearRolls info.func = pfUI.loot.ClearRolls
@@ -193,9 +185,7 @@ pfUI:RegisterModule("loot", function ()
info = wipe(info) info = wipe(info)
info.text = T["Reroll Ties"] info.text = T["Reroll Ties"]
info.textR = NORMAL_FONT_COLOR.r info.textR, info.textG, info.textB = NORMAL_FONT_COLOR:GetRGB()
info.textG = NORMAL_FONT_COLOR.g
info.textB = NORMAL_FONT_COLOR.b
info.value = "PFTIEROLL" info.value = "PFTIEROLL"
info.notCheckable = 1 info.notCheckable = 1
info.arg1 = pfUI.loot.rollers_sorted info.arg1 = pfUI.loot.rollers_sorted
@@ -236,7 +226,7 @@ pfUI:RegisterModule("loot", function ()
if (candidate) then if (candidate) then
index_to_name[i] = candidate index_to_name[i] = candidate
name_to_index[candidate] = i name_to_index[candidate] = i
randoms[table.getn(randoms)+1]=i table.insert(randoms, i)
if candidate == pfUI.loot.me then if candidate == pfUI.loot.me then
pfUI.loot.my_index = i pfUI.loot.my_index = i
end end
@@ -392,7 +382,7 @@ pfUI:RegisterModule("loot", function ()
end end
pfUI.loot:RemoveMasterlootMenus() -- remove then add to ensure no duplicate menus pfUI.loot:RemoveMasterlootMenus() -- remove then add to ensure no duplicate menus
pfUI.loot:AddMasterLootMenus() pfUI.loot:AddMasterLootMenus()
pfUI.hooksecurefunc("UnitPopup_OnClick",function() hooksecurefunc("UnitPopup_OnClick",function()
local dropdownFrame = _G[UIDROPDOWNMENU_INIT_MENU] local dropdownFrame = _G[UIDROPDOWNMENU_INIT_MENU]
if not dropdownFrame then return end if not dropdownFrame then return end
local button = this.value local button = this.value
@@ -405,7 +395,7 @@ pfUI:RegisterModule("loot", function ()
end end
end end
end) end)
pfUI.hooksecurefunc("UnitPopup_HideButtons",function() hooksecurefunc("UnitPopup_HideButtons",function()
local dropdownFrame = _G[UIDROPDOWNMENU_INIT_MENU] local dropdownFrame = _G[UIDROPDOWNMENU_INIT_MENU]
local unit = dropdownFrame.unit local unit = dropdownFrame.unit
local name = dropdownFrame.name local name = dropdownFrame.name
@@ -521,7 +511,7 @@ pfUI:RegisterModule("loot", function ()
end end
function pfUI.loot:CreateSlot(id) function pfUI.loot:CreateSlot(id)
local frame = CreateFrame(LOOT_BUTTON_FRAME_TYPE, 'pfLootButton'..id, pfUI.loot) local frame = CreateFrame("LootButton", 'pfLootButton'..id, pfUI.loot)
frame:RegisterForClicks('LeftButtonUp', 'RightButtonUp') frame:RegisterForClicks('LeftButtonUp', 'RightButtonUp')
frame:SetPoint("LEFT", border*2, 0) frame:SetPoint("LEFT", border*2, 0)
frame:SetPoint("RIGHT", -border*2, 0) frame:SetPoint("RIGHT", -border*2, 0)
@@ -693,7 +683,7 @@ pfUI:RegisterModule("loot", function ()
else -- not an eligible candidate for that item else -- not an eligible candidate for that item
pfUI.loot.rollers[who] = {roll=tonumber(roll),value="disabled"} pfUI.loot.rollers[who] = {roll=tonumber(roll),value="disabled"}
end end
pfUI.loot.rollers_sorted[table.getn(pfUI.loot.rollers_sorted)+1]={who=who,roll=tonumber(roll),value=pfUI.loot.rollers[who].value} table.insert(pfUI.loot.rollers_sorted, {who=who,roll=tonumber(roll),value=pfUI.loot.rollers[who].value})
end end
end end
table.sort(pfUI.loot.rollers_sorted,function(a,b) table.sort(pfUI.loot.rollers_sorted,function(a,b)
modules/loothistory.lua
+371
View File
@@ -0,0 +1,371 @@
pfUI:RegisterModule("loothistory", function ()
local rawborder, border = GetBorderSize()
-- Layout
local ITEM_H, PLAYER_H = 24, 18
local ITEM_W, PLAYER_W = 350, 330
-- rollType constants returned by C_LootHistory.GetPlayerInfo (0/1/2; vanilla
-- has no disenchant roll).
local ROLL_PASS, ROLL_NEED, ROLL_GREED = 0, 1, 2
local ROLL_TEX = {
[ROLL_NEED] = "Interface\\Buttons\\UI-GroupLoot-Dice-Up",
[ROLL_GREED] = "Interface\\Buttons\\UI-GroupLoot-Coin-Up",
[ROLL_PASS] = "Interface\\Buttons\\UI-GroupLoot-Pass-Up",
}
local WINMARK = "Interface\\Buttons\\UI-CheckBox-Check"
local QUESTIONMARK = "Interface\\Icons\\INV_Misc_QuestionMark"
-- Paint an item row's icon/name/quality from a loaded Item mixin.
local function RenderItemVisual(f, item)
local r, g, b = 1, 1, 1
local qc = item:GetItemQualityColor()
if qc then r, g, b = qc.r, qc.g, qc.b end
f.icon:SetTexture(item:GetItemIcon())
f.iconbg:SetBackdropBorderColor(r, g, b, 1)
f.name:SetText(item:GetItemName() or UNKNOWN)
f.name:SetTextColor(r, g, b)
end
local function ShowRetrieving(f)
f.icon:SetTexture(QUESTIONMARK)
f.iconbg:SetBackdropBorderColor(1, .3, .3, 1)
f.name:SetText(T["Retrieving item information..."])
f.name:SetTextColor(1, .3, .3)
end
-- expansion state keyed on the stable rollID (survives ring-index shifts)
local expanded = {}
-- ==========================================================================
-- Window
-- ==========================================================================
pfUI.loothistory = CreateFrame("Frame", "pfLootHistory", UIParent)
pfUI.loothistory:SetFrameStrata("DIALOG")
pfUI.loothistory:SetSize(380, 490)
pfUI.loothistory:SetPoint("CENTER", 0, 0)
pfUI.loothistory:SetMovable(true)
pfUI.loothistory:EnableMouse(true)
pfUI.loothistory:RegisterForDrag("LeftButton")
pfUI.loothistory:SetScript("OnDragStart", function() this:StartMoving() end)
pfUI.loothistory:SetScript("OnDragStop", function() this:StopMovingOrSizing() end)
pfUI.loothistory:Hide()
CreateBackdrop(pfUI.loothistory, nil, true, .75)
CreateBackdropShadow(pfUI.loothistory)
tinsert(UISpecialFrames, "pfLootHistory")
pfUI.loothistory.caption = pfUI.loothistory:CreateFontString("Status", "LOW", "GameFontNormal")
pfUI.loothistory.caption:SetFont(pfUI.font_default, C.global.font_size + 4, "OUTLINE")
pfUI.loothistory.caption:SetTextColor(.2, 1, .8, 1)
pfUI.loothistory.caption:SetPoint("TOP", 0, -10)
pfUI.loothistory.caption:SetText(T["Loot History"])
-- close button
pfUI.loothistory.close = CreateFrame("Button", nil, pfUI.loothistory)
pfUI.loothistory.close:SetPoint("TOPRIGHT", -border*2, -border*2)
CreateBackdrop(pfUI.loothistory.close)
pfUI.loothistory.close:SetSize(15, 15)
pfUI.loothistory.close.texture = pfUI.loothistory.close:CreateTexture("pfLootHistoryClose")
pfUI.loothistory.close.texture:SetTexture(pfUI.media["img:close"])
pfUI.loothistory.close.texture:SetPoint("TOPLEFT", pfUI.loothistory.close, "TOPLEFT", 4, -4)
pfUI.loothistory.close.texture:SetPoint("BOTTOMRIGHT", pfUI.loothistory.close, "BOTTOMRIGHT", -4, 4)
pfUI.loothistory.close.texture:SetVertexColor(1, .25, .25, 1)
pfUI.loothistory.close:SetScript("OnEnter", function()
CreateBackdrop(pfUI.loothistory.close)
pfUI.loothistory.close.backdrop:SetBackdropBorderColor(1, .25, .25, 1)
end)
pfUI.loothistory.close:SetScript("OnLeave", function() CreateBackdrop(pfUI.loothistory.close) end)
pfUI.loothistory.close:SetScript("OnClick", function() pfUI.loothistory:Hide() end)
-- clear button
pfUI.loothistory.clear = CreateFrame("Button", nil, pfUI.loothistory, "UIPanelButtonTemplate")
SkinButton(pfUI.loothistory.clear)
pfUI.loothistory.clear:SetSize(60, 16)
pfUI.loothistory.clear:SetPoint("TOPLEFT", 10, -8)
pfUI.loothistory.clear:SetText(T["Clear"])
pfUI.loothistory.clear:SetScript("OnClick", function() C_LootHistory.Clear() end)
-- scroll frame
pfUI.loothistory.scroll = CreateScrollFrame("pfLootHistoryScroll", pfUI.loothistory)
pfUI.loothistory.scroll:SetSize(360, 440)
pfUI.loothistory.scroll:SetPoint("BOTTOM", 0, 10)
pfUI.loothistory.scroll.backdrop = CreateFrame("Frame", nil, pfUI.loothistory.scroll)
pfUI.loothistory.scroll.backdrop:SetFrameLevel(1)
pfUI.loothistory.scroll.backdrop:SetPoint("TOPLEFT", pfUI.loothistory.scroll, "TOPLEFT", -5, 5)
pfUI.loothistory.scroll.backdrop:SetPoint("BOTTOMRIGHT", pfUI.loothistory.scroll, "BOTTOMRIGHT", 5, -5)
CreateBackdrop(pfUI.loothistory.scroll.backdrop, nil, true)
local list = CreateScrollChild("pfLootHistoryList", pfUI.loothistory.scroll)
pfUI.loothistory.list = list
-- ==========================================================================
-- Frame pools
-- ==========================================================================
local itemFrames = {}
local FullUpdate -- forward declaration (toggle handlers call it)
local function CreateItemFrame()
local f = CreateFrame("Button", nil, list)
f:SetSize(ITEM_W, ITEM_H)
f:SetBackdrop(pfUI.backdrop_hover)
f:SetBackdropBorderColor(1, 1, 1, .04)
f:EnableMouse(1)
-- expand / collapse toggle
f.toggle = CreateFrame("Button", nil, f)
f.toggle:SetSize(14, 14)
f.toggle:SetPoint("LEFT", 4, 0)
f.toggle:SetScript("OnClick", function()
local id = f.rollID
if id then expanded[id] = not expanded[id]; FullUpdate() end
end)
-- icon + quality-colored border
f.iconbg = CreateFrame("Frame", nil, f)
f.iconbg:SetSize(ITEM_H - 8, ITEM_H - 8)
f.iconbg:SetPoint("LEFT", f.toggle, "RIGHT", 4, 0)
CreateBackdrop(f.iconbg, nil, true)
f.icon = f.iconbg:CreateTexture(nil, "ARTWORK")
f.icon:SetPoint("TOPLEFT", f.iconbg, "TOPLEFT", 2, -2)
f.icon:SetPoint("BOTTOMRIGHT", f.iconbg, "BOTTOMRIGHT", -2, 2)
f.icon:SetTexCoord(.08, .92, .08, .92)
-- winner block (right side, shown for decided rolls)
f.winicon = f:CreateTexture(nil, "OVERLAY")
f.winicon:SetSize(14, 14)
f.winicon:SetPoint("RIGHT", f, "RIGHT", -6, 0)
f.winroll = f:CreateFontString("Status", "OVERLAY", "GameFontNormal")
f.winroll:SetFont(pfUI.font_default, C.global.font_size, "OUTLINE")
f.winroll:SetPoint("RIGHT", f.winicon, "LEFT", -2, 0)
f.winroll:SetTextColor(1, 1, 1, 1)
f.winname = f:CreateFontString("Status", "OVERLAY", "GameFontNormal")
f.winname:SetFont(pfUI.font_default, C.global.font_size, "OUTLINE")
f.winname:SetPoint("RIGHT", f.winroll, "LEFT", -4, 0)
f.winname:SetJustifyH("RIGHT")
-- item name (leaves room on the right for the winner block)
f.name = f:CreateFontString("Status", "OVERLAY", "GameFontNormal")
f.name:SetFont(pfUI.font_default, C.global.font_size, "OUTLINE")
f.name:SetPoint("LEFT", f.iconbg, "RIGHT", 5, 0)
f.name:SetPoint("RIGHT", f, "RIGHT", -100, 0)
f.name:SetJustifyH("LEFT")
f:SetScript("OnEnter", function()
this:SetBackdropBorderColor(1, 1, 1, .08)
if this.itemLink then
GameTooltip:SetOwner(this, "ANCHOR_RIGHT")
GameTooltip:SetHyperlink(this.itemLink)
GameTooltip:Show()
end
end)
f:SetScript("OnLeave", function()
this:SetBackdropBorderColor(1, 1, 1, .04)
GameTooltip:Hide()
end)
f:SetScript("OnClick", function()
local id = this.rollID
if id then expanded[id] = not expanded[id]; FullUpdate() end
end)
return f
end
local function CreatePlayerFrame()
local f = CreateFrame("Frame", nil, list)
f:SetSize(PLAYER_W, PLAYER_H)
-- name is indented to leave room for the winner checkmark on its left
f.name = f:CreateFontString("Status", "OVERLAY", "GameFontNormal")
f.name:SetFont(pfUI.font_default, C.global.font_size, "OUTLINE")
f.name:SetPoint("LEFT", 20, 0)
f.name:SetJustifyH("LEFT")
f.rollicon = f:CreateTexture(nil, "OVERLAY")
f.rollicon:SetSize(16, 16)
f.rollicon:SetPoint("RIGHT", -4, 0)
f.rolltext = f:CreateFontString("Status", "OVERLAY", "GameFontNormal")
f.rolltext:SetFont(pfUI.font_default, C.global.font_size, "OUTLINE")
f.rolltext:SetPoint("RIGHT", f.rollicon, "LEFT", -3, 0)
f.rolltext:SetTextColor(1, 1, 1, 1)
-- winner checkmark, just left of the player name (matches reference)
f.winmark = f:CreateTexture(nil, "OVERLAY")
f.winmark:SetSize(16, 16)
f.winmark:SetTexture(WINMARK)
f.winmark:SetPoint("RIGHT", f.name, "LEFT", -1, 0)
return f
end
local playerPool = CreateObjectPool(CreatePlayerFrame, function(_, pf)
pf:Hide()
pf:ClearAllPoints()
end)
local function SetToggleTexture(toggle, isExpanded)
if isExpanded then
toggle:SetNormalTexture("Interface\\Buttons\\UI-MinusButton-Up")
toggle:SetPushedTexture("Interface\\Buttons\\UI-MinusButton-Down")
else
toggle:SetNormalTexture("Interface\\Buttons\\UI-PlusButton-Up")
toggle:SetPushedTexture("Interface\\Buttons\\UI-PlusButton-Down")
end
end
-- ==========================================================================
-- Rendering
-- ==========================================================================
local function UpdateItemFrame(f, i)
local rollID, itemLink, numPlayers, isDone, winnerIdx = C_LootHistory.GetItem(i)
f.rollID = rollID
f.itemIdx = i
f.itemLink = itemLink
f.numPlayers = numPlayers or 0
f.isDone = isDone
local isExpanded = rollID and expanded[rollID]
SetToggleTexture(f.toggle, isExpanded)
-- Item icon/name/quality via the ClassicAPI Item mixin. When the item
-- isn't cached yet, show a placeholder and re-paint this row from the
-- ContinueOnItemLoad callback (guarded on rollID: rows are pooled, so the
-- callback must no-op if the row has since been reused for another roll).
local item = itemLink and Item:CreateFromItemLink(itemLink)
if item and not item:IsItemEmpty() then
if item:IsItemDataCached() then
RenderItemVisual(f, item)
else
ShowRetrieving(f)
local pending = rollID
item:ContinueOnItemLoad(function()
if f.rollID == pending then RenderItemVisual(f, item) end
end)
end
else
ShowRetrieving(f)
end
-- winner summary only on a decided, collapsed row
if isDone and not isExpanded then
if winnerIdx then
local wname, wclass, wrollType, wroll = C_LootHistory.GetPlayerInfo(i, winnerIdx)
f.winicon:SetTexture(ROLL_TEX[wrollType] or ROLL_TEX[ROLL_NEED])
f.winicon:Show()
if wroll and wroll > 0 then f.winroll:SetText(wroll) else f.winroll:SetText("") end
f.winroll:Show()
f.winname:SetText(wname or UNKNOWN)
f.winname:SetTextColor(PFUI_CLASS_COLORS[wclass]:GetRGB())
f.winname:Show()
else
-- nobody won: everyone passed
f.winicon:SetTexture(ROLL_TEX[ROLL_PASS])
f.winicon:Show()
f.winroll:SetText("")
f.winroll:Show()
f.winname:SetText(T["All players passed"])
f.winname:SetTextColor(1, .4, .4)
f.winname:Show()
end
else
f.winicon:Hide()
f.winroll:Hide()
f.winname:Hide()
end
end
local function RenderPlayerFrame(pf, name, class, rollType, roll, isWinner)
pf.name:SetText(name or UNKNOWN)
pf.name:SetTextColor(PFUI_CLASS_COLORS[class]:GetRGB())
pf.rollicon:SetTexture(ROLL_TEX[rollType] or ROLL_TEX[ROLL_PASS])
if roll and roll > 0 then pf.rolltext:SetText(roll) else pf.rolltext:SetText("") end
if isWinner then pf.winmark:Show() else pf.winmark:Hide() end
end
-- A player row is worth showing while the roll is undecided (see everyone),
-- or afterwards only if they actually rolled or it's you (hide the passers'
-- noise on a decided roll) — mirrors Blizzard's ShouldDisplayPlayer.
local function ShouldDisplayPlayer(isDone, roll, isMe)
return isMe or (roll and roll > 0) or not isDone
end
function FullUpdate()
if not pfUI.loothistory:IsShown() then return end
playerPool:ReleaseAll()
local num = C_LootHistory.GetNumItems()
local y = -2
for i = 1, num do
local f = itemFrames[i] or CreateItemFrame()
itemFrames[i] = f
UpdateItemFrame(f, i)
f:ClearAllPoints()
f:SetPoint("TOPLEFT", list, "TOPLEFT", 4, y)
f:Show()
y = y - ITEM_H - 2
if f.rollID and expanded[f.rollID] then
for p = 1, f.numPlayers do
local name, class, rollType, roll, isWinner, isMe = C_LootHistory.GetPlayerInfo(i, p)
if ShouldDisplayPlayer(f.isDone, roll, isMe) then
local pf = playerPool:Acquire()
RenderPlayerFrame(pf, name, class, rollType, roll, isWinner)
pf:ClearAllPoints()
pf:SetPoint("TOPLEFT", list, "TOPLEFT", 22, y)
pf:Show()
y = y - PLAYER_H
end
end
y = y - 2
end
end
for i = num + 1, table.getn(itemFrames) do
itemFrames[i]:Hide()
end
-- Resize the scroll child and re-attach it: SetHeight alone on a
-- SetAllPoints'd child doesn't make the ScrollFrame recompute its scroll
-- range, so a dynamically-grown list wouldn't scroll until a /reload.
list:SetHeight(math.max(1, -y + 2))
pfUI.loothistory.scroll:SetScrollChild(list)
pfUI.loothistory.scroll:UpdateScrollState()
end
pfUI.loothistory:SetScript("OnShow", function() FullUpdate() end)
-- ==========================================================================
-- Events
-- ==========================================================================
local events = CreateFrame("Frame")
events:RegisterEvent("LOOT_HISTORY_FULL_UPDATE")
events:RegisterEvent("LOOT_HISTORY_ROLL_CHANGED")
events:RegisterEvent("LOOT_HISTORY_ROLL_COMPLETE")
events:SetScript("OnEvent", function()
-- auto-show on a new roll opening / completing, if enabled
if C.loothistory.autoshow == "1"
and (event == "LOOT_HISTORY_FULL_UPDATE" or event == "LOOT_HISTORY_ROLL_COMPLETE")
and not pfUI.loothistory:IsShown() then
pfUI.loothistory:Show() -- OnShow runs FullUpdate
return
end
FullUpdate() -- no-op while hidden
end)
-- ==========================================================================
-- Slash command
-- ==========================================================================
local function Toggle()
pfUI.loothistory:SetShown(not pfUI.loothistory:IsShown())
end
pfUI.api.RegisterSlashCommand("PFLOOTHISTORY", { "/loothistory", "/pfloothistory" }, Toggle, true)
end)
modules/macroicons.lua
+128
View File
@@ -0,0 +1,128 @@
-- Macro icon picker
-- Replaces Blizzard's MacroPopupFrame (the "name + icon" dialog opened by the
-- New / Change-Icon buttons) with a pfUI-native picker driven by
-- IconDataProviderMixin, so the full spell + item + loose icon set is
-- available instead of the stock spell-only list. Saving goes through
-- C_Macro.CreateMacro / C_Macro.EditMacro, which take the icon as a texture
-- string -- so arbitrary icons (including index-less INV_* item icons) persist
-- on both the modern (Turtle/Octo) and stock-vanilla macro UIs. The surrounding
-- MacroFrame (list + body editor) is Blizzard's, already skinned elsewhere.
pfUI:RegisterModule("macroicons", function ()
HookAddonOrVariable("Blizzard_MacroUI", function()
-- ============================================================
-- Popup frame
-- ============================================================
local picker = CreateFrame("Frame", "pfMacroIconPicker", UIParent)
picker:SetFrameStrata("DIALOG")
picker:SetSize(472, 484)
-- Starts anchored to the right of the macro panel (re-anchored at open
-- once the skin's backdrop exists); dragging pins it in place after.
picker:SetPoint("BOTTOMLEFT", MacroFrame, "BOTTOMRIGHT", 8, 0)
picker:Hide()
CreateBackdrop(picker, nil, nil, .9)
CreateBackdropShadow(picker)
picker:EnableMouse(true)
picker:SetMovable(true)
picker:RegisterForDrag("LeftButton")
picker:SetScript("OnDragStart", function() this:StartMoving() end)
picker:SetScript("OnDragStop", function()
this:StopMovingOrSizing()
this.userMoved = true
end)
-- Spellbook seed leads the grid with class-relevant spell/talent icons.
local iconPicker = CreateIconPicker("pfMacroIcon", picker,
IconDataProviderExtraType.Spellbook, MACRO_POPUP_TEXT)
-- ============================================================
-- Open / save
-- ============================================================
-- Blizzard's popup disables these while it is open; mirror that so the
-- underlying frame can't be double-driven, then let MacroFrame_Update
-- restore the correct states on close.
local function SetMacroButtons(enabled)
local m = enabled and "Enable" or "Disable"
MacroNewButton[m](MacroNewButton)
MacroEditButton[m](MacroEditButton)
MacroDeleteButton[m](MacroDeleteButton)
end
local function OpenMacroPopup(mode)
if mode == "edit" and MacroFrame.selectedMacro then
picker.mode = "edit"
local name, texture = GetMacroInfo(MacroFrame.selectedMacro)
picker.editbox:SetText(name or "")
iconPicker.SetIcon(texture)
else
picker.mode = "new"
picker.editbox:SetText("")
iconPicker.SetIcon(nil)
end
picker.search:SetText("")
if not picker.userMoved then
picker:ClearAllPoints()
picker:SetPoint("BOTTOMLEFT", MacroFrame.backdrop or MacroFrame, "BOTTOMRIGHT", 8, 0)
end
SetMacroButtons(false)
picker:Show()
picker.editbox:SetFocus()
iconPicker.Refresh()
end
local function SaveMacroPopup()
local text = picker.editbox:GetText()
if text == "" then return end
local icon = iconPicker.GetIcon()
if picker.mode == "edit" and MacroFrame.selectedMacro then
C_Macro.EditMacro(MacroFrame.selectedMacro, text, icon, nil)
MacroFrame_SelectMacro(MacroFrame.selectedMacro)
else
local idx = C_Macro.CreateMacro(text, icon, nil, (MacroFrame.macroBase or 0) > 0)
if idx then MacroFrame_SelectMacro(idx) end
end
picker:Hide()
end
picker:SetScript("OnHide", function() MacroFrame_Update() end)
picker.editbox:SetScript("OnEnterPressed", SaveMacroPopup)
picker.editbox:SetScript("OnEscapePressed", function() picker:Hide() end)
-- OK / Cancel
local okay = CreateFrame("Button", "pfMacroIconPickerOkay", picker, "UIPanelButtonTemplate")
okay:SetSize(80, 22)
okay:SetText(OKAY)
okay:SetScript("OnClick", SaveMacroPopup)
SkinButton(okay)
local cancel = CreateFrame("Button", "pfMacroIconPickerCancel", picker, "UIPanelButtonTemplate")
cancel:SetSize(80, 22)
cancel:SetText(CANCEL)
cancel:SetPoint("BOTTOMRIGHT", picker, "BOTTOMRIGHT", -14, 12)
cancel:SetScript("OnClick", function() picker:Hide() end)
SkinButton(cancel)
-- Okay | Cancel, both anchored to the bottom-right corner.
okay:SetPoint("BOTTOMRIGHT", cancel, "BOTTOMLEFT", -6, 0)
-- ============================================================
-- Take over the New / Change-Icon buttons; retire Blizzard's popup
-- ============================================================
MacroNewButton:SetScript("OnClick", function()
MacroFrame_SaveMacro()
OpenMacroPopup("new")
end)
MacroEditButton:SetScript("OnClick", function()
MacroFrame_SaveMacro()
OpenMacroPopup("edit")
end)
-- Closing the macro window takes the picker with it.
MacroFrame:HookScript("OnHide", function() picker:Hide() end)
end)
end)
modules/macrotweak.lua
-70
View File
@@ -1,70 +0,0 @@
pfUI:RegisterModule("macrotweak", function ()
local conflictAddons = { "Supermacro", "SuperCleveRoidMacros", "UltimaMacros" }
local disabled = false
local function CheckConflicts()
for _, name in pairs(conflictAddons) do
if IsAddOnLoaded(name) then
DEFAULT_CHAT_FRAME:AddMessage("|cff33ffccpfUI|r: " .. name .. " found, macrotweak disabled.")
disabled = true
return true
end
end
return false
end
-- do not write macro calls into chat input history
if ChatFrameEditBox._AddHistoryLine then
local userinput
ChatFrameEditBox._AddHistoryLine = ChatFrameEditBox.AddHistoryLine
ChatFrameEditBox.AddHistoryLine = function(self, text)
if disabled then return ChatFrameEditBox._AddHistoryLine(self, text) end
if not userinput and text and string.find(text, "^/run(.+)") then return end
if not userinput and string.find(text, "^/script(.+)") then return end
if not userinput and string.find(text, "^/cast(.+)") then return end
ChatFrameEditBox._AddHistoryLine(self, text)
end
local OnEnter = ChatFrameEditBox:GetScript("OnEnterPressed")
ChatFrameEditBox:SetScript("OnEnterPressed", function(a1,a2,a3,a4)
userinput = true
OnEnter(a1,a2,a3,a4)
userinput = nil
end)
end
-- make sure #showtooltip inside macros won't be sent
local hookSendChatMessage = SendChatMessage
function _G.SendChatMessage(msg, ...)
if disabled then return hookSendChatMessage(msg, unpack(arg)) end
if msg and string.find(msg, "^#showtooltip ") then return end
hookSendChatMessage(msg, unpack(arg))
end
-- add /use and /equip to the macro api:
-- https://wowwiki.fandom.com/wiki/Making_a_macro
-- supported arguments:
-- /use <itemname>
-- /use <inventory slot>
-- /use <bag> <slot>
pfUI.api.RegisterSlashCommand("PFUSE", { "/equip" , "/use", "/pfequip", "/pfuse" }, function (msg)
if not msg or msg == "" then return end
local bag, slot, _
if string.find(msg, "%d+%s+%d+") then
_, _, bag, slot = string.find(msg, "(%d+)%s+(%d+)")
elseif string.find(msg, "%d+") then
_, _, slot = string.find(msg, "(%d+)")
else
bag, slot = FindItem(msg)
end
if bag and slot then
UseContainerItem(bag, slot)
elseif not bag and slot then
UseInventoryItem(slot)
end
end)
-- Check conflicts after one tick so all addons have finished loading
RunNextFrame(CheckConflicts)
end)
modules/map.lua
+17 -17
View File
@@ -25,11 +25,7 @@ pfUI:RegisterModule("map", function ()
pfUI.map = { UpdateConfig = UpdateTooltipScale } pfUI.map = { UpdateConfig = UpdateTooltipScale }
function _G.ToggleWorldMap() function _G.ToggleWorldMap()
if WorldMapFrame:IsShown() then WorldMapFrame:SetShown(not WorldMapFrame:IsShown())
WorldMapFrame:Hide()
else
WorldMapFrame:Show()
end
end end
C.position["WorldMapFrame"] = C.position["WorldMapFrame"] or { alpha = 1.0, scale = 0.7 } C.position["WorldMapFrame"] = C.position["WorldMapFrame"] or { alpha = 1.0, scale = 0.7 }
@@ -54,7 +50,7 @@ pfUI:RegisterModule("map", function ()
if not this.hooked then if not this.hooked then
this.hooked = true this.hooked = true
HookScript(WorldMapFrame, "OnShow", function() WorldMapFrame:HookScript("OnShow", function()
-- customize -- customize
this:EnableKeyboard(false) this:EnableKeyboard(false)
this:EnableMouseWheel(1) this:EnableMouseWheel(1)
@@ -66,7 +62,7 @@ pfUI:RegisterModule("map", function ()
pfOrigSetMapToCurrentZone() pfOrigSetMapToCurrentZone()
end) end)
HookScript(WorldMapFrame, "OnMouseWheel", function() WorldMapFrame:HookScript("OnMouseWheel", function()
if IsShiftKeyDown() then if IsShiftKeyDown() then
alpha = clamp(WorldMapFrame:GetAlpha() + arg1/10, 0.1, 1.0) alpha = clamp(WorldMapFrame:GetAlpha() + arg1/10, 0.1, 1.0)
WorldMapFrame:SetAlpha(alpha) WorldMapFrame:SetAlpha(alpha)
@@ -81,7 +77,13 @@ pfUI:RegisterModule("map", function ()
if point == "TOPLEFT" and relpoint == "TOPLEFT" then if point == "TOPLEFT" and relpoint == "TOPLEFT" then
offx = offx*oldscale/scale offx = offx*oldscale/scale
offy = offy*oldscale/scale offy = offy*oldscale/scale
WorldMapFrame:SetPoint(point, rel, relpoint, offx, offy) -- Anchor to the parent (3-arg SetPoint) rather than re-using the frame
-- GetPoint handed back. Re-anchoring to `rel` throws
-- "<unnamed> is dependent on this" as soon as anything else has anchored
-- itself to WorldMapFrame, which aborts the whole zoom handler. The
-- parent-relative form is also what LoadMovable/SaveMovable already
-- assume: SaveMovable stores only xpos/ypos, with no relative frame.
WorldMapFrame:SetPoint(point, offx, offy)
end end
WorldMapFrame:SetScale(scale) WorldMapFrame:SetScale(scale)
@@ -91,11 +93,11 @@ pfUI:RegisterModule("map", function ()
SaveMovable(this, true) SaveMovable(this, true)
end) end)
HookScript(WorldMapFrame, "OnDragStart", function() WorldMapFrame:HookScript("OnDragStart", function()
WorldMapFrame:StartMoving() WorldMapFrame:StartMoving()
end) end)
HookScript(WorldMapFrame, "OnDragStop",function() WorldMapFrame:HookScript("OnDragStop",function()
WorldMapFrame:StopMovingOrSizing() WorldMapFrame:StopMovingOrSizing()
SaveMovable(this, true) SaveMovable(this, true)
end) end)
@@ -107,8 +109,8 @@ pfUI:RegisterModule("map", function ()
WorldMapFrame:ClearAllPoints() WorldMapFrame:ClearAllPoints()
WorldMapFrame:SetPoint("CENTER", UIParent, "CENTER", 0, 0) WorldMapFrame:SetPoint("CENTER", UIParent, "CENTER", 0, 0)
WorldMapFrame:SetWidth(WorldMapButton:GetWidth() + 15) local wmWidth, wmHeight = WorldMapButton:GetSize()
WorldMapFrame:SetHeight(WorldMapButton:GetHeight() + 55) WorldMapFrame:SetSize(wmWidth + 15, wmHeight + 55)
LoadMovable(WorldMapFrame) LoadMovable(WorldMapFrame)
-- skin -- skin
@@ -130,8 +132,7 @@ pfUI:RegisterModule("map", function ()
btn:SetHighlightTexture("") btn:SetHighlightTexture("")
btn.text = _G["pfUI_map_autozoneswitchText"] btn.text = _G["pfUI_map_autozoneswitchText"]
CreateBackdrop(btn, nil, true) CreateBackdrop(btn, nil, true)
btn:SetWidth(14) btn:SetSize(14, 14)
btn:SetHeight(14)
btn:SetPoint("RIGHT", WorldMapContinentDropDown, "LEFT", -8, 2) btn:SetPoint("RIGHT", WorldMapContinentDropDown, "LEFT", -8, 2)
btn.text:ClearAllPoints() btn.text:ClearAllPoints()
btn.text:SetPoint("RIGHT", btn, "LEFT", -4, 1) btn.text:SetPoint("RIGHT", btn, "LEFT", -4, 1)
@@ -169,8 +170,7 @@ pfUI:RegisterModule("map", function ()
WorldMapButton.coords.text:SetJustifyH("RIGHT") WorldMapButton.coords.text:SetJustifyH("RIGHT")
WorldMapButton.coords:SetScript("OnUpdate", function() WorldMapButton.coords:SetScript("OnUpdate", function()
local width = WorldMapButton:GetWidth() local width, height = WorldMapButton:GetSize()
local height = WorldMapButton:GetHeight()
local mx, my = WorldMapButton:GetCenter() local mx, my = WorldMapButton:GetCenter()
local scale = WorldMapButton:GetEffectiveScale() local scale = WorldMapButton:GetEffectiveScale()
local x, y = GetCursorPosition() local x, y = GetCursorPosition()
@@ -181,7 +181,7 @@ pfUI:RegisterModule("map", function ()
end end
if mx and my and MouseIsOver(WorldMapButton) then if mx and my and MouseIsOver(WorldMapButton) then
WorldMapButton.coords.text:SetText(string.format('%.1f / %.1f', mx, my)) WorldMapButton.coords.text:SetFormattedText('%.1f / %.1f', mx, my)
else else
WorldMapButton.coords.text:SetText("") WorldMapButton.coords.text:SetText("")
end end
modules/mapcolors.lua
+5 -5
View File
@@ -85,7 +85,7 @@ pfUI:RegisterModule("mapcolors", function ()
end end
local function ColorizeName(frame) local function ColorizeName(frame)
local _, class = UnitClass(frame.unit) local class = UnitClassBase(frame.unit)
local color = PFUI_CLASS_COLORS[class] local color = PFUI_CLASS_COLORS[class]
frame.name = frame.name or UnitName(frame.unit) frame.name = frame.name or UnitName(frame.unit)
frame.name = '|c'..color.colorStr..frame.name..'|r' frame.name = '|c'..color.colorStr..frame.name..'|r'
@@ -125,13 +125,13 @@ pfUI:RegisterModule("mapcolors", function ()
-- WorldMap -- WorldMap
Initialize('WorldMap') Initialize('WorldMap')
pfUI.hooksecurefunc('WorldMapButton_OnUpdate', function() hooksecurefunc('WorldMapButton_OnUpdate', function()
if ( this.tick or .5) > GetTime() then return else this.tick = GetTime() + .5 end if ( this.tick or .5) > GetTime() then return else this.tick = GetTime() + .5 end
UpdateUnitFrames('WorldMap') UpdateUnitFrames('WorldMap')
end) end)
if C.appearance.worldmap.colornames == "1" then if C.appearance.worldmap.colornames == "1" then
pfUI.hooksecurefunc('WorldMapUnit_OnEnter', function() hooksecurefunc('WorldMapUnit_OnEnter', function()
if ( this.tick or .5) > GetTime() then return else this.tick = GetTime() + .5 end if ( this.tick or .5) > GetTime() then return else this.tick = GetTime() + .5 end
UpdateUnitColors('WorldMap', WorldMapTooltip) UpdateUnitColors('WorldMap', WorldMapTooltip)
end) end)
@@ -141,13 +141,13 @@ pfUI:RegisterModule("mapcolors", function ()
HookAddonOrVariable("Blizzard_BattlefieldMinimap", function() HookAddonOrVariable("Blizzard_BattlefieldMinimap", function()
Initialize('BattlefieldMinimap') Initialize('BattlefieldMinimap')
pfUI.hooksecurefunc('BattlefieldMinimap_OnUpdate', function() hooksecurefunc('BattlefieldMinimap_OnUpdate', function()
if ( this.tick or .5) > GetTime() then return else this.tick = GetTime() + .5 end if ( this.tick or .5) > GetTime() then return else this.tick = GetTime() + .5 end
UpdateUnitFrames('BattlefieldMinimap') UpdateUnitFrames('BattlefieldMinimap')
end) end)
if C.appearance.worldmap.colornames == "1" then if C.appearance.worldmap.colornames == "1" then
pfUI.hooksecurefunc('BattlefieldMinimapUnit_OnEnter', function() hooksecurefunc('BattlefieldMinimapUnit_OnEnter', function()
if ( this.tick or .5) > GetTime() then return else this.tick = GetTime() + .5 end if ( this.tick or .5) > GetTime() then return else this.tick = GetTime() + .5 end
UpdateUnitColors('BattlefieldMinimap', GameTooltip) UpdateUnitColors('BattlefieldMinimap', GameTooltip)
end) end)
modules/mapreveal.lua
+71 -109
View File
@@ -30,39 +30,14 @@ pfUI:RegisterModule("mapreveal", function ()
pfUI.mapreveal:UpdateConfig() pfUI.mapreveal:UpdateConfig()
end) end)
local function unpack_hash(prefix, hash)
local _, stored_prefix, textureName, textureWidth, textureHeight, offsetX, offsetY, mapPointX, mapPointY, name
_, _, stored_prefix, textureName, textureWidth, textureHeight, offsetX, offsetY = string.find(hash, "^([|]?)([^:]+):([^:]+):([^:]+):([^:]+):([^:]+)")
if (not textureName or not offsetY) then
return
end
if (offsetY) then
_, _, mapPointX, mapPointY = string.find(hash,"^[|]?[^:]+:[^:]+:[^:]+:[^:]+:[^:]+:([^:]+):([^:]+)")
end
if (not mapPointY) then
mapPointX = 0 mapPointY = 0
end
if (stored_prefix ~= "|") then
name = textureName
textureName = string.format("%s%s",prefix,textureName)
end
return textureName, textureWidth + 0, textureHeight + 0, offsetX + 0, offsetY + 0, mapPointX + 0, mapPointY + 0, name
end
local explores = {}
local explorecaches = {} local explorecaches = {}
local alreadyknown = {} -- per-zone accumulator: { [zone] = { [texName] = true } } local alreadyknown = {} -- per-zone accumulator: { [zone] = { [texName] = true } }
-- Own texture pool - separate from Blizzard's WorldMapOverlay textures -- Own texture pool - separate from Blizzard's WorldMapOverlay textures
local pfOverlays = {} local overlayPool = CreateTexturePool(WorldMapDetailFrame, "BORDER", nil, nil, function(_, tex)
local pfOverlayMax = 0 tex:Hide()
tex:ClearAllPoints()
local function pfGetOverlay(idx) end)
if not pfOverlays[idx] then
pfOverlays[idx] = WorldMapDetailFrame:CreateTexture("pfReveal"..idx, "BORDER")
end
return pfOverlays[idx]
end
local exploreEnter = function() local exploreEnter = function()
WorldMapTooltip:ClearLines() WorldMapTooltip:ClearLines()
@@ -71,44 +46,60 @@ pfUI:RegisterModule("mapreveal", function ()
WorldMapTooltip:AddLine(this.name, 1, 1, 1) WorldMapTooltip:AddLine(this.name, 1, 1, 1)
WorldMapTooltip:Show() WorldMapTooltip:Show()
if not explorecaches[this.name] then return end if not explorecaches[this.area] then return end
if C.appearance.worldmap.mapreveal == "0" then return end if C.appearance.worldmap.mapreveal == "0" then return end
for texture in pairs(explorecaches[this.name]) do for texture in pairs(explorecaches[this.area]) do
texture:SetVertexColor(1,1,1,1) texture:SetVertexColor(1,1,1,1)
end end
end end
local exploreLeave = function() local exploreLeave = function()
WorldMapTooltip:Hide() WorldMapTooltip:Hide()
if not explorecaches[this.name] then return end if not explorecaches[this.area] then return end
if C.appearance.worldmap.mapreveal == "0" then return end if C.appearance.worldmap.mapreveal == "0" then return end
local r,g,b,a = GetStringColor(C.appearance.worldmap.mapreveal_color) local r,g,b,a = GetStringColor(C.appearance.worldmap.mapreveal_color)
for texture in pairs(explorecaches[this.name]) do for texture in pairs(explorecaches[this.area]) do
texture:SetVertexColor(r,g,b,a) texture:SetVertexColor(r,g,b,a)
end end
end end
-- overlay data with lazy init -- Magnifying-glass icons for unexplored overlays. Everything constant lives
local overlayData = setmetatable(pfMapOverlayData, {__index = function(t,k) -- in the creator; the update only anchors and labels what it acquires -- and
local v = {} -- it only acquires the ones it is going to show, where the old table grew an
rawset(t,k,v) -- icon for every overlay in the zone and hid most of them again.
return v local function CreateExplore()
end}) local explore = CreateFrame("Frame", nil, WorldMapDetailFrame)
explore:SetSize(16, 16)
explore:SetScript("OnEnter", exploreEnter)
explore:SetScript("OnLeave", exploreLeave)
explore:EnableMouse(true)
explore:SetFrameLevel(255)
explore.tex = explore:CreateTexture(nil, "OVERLAY")
explore.tex:SetTexture("Interface\\WorldMap\\WorldMap-MagnifyingGlass")
explore.tex:SetBlendMode("ADD")
explore.tex:SetTexCoord(.08, .92, .08, .92)
explore.tex:SetAllPoints()
return explore
end
local explorePool = CreateObjectPool(CreateExplore, function(_, explore)
explore:Hide()
explore:ClearAllPoints()
end)
local function pfWorldMapFrame_Update() local function pfWorldMapFrame_Update()
-- clear stale caches -- clear stale caches
for k in pairs(explorecaches) do explorecaches[k] = nil end for k in pairs(explorecaches) do explorecaches[k] = nil end
-- hide all our textures from last frame -- hide all our textures from last frame
for i = 1, pfOverlayMax do overlayPool:ReleaseAll()
pfOverlays[i]:Hide()
end
local r,g,b,a = GetStringColor(C.appearance.worldmap.mapreveal_color) local r,g,b,a = GetStringColor(C.appearance.worldmap.mapreveal_color)
local mapFileName = GetMapInfo() local mapFileName = GetMapInfo()
if not mapFileName then mapFileName = "World" end if not mapFileName then mapFileName = "World" end
local prefix = string.format("Interface\\WorldMap\\%s\\", mapFileName)
local numOverlays = GetNumMapOverlays() local numOverlays = GetNumMapOverlays()
-- accumulate explored overlays per zone (never clear, only add) -- accumulate explored overlays per zone (never clear, only add)
@@ -121,88 +112,59 @@ pfUI:RegisterModule("mapreveal", function ()
local zoneKnown = alreadyknown[mapFileName] local zoneKnown = alreadyknown[mapFileName]
-- hide explore icons -- hide explore icons
for _, frame in pairs(explores) do frame:Hide() end explorePool:ReleaseAll()
local zoneData = overlayData[mapFileName] -- ClassicAPI: full overlay list for the viewed zone (explored + unexplored),
local textureCount = 0 -- read straight from WorldMapOverlay.dbc. Replaces the hand-measured pfMapOverlayData.
local zoneData = C_Map.GetMapOverlays() or {}
for i, hash in ipairs(zoneData) do for _, overlay in ipairs(zoneData) do
local textureName, textureWidth, textureHeight, offsetX, offsetY, mapPointX, mapPointY, name = unpack_hash(prefix, hash) local name = overlay.textureName -- bare, e.g. "DRYGULCHRAVINE"
if not textureName then break end local textureName = overlay.texturePath -- full engine path (for SetTexture)
local textureWidth = overlay.textureWidth
-- explore magnifying glass icon local textureHeight = overlay.textureHeight
explores[i] = explores[i] or CreateFrame("Frame", nil, WorldMapDetailFrame) local offsetX = overlay.offsetX
local explore = explores[i] local offsetY = overlay.offsetY
explore:SetWidth(16)
explore:SetHeight(16)
explore:SetPoint("TOPLEFT", "WorldMapDetailFrame", "TOPLEFT", offsetX + textureWidth/2, -offsetY - textureHeight/2)
explore:SetScript("OnEnter", exploreEnter)
explore:SetScript("OnLeave", exploreLeave)
explore:EnableMouse(true)
explore:SetFrameLevel(255)
explore.name = mapFileName .. " (" .. name .. ")"
explore.tex = explore.tex or explore:CreateTexture("", "OVERLAY")
explore.tex:SetBlendMode("ADD")
explore.tex:SetTexCoord(.08, .92, .08, .92)
explore.tex:SetAllPoints()
-- explore magnifying glass icon. `alreadyknown` stores the FULL paths
-- GetMapOverlayInfo returns, so compare with the full path, not the bare
-- name.
if C.appearance.worldmap.mapexploration == "1" and not zoneKnown[string.upper(textureName)] then if C.appearance.worldmap.mapexploration == "1" and not zoneKnown[string.upper(textureName)] then
explore.tex:SetTexture("Interface\\WorldMap\\WorldMap-MagnifyingGlass") local explore = explorePool:Acquire()
explore:SetPoint("TOPLEFT", "WorldMapDetailFrame", "TOPLEFT", offsetX + textureWidth/2, -offsetY - textureHeight/2)
explore.name = mapFileName .. " (" .. name .. ")"
explore.area = name -- cache key: explorecaches is keyed by the plain area name
explore:Show() explore:Show()
else
explore:Hide()
end end
-- render overlay texture tiles on BORDER draw layer -- render overlay texture tiles on BORDER draw layer
-- Blizzard's explored overlays on ARTWORK draw on top of BORDER -- Blizzard's explored overlays on ARTWORK draw on top of BORDER
--
-- overlay.tiles is pre-resolved by ClassicAPI: per-tile file /
-- draw size / texcoords / canvas position, with Octo's data
-- quirks (sliver columns the DBC rect rounds away, foreign tiles
-- appended to the number sequence, upscaled re-exports) already
-- disambiguated from the actual BLP dimensions. No 256px grid
-- math here — deriving the grid from textureWidth/Height is
-- exactly what shears quirky overlays (e.g. Icepoint's Kaneq'nuun).
if C.appearance.worldmap.mapreveal == "1" then if C.appearance.worldmap.mapreveal == "1" then
local numH = math.ceil(textureWidth / 256) for _, tile in ipairs(overlay.tiles) do
local numV = math.ceil(textureHeight / 256) local tex = overlayPool:Acquire()
local texPixW, texFileW, texPixH, texFileH
for j = 1, numV do tex:SetSize(tile.width, tile.height)
if j < numV then tex:SetTexCoord(0, tile.texCoordX, 0, tile.texCoordY)
texPixH = 256 tex:ClearAllPoints()
texFileH = 256 tex:SetPoint("TOPLEFT", "WorldMapDetailFrame", "TOPLEFT", tile.offsetX, -tile.offsetY)
else tex:SetTexture(tile.file)
texPixH = mod(textureHeight, 256)
if texPixH == 0 then texPixH = 256 end
texFileH = 16
while texFileH < texPixH do texFileH = texFileH * 2 end
end
for k = 1, numH do explorecaches[name] = explorecaches[name] or {}
textureCount = textureCount + 1 explorecaches[name][tex] = true
local tex = pfGetOverlay(textureCount)
if k < numH then tex:SetVertexColor(r,g,b,a)
texPixW = 256 tex:Show()
texFileW = 256
else
texPixW = mod(textureWidth, 256)
if texPixW == 0 then texPixW = 256 end
texFileW = 16
while texFileW < texPixW do texFileW = texFileW * 2 end
end
tex:SetWidth(texPixW)
tex:SetHeight(texPixH)
tex:SetTexCoord(0, texPixW/texFileW, 0, texPixH/texFileH)
tex:ClearAllPoints()
tex:SetPoint("TOPLEFT", "WorldMapDetailFrame", "TOPLEFT", offsetX + 256*(k-1), -(offsetY + 256*(j-1)))
tex:SetTexture(string.format("%s%s", textureName, ((j-1)*numH + k)))
explorecaches[name] = explorecaches[name] or {}
explorecaches[name][tex] = true
tex:SetVertexColor(r,g,b,a)
tex:Show()
end
end end
end end
end end
pfOverlayMax = math.max(pfOverlayMax, textureCount)
end end
-- hook WorldMapFrame_Update -- hook WorldMapFrame_Update
modules/marktracking.lua
+85 -71
View File
@@ -1,58 +1,30 @@
pfUI:RegisterNewModule("marktracking", "Mark Tracker")
pfUI:RegisterModule("marktracking", function () pfUI:RegisterModule("marktracking", function ()
-- Requires mark1-mark8 unit tokens (Turtle WoW / Nampower)
if not UnitExists("mark1") and not UnitExists("mark8") then
if not pcall(function() UnitExists("mark1") end) then return end
end
local rawborder, border = GetBorderSize() local rawborder, border = GetBorderSize()
-- Parse color strings "r,g,b,a" into components
local function ParseColor(str, dr, dg, db, da)
if not str or str == "" then return dr, dg, db, da end
local _, _, r, g, b, a = string.find(str, "([%d%.]+),([%d%.]+),([%d%.]+),([%d%.]+)")
if r then
return tonumber(r) or dr, tonumber(g) or dg, tonumber(b) or db, tonumber(a) or da
end
return dr, dg, db, da
end
local markerOrder = { 8, 7, 6, 5, 4, 3, 2, 1 } -- skull, cross, square, moon, triangle, diamond, circle, star local markerOrder = { 8, 7, 6, 5, 4, 3, 2, 1 } -- skull, cross, square, moon, triangle, diamond, circle, star
local markerTokens = {} local markerTokens = {} -- [i] = "markN"
for i = 1, 8 do markerTokens[i] = "mark" .. i end local markerIndex = {} -- ["markN"] = i, for the event handler's arg1
-- Default colors per marker
local defaultColors = {
[1] = { 1.0, 0.9, 0.0, 1 }, -- star: yellow
[2] = { 1.0, 0.5, 0.0, 1 }, -- circle: orange
[3] = { 0.8, 0.0, 0.8, 1 }, -- diamond: purple
[4] = { 0.0, 0.8, 0.0, 1 }, -- triangle: green
[5] = { 0.7, 0.7, 0.7, 1 }, -- moon: silver
[6] = { 0.0, 0.4, 0.9, 1 }, -- square: blue
[7] = { 0.9, 0.0, 0.0, 1 }, -- cross: red
[8] = { 1.0, 1.0, 1.0, 1 }, -- skull: white
}
local markerConfigKeys = { local markerConfigKeys = {
[1] = "raidmarkercolor_star", "raidmarkercolor_star",
[2] = "raidmarkercolor_circle", "raidmarkercolor_circle",
[3] = "raidmarkercolor_diamond", "raidmarkercolor_diamond",
[4] = "raidmarkercolor_triangle", "raidmarkercolor_triangle",
[5] = "raidmarkercolor_moon", "raidmarkercolor_moon",
[6] = "raidmarkercolor_square", "raidmarkercolor_square",
[7] = "raidmarkercolor_cross", "raidmarkercolor_cross",
[8] = "raidmarkercolor_skull", "raidmarkercolor_skull",
} }
local markerColors = {} local markerColors = {}
for i = 1, 8 do for i, markKey in ipairs(markerConfigKeys) do
local d = defaultColors[i] markerTokens[i] = "mark" .. i
local r, g, b, a = ParseColor(C.unitframes[markerConfigKeys[i]], d[1], d[2], d[3], d[4]) markerIndex[markerTokens[i]] = i
markerColors[i] = { r, g, b, a } local r, g, b, a = GetStringColor(C.unitframes[markKey])
markerColors[i] = { tonumber(r), tonumber(g), tonumber(b), tonumber(a) }
end end
local FALLBACK_INTERVAL = 1.0 -- safety net for units that come into range after marker was set local FALLBACK_INTERVAL = 1.0 -- safety net for units that come into range after marker was set
local elapsed = 0
local isUnlocked = false local isUnlocked = false
local ROW_HEIGHT = tonumber(C.unitframes.raidmarkerheight) or 14 local ROW_HEIGHT = tonumber(C.unitframes.raidmarkerheight) or 14
local BAR_WIDTH = tonumber(C.unitframes.raidmarkerwidth) or 80 local BAR_WIDTH = tonumber(C.unitframes.raidmarkerwidth) or 80
@@ -99,8 +71,7 @@ pfUI.marktracking = CreateFrame("Frame", "pfMarkTracking", UIParent)
else else
pfUI.marktracking:SetPoint("TOP", UIParent, "CENTER", 0, 0) pfUI.marktracking:SetPoint("TOP", UIParent, "CENTER", 0, 0)
end end
pfUI.marktracking:SetWidth(TOTAL_ROW_WIDTH) pfUI.marktracking:SetSize(TOTAL_ROW_WIDTH, 8 * (ROW_HEIGHT + 1) + border * 2 - 1)
pfUI.marktracking:SetHeight(8 * (ROW_HEIGHT + 1) + border * 2 - 1)
pfUI.marktracking:Hide() pfUI.marktracking:Hide()
CreateBackdrop(pfUI.marktracking) CreateBackdrop(pfUI.marktracking)
@@ -126,19 +97,16 @@ pfUI.marktracking = CreateFrame("Frame", "pfMarkTracking", UIParent)
local i = markerOrder[idx] local i = markerOrder[idx]
local row = CreateFrame("Button", nil, pfUI.marktracking) local row = CreateFrame("Button", nil, pfUI.marktracking)
row:SetWidth(TOTAL_ROW_WIDTH) row:SetSize(TOTAL_ROW_WIDTH, ROW_HEIGHT)
row:SetHeight(ROW_HEIGHT)
row:Hide() row:Hide()
row:RegisterForClicks("LeftButtonUp") row:RegisterForClicks("LeftButtonUp", "RightButtonUp")
row:SetScript("OnClick", function() row:SetAttribute("type1", "target")
TargetUnit(markerTokens[this.markerIndex]) row:SetAttribute("type2", "menu")
end)
-- raid icon -- raid icon
row.icon = row:CreateTexture(nil, "ARTWORK") row.icon = row:CreateTexture(nil, "ARTWORK")
row.icon:SetWidth(ROW_HEIGHT) row.icon:SetSize(ROW_HEIGHT, ROW_HEIGHT)
row.icon:SetHeight(ROW_HEIGHT)
row.icon:SetPoint("LEFT", row, "LEFT", 1, 0) row.icon:SetPoint("LEFT", row, "LEFT", 1, 0)
local markTex = C.unitframes.blizzard_raidicons == "1" and "Interface\\TargetingFrame\\UI-RaidTargetingIcons" or pfUI.media["img:raidicons"] local markTex = C.unitframes.blizzard_raidicons == "1" and "Interface\\TargetingFrame\\UI-RaidTargetingIcons" or pfUI.media["img:raidicons"]
row.icon:SetTexture(markTex) row.icon:SetTexture(markTex)
@@ -146,8 +114,7 @@ pfUI.marktracking = CreateFrame("Frame", "pfMarkTracking", UIParent)
-- portrait (right side) -- portrait (right side)
row.portrait = row:CreateTexture(nil, "ARTWORK") row.portrait = row:CreateTexture(nil, "ARTWORK")
row.portrait:SetWidth(PORTRAIT_SIZE) row.portrait:SetSize(PORTRAIT_SIZE, PORTRAIT_SIZE)
row.portrait:SetHeight(PORTRAIT_SIZE)
row.portrait:SetPoint("RIGHT", row, "RIGHT", -1, 0) row.portrait:SetPoint("RIGHT", row, "RIGHT", -1, 0)
row.portrait:SetTexCoord(.1, .9, .1, .9) row.portrait:SetTexCoord(.1, .9, .1, .9)
if not rm_showportrait then row.portrait:Hide() end if not rm_showportrait then row.portrait:Hide() end
@@ -205,8 +172,8 @@ pfUI.marktracking = CreateFrame("Frame", "pfMarkTracking", UIParent)
local token = markerTokens[i] local token = markerTokens[i]
if UnitExists(token) and not UnitIsDead(token) then if UnitExists(token) and not UnitIsDead(token) then
local hp = UnitHealth(token) local hp, maxhp = UnitHealth(token), UnitHealthMax(token)
local maxhp = UnitHealthMax(token) row:SetAttribute('unit', token)
if hp and maxhp and maxhp > 0 and hp > 0 then if hp and maxhp and maxhp > 0 and hp > 0 then
local pct = hp / maxhp local pct = hp / maxhp
@@ -268,6 +235,27 @@ pfUI.marktracking = CreateFrame("Frame", "pfMarkTracking", UIParent)
end end
end end
-- Fast per-row refresh for a single mark's UNIT_HEALTH/UNIT_MAXHEALTH: moves
-- just the bar + hp text. If the mark's visibility flips (comes into range,
-- dies, hp crosses 0) the visible rows re-pack, so hand off to UpdateDisplay.
local function UpdateRow(i)
if isUnlocked then return end
local row = pfUI.marktracking.rows[i]
if not row then return end
local token = markerTokens[i]
local hp, maxhp = UnitHealth(token), UnitHealthMax(token)
local shouldShow = UnitExists(token) and not UnitIsDead(token)
and hp and maxhp and maxhp > 0 and hp > 0 and true or false
if shouldShow ~= (row:IsShown() and true or false) then
UpdateDisplay()
return
end
if not shouldShow then return end
local pct = hp / maxhp
row.health:SetValue(pct)
if rm_showpct then row.hptext:SetText(math.ceil(pct * 100) .. "%") end
end
-- Unlock mode: show fixed 1-row placeholder so positioning works correctly -- Unlock mode: show fixed 1-row placeholder so positioning works correctly
if pfUI.unlock then if pfUI.unlock then
local origShow = pfUI.unlock:GetScript("OnShow") local origShow = pfUI.unlock:GetScript("OnShow")
@@ -293,24 +281,50 @@ pfUI.marktracking = CreateFrame("Frame", "pfMarkTracking", UIParent)
-- Event-driven scanner frame -- Event-driven scanner frame
local scanner = CreateFrame("Frame") local scanner = CreateFrame("Frame")
-- RAID_TARGET_UPDATE: fires when a raid marker is set/cleared -- Fallback poll: catches units that come into range AFTER a marker was set
-- PLAYER_ENTERING_WORLD: fires on login, reload, and zone transitions -- (no event fires for that case, so we need this safety net). UpdateDisplay
-- UNIT_HEALTH/UNIT_MAXHEALTH: fires on HP changes for real-time bar updates -- is a full eight-row rebuild, so it exists only while grouped -- raid markers
-- are a group feature and there is nothing to discover alone. The group events
-- below start and cancel it, so outside a group there is no timer queued at
-- all rather than one waking every second to return early.
--
-- Deliberately NOT keyed on a mark being visible: a marker set on a unit that
-- is out of range shows no row, and that is exactly what this poll catches.
local poll
local function UpdatePoll()
local grouped = IsInGroup()
if grouped and not poll then
poll = C_Timer.NewTicker(FALLBACK_INTERVAL, UpdateDisplay)
elseif not grouped and poll then
poll:Cancel()
poll = nil
end
end
-- RAID_TARGET_UPDATE: a raid marker was set/cleared -> full refresh
-- PLAYER_ENTERING_WORLD: login/reload/zone -> full refresh
-- PARTY_MEMBERS_CHANGED/RAID_ROSTER_UPDATE: joined or left a group -> the rows
-- can change, and the fallback poll starts or stops with it
-- UNIT_HEALTH/UNIT_MAXHEALTH: filtered to the eight mark tokens, so arg1 is
-- always "markN" and we refresh just that row (UpdateRow) instead of
-- rescanning all eight.
scanner:RegisterEvent("RAID_TARGET_UPDATE") scanner:RegisterEvent("RAID_TARGET_UPDATE")
scanner:RegisterEvent("PLAYER_ENTERING_WORLD") scanner:RegisterEvent("PLAYER_ENTERING_WORLD")
scanner:RegisterEvent("UNIT_HEALTH") scanner:RegisterEvent("PARTY_MEMBERS_CHANGED")
scanner:RegisterEvent("UNIT_MAXHEALTH") scanner:RegisterEvent("RAID_ROSTER_UPDATE")
scanner:RegisterUnitEvent("UNIT_HEALTH", "mark1", "mark2", "mark3", "mark4", "mark5", "mark6", "mark7", "mark8")
scanner:RegisterUnitEvent("UNIT_MAXHEALTH", "mark1", "mark2", "mark3", "mark4", "mark5", "mark6", "mark7", "mark8")
scanner:SetScript("OnEvent", function() scanner:SetScript("OnEvent", function()
UpdateDisplay() if event == "UNIT_HEALTH" or event == "UNIT_MAXHEALTH" then
end) -- arg1 is one of the eight tokens we registered for, so this is a lookup
-- rather than a parse -- string.match would allocate a capture and
-- Fallback poll at 1s: catches units that come into range AFTER a marker was set -- tonumber would parse it, on every health tick of every marked unit.
-- (no event fires for that case, so we need this safety net) local i = arg1 and markerIndex[arg1]
scanner:SetScript("OnUpdate", function() if i then UpdateRow(i) end
elapsed = elapsed + arg1 return
if elapsed < FALLBACK_INTERVAL then return end end
elapsed = 0 if event ~= "RAID_TARGET_UPDATE" then UpdatePoll() end
UpdateDisplay() UpdateDisplay()
end) end)
end) end)
modules/minimap.lua
+18 -37
View File
@@ -33,11 +33,9 @@ pfUI:RegisterModule("minimap", function ()
pfUI.minimap.UpdateConfig = function(self) pfUI.minimap.UpdateConfig = function(self)
size = tonumber(C.appearance.minimap.size) or 140 size = tonumber(C.appearance.minimap.size) or 140
pfUI.minimap:SetWidth(size) pfUI.minimap:SetSize(size, size)
pfUI.minimap:SetHeight(size)
Minimap:SetWidth(size) Minimap:SetSize(size, size)
Minimap:SetHeight(size)
-- vanilla+tbc: do the best to detect the minimap arrow -- vanilla+tbc: do the best to detect the minimap arrow
local arrowscale = tonumber(C.appearance.minimap.arrowscale) local arrowscale = tonumber(C.appearance.minimap.arrowscale)
@@ -58,7 +56,7 @@ pfUI:RegisterModule("minimap", function ()
pfUI.minimap:UpdateConfig() pfUI.minimap:UpdateConfig()
pfUI.hooksecurefunc("ToggleMinimap", function() hooksecurefunc("ToggleMinimap", function()
if pfUI.farmmap and pfUI.farmmap:IsShown() then if pfUI.farmmap and pfUI.farmmap:IsShown() then
Minimap:Hide() Minimap:Hide()
return return
@@ -133,18 +131,16 @@ pfUI:RegisterModule("minimap", function ()
-- Create coordinates text frame with location configurable -- Create coordinates text frame with location configurable
pfUI.minimapCoordinates = CreateFrame("Frame", "pfMinimapCoord", pfUI.minimap) pfUI.minimapCoordinates = CreateFrame("Frame", "pfMinimapCoord", pfUI.minimap)
pfUI.minimapCoordinates:SetScript("OnUpdate", function() -- Update coords every 0.1 seconds
-- Throttle to update coords every 0.1 seconds C_Timer.NewTicker(0.1, function()
if ( this.tick or 0) > GetTime() then return end
this.tick = GetTime() + .1
if C.appearance.minimap.coordstext == "off" then return end if C.appearance.minimap.coordstext == "off" then return end
this.posX, this.posY = GetPlayerMapPosition("player") local coord = pfUI.minimapCoordinates
if this.posX ~= 0 and this.posY ~= 0 then coord.posX, coord.posY = GetPlayerMapPosition("player")
this.text:SetText(string.format("%.1f, %.1f", round(this.posX * 100, 1), round(this.posY * 100, 1))) if coord.posX ~= 0 and coord.posY ~= 0 then
coord.text:SetFormattedText("%.1f, %.1f", round(coord.posX * 100, 1), round(coord.posY * 100, 1))
else else
this.text:SetText("|cffffaaaaN/A") coord.text:SetText("|cffffaaaaN/A")
end end
end) end)
@@ -158,8 +154,7 @@ pfUI:RegisterModule("minimap", function ()
pfUI.minimapCoordinates:SetPoint("BOTTOMLEFT", 3, 3) pfUI.minimapCoordinates:SetPoint("BOTTOMLEFT", 3, 3)
end end
pfUI.minimapCoordinates:SetHeight(C.global.font_size) pfUI.minimapCoordinates:SetSize(Minimap:GetWidth(), C.global.font_size)
pfUI.minimapCoordinates:SetWidth(Minimap:GetWidth())
pfUI.minimapCoordinates.text = pfUI.minimapCoordinates:CreateFontString("MinimapCoordinatesText", "LOW", "GameFontNormal") pfUI.minimapCoordinates.text = pfUI.minimapCoordinates:CreateFontString("MinimapCoordinatesText", "LOW", "GameFontNormal")
pfUI.minimapCoordinates.text:SetFont(pfUI.font_default, C.global.font_size, "OUTLINE") pfUI.minimapCoordinates.text:SetFont(pfUI.font_default, C.global.font_size, "OUTLINE")
pfUI.minimapCoordinates.text:SetTextColor(1,1,1,1) pfUI.minimapCoordinates.text:SetTextColor(1,1,1,1)
@@ -171,19 +166,14 @@ pfUI:RegisterModule("minimap", function ()
pfUI.minimapCoordinates.text:SetJustifyH("LEFT") pfUI.minimapCoordinates.text:SetJustifyH("LEFT")
end end
if C.appearance.minimap.coordstext ~= "on" then pfUI.minimapCoordinates:SetShown(C.appearance.minimap.coordstext == "on")
pfUI.minimapCoordinates:Hide()
else
pfUI.minimapCoordinates:Show()
end
-- Create zone text frame in top center of minimap -- Create zone text frame in top center of minimap
pfUI.minimapZone = CreateFrame("Frame", "pfMinimapZone", pfUI.minimap) pfUI.minimapZone = CreateFrame("Frame", "pfMinimapZone", pfUI.minimap)
pfUI.minimapZone:RegisterEvent("MINIMAP_ZONE_CHANGED") pfUI.minimapZone:RegisterEvent("MINIMAP_ZONE_CHANGED")
pfUI.minimapZone:RegisterEvent("PLAYER_ENTERING_WORLD") pfUI.minimapZone:RegisterEvent("PLAYER_ENTERING_WORLD")
pfUI.minimapZone:SetPoint("TOP", 0, -3) pfUI.minimapZone:SetPoint("TOP", 0, -3)
pfUI.minimapZone:SetHeight(C.global.font_size + 2) pfUI.minimapZone:SetSize(Minimap:GetWidth(), C.global.font_size + 2)
pfUI.minimapZone:SetWidth(Minimap:GetWidth())
pfUI.minimapZone.text = pfUI.minimapZone:CreateFontString("minimapZoneText", "LOW", "GameFontNormal") pfUI.minimapZone.text = pfUI.minimapZone:CreateFontString("minimapZoneText", "LOW", "GameFontNormal")
pfUI.minimapZone.text:SetFont(pfUI.font_default, C.global.font_size + 2, "OUTLINE") pfUI.minimapZone.text:SetFont(pfUI.font_default, C.global.font_size + 2, "OUTLINE")
pfUI.minimapZone.text:SetAllPoints(pfUI.minimapZone) pfUI.minimapZone.text:SetAllPoints(pfUI.minimapZone)
@@ -205,17 +195,13 @@ pfUI:RegisterModule("minimap", function ()
elseif pvp == "contested" then elseif pvp == "contested" then
pfUI.minimapZone.text:SetTextColor(1.0, 0.7, 0) pfUI.minimapZone.text:SetTextColor(1.0, 0.7, 0)
else else
pfUI.minimapZone.text:SetTextColor(1, 1, 1, 1) pfUI.minimapZone.text:SetTextColor(WHITE_FONT_COLOR:GetRGBA())
end end
pfUI.minimapZone.text:SetText(GetMinimapZoneText()) pfUI.minimapZone.text:SetText(GetMinimapZoneText())
end end
end) end)
if C.appearance.minimap.zonetext ~= "on" then pfUI.minimapZone:SetShown(C.appearance.minimap.zonetext == "on")
pfUI.minimapZone:Hide()
else
pfUI.minimapZone:Show()
end
-- Minimap hover event -- Minimap hover event
-- Update and toggle showing of coordinates and zone text on mouse enter/leave -- Update and toggle showing of coordinates and zone text on mouse enter/leave
@@ -239,10 +225,9 @@ pfUI:RegisterModule("minimap", function ()
pfUI.minimap.pvpicon = CreateFrame("Frame", nil, pfUI.minimap) pfUI.minimap.pvpicon = CreateFrame("Frame", nil, pfUI.minimap)
pfUI.minimap.pvpicon:Hide() pfUI.minimap.pvpicon:Hide()
pfUI.minimap.pvpicon:RegisterEvent("UPDATE_FACTION") pfUI.minimap.pvpicon:RegisterEvent("UPDATE_FACTION")
pfUI.minimap.pvpicon:RegisterEvent("UNIT_FACTION") pfUI.minimap.pvpicon:RegisterUnitEvent("UNIT_FACTION", "player")
pfUI.minimap.pvpicon:SetFrameStrata("HIGH") pfUI.minimap.pvpicon:SetFrameStrata("HIGH")
pfUI.minimap.pvpicon:SetWidth(16) pfUI.minimap.pvpicon:SetSize(16, 16)
pfUI.minimap.pvpicon:SetHeight(16)
pfUI.minimap.pvpicon:SetAlpha(.5) pfUI.minimap.pvpicon:SetAlpha(.5)
pfUI.minimap.pvpicon:SetParent(pfUI.minimap) pfUI.minimap.pvpicon:SetParent(pfUI.minimap)
pfUI.minimap.pvpicon:SetPoint("BOTTOMRIGHT", pfUI.minimap, "BOTTOMRIGHT", -5, 5) pfUI.minimap.pvpicon:SetPoint("BOTTOMRIGHT", pfUI.minimap, "BOTTOMRIGHT", -5, 5)
@@ -251,11 +236,7 @@ pfUI:RegisterModule("minimap", function ()
pfUI.minimap.pvpicon.texture:SetAllPoints(pfUI.minimap.pvpicon) pfUI.minimap.pvpicon.texture:SetAllPoints(pfUI.minimap.pvpicon)
pfUI.minimap.pvpicon:SetScript("OnEvent", function() pfUI.minimap.pvpicon:SetScript("OnEvent", function()
if C.unitframes.player.showPVPMinimap == "1" and UnitIsPVP("player") then pfUI.minimap.pvpicon:SetShown(C.unitframes.player.showPVPMinimap == "1" and UnitIsPVP("player"))
pfUI.minimap.pvpicon:Show()
else
pfUI.minimap.pvpicon:Hide()
end
end) end)
end) end)
modules/mouseover.lua
+2 -3
View File
@@ -1,6 +1,5 @@
pfUI:RegisterModule("mouseover", function () pfUI:RegisterModule("mouseover", function ()
_G.SLASH_PFCAST1, _G.SLASH_PFCAST2 = "/pfcast", "/pfmouse" pfUI.api.RegisterSlashCommand("PFCAST", { "/pfcast", "/pfmouse" }, function(msg)
function SlashCmdList.PFCAST(msg)
local func = pfUI.api.TryMemoizedFuncLoadstringForSpellCasts(msg) local func = pfUI.api.TryMemoizedFuncLoadstringForSpellCasts(msg)
local unit = "mouseover" local unit = "mouseover"
@@ -30,5 +29,5 @@ pfUI:RegisterModule("mouseover", function ()
if restore_target then TargetUnit(unit) end if restore_target then TargetUnit(unit) end
func() func()
if restore_target then TargetLastTarget() end if restore_target then TargetLastTarget() end
end end, true)
end) end)
modules/nameplates.lua
+405 -267
View File
File diff suppressed because it is too large Load Diff
modules/nampower.lua
+19 -220
View File
@@ -15,8 +15,7 @@ pfUI:RegisterModule("nampower", function ()
pfUI.spellqueue = CreateFrame("Frame", "pfSpellQueue", UIParent) pfUI.spellqueue = CreateFrame("Frame", "pfSpellQueue", UIParent)
pfUI.spellqueue:SetFrameStrata("HIGH") pfUI.spellqueue:SetFrameStrata("HIGH")
pfUI.spellqueue:SetWidth(size) pfUI.spellqueue:SetSize(size, size)
pfUI.spellqueue:SetHeight(size)
pfUI.spellqueue:Hide() pfUI.spellqueue:Hide()
-- Position near player castbar if available -- Position near player castbar if available
@@ -53,8 +52,7 @@ pfUI:RegisterModule("nampower", function ()
return return
end end
local eventCode = arg1 local eventCode, spellId = arg1, arg2
local spellId = arg2
if eventCode == NORMAL_QUEUED or eventCode == NON_GCD_QUEUED or eventCode == ON_SWING_QUEUED then if eventCode == NORMAL_QUEUED or eventCode == NON_GCD_QUEUED or eventCode == ON_SWING_QUEUED then
local texture = C_Spell.GetSpellTexture(spellId) local texture = C_Spell.GetSpellTexture(spellId)
@@ -74,21 +72,21 @@ pfUI:RegisterModule("nampower", function ()
-- Shows when reactive abilities like Overpower, Revenge, Execute are usable -- Shows when reactive abilities like Overpower, Revenge, Execute are usable
if C.unitframes.reactive_indicator == "1" then if C.unitframes.reactive_indicator == "1" then
local size = tonumber(C.unitframes.reactive_size) or 28 local size = tonumber(C.unitframes.reactive_size) or 28
local _, class = UnitClass("player") local class = UnitClassBase("player")
-- Reactive spells by class -- Reactive spells by class
local reactiveSpells = { local reactiveSpells = {
WARRIOR = { WARRIOR = {
{ name = "Overpower", texture = "Interface\\Icons\\Ability_MeleeDamage" }, 7384, -- Overpower
{ name = "Revenge", texture = "Interface\\Icons\\Ability_Warrior_Revenge" }, 6572, -- Revenge
{ name = "Execute", texture = "Interface\\Icons\\INV_Sword_48" }, 5283, -- Execute
}, },
ROGUE = { ROGUE = {
{ name = "Riposte", texture = "Interface\\Icons\\Ability_Warrior_Challange" }, 76, -- Riposte
}, },
HUNTER = { HUNTER = {
{ name = "Mongoose Bite", texture = "Interface\\Icons\\Ability_Hunter_SwiftStrike" }, 1495, -- Mongoose Bite
{ name = "Counterattack", texture = "Interface\\Icons\\Ability_Warrior_Challange" }, 19306, -- Counterattack
}, },
} }
@@ -97,21 +95,19 @@ pfUI:RegisterModule("nampower", function ()
pfUI.reactive = CreateFrame("Frame", "pfReactiveIndicator", UIParent) pfUI.reactive = CreateFrame("Frame", "pfReactiveIndicator", UIParent)
pfUI.reactive:SetFrameStrata("HIGH") pfUI.reactive:SetFrameStrata("HIGH")
local spellCount = table.getn(spells) local spellCount = table.getn(spells)
pfUI.reactive:SetWidth(size * spellCount + 4 * (spellCount - 1)) pfUI.reactive:SetSize(size * spellCount + 4 * (spellCount - 1), size)
pfUI.reactive:SetHeight(size)
pfUI.reactive:SetPoint("CENTER", UIParent, "CENTER", 0, -200) pfUI.reactive:SetPoint("CENTER", UIParent, "CENTER", 0, -200)
pfUI.reactive:Hide() pfUI.reactive:Hide()
pfUI.reactive.icons = {} pfUI.reactive.icons = {}
for i, spell in ipairs(spells) do for i, spell in ipairs(spells) do
local icon = CreateFrame("Frame", nil, pfUI.reactive) local icon = CreateFrame("Frame", nil, pfUI.reactive)
icon:SetWidth(size) icon:SetSize(size, size)
icon:SetHeight(size)
icon:SetPoint("LEFT", pfUI.reactive, "LEFT", (i-1) * (size + 4), 0) icon:SetPoint("LEFT", pfUI.reactive, "LEFT", (i-1) * (size + 4), 0)
icon.texture = icon:CreateTexture(nil, "ARTWORK") icon.texture = icon:CreateTexture(nil, "ARTWORK")
icon.texture:SetAllPoints(icon) icon.texture:SetAllPoints(icon)
icon.texture:SetTexture(spell.texture) icon.texture:SetTexture(C_Spell.GetSpellTexture(spell))
icon.texture:SetTexCoord(.08, .92, .08, .92) icon.texture:SetTexCoord(.08, .92, .08, .92)
icon.glow = icon:CreateTexture(nil, "OVERLAY") icon.glow = icon:CreateTexture(nil, "OVERLAY")
@@ -122,7 +118,7 @@ pfUI:RegisterModule("nampower", function ()
CreateBackdrop(icon) CreateBackdrop(icon)
icon:Hide() icon:Hide()
icon.spellName = spell.name icon.spellName = C_Spell.GetSpellName(spell)
pfUI.reactive.icons[i] = icon pfUI.reactive.icons[i] = icon
end end
@@ -132,27 +128,17 @@ pfUI:RegisterModule("nampower", function ()
local anyVisible = false local anyVisible = false
for _, icon in ipairs(this.icons) do for _, icon in ipairs(this.icons) do
local usable = C_Spell.IsSpellUsable(icon.spellName) local usable = C_Spell.IsSpellUsable(icon.spellName)
if usable then icon:SetShown(usable)
icon:Show() anyVisible = anyVisible or usable
anyVisible = true
else
icon:Hide()
end
end
if anyVisible then
this:Show()
else
this:Hide()
end end
this:SetShown(anyVisible)
end) end)
end end
end end
-- /disenchantall slash command (DisenchantAll is Nampower-provided) -- /disenchantall slash command (DisenchantAll is Nampower-provided)
if DisenchantAll then if DisenchantAll then
_G.SLASH_PFDISENCHANTALL1 = "/disenchantall" pfUI.api.RegisterSlashCommand("PFDISENCHANTALL", { "/disenchantall", "/dea" }, function(msg)
_G.SLASH_PFDISENCHANTALL2 = "/dea"
SlashCmdList["PFDISENCHANTALL"] = function(msg)
-- DisenchantAll(itemIdOrName | quality, [includeSoulbound]). -- DisenchantAll(itemIdOrName | quality, [includeSoulbound]).
-- Quality is a string keyword ("greens", "blues", "purples", or pipe- -- Quality is a string keyword ("greens", "blues", "purples", or pipe-
-- combined). Numbers are interpreted as item IDs, not quality levels. -- combined). Numbers are interpreted as item IDs, not quality levels.
@@ -160,195 +146,8 @@ pfUI:RegisterModule("nampower", function ()
local arg = (msg and msg ~= "") and msg or "greens" local arg = (msg and msg ~= "") and msg or "greens"
local target = tonumber(arg) or arg local target = tonumber(arg) or arg
DisenchantAll(target) DisenchantAll(target)
DEFAULT_CHAT_FRAME:AddMessage("|cff33ffccpfUI|r: DisenchantAll(" .. tostring(target) .. ")") print("|cff33ffccpfUI|r: DisenchantAll(" .. tostring(target) .. ")")
end end, true)
end end
-- Druid Secondary Mana Bar
-- Shows base mana when druid is in shapeshift form (Bear/Cat uses Rage/Energy)
-- Uses Nampower's GetUnitField to get base mana values
-- Fully self-contained: uses its own config settings from C.unitframes.druidmana*
if GetUnitField and pfUI.uf and pfUI_config.unitframes.druidmanabar == "1" then
local rawborder, default_border = GetBorderSize("unitframes")
local DC = C.unitframes -- druid mana config lives here as druidmana* keys
-- Shared helper: create a druid mana bar on a unit frame
local function CreateDruidManaBar(parent, unit)
if not parent then return nil end
local parentConfig = parent.config
-- Read own config values
local dmHeight = tonumber(DC.druidmanaheight) or 10
local dmWidth = DC.druidmanawidth or "-1"
local dmOffX = tonumber(DC.druidmanaoffx) or 0
local dmOffY = tonumber(DC.druidmanaoffy) or 0
local dmSpace = tonumber(DC.druidmanaspace) or -3
local dmTexture = DC.druidmanatexture or "Interface\\AddOns\\pfUI\\img\\bar"
local bar = CreateFrame("StatusBar", "pfDruidMana_" .. unit, parent)
bar:SetFrameStrata(parent:GetFrameStrata())
bar:SetFrameLevel(parent:GetFrameLevel() + 5)
bar:SetStatusBarTexture(pfUI.media[dmTexture] or dmTexture)
-- Bar color: use same manacolor logic as the normal power bar
local manacolor = parentConfig.defcolor == "0" and parentConfig.manacolor or C.unitframes.manacolor
local r, g, b, a = pfUI.api.strsplit(",", manacolor)
bar:SetStatusBarColor(tonumber(r) or .25, tonumber(g) or .25, tonumber(b) or 1, tonumber(a) or 1)
-- Size: own width/height, fallback to parent power bar width if -1
local width = dmWidth ~= "-1" and tonumber(dmWidth) or nil
if width then
bar:SetWidth(width)
end
bar:SetHeight(dmHeight)
-- Position below the power bar with own spacing + offsets
local spacing = -2 * default_border - dmSpace
if width then
-- Fixed width: use single point with offset
bar:SetPoint("TOP", parent.power, "BOTTOM", dmOffX, spacing + dmOffY)
else
-- Auto width: anchor to both sides of power bar
bar:SetPoint("TOPLEFT", parent.power, "BOTTOMLEFT", dmOffX, spacing + dmOffY)
bar:SetPoint("TOPRIGHT", parent.power, "BOTTOMRIGHT", dmOffX, spacing + dmOffY)
end
bar:Hide()
CreateBackdrop(bar)
CreateBackdropShadow(bar)
-- Font settings (same logic as power bar)
local fontname = pfUI.font_unit
local fontsize = tonumber(pfUI_config.global.font_unit_size)
local fontstyle = pfUI_config.global.font_unit_style
if parentConfig.customfont == "1" then
fontname = pfUI.media[parentConfig.customfont_name]
fontsize = tonumber(parentConfig.customfont_size)
fontstyle = parentConfig.customfont_style
end
-- Text color (always mana-colored)
local tr, tg, tb = ManaBarColor[0].r, ManaBarColor[0].g, ManaBarColor[0].b
if C.unitframes.pastel == "1" then
tr, tg, tb = (tr + .75) * .5, (tg + .75) * .5, (tb + .75) * .5
end
-- Single center text showing current/max
bar.text = bar:CreateFontString(nil, "OVERLAY", "GameFontNormalSmall")
bar.text:SetFontObject(GameFontWhite)
bar.text:SetFont(fontname, fontsize, fontstyle)
bar.text:SetPoint("CENTER", bar, "CENTER", 0, 0)
bar.text:SetJustifyH("CENTER")
bar.text:SetTextColor(tr, tg, tb, 1)
return bar
end
-- Shared helper: update druid mana bar values and text
local function UpdateDruidManaBar(bar, unit)
if not UnitExists(unit) then
bar:Hide()
return
end
-- For non-player units, only show if the target is a Druid
if unit ~= "player" then
local _, unitClass = UnitClass(unit)
if unitClass ~= "DRUID" then
bar:Hide()
return
end
end
local powerType = UnitPowerType(unit)
-- Only show when NOT using mana (i.e., in Bear/Cat form)
if powerType == 0 then
bar:Hide()
return
end
-- Get base mana using Nampower's GetUnitField
local baseMana, baseMaxMana
local guid = UnitGUID(unit)
if guid then
baseMana = GetUnitField(guid, "power1")
baseMaxMana = GetUnitField(guid, "maxPower1")
end
-- Round down power values (Nampower can return decimals)
if baseMana then baseMana = math.floor(baseMana) end
if baseMaxMana then baseMaxMana = math.floor(baseMaxMana) end
if type(baseMana) ~= "number" or type(baseMaxMana) ~= "number" or baseMaxMana == 0 then
bar:Hide()
return
end
-- Update bar
bar:SetMinMaxValues(0, baseMaxMana)
bar:SetValue(baseMana)
-- Always show current/max
bar.text:SetText(string.format("%s/%s", Abbreviate(baseMana), Abbreviate(baseMaxMana)))
bar:Show()
end
-- ===== Player Druid Mana Bar =====
local _, playerClass = UnitClass("player")
if pfUI.uf.player and playerClass == "DRUID" then
local playerMana = CreateDruidManaBar(pfUI.uf.player, "player")
if playerMana then
playerMana:RegisterEvent("UNIT_MANA")
playerMana:RegisterEvent("UNIT_MAXMANA")
playerMana:RegisterEvent("UNIT_DISPLAYPOWER")
playerMana:RegisterEvent("UPDATE_SHAPESHIFT_FORM")
playerMana:RegisterEvent("PLAYER_LOGOUT")
playerMana:SetScript("OnEvent", function()
if event == "PLAYER_LOGOUT" then
this:UnregisterAllEvents()
this:SetScript("OnEvent", nil)
return
end
if arg1 == nil or arg1 == "player" then
UpdateDruidManaBar(playerMana, "player")
end
end)
-- Initial update
UpdateDruidManaBar(playerMana, "player")
end
end
-- ===== Target Druid Mana Bar =====
if pfUI.uf.target then
local targetMana = CreateDruidManaBar(pfUI.uf.target, "target")
if targetMana then
targetMana:RegisterEvent("UNIT_MANA")
targetMana:RegisterEvent("UNIT_MAXMANA")
targetMana:RegisterEvent("UNIT_DISPLAYPOWER")
targetMana:RegisterEvent("PLAYER_TARGET_CHANGED")
targetMana:RegisterEvent("PLAYER_LOGOUT")
targetMana:SetScript("OnEvent", function()
if event == "PLAYER_LOGOUT" then
this:UnregisterAllEvents()
this:SetScript("OnEvent", nil)
return
end
if event == "PLAYER_TARGET_CHANGED" or arg1 == nil or arg1 == "target" then
UpdateDruidManaBar(targetMana, "target")
end
end)
-- Initial update
UpdateDruidManaBar(targetMana, "target")
end
end
end
end) end)
modules/newitem.lua
+68
View File
@@ -0,0 +1,68 @@
pfUI:RegisterModule("newitem", function ()
if not pfUI.bag then return end
if C.appearance.bags.newitem ~= "1" then return end
pfUI.newitem = {}
local r, g, b, a = pfUI.api.GetStringColor(C.appearance.bags.newitem_color)
function pfUI.newitem:UpdateSlot(bag, slot)
if bag < 0 or bag > 4 then return end
if not pfUI.bags[bag] then return end
if not pfUI.bags[bag].slots[slot] then return end
local frame = pfUI.bags[bag].slots[slot].frame
if frame.hasItem and C_NewItems.IsNewItem(bag, slot) then
if not frame.newitem then
local glow = frame:CreateTexture(nil, "OVERLAY")
glow:SetTexture("Interface\\Buttons\\UI-ActionButton-Border")
glow:SetBlendMode("ADD")
glow:SetVertexColor(r, g, b, a)
glow:SetPoint("CENTER", frame, "CENTER")
glow:Hide()
glow.RefreshSize = function(g)
local w = g:GetParent():GetWidth()
if w > 0 then g:SetSize(w * 1.8, w * 1.8) end
end
frame.newitem = glow
frame:HookScript("OnEnter", function()
C_NewItems.RemoveNewItem(bag, slot)
end)
end
frame.newitem:RefreshSize()
frame.newitem:Show()
elseif frame.newitem and frame.newitem:IsShown() then
frame.newitem:Hide()
end
end
-- The new-item set can change without any slot's contents changing (an item
-- acknowledged, pruned when it leaves the bags, or ClearAll) -- re-evaluate
-- every decorated slot when that happens.
function pfUI.newitem:RefreshAll()
for bag in pairs(pfUI.bags) do
local slots = pfUI.bags[bag] and pfUI.bags[bag].slots
if slots then
for slot in pairs(slots) do
pfUI.newitem:UpdateSlot(bag, slot)
end
end
end
end
-- per-slot: pfUI re-runs UpdateSlot whenever a slot's contents change.
hooksecurefunc(pfUI.bag, "UpdateSlot", function(self, bag, slot)
pfUI.newitem:UpdateSlot(bag, slot)
end)
EventRegistry:RegisterFrameEventAndCallback("BAG_NEW_ITEMS_UPDATED", function()
pfUI.newitem:RefreshAll()
end)
pfUI.events:RegisterCallback("bag:closed", function(_, object)
if object then return end
C_NewItems.ClearAll()
end, "newitem")
end)
modules/panel.lua
+43 -60
View File
@@ -37,18 +37,12 @@ pfUI:RegisterModule("panel", function()
return return
end end
if arg1 == "LeftButton" then if arg1 == "LeftButton" then
if widget.timerFrame:IsShown() then widget.timerFrame:SetShown(not widget.timerFrame:IsShown())
widget.timerFrame:Hide()
else
widget.timerFrame:Show()
end
elseif arg1 == "RightButton" then elseif arg1 == "RightButton" then
widget.timerFrame.Snapshot = GetTime() widget.timerFrame.Snapshot = GetTime()
end end
end end
widget:SetScript("OnUpdate",function() C_Timer.NewTicker(1, function()
if ( this.tick or 1) > GetTime() then return else this.tick = GetTime() + 1 end
local secondsenabled = C.panel.seconds == "1" local secondsenabled = C.panel.seconds == "1"
local fmt local fmt
if C.global.twentyfour == "0" then if C.global.twentyfour == "0" then
@@ -62,8 +56,7 @@ pfUI:RegisterModule("panel", function()
widget.timerFrame = CreateFrame("Frame", "pfUITimer", UIParent) widget.timerFrame = CreateFrame("Frame", "pfUITimer", UIParent)
widget.timerFrame:Hide() widget.timerFrame:Hide()
widget.timerFrame:SetWidth(120) widget.timerFrame:SetSize(120, 35)
widget.timerFrame:SetHeight(35)
widget.timerFrame:SetPoint("TOP", 0, -100) widget.timerFrame:SetPoint("TOP", 0, -100)
UpdateMovable(widget.timerFrame) UpdateMovable(widget.timerFrame)
@@ -103,11 +96,9 @@ pfUI:RegisterModule("panel", function()
pfUI.panel:OutputPanel("combat", T["Combat"] .. ": " .. NOT_APPLICABLE) pfUI.panel:OutputPanel("combat", T["Combat"] .. ": " .. NOT_APPLICABLE)
end end
end) end)
widget.combat:SetScript("OnUpdate", function() C_Timer.NewTicker(1, function()
if not this.tick then this.tick = GetTime() end if widget.combat.combat then
if GetTime() <= this.tick + 1 then return else this.tick = GetTime() end pfUI.panel:OutputPanel("combat", "|cffffaaaa" .. SecondsToTime(ceil(GetTime() - widget.combat.combat)))
if this.combat then
pfUI.panel:OutputPanel("combat", "|cffffaaaa" .. SecondsToTime(ceil(GetTime() - this.combat)))
end end
end) end)
end end
@@ -153,9 +144,7 @@ pfUI:RegisterModule("panel", function()
pfUI.addons:Show() pfUI.addons:Show()
end end
end end
widget:SetScript("OnUpdate",function() C_Timer.NewTicker(1, function()
if ( this.tick or 1) > GetTime() then return else this.tick = GetTime() + 1 end
fps = floor(GetFramerate()) fps = floor(GetFramerate())
_, _, lag = GetNetStats() _, _, lag = GetNetStats()
@@ -307,18 +296,18 @@ pfUI:RegisterModule("panel", function()
local playerzone = GetRealZoneText() local playerzone = GetRealZoneText()
for friendIndex=1, all do for friendIndex=1, all do
local friend_name, friend_level, friend_class, friend_area, friend_connected = GetFriendInfo(friendIndex) local info = C_FriendList.GetFriendInfoByIndex(friendIndex)
if friend_connected and friend_class and friend_level then if info and info.connected and info.classFilename and info.level then
if not init then if not init then
GameTooltip_SetDefaultAnchor(GameTooltip, this) GameTooltip_SetDefaultAnchor(GameTooltip, this)
GameTooltip:ClearLines() GameTooltip:ClearLines()
GameTooltip:AddLine("|cff555555" .. T["Friends Online"]) GameTooltip:AddLine("|cff555555" .. T["Friends Online"])
init = true init = true
end end
local ccolor = PFUI_CLASS_COLORS[L["class"][friend_class]] or { 1, 1, 1 } local ccolor = PFUI_CLASS_COLORS[info.classFilename]
local lcolor = GetDifficultyColor(tonumber(friend_level)) or { 1, 1, 1 } local lcolor = GetDifficultyColor(tonumber(info.level)) or { 1, 1, 1 }
local zcolor = friend_area == playerzone and "|cff33ffcc" or "|cffcccccc" local zcolor = info.area == playerzone and "|cff33ffcc" or "|cffcccccc"
GameTooltip:AddDoubleLine(rgbhex(ccolor) .. friend_name .. rgbhex(lcolor) .. " [" .. friend_level .. "]", zcolor .. friend_area) GameTooltip:AddDoubleLine(ccolor:WrapTextInColorCode(info.name) .. rgbhex(lcolor) .. " [" .. info.level .. "]", zcolor .. info.area)
end end
end end
@@ -326,15 +315,7 @@ pfUI:RegisterModule("panel", function()
end end
widget.Click = function() ToggleFriendsFrame(1) end widget.Click = function() ToggleFriendsFrame(1) end
widget:SetScript("OnEvent", function() widget:SetScript("OnEvent", function()
local online = 0 local online = C_FriendList.GetNumOnlineFriends()
local all = GetNumFriends()
for friendIndex=1, all do
local friend_name, friend_level, friend_class, friend_area, friend_connected = GetFriendInfo(friendIndex)
if ( friend_connected ) then
online = online + 1
end
end
pfUI.panel:OutputPanel("friends", FRIENDS .. ": " .. online, widget.Tooltip, widget.Click) pfUI.panel:OutputPanel("friends", FRIENDS .. ": " .. online, widget.Tooltip, widget.Click)
end) end)
end end
@@ -346,7 +327,7 @@ pfUI:RegisterModule("panel", function()
widget:RegisterEvent("PLAYER_GUILD_UPDATE") widget:RegisterEvent("PLAYER_GUILD_UPDATE")
widget.Tooltip = function() widget.Tooltip = function()
-- skip without guild -- skip without guild
if not GetGuildInfo("player") then return end if not IsInGuild() then return end
local raidparty = {} local raidparty = {}
for i=1,4 do -- detect people in group for i=1,4 do -- detect people in group
@@ -398,7 +379,7 @@ pfUI:RegisterModule("panel", function()
end end
widget.Click = function() ToggleFriendsFrame(3) end widget.Click = function() ToggleFriendsFrame(3) end
widget:SetScript("OnEvent", function() widget:SetScript("OnEvent", function()
if GetGuildInfo("player") then if IsInGuild() then
local count = 0 local count = 0
for i = 1, GetNumGuildMembers() do for i = 1, GetNumGuildMembers() do
local _, _, _, _, _, _, _, _, online = GetGuildRosterInfo(i) local _, _, _, _, _, _, _, _, online = GetGuildRosterInfo(i)
@@ -411,9 +392,8 @@ pfUI:RegisterModule("panel", function()
end end
end) end)
widget:SetScript("OnUpdate",function() C_Timer.NewTicker(60, function()
if ( this.tick or 60) > GetTime() then return else this.tick = GetTime() + 60 end if IsInGuild() then GuildRoster() end
if GetGuildInfo("player") then GuildRoster() end
end) end)
end end
@@ -438,8 +418,13 @@ pfUI:RegisterModule("panel", function()
local repPercent = floor(cur / max * 100) local repPercent = floor(cur / max * 100)
if repPercent < 100 then if repPercent < 100 then
local _, _, _, hex = GetColorGradient(repPercent/100) local _, _, _, hex = GetColorGradient(repPercent/100)
local link = GetInventoryItemLink("player", id)
local texture = GetInventoryItemTexture("player", id)
if texture then
link = CreateSimpleTextureMarkup(texture, 24) .. " " .. link
end
itemLines[table.getn(itemLines)+1] = { itemLines[table.getn(itemLines)+1] = {
GetInventoryItemLink("player", id), link,
string.format("%s%s%%|r", hex, repPercent) string.format("%s%s%%|r", hex, repPercent)
} }
end end
@@ -448,8 +433,7 @@ pfUI:RegisterModule("panel", function()
if totalRep > 0 then if totalRep > 0 then
GameTooltip:ClearLines() GameTooltip:ClearLines()
GameTooltip_SetDefaultAnchor(GameTooltip, this) GameTooltip_SetDefaultAnchor(GameTooltip, this)
GameTooltip:SetText("|cff555555"..(string.gsub(REPAIR_COST,":","")).."|r") GameTooltip:AddLine(REPAIR_COST.." " .. CreateGoldString(totalRep), 0.3333, 0.3333, 0.3333)
SetTooltipMoney(GameTooltip, totalRep)
for _,line in ipairs(itemLines) do for _,line in ipairs(itemLines) do
GameTooltip:AddDoubleLine(line[1],line[2]) GameTooltip:AddDoubleLine(line[1],line[2])
end end
@@ -473,7 +457,7 @@ pfUI:RegisterModule("panel", function()
do -- Zone do -- Zone
local widget = CreateFrame("Frame", "pfPanelWidgetZone", UIParent) local widget = CreateFrame("Frame", "pfPanelWidgetZone", UIParent)
for _,event in pairs(EVENTS_MINIMAP_ZONE_UPDATE) do for _,event in pairs({"PLAYER_ENTERING_WORLD", "MINIMAP_ZONE_CHANGED"}) do
widget:RegisterEvent(event) widget:RegisterEvent(event)
end end
widget.Tooltip = function() widget.Tooltip = function()
@@ -492,11 +476,7 @@ pfUI:RegisterModule("panel", function()
GameTooltip:Show() GameTooltip:Show()
end end
widget.Click = function() widget.Click = function()
if WorldMapFrame:IsShown() then WorldMapFrame:SetShown(not WorldMapFrame:IsShown())
WorldMapFrame:Hide()
else
WorldMapFrame:Show()
end
end end
widget:SetScript("OnEvent", function() widget:SetScript("OnEvent", function()
pfUI.panel:OutputPanel("zone", GetMinimapZoneText(), widget.Tooltip, widget.Click) pfUI.panel:OutputPanel("zone", GetMinimapZoneText(), widget.Tooltip, widget.Click)
@@ -506,7 +486,7 @@ pfUI:RegisterModule("panel", function()
do -- Ammo do -- Ammo
local widget = CreateFrame("Frame", "pfPanelWidgetAmmo", UIParent) local widget = CreateFrame("Frame", "pfPanelWidgetAmmo", UIParent)
widget:RegisterEvent("PLAYER_ENTERING_WORLD") widget:RegisterEvent("PLAYER_ENTERING_WORLD")
widget:RegisterEvent("UNIT_INVENTORY_CHANGED") widget:RegisterUnitEvent("UNIT_INVENTORY_CHANGED", "player")
widget:RegisterEvent("BAG_UPDATE_DELAYED") widget:RegisterEvent("BAG_UPDATE_DELAYED")
widget.Tooltip = function() widget.Tooltip = function()
if GetInventoryItemQuality("player", 0) then if GetInventoryItemQuality("player", 0) then
@@ -532,7 +512,7 @@ pfUI:RegisterModule("panel", function()
-- Hearthstone bind location -- Hearthstone bind location
local hearth = CreateFrame("Frame", "pfPanelBindLocation", UIParent) local hearth = CreateFrame("Frame", "pfPanelBindLocation", UIParent)
hearth:RegisterEvent("PLAYER_ENTERING_WORLD") hearth:RegisterEvent("PLAYER_ENTERING_WORLD")
hearth:RegisterEvent("CHAT_MSG_SYSTEM") hearth:RegisterEvent("HEARTHSTONE_BOUND")
hearth:SetScript("OnEvent", function() hearth:SetScript("OnEvent", function()
pfUI.panel:OutputPanel("bindlocation", T["Hearthstone"] .. ": " .. (GetBindLocation() or T["Not Set"])) pfUI.panel:OutputPanel("bindlocation", T["Hearthstone"] .. ": " .. (GetBindLocation() or T["Not Set"]))
end) end)
@@ -645,8 +625,7 @@ pfUI:RegisterModule("panel", function()
local frame = CreateFrame("Button", nil, parent) local frame = CreateFrame("Button", nil, parent)
frame:SetFrameLevel(0) frame:SetFrameLevel(0)
frame:ClearAllPoints() frame:ClearAllPoints()
frame:SetWidth(width) frame:SetSize(width, parent:GetHeight())
frame:SetHeight(parent:GetHeight())
frame:SetPoint(location, 0, 0) frame:SetPoint(location, 0, 0)
frame.text = frame:CreateFontString("Status", "LOW", "GameFontNormal") frame.text = frame:CreateFontString("Status", "LOW", "GameFontNormal")
frame.text:ClearAllPoints() frame.text:ClearAllPoints()
@@ -687,8 +666,7 @@ pfUI:RegisterModule("panel", function()
local imgstring = "img:" .. leftright local imgstring = "img:" .. leftright
parent.texture:SetTexture(pfUI.media[imgstring]) parent.texture:SetTexture(pfUI.media[imgstring])
parent.texture:SetPoint("CENTER", 0, 0) parent.texture:SetPoint("CENTER", 0, 0)
parent.texture:SetWidth(8) parent.texture:SetSize(8, 8)
parent.texture:SetHeight(8)
parent.texture:SetVertexColor(.25,.25,.25,1) parent.texture:SetVertexColor(.25,.25,.25,1)
return parent.texture return parent.texture
end end
@@ -710,7 +688,7 @@ pfUI:RegisterModule("panel", function()
UpdateMovable(pfUI.panel.left) UpdateMovable(pfUI.panel.left)
pfUI.panel.left.hide:SetScript("OnClick", function() pfUI.panel.left.hide:SetScript("OnClick", function()
if pfUI.chat.left:IsShown() then pfUI.chat.left:Hide() else pfUI.chat.left:Show() end pfUI.chat.left:SetShown(not pfUI.chat.left:IsShown())
end) end)
if not pfUI.chat then pfUI.panel.left.hide:Hide() end if not pfUI.chat then pfUI.panel.left.hide:Hide() end
@@ -747,7 +725,7 @@ pfUI:RegisterModule("panel", function()
UpdateMovable(pfUI.panel.right) UpdateMovable(pfUI.panel.right)
pfUI.panel.right.hide:SetScript("OnClick", function() pfUI.panel.right.hide:SetScript("OnClick", function()
if pfUI.chat.right:IsShown() then pfUI.chat.right:Hide() else pfUI.chat.right:Show() end pfUI.chat.right:SetShown(not pfUI.chat.right:IsShown())
end) end)
if not pfUI.chat then pfUI.panel.right.hide:Hide() end if not pfUI.chat then pfUI.panel.right.hide:Hide() end
@@ -796,13 +774,18 @@ pfUI:RegisterModule("panel", function()
pfUI.panel.microbutton = CreateFrame("Frame", "pfPanelMicroButton", UIParent) pfUI.panel.microbutton = CreateFrame("Frame", "pfPanelMicroButton", UIParent)
pfUI.panel.microbutton:SetPoint("TOP", pfUI.panel.minimap, "BOTTOM", 0, -2*default_border) pfUI.panel.microbutton:SetPoint("TOP", pfUI.panel.minimap, "BOTTOM", 0, -2*default_border)
UpdateMovable(pfUI.panel.microbutton) UpdateMovable(pfUI.panel.microbutton)
pfUI.panel.microbutton:SetHeight(23) pfUI.panel.microbutton:SetSize(145, 23)
pfUI.panel.microbutton:SetWidth(145)
pfUI.panel.microbutton:SetFrameStrata("MEDIUM") pfUI.panel.microbutton:SetFrameStrata("MEDIUM")
for i=1,table.getn(MICRO_BUTTONS) do local microButtons = {
local anchor = _G[MICRO_BUTTONS[i-1]] or pfUI.panel.microbutton 'CharacterMicroButton', 'SpellbookMicroButton', 'TalentMicroButton',
local button = _G[MICRO_BUTTONS[i]] 'QuestLogMicroButton', 'SocialsMicroButton', 'WorldMapMicroButton',
'MainMenuMicroButton', 'HelpMicroButton',
}
for i=1,table.getn(microButtons) do
local anchor = _G[microButtons[i-1]] or pfUI.panel.microbutton
local button = _G[microButtons[i]]
button:ClearAllPoints() button:ClearAllPoints()
button:SetParent(pfUI.panel.microbutton) button:SetParent(pfUI.panel.microbutton)
if i == 1 then if i == 1 then
modules/player.lua
+35 -40
View File
@@ -34,22 +34,25 @@ pfUI:RegisterModule("player", function ()
playerFrame.infoTopCenterText:SetHeight(14) playerFrame.infoTopCenterText:SetHeight(14)
end end
local _, myclass = UnitClass("player") local myclass = UnitClassBase("player")
playerFrame.myclass = myclass playerFrame.myclass = myclass
playerFrame.isSpellCaster = myclass ~= "WARRIOR" and myclass ~= "ROGUE" and myclass ~= "HUNTER" playerFrame.isSpellCaster = myclass ~= "WARRIOR" and myclass ~= "ROGUE" and myclass ~= "HUNTER"
-- Convert "r,g,b,a" config color string to a 6-char hex string, or nil if unset -- Convert "r,g,b,a" config color string to a 6-char hex string, or nil if unset
local function cfgColorToHex(colorStr) local cfgColorToHexTable = setmetatable({}, {
if not colorStr or colorStr == "" then return nil end __index = function (t, colorStr)
local r, g, b = strsplit(",", colorStr) if not colorStr or colorStr == "" then return nil end
r, g, b = tonumber(r), tonumber(g), tonumber(b) local r, g, b = GetStringColor(colorStr)
if not r or not g or not b then return nil end if not r or not g or not b then return nil end
return string.format("%02X%02X%02X", r * 255, g * 255, b * 255) local hex = C_ColorUtil.GenerateTextColorCode({ r=r, g = g, b=b})
end rawset(t, colorStr, hex)
return hex
end
})
-- SP school colors indexed by GetSpellPower("net") return order -- SP school colors indexed by GetSpellBonusDamage's 1-based school order
-- (1=phys, 2=holy, 3=fire, 4=nature, 5=frost, 6=shadow, 7=arcane) -- (1=phys, 2=holy, 3=fire, 4=nature, 5=frost, 6=shadow, 7=arcane)
local spColors = { "FFFFFF", "FFFF80", "FF8000", "4DFF4D", "80FFFF", "9482C9", "FFFFFF" } local spColors = { "FFFFFFFF", "FFFFFF80", "FFFF8000", "FF4DFF4D", "FF80FFFF", "FF9482C9", "FFFFFFFF" }
-- Default SP school per class used as tiebreaker when multiple schools are equal -- Default SP school per class used as tiebreaker when multiple schools are equal
local spDefaultSchool = { local spDefaultSchool = {
@@ -60,53 +63,45 @@ pfUI:RegisterModule("player", function ()
-- Compute and cache the haste/SP text; called from OnUpdate, throttled to 0.25s -- Compute and cache the haste/SP text; called from OnUpdate, throttled to 0.25s
local function UpdateInfoText() local function UpdateInfoText()
if not GetUnitField then return end -- do nothing for older nampower
local cfg = playerFrame.config local cfg = playerFrame.config
if not cfg then if not cfg then
return return
end end
-- display_haste: "0"=hidden, "1"=show modCastSpeed (gear haste). Talent- -- display_haste: "0"=hidden, "1"=show cast-speed haste (UnitSpellHaste,
-- side cast-time reductions show up in the actual cast bar via -- from UNIT_MOD_CAST_SPEED). Talent/spell-specific cast-time reductions
-- C_Spell.UnitCastingInfo; double-folding them into this overlay was -- show up in the actual cast bar via C_Spell.UnitCastingInfo; folding them
-- mixing two different concepts into one number. -- in here too was mixing two different concepts into one number.
local showHaste = cfg.display_haste == "1"
local showSP = cfg.display_spellpower == "1"
local isSpellCaster = playerFrame.isSpellCaster local isSpellCaster = playerFrame.isSpellCaster
if (not showHaste or not isSpellCaster) and not showSP then local showHaste = isSpellCaster and cfg.display_haste == "1"
local showSP = isSpellCaster and cfg.display_spellpower == "1"
if not showHaste and not showSP then
playerFrame.infoTopCenterText:SetText("") playerFrame.infoTopCenterText:SetText("")
return return
end end
local haste = GetUnitField("player", "modCastSpeed") local parts = {}
local text = ""
if showHaste and isSpellCaster and haste then if showHaste then
local hasteHex = cfgColorToHex(cfg.display_haste_color) or "FFFFFF" local hex = cfgColorToHexTable[cfg.display_haste_color] or "FFFFFFFF"
text = string.format("|cff%s%.1f%%|r", hasteHex, (1 / haste - 1) * 100) table.insert(parts, string.format("|c%s%.1f%%|r", hex, UnitSpellHaste("player")))
end end
if showSP and isSpellCaster then if showSP then
local schools = { GetSpellPower("net") } local school = spDefaultSchool[myclass] or 2
local defSchool = spDefaultSchool[myclass] or 2 local maxSP = GetSpellBonusDamage(school) or 0
local maxSP = schools[defSchool] or 0
local maxColor = spColors[defSchool]
for i = 2, 7 do -- skip physical (1) for i = 2, 7 do -- skip physical (1)
local v = schools[i] or 0 local v = GetSpellBonusDamage(i) or 0
if v > maxSP then if v > maxSP then maxSP, school = v, i end
maxSP = v
maxColor = spColors[i]
end
end end
if maxSP > 0 then if maxSP > 0 then
local spHex = (cfg.display_sp_color_override == "1" and cfgColorToHex(cfg.display_sp_color)) or maxColor local hex = (cfg.display_sp_color_override == "1" and cfgColorToHexTable[cfg.display_sp_color]) or spColors[school]
if text ~= "" then text = text .. " " end table.insert(parts, string.format("|c%s+%d SP|r", hex, maxSP))
text = text .. string.format("|cff%s+%d SP|r", spHex, maxSP)
end end
end end
playerFrame.infoTopCenterText:SetText(text) playerFrame.infoTopCenterText:SetText(table.concat(parts, " "))
end end
-- Keep a reference to the generic UF UpdateConfig so we can chain it -- Keep a reference to the generic UF UpdateConfig so we can chain it
@@ -141,7 +136,7 @@ pfUI:RegisterModule("player", function ()
end end
end end
pfUI.hooksecurefunc("UnitPopup_OnClick", function() hooksecurefunc("UnitPopup_OnClick", function()
local button = this.value local button = this.value
if button == "RESET_INSTANCES_FIX" then if button == "RESET_INSTANCES_FIX" then
StaticPopup_Show("CONFIRM_RESET_INSTANCES") StaticPopup_Show("CONFIRM_RESET_INSTANCES")
modules/questitem.lua
+58 -37
View File
@@ -1,8 +1,43 @@
pfUI:RegisterModule("questitem", function () pfUI:RegisterModule("questitem", function ()
-- [itemID] = { index = questLogIndex, count = requiredCount }. Rebuilt
-- on QUEST_LOG_UPDATE from ClassicAPI's per-quest cached requirements.
local requiredItems = {} local requiredItems = {}
local function AddQuest(questID)
local details = C_QuestLog.GetQuestDetails(questID)
if not details then return false end
if details.requirements then
for _, req in ipairs(details.requirements) do
if req.kind == "item" and req.id and req.id > 0 then
requiredItems[req.id] = {
questID = questID,
title = details.title,
level = details.level,
count = req.count,
}
end
end
end
return true
end
local function RemoveQuest(questID)
for itemID, entry in pairs(requiredItems) do
if entry.questID == questID then requiredItems[itemID] = nil end
end
end
local function Seed()
for k in pairs(requiredItems) do requiredItems[k] = nil end
local complete = true
local i = 1
while true do
local questID = C_QuestLog.GetQuestIDForLogIndex(i)
if questID == nil then break end
if questID > 0 and not AddQuest(questID) then complete = false end
i = i + 1
end
return complete
end
local function AddTooltip(frame, itemID) local function AddTooltip(frame, itemID)
if not itemID then return end if not itemID then return end
if C.tooltip.questitem.showquest ~= "1" then return end if C.tooltip.questitem.showquest ~= "1" then return end
@@ -19,7 +54,7 @@ pfUI:RegisterModule("questitem", function ()
if not entry and not replace then return end if not entry and not replace then return end
local quest, level = UNKNOWN, 255 local quest, level = UNKNOWN, 255
if entry then quest, level = GetQuestLogTitle(entry.index) end if entry then quest, level = entry.title, entry.level end
if not quest then return end if not quest then return end
local color = GetDifficultyColor(level) local color = GetDifficultyColor(level)
@@ -42,48 +77,37 @@ pfUI:RegisterModule("questitem", function ()
pfUI.questitem = CreateFrame("Frame", "pfQuestItemScanner", UIParent) pfUI.questitem = CreateFrame("Frame", "pfQuestItemScanner", UIParent)
pfUI.questitem:RegisterEvent("PLAYER_ENTERING_WORLD") pfUI.questitem:RegisterEvent("PLAYER_ENTERING_WORLD")
pfUI.questitem:RegisterEvent("QUEST_LOG_UPDATE") pfUI.questitem:RegisterEvent("QUEST_LOG_UPDATE")
pfUI.questitem:RegisterEvent("QUEST_ACCEPTED")
pfUI.questitem:RegisterEvent("QUEST_REMOVED")
pfUI.questitem:SetScript("OnEvent", function() pfUI.questitem:SetScript("OnEvent", function()
-- debounce rebuilds — QUEST_LOG_UPDATE fires in bursts if C.tooltip.questitem.showquest ~= "1" then return end
this.run = GetTime() + .5 if event == "QUEST_ACCEPTED" then -- arg1 = logIndex, arg2 = questID
if not AddQuest(arg2) then -- cache cold (rare) -> reseed
this.seeding = true
this.run = GetTime() + .5
end
elseif event == "QUEST_REMOVED" then -- arg1 = questID
RemoveQuest(arg1)
elseif event == "PLAYER_ENTERING_WORLD" then
this.seeding = true -- seed pre-existing quests
this.run = GetTime() + .5
elseif event == "QUEST_LOG_UPDATE" and this.seeding then
this.run = GetTime() + .5 -- keep retrying while cache warms
end
end) end)
pfUI.questitem:SetScript("OnUpdate", function() pfUI.questitem:SetScript("OnUpdate", function()
if C.tooltip.questitem.showquest ~= "1" then return end
if not this.run or GetTime() < this.run then return end if not this.run or GetTime() < this.run then return end
for k in pairs(requiredItems) do requiredItems[k] = nil end
-- GetQuestIDForLogIndex returns nil past the end, 0 for headers, else
-- the questID. GetQuestDetails reads the engine's static-info cache —
-- nil if not yet populated; we'll catch it on the next refresh.
local i = 1
while true do
local questID = C_QuestLog.GetQuestIDForLogIndex(i)
if questID == nil then break end
if questID > 0 then
local details = C_QuestLog.GetQuestDetails(questID)
if details and details.requirements then
for _, req in ipairs(details.requirements) do
if req.kind == "item" and req.id and req.id > 0 then
requiredItems[req.id] = { index = i, count = req.count }
end
end
end
end
i = i + 1
end
this.run = nil this.run = nil
if Seed() then this.seeding = nil end
end) end)
-- reload quest entries on config change
pfUI.questitem.UpdateConfig = function() pfUI.questitem.UpdateConfig = function()
if C.tooltip.questitem.showquest ~= "1" then return end
pfUI.questitem.seeding = true
pfUI.questitem.run = GetTime() + .5 pfUI.questitem.run = GetTime() + .5
end end
-- regular tooltip: catch every Show via a child frame's OnShow, then ask
-- the tooltip directly for the item it's displaying. Replaces a libtooltip
-- indirection that did the same query with extra caching layers.
pfUI.questitem.tooltip = CreateFrame("Frame", "pfQuestItems", GameTooltip) pfUI.questitem.tooltip = CreateFrame("Frame", "pfQuestItems", GameTooltip)
pfUI.questitem.tooltip:SetScript("OnShow", function() pfUI.questitem.tooltip:SetScript("OnShow", function()
if GameTooltip:HasItem() then if GameTooltip:HasItem() then
@@ -92,10 +116,7 @@ pfUI:RegisterModule("questitem", function ()
end end
end) end)
-- itemref tooltip (chat link clicks): hooksecurefunc runs after SetItemRef hooksecurefunc("SetItemRef", function()
-- populates ItemRefTooltip, so we just read the item back out of the tooltip
-- instead of re-parsing the "item:NNN" out of the link string.
pfUI.hooksecurefunc("SetItemRef", function()
if IsModifierKeyDown() then return end if IsModifierKeyDown() then return end
if ItemRefTooltip:HasItem() then if ItemRefTooltip:HasItem() then
local _, _, id = ItemRefTooltip:GetItem() local _, _, id = ItemRefTooltip:GetItem()
modules/raid.lua
+144 -12
View File
@@ -4,7 +4,9 @@ pfUI:RegisterModule("raid", function ()
-- tell RaidFrame.lua pfUI replaces party frames -- tell RaidFrame.lua pfUI replaces party frames
HookAddonOrVariable("Blizzard_RaidUI", function() HookAddonOrVariable("Blizzard_RaidUI", function()
GROUP_REPLACE_PARTY = "1" -- must reach _G: RaidFrame.lua reads this global, and pfUI.env has
-- __index but no __newindex, so a bare assignment stays in the sandbox
_G.GROUP_REPLACE_PARTY = "1"
end) end)
pfUI.uf.raid = CreateFrame("Frame", "pfRaidUpdater", UIParent) pfUI.uf.raid = CreateFrame("Frame", "pfRaidUpdater", UIParent)
@@ -13,11 +15,32 @@ pfUI:RegisterModule("raid", function ()
local rawborder, default_border = GetBorderSize("chat") local rawborder, default_border = GetBorderSize("chat")
local cluster = CreateFrame("Frame", "pfRaidCluster", UIParent) local cluster = CreateFrame("Frame", "pfRaidCluster", UIParent)
cluster:SetFrameLevel(20) cluster:SetFrameLevel(20)
cluster:SetWidth(120) cluster:SetSize(120, 10)
cluster:SetHeight(10)
cluster:SetPoint("BOTTOMLEFT", UIParent, "BOTTOMLEFT", default_border*2, C.chat.left.height + default_border*5) cluster:SetPoint("BOTTOMLEFT", UIParent, "BOTTOMLEFT", default_border*2, C.chat.left.height + default_border*5)
UpdateMovable(cluster) UpdateMovable(cluster)
-- Separate, independently-movable block that mirrors the raid grid layout
-- for pet frames (raidpet1..40). Defaults to the right of the raid grid.
local petcluster = CreateFrame("Frame", "pfRaidPetCluster", UIParent)
petcluster:SetFrameLevel(20)
petcluster:SetSize(120, 10)
petcluster:SetPoint("BOTTOMLEFT", UIParent, "BOTTOMLEFT", default_border*2 + 300, C.chat.left.height + default_border*5)
UpdateMovable(petcluster)
-- flat pool of pet frames, laid out by LayoutPets (mirror or collapsed)
pfUI.uf.raid.pets = {}
-- 1-based grid slot -> (row, col) for the current fill direction, matching
-- the raid grid's own fill loops.
local function SlotToCoord(slot, fill, x, y)
slot = slot - 1
if fill == "VERTICAL" then
return floor(slot / y) + 1, mod(slot, y) + 1
else
return mod(slot, x) + 1, floor(slot / x) + 1
end
end
pfUI.uf.raid.tanksfirst = { pfUI.uf.raid.tanksfirst = {
["PF_TANK_TOGGLE"] = { T["Toggle as Tank"], "toggleTank" } ["PF_TANK_TOGGLE"] = { T["Toggle as Tank"], "toggleTank" }
} }
@@ -28,6 +51,8 @@ pfUI:RegisterModule("raid", function ()
function pfUI.uf.raid:UpdateConfig() function pfUI.uf.raid:UpdateConfig()
local rawborder, default_border = GetBorderSize("unitframes") local rawborder, default_border = GetBorderSize("unitframes")
maxraid = tonumber(C.unitframes.maxraid) maxraid = tonumber(C.unitframes.maxraid)
local showpets = C.unitframes.raidpet.visible == "1"
self.showpets = showpets
for i=1,maxraid do for i=1,maxraid do
pfUI.uf.raid[i] = pfUI.uf.raid[i] or pfUI.uf:CreateUnitFrame("Raid", i, C.unitframes.raid) pfUI.uf.raid[i] = pfUI.uf.raid[i] or pfUI.uf:CreateUnitFrame("Raid", i, C.unitframes.raid)
@@ -36,6 +61,18 @@ pfUI:RegisterModule("raid", function ()
pfUI.uf.raid[i]:UpdateConfig() pfUI.uf.raid[i]:UpdateConfig()
pfUI.uf.raid[i]:UpdateFrameSize() pfUI.uf.raid[i]:UpdateFrameSize()
if showpets then
self.pets[i] = self.pets[i] or pfUI.uf:CreateUnitFrame("RaidPet", i, C.unitframes.raidpet, 0.5)
self.pets[i]:SetParent(petcluster)
self.pets[i]:SetFrameLevel(5)
self.pets[i]:UpdateConfig()
self.pets[i]:UpdateFrameSize()
elseif self.pets[i] then
self.pets[i]:UpdateConfig()
self.pets[i]:Hide()
RemoveMovable(self.pets[i])
end
end end
local i = 1 local i = 1
@@ -47,6 +84,17 @@ pfUI:RegisterModule("raid", function ()
local _, _, x, y = string.find(layout,"(.+)x(.+)") local _, _, x, y = string.find(layout,"(.+)x(.+)")
x, y = tonumber(x), tonumber(y) x, y = tonumber(x), tonumber(y)
if showpets then
local petcfg = C.unitframes.raidpet
local _, _, px, py = string.find(petcfg.raidlayout, "(.+)x(.+)")
self.petgrid = {
fill = petcfg.raidfill, x = tonumber(px), y = tonumber(py),
pad = tonumber(petcfg.raidpadding) * GetPerfectPixel(),
w = self.pets[1]:GetWidth()+2*default_border,
h = self.pets[1]:GetHeight()+2*default_border,
}
end
if fill == "VERTICAL" then if fill == "VERTICAL" then
for r=1, x do for g=1, y do for r=1, x do for g=1, y do
if pfUI.uf.raid[i] then if pfUI.uf.raid[i] then
@@ -66,6 +114,67 @@ pfUI:RegisterModule("raid", function ()
i = i + 1 i = i + 1
end end end end
end end
self:LayoutPets()
self:Show()
end
function pfUI.uf.raid:LayoutPets()
if not self.showpets or not self.petgrid then return end
local grid = self.petgrid
local function place(pet, cell, id)
pet.label = "raidpet"
pet.id = id
local r, g = SlotToCoord(cell, grid.fill, grid.x, grid.y)
pet:ClearAllPoints()
pet:SetPoint("BOTTOMLEFT", petcluster, "BOTTOMLEFT", (r-1)*(grid.pad+grid.w), (g-1)*(grid.pad+grid.h))
UpdateMovable(pet, true)
pet:UpdateVisibility()
end
if pfUI.uf.showall then
for id = 1, maxraid do
if self.pets[id] then place(self.pets[id], id, id) end
end
return
end
-- Party shown as a raid grid: mirror slots 1..5 (player + party members)
-- into fixed cells. UpdateVisibility maps each slot to pet / partypet<N>.
if not IsInRaid() and IsInGroup() and C.unitframes.raidforgroup == "1" then
for id = 1, maxraid do
if self.pets[id] then
if id <= 5 then
place(self.pets[id], id, id)
else
self.pets[id].id = 0
self.pets[id]:Hide()
end
end
end
return
end
if C.unitframes.raidpet.collapse == "1" then
-- Pack the pets that exist into the leading cells, no gaps.
local k = 0
for id = 1, maxraid do
if UnitExists("raidpet"..id) and self.pets[k+1] then
k = k + 1
place(self.pets[k], k, id)
end
end
for j = k+1, maxraid do
if self.pets[j] then self.pets[j].id = 0 self.pets[j]:Hide() end
end
else
-- Mirror: cell N always shows raidpet<N> at a fixed position.
for id = 1, maxraid do
if self.pets[id] then place(self.pets[id], id, id) end
end
end
end end
pfUI.uf.raid:UpdateConfig() pfUI.uf.raid:UpdateConfig()
@@ -76,13 +185,22 @@ pfUI:RegisterModule("raid", function ()
frame:UpdateVisibility() frame:UpdateVisibility()
end end
-- add units to the beginning of their groups -- add units to their groups; collapse packs everyone into the leading slots
function pfUI.uf.raid:AddUnitToGroup(index, group) function pfUI.uf.raid:AddUnitToGroup(index, group)
for subindex = 1, 5 do if C.unitframes.raid.collapse == "1" then
local ids = subindex + 5*(group-1) for ids = 1, maxraid do
if pfUI.uf.raid[ids] and pfUI.uf.raid[ids].id == 0 and pfUI.uf.raid[ids].config.visible == "1" then if pfUI.uf.raid[ids] and pfUI.uf.raid[ids].id == 0 and pfUI.uf.raid[ids].config.visible == "1" then
SetRaidIndex(pfUI.uf.raid[ids], index) SetRaidIndex(pfUI.uf.raid[ids], index)
return return
end
end
else
for subindex = 1, 5 do
local ids = subindex + 5*(group-1)
if pfUI.uf.raid[ids] and pfUI.uf.raid[ids].id == 0 and pfUI.uf.raid[ids].config.visible == "1" then
SetRaidIndex(pfUI.uf.raid[ids], index)
return
end
end end
end end
end end
@@ -92,7 +210,14 @@ pfUI:RegisterModule("raid", function ()
pfUI.uf.raid:RegisterEvent("PARTY_MEMBERS_CHANGED") pfUI.uf.raid:RegisterEvent("PARTY_MEMBERS_CHANGED")
pfUI.uf.raid:RegisterEvent("PARTY_LEADER_CHANGED") pfUI.uf.raid:RegisterEvent("PARTY_LEADER_CHANGED")
pfUI.uf.raid:RegisterEvent("VARIABLES_LOADED") pfUI.uf.raid:RegisterEvent("VARIABLES_LOADED")
pfUI.uf.raid:RegisterEvent("UNIT_PET")
pfUI.uf.raid:SetScript("OnEvent", function() pfUI.uf.raid:SetScript("OnEvent", function()
if event == "UNIT_PET" then
if this.showpets and C.unitframes.raidpet.collapse == "1" then
this:LayoutPets()
end
return
end
this:Show() this:Show()
-- Debounce: delay update by 0.5s to batch rapid roster changes (mass swaps) -- Debounce: delay update by 0.5s to batch rapid roster changes (mass swaps)
this.pendingUpdate = GetTime() + 0.5 this.pendingUpdate = GetTime() + 0.5
@@ -105,8 +230,13 @@ pfUI:RegisterModule("raid", function ()
this.tick = GetTime() + 1.0 this.tick = GetTime() + 1.0
this.pendingUpdate = nil this.pendingUpdate = nil
-- don't proceed without raid -- Without a raid there is nothing to sort, but a party shown as a raid
if not IsInRaid() then return end -- grid still needs its pet frames placed and mapped to the party pets.
if not IsInRaid() then
this:LayoutPets()
this:Hide()
return
end
-- clear all existing frames -- clear all existing frames
for i=1, maxraid do SetRaidIndex(pfUI.uf.raid[i], 0) end for i=1, maxraid do SetRaidIndex(pfUI.uf.raid[i], 0) end
@@ -127,6 +257,8 @@ pfUI:RegisterModule("raid", function ()
end end
end end
this:LayoutPets()
-- Smart GUID-based updates: only refresh frames where unit changed -- Smart GUID-based updates: only refresh frames where unit changed
if pfUI.uf.guidTracker then if pfUI.uf.guidTracker then
local tracker = pfUI.uf.guidTracker local tracker = pfUI.uf.guidTracker
@@ -164,7 +296,7 @@ pfUI:RegisterModule("raid", function ()
end end
end end
pfUI.hooksecurefunc("UnitPopup_OnClick", function() hooksecurefunc("UnitPopup_OnClick", function()
local dropdownFrame = UIDROPDOWNMENU_INIT_MENU and _G[UIDROPDOWNMENU_INIT_MENU] local dropdownFrame = UIDROPDOWNMENU_INIT_MENU and _G[UIDROPDOWNMENU_INIT_MENU]
if not dropdownFrame then return end if not dropdownFrame then return end
local button = this.value local button = this.value
modules/roll.lua
+9 -4
View File
@@ -7,8 +7,12 @@ pfUI:RegisterModule("roll", function ()
local LOOT_ROLL_NEED = string.gsub(LOOT_ROLL_NEED, "%%s|Hitem:%%d:%%d:%%d:%%d|h%[%%s%]|h%%s", "%%s") local LOOT_ROLL_NEED = string.gsub(LOOT_ROLL_NEED, "%%s|Hitem:%%d:%%d:%%d:%%d|h%[%%s%]|h%%s", "%%s")
local LOOT_ROLL_PASSED = string.gsub(LOOT_ROLL_PASSED, "%%s|Hitem:%%d:%%d:%%d:%%d|h%[%%s%]|h%%s", "%%s") local LOOT_ROLL_PASSED = string.gsub(LOOT_ROLL_PASSED, "%%s|Hitem:%%d:%%d:%%d:%%d|h%[%%s%]|h%%s", "%%s")
-- try to detect the everyone string -- detect the "everyone passed" subject exactly as the loot scanner will capture
local _, _, everyone, _ = strfind(LOOT_ROLL_ALL_PASSED, LOOT_ROLL_PASSED) -- it: feed a dummy item into LOOT_ROLL_ALL_PASSED and run the same LOOT_ROLL_PASSED
-- match. (The old strfind had no captures, so `everyone` was always nil and
-- "Everyone has passed on: X" got counted as a fake roller.)
local everyoneSample = string.gsub(LOOT_ROLL_ALL_PASSED, "%%s", "x")
local everyone = cmatch(everyoneSample, LOOT_ROLL_PASSED)
pfUI.roll.blacklist = { YOU, everyone } pfUI.roll.blacklist = { YOU, everyone }
pfUI.roll.cache = {} pfUI.roll.cache = {}
@@ -42,7 +46,8 @@ pfUI:RegisterModule("roll", function ()
end end
local _, _, itemLink = string.find(hyperlink, "(item:%d+:%d+:%d+:%d+)") local _, _, itemLink = string.find(hyperlink, "(item:%d+:%d+:%d+:%d+)")
local itemName = GetItemInfo(itemLink) local itemName = C_Item.GetItemInfo(itemLink)
if not itemName then return end -- uncached item: avoid cache[nil] "table index is nil"
-- delete obsolete tables -- delete obsolete tables
if pfUI.roll.cache[itemName] and pfUI.roll.cache[itemName]["TIMESTAMP"] < GetTime() - 60 then if pfUI.roll.cache[itemName] and pfUI.roll.cache[itemName]["TIMESTAMP"] < GetTime() - 60 then
@@ -234,7 +239,7 @@ pfUI:RegisterModule("roll", function ()
f.time.bar:SetAllPoints(f.time) f.time.bar:SetAllPoints(f.time)
f.time.bar:SetStatusBarTexture(pfUI.media["img:bar"]) f.time.bar:SetStatusBarTexture(pfUI.media["img:bar"])
f.time.bar:SetMinMaxValues(0, 100) f.time.bar:SetMinMaxValues(0, 100)
local r, g, b, a = strsplit(",", C.appearance.border.color) local r, g, b, a = GetStringColor(C.appearance.border.color)
f.time.bar:SetStatusBarColor(r, g, b) f.time.bar:SetStatusBarColor(r, g, b)
f.time.bar:SetValue(20) f.time.bar:SetValue(20)
f.time.bar:SetScript("OnUpdate", function() f.time.bar:SetScript("OnUpdate", function()
modules/screenshot.lua
+4 -4
View File
@@ -119,7 +119,7 @@ pfUI:RegisterModule("screenshot", function ()
end end
function pfUI.screenshot:CHAT_MSG_SYSTEM() function pfUI.screenshot:CHAT_MSG_SYSTEM()
local _,_, standing, rep = string.find(arg1, FACTION_STANDING_CHANGEDregex) local standing, rep = string.match(arg1, FACTION_STANDING_CHANGEDregex)
if standing and rep then if standing and rep then
local dt = date("%a, %b %d, %Y %X") local dt = date("%a, %b %d, %Y %X")
local loc = string.format("%s - %s",GetRealZoneText(),GetSubZoneText()) local loc = string.format("%s - %s",GetRealZoneText(),GetSubZoneText())
@@ -150,13 +150,13 @@ pfUI:RegisterModule("screenshot", function ()
end end
function pfUI.screenshot:CHAT_MSG_LOOT() function pfUI.screenshot:CHAT_MSG_LOOT()
local _,_, item, amount = string.find(arg1, LOOT_ITEM_SELF_MULTIPLEregex) local item, amount = string.match(arg1, LOOT_ITEM_SELF_MULTIPLEregex)
if amount then -- ignore stacks if amount then -- ignore stacks
return return
else else
_,_, item = string.find(arg1, LOOT_ITEM_SELFregex) item = string.match(arg1, LOOT_ITEM_SELFregex)
if item then if item then
local _, _, itemColor, itemString, itemName = string.find(item, "^(|c%x+)|H(.+)|h(%[.+%])") local itemColor, itemString, itemName = string.match(item, "^(|c%x+)|H(.+)|h(%[.+%])")
local quality = color2quality[itemColor] local quality = color2quality[itemColor]
if quality and quality >= tonumber(C.screenshot.loot) then if quality and quality >= tonumber(C.screenshot.loot) then
local dt = date("%a, %b %d, %Y %X") local dt = date("%a, %b %d, %Y %X")
modules/sellvalue.lua
+138 -15
View File
@@ -1,13 +1,11 @@
pfUI:RegisterModule("sellvalue", function () pfUI:RegisterModule("sellvalue", function ()
local function AddVendorPrices(frame, id, count) local function AddVendorPrices(frame, id, count)
if not id then return end if not id then return end
-- Sell price comes from the engine (item DBC); buy price from pfSellData
-- (curated vendor data, since vendor purchase prices aren't a static field).
local sell = C_Item.GetItemSellPriceByID(id) or 0 local sell = C_Item.GetItemSellPriceByID(id) or 0
local buy = pfSellData[id] local buy = pfSellData[id]
if sell == 0 and not buy then return end if sell == 0 and not buy then return end
if C.tooltip.vendor.showalways == "1" or IsShiftKeyDown() then if C.tooltip.vendor.showalways == "1" or IsShiftKeyDown() then
frame:AddLine(" ") frame:AddLine(" ")
if sell > 0 then if sell > 0 then
@@ -25,26 +23,151 @@ pfUI:RegisterModule("sellvalue", function ()
frame:AddDoubleLine(T["Buy"] .. ":", CreateGoldString(buy), 1, 1, 1) frame:AddDoubleLine(T["Buy"] .. ":", CreateGoldString(buy), 1, 1, 1)
end end
end end
elseif not MerchantFrame:IsShown() and sell > 0 then
SetTooltipMoney(frame, sell * count)
end end
frame:Show() frame:Show()
end end
pfUI.sellvalue = CreateFrame("Frame", "pfGameTooltip", GameTooltip) hooksecurefunc("SetItemRef", function()
pfUI.sellvalue:SetScript("OnShow", function()
if GameTooltip:HasItem() then
local _, _, id = GameTooltip:GetItem()
if id then
local count = tonumber(libtooltip:GetItemCount()) or 1
AddVendorPrices(GameTooltip, id, math.max(count, 1))
end
end
end)
pfUI.hooksecurefunc("SetItemRef", function()
if IsModifierKeyDown() then return end if IsModifierKeyDown() then return end
if ItemRefTooltip:HasItem() then if ItemRefTooltip:HasItem() then
local _, _, id = ItemRefTooltip:GetItem() local _, _, id = ItemRefTooltip:GetItem()
if id then AddVendorPrices(ItemRefTooltip, id, 1) end if id then AddVendorPrices(ItemRefTooltip, id, 1) end
end end
end) end)
local TooltipHooks = {
SetLootRollItem = {
id = GetLootRollItemID,
count = function(slot)
local _, _, count = GetLootRollItemInfo(slot)
return count
end
},
SetLootItem = {
id = GetLootSlotItemID,
count = function(slot)
local _, _, count = GetLootSlotInfo(slot)
return count
end
},
SetQuestLogItem = {
id = GetQuestLogItemID,
count = function(type, index)
local itemCount, _;
if type == "choice" then
_, _, itemCount = GetQuestLogChoiceInfo(index);
else
_, _, itemCount = GetQuestLogRewardInfo(index)
end
return itemCount
end,
},
SetQuestItem = {
id = GetQuestItemID,
count = function(type, index)
local _, _, count = GetQuestItemInfo(type, index);
return count
end,
},
SetHyperlink = { id = C_Item.GetItemInfoInstant },
SetBagItem = {
id = C_Container.GetContainerItemID,
count = function(container, slot)
local _, count = GetContainerItemInfo(container, slot)
return count
end,
},
SetInboxItem = {
id = GetInboxItemID,
count = function(index)
local _, _, _, count = GetInboxItem(index)
return count
end,
},
SetSendMailItem = {
id = function()
local _, id = GetSendMailItemLink()
return id
end,
count = function()
local _, _, count = GetSendMailItem()
return count
end,
},
SetInventoryItem = { id = GetInventoryItemID },
SetTradeSkillItem = {
id = function(skillIndex, reagentIndex)
if reagentIndex then
return GetTradeSkillReagentItemID(skillIndex, reagentIndex)
else
return GetTradeSkillItemID(skillIndex)
end
end,
count = function(skillIndex, reagentIndex)
if reagentIndex then
local _, _, itemCount = GetTradeSkillReagentInfo(skillIndex, reagentIndex)
return itemCount
else
return GetTradeSkillNumMade(skillIndex)
end
end,
},
SetAuctionItem = {
id = GetAuctionItemLink,
count = function(viewType, index)
local _, _, count = GetAuctionItemInfo(viewType, index)
return count
end,
},
SetAuctionSellItem = { id = GetAuctionSellItemLink },
SetTradePlayerItem = {
id = GetTradePlayerItemLink,
count = function(id)
local _, _, count = GetTradePlayerItemInfo(id)
return count
end,
},
SetTradeTargetItem = {
id = GetTradeTargetItemLink,
count = function(id)
local _, _, count = GetTradeTargetItemInfo(id)
return count
end,
},
SetMerchantItem = {
id = GetMerchantItemID,
count = function(index)
local _, _, _, itemCount = GetMerchantItemInfo(index)
return itemCount
end
},
SetCraftItem = {
id = function(recipeIndex, reagentIndex)
return GetCraftReagentItemID(recipeIndex, reagentIndex)
end
},
SetBuybackItem = {
id = C_MerchantFrame.GetBuybackItemID,
count = function(slotIndex)
local _, _, _, itemCount = GetBuybackItemInfo(slotIndex)
return itemCount
end
}
}
local function makeHook(entry)
return function(tooltip, arg1, arg2, arg3)
AddVendorPrices(tooltip, entry.id(arg1, arg2, arg3), entry.count and entry.count(arg1, arg2, arg3) or 1)
end
end
local function HookTooltip(tooltip)
for setter, entry in pairs(TooltipHooks) do
hooksecurefunc(tooltip, setter, makeHook(entry))
end
end
HookTooltip(GameTooltip)
end) end)
modules/share.lua
+2 -3
View File
@@ -389,9 +389,8 @@ pfUI:RegisterModule("share", function ()
end) end)
end end
_G.SLASH_PFEXPORT1, _G.SLASH_PFEXPORT2, _G.SLASH_PFEXPORT3 = "/export", "/import", "/share" pfUI.api.RegisterSlashCommand("PFEXPORT", { "/export", "/import", "/share" }, function(msg, editbox)
function SlashCmdList.PFEXPORT(msg, editbox)
f:Show() f:Show()
end end, true)
end end
end) end)
modules/skin.lua
+2 -2
View File
@@ -51,12 +51,12 @@ pfUI:RegisterModule("skin", function ()
DurabilityFrame.SetPoint = function() return end DurabilityFrame.SetPoint = function() return end
if C.appearance.cd.blizzard == "1" then if C.appearance.cd.blizzard == "1" then
pfUI.hooksecurefunc("PaperDollItemSlotButton_Update", function() hooksecurefunc("PaperDollItemSlotButton_Update", function()
local cooldown = _G[this:GetName().."Cooldown"] local cooldown = _G[this:GetName().."Cooldown"]
if cooldown then cooldown.pfCooldownType = "BLIZZARD" end if cooldown then cooldown.pfCooldownType = "BLIZZARD" end
end) end)
pfUI.hooksecurefunc("SpellButton_UpdateButton", function() hooksecurefunc("SpellButton_UpdateButton", function()
local cooldown = _G[this:GetName().."Cooldown"] local cooldown = _G[this:GetName().."Cooldown"]
if cooldown then cooldown.pfCooldownType = "BLIZZARD" end if cooldown then cooldown.pfCooldownType = "BLIZZARD" end
end) end)
modules/socialmod.lua
+74 -76
View File
@@ -4,13 +4,13 @@ pfUI:RegisterModule("socialmod", function ()
pfUI.socialmod:RegisterEvent("CHAT_MSG_SYSTEM") pfUI.socialmod:RegisterEvent("CHAT_MSG_SYSTEM")
pfUI.socialmod:SetScript("OnEvent", function() pfUI.socialmod:SetScript("OnEvent", function()
local name = cmatch(arg1, _G.ERR_FRIEND_ONLINE_SS) local name = cmatch(arg1, _G.ERR_FRIEND_ONLINE_SS)
name = cmatch(arg1, _G.ERR_FRIEND_OFFLINE_S) name = name or cmatch(arg1, _G.ERR_FRIEND_OFFLINE_S)
if name and playerdb[name] and playerdb[name].cname then if name and playerdb[name] and playerdb[name].cname then
playerdb[name].lastseen = date("%a %d-%b-%Y") playerdb[name].lastseen = date("%a %d-%b-%Y")
end end
end) end)
do -- add colors to guild list do -- add colors to guild list
pfUI.hooksecurefunc("GuildStatus_Update", function() hooksecurefunc("GuildStatus_Update", function()
local playerzone = GetRealZoneText() local playerzone = GetRealZoneText()
local off = FauxScrollFrame_GetOffset(GuildListScrollFrame) local off = FauxScrollFrame_GetOffset(GuildListScrollFrame)
for i=1, GUILDMEMBERS_TO_DISPLAY, 1 do for i=1, GUILDMEMBERS_TO_DISPLAY, 1 do
@@ -70,27 +70,26 @@ pfUI:RegisterModule("socialmod", function ()
end end
do -- add colors to friend list do -- add colors to friend list
pfUI.hooksecurefunc("FriendsList_Update", function() hooksecurefunc("FriendsList_Update", function()
if GetNumFriends() == 0 then return end if GetNumFriends() == 0 then return end
local playerzone = GetRealZoneText() local playerzone = GetRealZoneText()
local off = FauxScrollFrame_GetOffset(FriendsFrameFriendsScrollFrame) local off = FauxScrollFrame_GetOffset(FriendsFrameFriendsScrollFrame)
for i=1, FRIENDS_TO_DISPLAY do for i=1, FRIENDS_TO_DISPLAY do
local name, level, class, zone, connected, status = GetFriendInfo(off + i) local info = C_FriendList.GetFriendInfoByIndex(off + i)
if not name or name == _G.UNKNOWN then break end if not info or not info.name or info.name == _G.UNKNOWN then break end
local name = info.name
local friendName = _G["FriendsFrameFriendButton"..i.."ButtonTextName"] local friendName = _G["FriendsFrameFriendButton"..i.."ButtonTextName"]
local friendLoc = _G["FriendsFrameFriendButton"..i..FRIENDS_NAME_LOCATION] local friendLoc = _G["FriendsFrameFriendButton"..i.."ButtonTextNameLocation"]
local friendInfo = _G["FriendsFrameFriendButton"..i.."ButtonTextInfo"] local friendInfo = _G["FriendsFrameFriendButton"..i.."ButtonTextInfo"]
local caption = friendName or friendLoc local caption = friendName or friendLoc
if connected then if info.connected then
if not class or class == _G.UNKNOWN then break end local ccolor = PFUI_CLASS_COLORS[info.classFilename]
local ccolor = PFUI_CLASS_COLORS[L["class"][class]] or { 1, 1, 1 } local status = info.afk and CHAT_FLAG_AFK or info.dnd and CHAT_FLAG_DND or ""
local lcolor = GetDifficultyColor(tonumber(level)) or { 1, 1, 1 } local zone = ( info.area == playerzone and "|cffffffff" or "|cffcccccc" ) .. info.area .. "|r"
local cname = ccolor:WrapTextInColorCode(name)
zone = ( zone == playerzone and "|cffffffff" or "|cffcccccc" ) .. zone .. "|r"
local cname = rgbhex(ccolor) .. name .. "|r"
if playerdb[name] then if playerdb[name] then
playerdb[name].lastseen = date("%a %d-%b-%Y") playerdb[name].lastseen = date("%a %d-%b-%Y")
playerdb[name].cname = cname playerdb[name].cname = cname
@@ -98,20 +97,20 @@ pfUI:RegisterModule("socialmod", function ()
if friendName then if friendName then
friendName:SetText(cname) friendName:SetText(cname)
friendLoc:SetText(format(TEXT(FRIENDS_LIST_TEMPLATE), zone, status)) friendLoc:SetFormattedText(TEXT(FRIENDS_LIST_TEMPLATE), zone, status)
else else
friendLoc:SetText(format(TEXT(FRIENDS_LIST_TEMPLATE), cname, zone, status)) friendLoc:SetFormattedText(TEXT(FRIENDS_LIST_TEMPLATE), cname, zone, status)
end end
friendInfo:SetText(format(TEXT(FRIENDS_LEVEL_TEMPLATE), level, class)) friendInfo:SetFormattedText(TEXT(FRIENDS_LEVEL_TEMPLATE), info.level, info.className)
caption:SetVertexColor(1,1,1,.9) caption:SetVertexColor(1,1,1,.9)
friendInfo:SetVertexColor(1,1,1,.9) friendInfo:SetVertexColor(1,1,1,.9)
else else
if playerdb[name] and playerdb[name].cname and playerdb[name].level and playerdb[name].lastseen then if playerdb[name] and playerdb[name].cname and playerdb[name].level and playerdb[name].lastseen then
caption:SetText(format(TEXT(FRIENDS_LIST_OFFLINE_TEMPLATE), playerdb[name].cname)) caption:SetFormattedText(TEXT(FRIENDS_LIST_OFFLINE_TEMPLATE), playerdb[name].cname)
friendInfo:SetText(format(TEXT(FRIENDS_LEVEL_TEMPLATE), playerdb[name].level, playerdb[name].lastseen)) friendInfo:SetFormattedText(TEXT(FRIENDS_LEVEL_TEMPLATE), playerdb[name].level, playerdb[name].lastseen)
else else
caption:SetText(format(TEXT(FRIENDS_LIST_OFFLINE_TEMPLATE), name.."|r")) caption:SetFormattedText(TEXT(FRIENDS_LIST_OFFLINE_TEMPLATE), name.."|r")
friendInfo:SetText(TEXT(UNKNOWN)) friendInfo:SetText(TEXT(UNKNOWN))
end end
@@ -123,75 +122,74 @@ pfUI:RegisterModule("socialmod", function ()
end end
do -- add colors to who list do -- add colors to who list
pfUI.hooksecurefunc("WhoList_Update", function() hooksecurefunc("WhoList_Update", function()
local num, max = GetNumWhoResults() local num, max = C_FriendList.GetNumWhoResults()
local off = FauxScrollFrame_GetOffset(WhoListScrollFrame) local off = FauxScrollFrame_GetOffset(WhoListScrollFrame)
local playerzone = GetRealZoneText() local playerzone = GetRealZoneText()
local playerrace = UnitRace("player") local playerrace = UnitRace("player")
local playerguild = GetGuildInfo("player") local playerguild = GetGuildInfo("player")
if num + 1 >= MAX_WHOS_FROM_SERVER then
WhoFrameTotals:SetFormattedText("|cffffffff" .. GetText("WHO_FRAME_TOTAL_TEMPLATE", nil, num) .. " |cffaaaaaa" .. WHO_FRAME_SHOWN_TEMPLATE, max, MAX_WHOS_FROM_SERVER)
else
WhoFrameTotals:SetFormattedText("|cffffffff" .. GetText("WHO_FRAME_TOTAL_TEMPLATE", nil, num) .. " |cffaaaaaa" .. WHO_FRAME_SHOWN_TEMPLATE, num, num)
end
for i=1, WHOS_TO_DISPLAY do for i=1, WHOS_TO_DISPLAY do
local name, guild, level, race, class, zone = GetWhoInfo(off + i) local info = C_FriendList.GetWhoInfo(off + i)
local displayedText = "" if info then
-- filename is the class token, so no L["class"] reversal is needed
local class = info.filename
if num + 1 >= MAX_WHOS_FROM_SERVER then _G["WhoFrameButton"..i.."Name"]:SetTextColor(NORMAL_FONT_COLOR:GetRGB())
displayedText = format(WHO_FRAME_SHOWN_TEMPLATE, MAX_WHOS_FROM_SERVER)
WhoFrameTotals:SetText("|cffffffff" .. format(GetText("WHO_FRAME_TOTAL_TEMPLATE", nil, num), max).." |cffaaaaaa"..displayedText)
else
displayedText = format(WHO_FRAME_SHOWN_TEMPLATE, num)
WhoFrameTotals:SetText("|cffffffff" .. format(GetText("WHO_FRAME_TOTAL_TEMPLATE", nil, num), num).." |cffaaaaaa"..displayedText)
end
class = L["class"][class] if (UIDropDownMenu_GetSelectedID(WhoFrameDropDown) == 1) then
if (info.area == playerzone) then
_G["WhoFrameButton"..i.."Name"]:SetTextColor(NORMAL_FONT_COLOR.r, NORMAL_FONT_COLOR.g, NORMAL_FONT_COLOR.b) _G["WhoFrameButton"..i.."Variable"]:SetTextColor(.5, 1, 1)
if (UIDropDownMenu_GetSelectedID(WhoFrameDropDown) == 1) then
if (zone == playerzone) then
_G["WhoFrameButton"..i.."Variable"]:SetTextColor(.5, 1, 1)
else
_G["WhoFrameButton"..i.."Variable"]:SetTextColor(1, 1, 1)
end
elseif (UIDropDownMenu_GetSelectedID(WhoFrameDropDown) == 2) then
if (guild == playerguild) then
_G["WhoFrameButton"..i.."Variable"]:SetTextColor(.5, 1, 1)
else
_G["WhoFrameButton"..i.."Variable"]:SetTextColor(1, 1, 1)
end
elseif (UIDropDownMenu_GetSelectedID(WhoFrameDropDown) == 3) then
if (race == playerrace) then
_G["WhoFrameButton"..i.."Variable"]:SetTextColor(.5, 1, 1)
else
_G["WhoFrameButton"..i.."Variable"]:SetTextColor(1, 1, 1)
end
end
if class then
local classicon = _G["WhoFrameButton"..i].classicon
local coords = CLASS_ICON_TCOORDS[class]
local color = PFUI_CLASS_COLORS[class]
-- do we have classicons? (skin enabled?)
if classicon then
_G["WhoFrameButton"..i.."Class"]:SetTextColor(0,0,0,0)
_G["WhoFrameButton"..i.."Name"]:SetTextColor(color.r,color.g,color.b,1)
if coords then
classicon:Show()
classicon:SetTexCoord(unpack(coords))
else else
classicon:Hide() _G["WhoFrameButton"..i.."Variable"]:SetTextColor(1, 1, 1)
end end
else
_G["WhoFrameButton"..i.."Class"]:SetTextColor(color.r,color.g,color.b,1)
end
end
local color = GetDifficultyColor(level) elseif (UIDropDownMenu_GetSelectedID(WhoFrameDropDown) == 2) then
_G["WhoFrameButton"..i.."Level"]:SetTextColor(color.r, color.g, color.b) if (info.fullGuildName == playerguild) then
_G["WhoFrameButton"..i.."Variable"]:SetTextColor(.5, 1, 1)
else
_G["WhoFrameButton"..i.."Variable"]:SetTextColor(1, 1, 1)
end
elseif (UIDropDownMenu_GetSelectedID(WhoFrameDropDown) == 3) then
if (info.raceStr == playerrace) then
_G["WhoFrameButton"..i.."Variable"]:SetTextColor(.5, 1, 1)
else
_G["WhoFrameButton"..i.."Variable"]:SetTextColor(1, 1, 1)
end
end
if class then
local classicon = _G["WhoFrameButton"..i].classicon
local coords = CLASS_ICON_TCOORDS[class]
local color = PFUI_CLASS_COLORS[class]
-- do we have classicons? (skin enabled?)
if classicon then
_G["WhoFrameButton"..i.."Class"]:SetTextColor(0,0,0,0)
_G["WhoFrameButton"..i.."Name"]:SetTextColor(color.r,color.g,color.b,1)
if coords then
classicon:Show()
classicon:SetTexCoord(unpack(coords))
else
classicon:Hide()
end
else
_G["WhoFrameButton"..i.."Class"]:SetTextColor(color.r,color.g,color.b,1)
end
end
local color = GetDifficultyColor(info.level)
_G["WhoFrameButton"..i.."Level"]:SetTextColor(color.r, color.g, color.b)
end
end end
end) end)
end end
modules/superwow.lua
+8 -8
View File
@@ -2,8 +2,7 @@
-- https://github.com/balakethelock/SuperWoW -- https://github.com/balakethelock/SuperWoW
-- DLL Status Check Command (always available) -- DLL Status Check Command (always available)
SLASH_PFDLLSTATUS1 = "/pfdll" pfUI.api.RegisterSlashCommand("PFDLLSTATUS", { "/pfdll" }, function()
SlashCmdList["PFDLLSTATUS"] = function()
local chat = DEFAULT_CHAT_FRAME local chat = DEFAULT_CHAT_FRAME
chat:AddMessage("|cff33ffccpfUI|r: DLL Status Check") chat:AddMessage("|cff33ffccpfUI|r: DLL Status Check")
@@ -43,7 +42,7 @@ SlashCmdList["PFDLLSTATUS"] = function()
else else
chat:AddMessage(" |cffff0000Target frame|r: NOT found") chat:AddMessage(" |cffff0000Target frame|r: NOT found")
end end
end end, true)
pfUI:RegisterModule("superwow", function () pfUI:RegisterModule("superwow", function ()
if SetAutoloot and SpellInfo and not SUPERWOW_VERSION then if SetAutoloot and SpellInfo and not SUPERWOW_VERSION then
@@ -76,7 +75,10 @@ pfUI:RegisterModule("superwow", function ()
DEFAULT_CHAT_FRAME:AddMessage("-> https://github.com/balakethelock/SuperWoW/releases/") DEFAULT_CHAT_FRAME:AddMessage("-> https://github.com/balakethelock/SuperWoW/releases/")
end end
if SUPERWOW_VERSION == "1.5" then -- compare numerically: an exact string match silently drops this on any
-- SuperWoW release past 1.5
local swVersion = tonumber(SUPERWOW_VERSION)
if swVersion and swVersion >= 1.5 then
QueueFunction(function() QueueFunction(function()
local pfCombatText_AddMessage = _G.CombatText_AddMessage local pfCombatText_AddMessage = _G.CombatText_AddMessage
_G.CombatText_AddMessage = function(message, a, b, c, d, e, f) _G.CombatText_AddMessage = function(message, a, b, c, d, e, f)
@@ -173,12 +175,10 @@ pfUI:RegisterModule("superwow", function ()
end end
-- Add slash command for clickthrough toggle -- Add slash command for clickthrough toggle
_G.SLASH_PFCLICKTHROUGH1 = "/clickthrough" pfUI.api.RegisterSlashCommand("PFCLICKTHROUGH", { "/clickthrough", "/ct" }, function()
_G.SLASH_PFCLICKTHROUGH2 = "/ct"
SlashCmdList["PFCLICKTHROUGH"] = function()
local enabled = pfUI.api.ToggleClickthrough() local enabled = pfUI.api.ToggleClickthrough()
DEFAULT_CHAT_FRAME:AddMessage("|cff33ffccpfUI|r: Clickthrough mode " .. (enabled and "|cff00ff00enabled|r" or "|cffff0000disabled|r")) DEFAULT_CHAT_FRAME:AddMessage("|cff33ffccpfUI|r: Clickthrough mode " .. (enabled and "|cff00ff00enabled|r" or "|cffff0000disabled|r"))
end end, true)
end end
end) end)
modules/swingtimer.lua
+67 -43
View File
@@ -1,4 +1,3 @@
pfUI:RegisterNewModule("swingtimer", "Swing Timer")
pfUI:RegisterModule("swingtimer", function () pfUI:RegisterModule("swingtimer", function ()
local rawborder, border = GetBorderSize() local rawborder, border = GetBorderSize()
@@ -10,11 +9,6 @@ pfUI:RegisterModule("swingtimer", function ()
local ON_SWING_QUEUED = 0 local ON_SWING_QUEUED = 0
local ON_SWING_QUEUE_POPPED = 1 local ON_SWING_QUEUE_POPPED = 1
-- Spell.dbc bits used to mirror server-side swing-reset rules.
local FLAG_AUTOATTACK = tonumber("0x08", 16) -- SPELL_INTERRUPT_FLAG_AUTOATTACK
local ATTR_KEEP_SWINGS = tonumber("0x20000", 16) -- SPELL_ATTR_EX2_NOT_RESET_AUTO_ACTIONS
local ATTR_ON_NEXT_SWING = tonumber("0x04", 16) -- SPELL_ATTR_ON_NEXT_SWING
-- Consolidate state into a table to avoid Lua 5.0 upvalue limit (32 max) -- Consolidate state into a table to avoid Lua 5.0 upvalue limit (32 max)
local S = { local S = {
mhTimer = 0, mhTimerMax = 1, mhTimer = 0, mhTimerMax = 1,
@@ -28,9 +22,10 @@ pfUI:RegisterModule("swingtimer", function ()
pendingCastSpellId = nil, pendingCastSpellId = nil,
mhFrozenAt = nil, mhFrozenAt = nil,
hsQueued = false, cleaveQueued = false, maulQueued = false, hsQueued = false, cleaveQueued = false, maulQueued = false,
hsSeenCurrent = false, cleaveSeenCurrent = false, maulSeenCurrent = false,
isWarrior = false, isWarrior = false,
isDruid = false, isDruid = false,
cachedHSSlots = {}, cachedCleaveSlots = {}, cachedHSSlots = {}, cachedCleaveSlots = {}, cachedMaulSlots = {},
useSpellQueueEvent = false, useSpellQueueEvent = false,
swingThrottle = 0, swingThrottle = 0,
onSwingCache = {}, onSwingCache = {},
@@ -43,12 +38,11 @@ pfUI:RegisterModule("swingtimer", function ()
local WAND_SHOOT_SPELLID = 5019 local WAND_SHOOT_SPELLID = 5019
local THROW_SPELLID = 2764 -- one-shot ranged, not auto-repeat local THROW_SPELLID = 2764 -- one-shot ranged, not auto-repeat
-- ATTR_ON_NEXT_SWING: spell replaces next auto-attack swing. -- On-next-swing spells replace the next auto-attack swing.
-- Covers Raptor Strike, Maul, Mongoose Bite, Holy Strike, etc. automatically. -- Covers Raptor Strike, Maul, Mongoose Bite, Holy Strike, etc. automatically.
local function IsOnSwingSpell(spellId) local function IsOnSwingSpell(spellId)
if S.onSwingCache[spellId] ~= nil then return S.onSwingCache[spellId] end if S.onSwingCache[spellId] ~= nil then return S.onSwingCache[spellId] end
local attr = GetSpellRecField(spellId, "attributes") or 0 local result = C_Spell.IsNextMeleeSpell(spellId)
local result = bit.band(attr, ATTR_ON_NEXT_SWING) ~= 0
S.onSwingCache[spellId] = result S.onSwingCache[spellId] = result
return result return result
end end
@@ -82,7 +76,7 @@ pfUI:RegisterModule("swingtimer", function ()
local ohR, ohG, ohB, ohA = ParseColor(C.unitframes.swingtimerohcolor, 0.3, 0.8, 0.3, 1) local ohR, ohG, ohB, ohA = ParseColor(C.unitframes.swingtimerohcolor, 0.3, 0.8, 0.3, 1)
local raR, raG, raB, raA = ParseColor(C.unitframes.swingtimerrangedcolor, 0.3, 0.6, 1.0, 1) local raR, raG, raB, raA = ParseColor(C.unitframes.swingtimerrangedcolor, 0.3, 0.6, 1.0, 1)
local rwR, rwG, rwB, rwA = ParseColor(C.unitframes.swingtimerrangedwarncolor, 0.9, 0.0, 0.0, 1) local rwR, rwG, rwB, rwA = ParseColor(C.unitframes.swingtimerrangedwarncolor, 0.9, 0.0, 0.0, 1)
local isHunter = UnitClass("player") == "Hunter" local isHunter = UnitClassBase("player") == "HUNTER"
local mhDefaultR, mhDefaultG, mhDefaultB = mhR, mhG, mhB local mhDefaultR, mhDefaultG, mhDefaultB = mhR, mhG, mhB
@@ -290,7 +284,9 @@ pfUI:RegisterModule("swingtimer", function ()
UpdateMovable(pfUI.swingtimer.ranged) UpdateMovable(pfUI.swingtimer.ranged)
-- OH weapon detection -- OH weapon detection
local OH_WEAPON_TYPES = { [13]=true, [21]=true } -- OH weapon detection: slot 17 (off hand) accepts one-hand (13) and off-hand
-- weapons (22); main-hand-only (21) can never sit there.
local OH_WEAPON_TYPES = { [13]=true, [22]=true }
local function HasOffhandWeapon() local function HasOffhandWeapon()
local l = GetInventoryItemLink("player", 17) local l = GetInventoryItemLink("player", 17)
if not l then return false end if not l then return false end
@@ -416,17 +412,20 @@ pfUI:RegisterModule("swingtimer", function ()
S.hsQueued = (kind == "hs") S.hsQueued = (kind == "hs")
S.cleaveQueued = (kind == "cleave") S.cleaveQueued = (kind == "cleave")
S.maulQueued = (kind == "maul") S.maulQueued = (kind == "maul")
S.hsSeenCurrent, S.cleaveSeenCurrent, S.maulSeenCurrent = false, false, false
end end
local function RebuildQueueSlotCache() local function RebuildQueueSlotCache()
if not S.isWarrior or not sw_hsqueue or S.useSpellQueueEvent then return end if not sw_hsqueue then return end
S.cachedHSSlots = {} S.cachedHSSlots = {}
S.cachedCleaveSlots = {} S.cachedCleaveSlots = {}
S.cachedMaulSlots = {}
if not (S.isWarrior or S.isDruid) then return end
for slot = 1, 120 do for slot = 1, 120 do
local kind, id = GetActionInfo(slot) local kind, id = GetActionInfo(slot)
local name local name
if kind == "spell" then if kind == "spell" then
name = GetSpellInfo(id) name = C_Spell.GetSpellName(id)
elseif kind == "macro" then elseif kind == "macro" then
name = GetMacroSpell(id) name = GetMacroSpell(id)
end end
@@ -434,6 +433,8 @@ pfUI:RegisterModule("swingtimer", function ()
table.insert(S.cachedHSSlots, slot) table.insert(S.cachedHSSlots, slot)
elseif name == CLEAVE_NAME then elseif name == CLEAVE_NAME then
table.insert(S.cachedCleaveSlots, slot) table.insert(S.cachedCleaveSlots, slot)
elseif name == MAUL_NAME then
table.insert(S.cachedMaulSlots, slot)
end end
end end
end end
@@ -445,9 +446,30 @@ pfUI:RegisterModule("swingtimer", function ()
return false return false
end end
-- Reconcile a stale event-driven queue flag against the client's current
-- action. Not every de-queue emits a SPELL_QUEUE pop — pressing Esc or
-- re-pressing to cancel an on-swing spell doesn't — so the flag alone stays
-- set. IsCurrentAction, which the client clears on cancel, is the reconciling
-- signal, but only after it has confirmed the ability as current at least once
-- (`seen`): a nampower-initiated cast may never flip IsCurrentAction, and must
-- keep its color until its own pop/resolve rather than be cleared early.
-- Returns the updated (queued, seen).
local function ReconcileQueued(queued, slots, seen)
if not queued then return false, false end
if CheckQueuedAction(slots) then return true, true end
if seen then return false, false end -- was current, now gone -> cancelled
return true, false -- never confirmed current -> keep
end
local function IsHSOrCleaveQueued() local function IsHSOrCleaveQueued()
if not sw_hsqueue or not S.isWarrior then return false, false end if not sw_hsqueue or not S.isWarrior then return false, false end
if S.useSpellQueueEvent then return S.hsQueued, S.cleaveQueued end if S.useSpellQueueEvent then
S.hsQueued, S.hsSeenCurrent =
ReconcileQueued(S.hsQueued, S.cachedHSSlots, S.hsSeenCurrent)
S.cleaveQueued, S.cleaveSeenCurrent =
ReconcileQueued(S.cleaveQueued, S.cachedCleaveSlots, S.cleaveSeenCurrent)
return S.hsQueued, S.cleaveQueued
end
return CheckQueuedAction(S.cachedHSSlots), CheckQueuedAction(S.cachedCleaveSlots) return CheckQueuedAction(S.cachedHSSlots), CheckQueuedAction(S.cachedCleaveSlots)
end end
@@ -526,6 +548,10 @@ pfUI:RegisterModule("swingtimer", function ()
-- HS/Cleave color -- HS/Cleave color
local curR, curG, curB = mhDefaultR, mhDefaultG, mhDefaultB local curR, curG, curB = mhDefaultR, mhDefaultG, mhDefaultB
if sw_hsqueue then if sw_hsqueue then
if S.isDruid and S.useSpellQueueEvent then
S.maulQueued, S.maulSeenCurrent =
ReconcileQueued(S.maulQueued, S.cachedMaulSlots, S.maulSeenCurrent)
end
if S.maulQueued and S.isDruid then if S.maulQueued and S.isDruid then
curR, curG, curB = 1.0, 0.55, 0.0 -- orange for druid maul queue curR, curG, curB = 1.0, 0.55, 0.0 -- orange for druid maul queue
elseif S.isWarrior then elseif S.isWarrior then
@@ -566,10 +592,10 @@ pfUI:RegisterModule("swingtimer", function ()
end end
pfUI.swingtimer.mainhand:SetStatusBarColor(curR, curG, curB, mhA) pfUI.swingtimer.mainhand:SetStatusBarColor(curR, curG, curB, mhA)
if sw_showtext then if sw_showtext then
pfUI.swingtimer.mainhand.text:SetText(string.format("%.1f", math.floor(S.mhTimer * 10) / 10)) pfUI.swingtimer.mainhand.text:SetFormattedText("%.1f", math.floor(S.mhTimer * 10) / 10)
end end
if sw_showspeed and S.mhSpeed > 0 then if sw_showspeed and S.mhSpeed > 0 then
pfUI.swingtimer.mainhand.speed:SetText(string.format("%.2f", S.mhSpeed)) pfUI.swingtimer.mainhand.speed:SetFormattedText("%.2f", S.mhSpeed)
end end
anyActive = true anyActive = true
end end
@@ -600,10 +626,10 @@ pfUI:RegisterModule("swingtimer", function ()
end end
end end
if sw_showtext then if sw_showtext then
pfUI.swingtimer.offhand.text:SetText(string.format("%.1f", math.floor(S.ohTimer * 10) / 10)) pfUI.swingtimer.offhand.text:SetFormattedText("%.1f", math.floor(S.ohTimer * 10) / 10)
end end
if sw_showspeed and S.ohSpeed > 0 then if sw_showspeed and S.ohSpeed > 0 then
pfUI.swingtimer.offhand.speed:SetText(string.format("%.2f", S.ohSpeed)) pfUI.swingtimer.offhand.speed:SetFormattedText("%.2f", S.ohSpeed)
end end
anyActive = true anyActive = true
elseif not sw_showoh then elseif not sw_showoh then
@@ -642,9 +668,9 @@ pfUI:RegisterModule("swingtimer", function ()
end end
if sw_showtext then if sw_showtext then
if remaining <= 0.5 then if remaining <= 0.5 then
pfUI.swingtimer.ranged.text:SetText(string.format("%.1f", math.floor(remaining * 10) / 10)) pfUI.swingtimer.ranged.text:SetFormattedText("%.1f", math.floor(remaining * 10) / 10)
else else
pfUI.swingtimer.ranged.text:SetText(string.format("%.1f", math.floor((remaining - 0.5) * 10) / 10)) pfUI.swingtimer.ranged.text:SetFormattedText("%.1f", math.floor((remaining - 0.5) * 10) / 10)
end end
end end
else else
@@ -657,11 +683,11 @@ pfUI:RegisterModule("swingtimer", function ()
pfUI.swingtimer.ranged.right:Hide() pfUI.swingtimer.ranged.right:Hide()
pfUI.swingtimer.ranged.warn:Hide() pfUI.swingtimer.ranged.warn:Hide()
if sw_showtext then if sw_showtext then
pfUI.swingtimer.ranged.text:SetText(string.format("%.1f", math.floor(remaining * 10) / 10)) pfUI.swingtimer.ranged.text:SetFormattedText("%.1f", math.floor(remaining * 10) / 10)
end end
end end
if sw_showspeed and S.raSpeed > 0 then if sw_showspeed and S.raSpeed > 0 then
pfUI.swingtimer.ranged.speed:SetText(string.format("%.2f", S.raSpeed)) pfUI.swingtimer.ranged.speed:SetFormattedText("%.2f", S.raSpeed)
end end
local raProgress = 1 - (S.raTimer / S.raTimerMax) local raProgress = 1 - (S.raTimer / S.raTimerMax)
local raMarkerX = raProgress * sw_width local raMarkerX = raProgress * sw_width
@@ -704,13 +730,12 @@ pfUI:RegisterModule("swingtimer", function ()
S.pendingCastSpellId = arg1 S.pendingCastSpellId = arg1
-- Freeze the swing timer for cast-time spells that DON'T reset auto- -- Freeze the swing timer for cast-time spells that DON'T reset auto-
-- attack on completion (Slam, Hammer of Wrath on Turtle, etc.) — those -- attack on completion (Slam, Hammer of Wrath on Turtle, etc.) — those
-- let the swing resume from where it paused. Detect dynamically via the -- let the swing resume from where it paused. C_Spell.ResetsMeleeSwing
-- absent AUTOATTACK interrupt flag (8); spells with that bit reset on -- mirrors the server rule; spells that reset don't need freezing (they
-- SPELL_GO_SELF so freezing isn't necessary. Subsumes the old hardcoded -- reset on SPELL_GO_SELF). Subsumes the old hardcoded swingDelaySpells
-- swingDelaySpells list (no list maintenance for new Slam-style spells). -- list (no list maintenance for new Slam-style spells).
if S.mhActive then if S.mhActive then
local iflags = GetSpellRecField(arg1, "interruptFlags") or 0 if not C_Spell.ResetsMeleeSwing(arg1) then
if bit.band(iflags, FLAG_AUTOATTACK) == 0 then
S.mhFrozenAt = GetTime() S.mhFrozenAt = GetTime()
end end
end end
@@ -747,17 +772,13 @@ pfUI:RegisterModule("swingtimer", function ()
S.hsQueued = false; S.cleaveQueued = false; S.maulQueued = false S.hsQueued = false; S.cleaveQueued = false; S.maulQueued = false
ResetMH() ResetMH()
else else
-- Mirror the server rule for "does this spell reset the auto-attack -- C_Spell.ResetsMeleeSwing mirrors the server rule (Turtle's
-- swing" (Spell::IsMeleeAttackResetSpell in Turtle's core): -- Spell::IsMeleeAttackResetSpell): InterruptFlags has AUTOATTACK and
-- InterruptFlags has SPELL_INTERRUPT_FLAG_AUTOATTACK (0x08) -- AttributesEx2 lacks NOT_RESET_AUTO_ACTIONS. When the spell resets the
-- AND AttributesEx2 lacks NOT_RESET_AUTO_ACTIONS (0x20000). -- swing, snap the timers to full. Otherwise (elseif) a frozen-swing-
-- If neither path resets and we're holding a frozen-swing-during-cast -- during-cast is a Slam-style cast — push the timer forward by the cast
-- (mhFrozenAt set by SPELL_START_SELF for non-AUTOATTACK spells), this -- duration so the bar resumes from where it paused.
-- is a Slam-style cast — push the timer forward by the cast duration if C_Spell.ResetsMeleeSwing(spellId) then
-- so the bar resumes from where it paused.
local iflags = GetSpellRecField(spellId, "interruptFlags") or 0
if bit.band(iflags, FLAG_AUTOATTACK) ~= 0
and bit.band(GetSpellRecField(spellId, "attributesEx2") or 0, ATTR_KEEP_SWINGS) == 0 then
if S.mhActive and S.mhSpeed > 0 then if S.mhActive and S.mhSpeed > 0 then
UpdateWeaponSpeeds() UpdateWeaponSpeeds()
S.mhTimerMax = S.mhSpeed S.mhTimerMax = S.mhSpeed
@@ -780,7 +801,10 @@ pfUI:RegisterModule("swingtimer", function ()
-- SPELL_CAST_EVENT hook: HS/Cleave/Maul queue tracking -- SPELL_CAST_EVENT hook: HS/Cleave/Maul queue tracking
pfUI.libdebuff_spell_cast_hooks = pfUI.libdebuff_spell_cast_hooks or {} pfUI.libdebuff_spell_cast_hooks = pfUI.libdebuff_spell_cast_hooks or {}
pfUI.libdebuff_spell_cast_hooks["swingtimer"] = function(success, spellId) pfUI.libdebuff_spell_cast_hooks["swingtimer"] = function(success, spellId)
SetQueuedKind(ClassifyOnSwingSpell(spellId)) local kind = ClassifyOnSwingSpell(spellId)
if not kind then return end
S.useSpellQueueEvent = true
SetQueuedKind(kind)
end end
@@ -792,7 +816,7 @@ pfUI:RegisterModule("swingtimer", function ()
events:RegisterEvent("PLAYER_REGEN_DISABLED") events:RegisterEvent("PLAYER_REGEN_DISABLED")
events:RegisterEvent("PLAYER_REGEN_ENABLED") events:RegisterEvent("PLAYER_REGEN_ENABLED")
events:RegisterEvent("ACTIONBAR_SLOT_CHANGED") events:RegisterEvent("ACTIONBAR_SLOT_CHANGED")
events:RegisterEvent("UNIT_DIED") events:RegisterUnitEvent("UNIT_DIED", UnitGUID("player"))
events:RegisterEvent("SPELL_QUEUE_EVENT") events:RegisterEvent("SPELL_QUEUE_EVENT")
events:RegisterEvent("START_AUTOATTACK") events:RegisterEvent("START_AUTOATTACK")
events:RegisterEvent("STOP_AUTOATTACK") events:RegisterEvent("STOP_AUTOATTACK")
@@ -875,7 +899,7 @@ pfUI:RegisterModule("swingtimer", function ()
S.autoAttackActive = false S.autoAttackActive = false
elseif event == "PLAYER_ENTERING_WORLD" then elseif event == "PLAYER_ENTERING_WORLD" then
local _, class = UnitClass("player") local class = UnitClassBase("player")
S.isWarrior = (class == "WARRIOR") S.isWarrior = (class == "WARRIOR")
S.isDruid = (class == "DRUID") S.isDruid = (class == "DRUID")
UpdateWeaponSpeeds() UpdateWeaponSpeeds()
modules/thirdparty-vanilla.lua
+13 -13
View File
@@ -100,10 +100,10 @@ pfUI:RegisterModule("thirdparty-vanilla", function()
CreateBackdropShadow(KLHTM_Frame) CreateBackdropShadow(KLHTM_Frame)
if C.thirdparty.chatbg == "1" and C.chat.global.custombg == "1" then if C.thirdparty.chatbg == "1" and C.chat.global.custombg == "1" then
local r, g, b, a = strsplit(",", C.chat.global.background) local r, g, b, a = GetStringColor(C.chat.global.background)
KLHTM_Frame.backdrop:SetBackdropColor(tonumber(r), tonumber(g), tonumber(b), tonumber(a)) KLHTM_Frame.backdrop:SetBackdropColor(tonumber(r), tonumber(g), tonumber(b), tonumber(a))
local r, g, b, a = strsplit(",", C.chat.global.border) local r, g, b, a = GetStringColor(C.chat.global.border)
KLHTM_Frame.backdrop:SetBackdropBorderColor(tonumber(r), tonumber(g), tonumber(b), tonumber(a)) KLHTM_Frame.backdrop:SetBackdropBorderColor(tonumber(r), tonumber(g), tonumber(b), tonumber(a))
end end
@@ -199,10 +199,10 @@ pfUI:RegisterModule("thirdparty-vanilla", function()
CreateBackdropShadow(TWTMain) CreateBackdropShadow(TWTMain)
if C.thirdparty.chatbg == "1" and C.chat.global.custombg == "1" then if C.thirdparty.chatbg == "1" and C.chat.global.custombg == "1" then
local r, g, b, a = strsplit(",", C.chat.global.background) local r, g, b, a = GetStringColor(C.chat.global.background)
TWTMain.backdrop:SetBackdropColor(tonumber(r), tonumber(g), tonumber(b), tonumber(a)) TWTMain.backdrop:SetBackdropColor(tonumber(r), tonumber(g), tonumber(b), tonumber(a))
local r, g, b, a = strsplit(",", C.chat.global.border) local r, g, b, a = GetStringColor(C.chat.global.border)
TWTMain.backdrop:SetBackdropBorderColor(tonumber(r), tonumber(g), tonumber(b), tonumber(a)) TWTMain.backdrop:SetBackdropBorderColor(tonumber(r), tonumber(g), tonumber(b), tonumber(a))
end end
@@ -267,7 +267,7 @@ pfUI:RegisterModule("thirdparty-vanilla", function()
SW_BarFrame1_Selector:Hide() SW_BarFrame1_Selector:Hide()
-- let user select mode by clicking the title -- let user select mode by clicking the title
HookScript(SW_BarFrame1_Title, "OnMouseUp", function() SW_BarFrame1_Title:HookScript("OnMouseUp", function()
local page = SW_Settings and SW_Settings.BarFrames and SW_Settings.BarFrames.SW_BarFrame1 and SW_Settings.BarFrames.SW_BarFrame1.Selected local page = SW_Settings and SW_Settings.BarFrames and SW_Settings.BarFrames.SW_BarFrame1 and SW_Settings.BarFrames.SW_BarFrame1.Selected
if page then if page then
local target = (arg1 == "LeftButton") and (page + 1) or (arg1 == "RightButton") and (page - 1) local target = (arg1 == "LeftButton") and (page + 1) or (arg1 == "RightButton") and (page - 1)
@@ -328,10 +328,10 @@ pfUI:RegisterModule("thirdparty-vanilla", function()
CreateBackdropShadow(SW_BarFrame1) CreateBackdropShadow(SW_BarFrame1)
if C.thirdparty.chatbg == "1" and C.chat.global.custombg == "1" then if C.thirdparty.chatbg == "1" and C.chat.global.custombg == "1" then
local r, g, b, a = strsplit(",", C.chat.global.background) local r, g, b, a = GetStringColor(C.chat.global.background)
SW_BarFrame1.backdrop:SetBackdropColor(tonumber(r), tonumber(g), tonumber(b), tonumber(a)) SW_BarFrame1.backdrop:SetBackdropColor(tonumber(r), tonumber(g), tonumber(b), tonumber(a))
local r, g, b, a = strsplit(",", C.chat.global.border) local r, g, b, a = GetStringColor(C.chat.global.border)
SW_BarFrame1.backdrop:SetBackdropBorderColor(tonumber(r), tonumber(g), tonumber(b), tonumber(a)) SW_BarFrame1.backdrop:SetBackdropBorderColor(tonumber(r), tonumber(g), tonumber(b), tonumber(a))
end end
@@ -530,7 +530,7 @@ pfUI:RegisterModule("thirdparty-vanilla", function()
end end
-- replace wim class colors with pfUI ones -- replace wim class colors with pfUI ones
pfUI.hooksecurefunc("WIM_InitClassProps", function() hooksecurefunc("WIM_InitClassProps", function()
for class in pairs(PFUI_CLASS_COLORS) do for class in pairs(PFUI_CLASS_COLORS) do
local wimclass = _G[format("WIM_LOCALIZED_%s",class)] local wimclass = _G[format("WIM_LOCALIZED_%s",class)]
local colorstr = "|c" .. PFUI_CLASS_COLORS[class].colorStr local colorstr = "|c" .. PFUI_CLASS_COLORS[class].colorStr
@@ -547,7 +547,7 @@ pfUI:RegisterModule("thirdparty-vanilla", function()
btnClose:SetWidth(13) btnClose:SetWidth(13)
btnClose:SetHeight(13) btnClose:SetHeight(13)
end end
pfUI.hooksecurefunc("WIM_Icon_DropDown_Update", function() hooksecurefunc("WIM_Icon_DropDown_Update", function()
for i=1,_G.WIM_MaxMenuCount do for i=1,_G.WIM_MaxMenuCount do
local btn = _G["WIM_ConversationMenuTellButton"..i] local btn = _G["WIM_ConversationMenuTellButton"..i]
if i==1 and btn:IsEnabled() == 0 then return end if i==1 and btn:IsEnabled() == 0 then return end
@@ -729,7 +729,7 @@ pfUI:RegisterModule("thirdparty-vanilla", function()
SkinScrollbar(WIM_HelpScrollFrameScrollBar) SkinScrollbar(WIM_HelpScrollFrameScrollBar)
end end
pfUI.hooksecurefunc("WIM_WindowOnShow", function() hooksecurefunc("WIM_WindowOnShow", function()
if this.backdrop then return end -- already skinned if this.backdrop then return end -- already skinned
local windowname = this:GetName() local windowname = this:GetName()
@@ -904,7 +904,7 @@ pfUI:RegisterModule("thirdparty-vanilla", function()
end end
-- trigger the event whenever SuperMacro got an update -- trigger the event whenever SuperMacro got an update
pfUI.hooksecurefunc("SM_UpdateActionSpell", function() hooksecurefunc("SM_UpdateActionSpell", function()
for slot=1,120 do pfUI.bars.update[slot] = true end for slot=1,120 do pfUI.bars.update[slot] = true end
end) end)
end) end)
@@ -922,7 +922,7 @@ pfUI:RegisterModule("thirdparty-vanilla", function()
pfUI.bars.skip_macro = true pfUI.bars.skip_macro = true
-- send clevermacro events to pfUI actionbars -- send clevermacro events to pfUI actionbars
pfUI.hooksecurefunc("ActionButton_OnEvent", function(event) hooksecurefunc("ActionButton_OnEvent", function(event)
events(this, event) events(this, event)
end) end)
end) end)
@@ -944,7 +944,7 @@ pfUI:RegisterModule("thirdparty-vanilla", function()
if pfUI.eqcompare then if pfUI.eqcompare then
pfUI.eqcompare.HookTooltip(AtlasLootTooltip) pfUI.eqcompare.HookTooltip(AtlasLootTooltip)
HookScript(AtlasLootTooltip, "OnHide", function() AtlasLootTooltip:HookScript("OnHide", function()
ShoppingTooltip1:Hide() ShoppingTooltip1:Hide()
ShoppingTooltip2:Hide() ShoppingTooltip2:Hide()
end) end)

Some files were not shown because too many files have changed in this diff Show More