vanilla-wow-addons – Blame information for rev 1
?pathlinks?
Rev | Author | Line No. | Line |
---|---|---|---|
1 | office | 1 | --[[ |
2 | Name: CandyBar-2.0 |
||
3 | Revision: $Rev: 13442 $ |
||
4 | Author: Ammo (wouter@muze.nl) |
||
5 | Website: http://www.wowace.com/ |
||
6 | Documentation: http://www.wowace.com/ |
||
7 | SVN: svn://svn.wowace.com/root/trunk/CandyBar/CandyBar-2.0 |
||
8 | Description: A timer bars library |
||
9 | Dependencies: AceLibrary, AceOO-2.0, PaintChips-2.0, (optional) Compost-2.0 |
||
10 | ]] |
||
11 | |||
12 | local vmajor, vminor = "CandyBar-2.0", "$Revision: 13442 $" |
||
13 | |||
14 | if not AceLibrary then error(vmajor .. " requires AceLibrary.") end |
||
15 | if not AceLibrary:IsNewVersion(vmajor, vminor) then return end |
||
16 | |||
17 | if not AceLibrary:HasInstance("AceOO-2.0") then error(vmajor .. " requires AceOO-2.0") end |
||
18 | |||
19 | if not AceLibrary:HasInstance("PaintChips-2.0") then error(vmajor .. " requires PaintChips-2.0") end |
||
20 | |||
21 | local compost = AceLibrary:HasInstance("Compost-2.0") and AceLibrary("Compost-2.0") |
||
22 | local paint = AceLibrary("PaintChips-2.0") |
||
23 | |||
24 | local AceOO = AceLibrary:GetInstance("AceOO-2.0") |
||
25 | local Mixin = AceOO.Mixin |
||
26 | local CandyBar = Mixin { |
||
27 | "RegisterCandyBar", |
||
28 | "UnregisterCandyBar", |
||
29 | "IsCandyBarRegistered", |
||
30 | "StartCandyBar", |
||
31 | "StopCandyBar", |
||
32 | "PauseCandyBar", |
||
33 | "CandyBarStatus", |
||
34 | "SetCandyBarTexture", |
||
35 | "SetCandyBarTime", |
||
36 | "SetCandyBarColor", |
||
37 | "SetCandyBarText", |
||
38 | "SetCandyBarIcon", |
||
39 | "SetCandyBarWidth", |
||
40 | "SetCandyBarHeight", |
||
41 | "SetCandyBarBackgroundColor", |
||
42 | "SetCandyBarTextColor", |
||
43 | "SetCandyBarTimerTextColor", |
||
44 | "SetCandyBarFontSize", |
||
45 | "SetCandyBarPoint", |
||
46 | "SetCandyBarGradient", |
||
47 | "SetCandyBarScale", |
||
48 | "SetCandyBarTimeFormat", |
||
49 | "SetCandyBarTimeLeft", |
||
50 | "SetCandyBarCompletion", |
||
51 | "SetCandyBarFade", |
||
52 | "RegisterCandyBarGroup", |
||
53 | "UnregisterCandyBarGroup", |
||
54 | "IsCandyBarGroupRegistered", |
||
55 | "SetCandyBarGroupPoint", |
||
56 | "SetCandyBarGroupGrowth", |
||
57 | "UpdateCandyBarGroup", |
||
58 | "RegisterCandyBarWithGroup", |
||
59 | "UnregisterCandyBarWithGroup", |
||
60 | "IsCandyBarRegisteredWithGroup", |
||
61 | "SetCandyBarReversed", |
||
62 | "IsCandyBarReversed", |
||
63 | "SetCandyBarOnClick", |
||
64 | } |
||
65 | |||
66 | |||
67 | local function getnewtable() return compost and compost:Acquire() or {} end |
||
68 | local function reclaimtable(t) if compost then compost:Reclaim(t) end end |
||
69 | |||
70 | |||
71 | -- Registers a new candy bar |
||
72 | -- name - A unique identifier for your bar. |
||
73 | -- time - Time for the bar |
||
74 | -- text - text displayed on the bar [defaults to the name if not set] |
||
75 | -- icon - icon off the bar [optional] |
||
76 | -- c1 - c10 - color of the bar [optional] |
||
77 | -- returns true on a succesful register |
||
78 | function CandyBar:Register(name, time, text, icon, c1, c2, c3, c4, c5, c6, c7, c8, c9, c10) |
||
79 | CandyBar:argCheck(name, 2, "string") |
||
80 | CandyBar:argCheck(time, 3, "number") |
||
81 | if not name or not time then return end |
||
82 | if CandyBar.var.handlers[name] then self:Unregister(name) end |
||
83 | local t = getnewtable() |
||
84 | t.name, t.time, t.text, t.icon = name, time, text or name, icon |
||
85 | t.texture = CandyBar.var.defaults.texture |
||
86 | t.color = {} |
||
87 | if not paint:GetRGBPercent(c1) then c1 = "green" end |
||
88 | _, t.color[1], t.color[2], t.color[3] = paint:GetRGBPercent(c1) |
||
89 | t.color[4] = 1 |
||
90 | t.running = nil |
||
91 | t.endtime = 0 |
||
92 | t.reversed = nil |
||
93 | CandyBar.var.handlers[name] = t |
||
94 | CandyBar.var.handlers[name].frame = CandyBar:AcquireBarFrame(name) |
||
95 | if c1 and c2 then |
||
96 | CandyBar:SetGradient( name, c1, c2, c3, c4, c5, c6, c7, c8, c9, c10) |
||
97 | end |
||
98 | return true |
||
99 | end |
||
100 | |||
101 | |||
102 | -- Removes a candy bar |
||
103 | -- a1 - a10 handlers that you wish to remove |
||
104 | -- returns true upon sucessful removal |
||
105 | function CandyBar:Unregister(a1,a2,a3,a4,a5,a6,a7,a8,a9,a10) |
||
106 | CandyBar:argCheck(a1, 2, "string") |
||
107 | if not CandyBar.var.handlers[a1] then return end |
||
108 | CandyBar:UnregisterWithGroup(a1) |
||
109 | CandyBar:ReleaseBarFrame(a1) |
||
110 | reclaimtable(CandyBar.var.handlers[a1]) |
||
111 | CandyBar.var.handlers[a1] = nil |
||
112 | if a2 then CandyBar:Unregister(a2,a3,a4,a5,a6,a7,a8,a9,a10) |
||
113 | elseif not CandyBar:HasHandlers() then CandyBar.var.frame:Hide() end |
||
114 | return true |
||
115 | end |
||
116 | |||
117 | -- Checks if a candy bar is registered |
||
118 | -- Args: name - name of the candybar |
||
119 | -- returns true if a the candybar is registered |
||
120 | function CandyBar:IsRegistered(name) |
||
121 | CandyBar:argCheck(name, 2, "string") |
||
122 | if CandyBar.var.handlers[name] then return true end |
||
123 | return false |
||
124 | end |
||
125 | |||
126 | -- Start a bar |
||
127 | -- Args: name - the candybar you want to start |
||
128 | -- fireforget [optional] - pass true if you want the bar to unregister upon completion |
||
129 | -- returns true if succesful |
||
130 | function CandyBar:Start( name, fireforget ) |
||
131 | CandyBar:argCheck(name, 2, "string") |
||
132 | if not CandyBar.var.handlers[name] then return end |
||
133 | local t = GetTime() |
||
134 | if CandyBar.var.handlers[name].paused then |
||
135 | local pauseoffset = t - CandyBar.var.handlers[name].pausetime |
||
136 | CandyBar.var.handlers[name].endtime = CandyBar.var.handlers[name].endtime + pauseoffset |
||
137 | CandyBar.var.handlers[name].starttime = CandyBar.var.handlers[name].starttime + pauseoffset |
||
138 | else |
||
139 | -- bar hasn't elapsed a second. |
||
140 | CandyBar.var.handlers[name].elapsed = 0 |
||
141 | CandyBar.var.handlers[name].endtime = t + CandyBar.var.handlers[name].time |
||
142 | CandyBar.var.handlers[name].starttime = t |
||
143 | end |
||
144 | CandyBar.var.handlers[name].fireforget = fireforget |
||
145 | CandyBar.var.handlers[name].running = true |
||
146 | CandyBar.var.handlers[name].paused = nil |
||
147 | CandyBar.var.handlers[name].fading = nil |
||
148 | CandyBar:AcquireBarFrame( name ) -- this will reset the barframe incase we were fading out when it was restarted |
||
149 | CandyBar.var.handlers[name].frame:Show() |
||
150 | if CandyBar.var.handlers[name].group then CandyBar:UpdateGroup( CandyBar.var.handlers[name].group ) end -- update the group |
||
151 | CandyBar.var.frame:Show() |
||
152 | return true |
||
153 | |||
154 | end |
||
155 | |||
156 | -- Stop a bar |
||
157 | -- Args: name - the candybar you want to stop |
||
158 | -- returns true if succesful |
||
159 | function CandyBar:Stop( name) |
||
160 | CandyBar:argCheck(name, 2, "string") |
||
161 | if not CandyBar.var.handlers[name] then return end |
||
162 | |||
163 | CandyBar.var.handlers[name].running = nil |
||
164 | CandyBar.var.handlers[name].paused = nil |
||
165 | |||
166 | if CandyBar.var.handlers[name].fadeout then |
||
167 | CandyBar.var.handlers[name].frame.spark:Hide() |
||
168 | CandyBar.var.handlers[name].fading = true |
||
169 | CandyBar.var.handlers[name].fadeelapsed = 0 |
||
170 | local t = GetTime() |
||
171 | if CandyBar.var.handlers[name].endtime > t then |
||
172 | CandyBar.var.handlers[name].endtime = t |
||
173 | end |
||
174 | |||
175 | local reversed = CandyBar.var.handlers[name].reversed |
||
176 | else |
||
177 | CandyBar.var.handlers[name].frame:Hide() |
||
178 | CandyBar.var.handlers[name].starttime = nil |
||
179 | CandyBar.var.handlers[name].endtime = 0 |
||
180 | if CandyBar.var.handlers[name].group then CandyBar:UpdateGroup(CandyBar.var.handlers[name].group) end |
||
181 | if CandyBar.var.handlers[name].fireforget then |
||
182 | return CandyBar:Unregister(name) |
||
183 | end |
||
184 | end |
||
185 | if not CandyBar:HasHandlers() then CandyBar.var.frame:Hide() end |
||
186 | return true |
||
187 | end |
||
188 | |||
189 | -- Pause a bar |
||
190 | -- Name - the candybar you want to pause |
||
191 | -- returns true if succesful |
||
192 | function CandyBar:Pause( name ) |
||
193 | CandyBar:argCheck(name, 2, "string") |
||
194 | if not CandyBar.var.handlers[name] then return end |
||
195 | CandyBar.var.handlers[name].pausetime = GetTime() |
||
196 | CandyBar.var.handlers[name].paused = true |
||
197 | CandyBar.var.handlers[name].running = nil |
||
198 | end |
||
199 | |||
200 | -- Query a timer's status |
||
201 | -- Args: name - the schedule you wish to look up |
||
202 | -- Returns: registered - true if a schedule exists with this name |
||
203 | -- time - time for this bar |
||
204 | -- elapsed - time elapsed for this bar |
||
205 | -- running - true if this schedule is currently running |
||
206 | function CandyBar:Status(name) |
||
207 | CandyBar:argCheck(name, 2, "string") |
||
208 | if not CandyBar.var.handlers[name] then return end |
||
209 | return true, CandyBar.var.handlers[name].time, CandyBar.var.handlers[name].elapsed, CandyBar.var.handlers[name].running, CandyBar.var.handlers[name].paused |
||
210 | end |
||
211 | |||
212 | |||
213 | -- Set the time for a bar. |
||
214 | -- Args: name - the candybar name |
||
215 | -- time - the new time for this bar |
||
216 | -- returns true if succesful |
||
217 | function CandyBar:SetTime(name, time) |
||
218 | CandyBar:argCheck(name, 2, "string") |
||
219 | CandyBar:argCheck(time, 3, "number") |
||
220 | if not CandyBar.var.handlers[name] then return end |
||
221 | CandyBar.var.handlers[name].time = time |
||
222 | |||
223 | return true |
||
224 | end |
||
225 | |||
226 | -- Set the time left for a bar. |
||
227 | -- Args: name - the candybar name |
||
228 | -- time - time left on the bar |
||
229 | -- returns true if succesful |
||
230 | |||
231 | function CandyBar:SetTimeLeft(name, time) |
||
232 | CandyBar:argCheck(name, 2, "string") |
||
233 | CandyBar:argCheck(time, 3, "number") |
||
234 | if not CandyBar.var.handlers[name] then return end |
||
235 | if CandyBar.var.handlers[name].time < time or time < 0 then return end |
||
236 | |||
237 | local e = CandyBar.var.handlers[name].time - time |
||
238 | local d = CandyBar.var.handlers[name].elapsed - e |
||
239 | if CandyBar.var.handlers[name].starttime and CandyBar.var.handlers[name].endtime then |
||
240 | CandyBar.var.handlers[name].starttime = CandyBar.var.handlers[name].starttime + d |
||
241 | CandyBar.var.handlers[name].endtime = CandyBar.var.handlers[name].endtime + d |
||
242 | end |
||
243 | |||
244 | CandyBar.var.handlers[name].elapsed = e |
||
245 | |||
246 | return true |
||
247 | end |
||
248 | |||
249 | -- Sets smooth coloring of the bar depending on time elapsed |
||
250 | -- Args: name - the candybar name |
||
251 | -- c1 - c10 color order of the gradient |
||
252 | -- returns true when succesful |
||
253 | function CandyBar:SetGradient(name, c1, c2, c3, c4, c5, c6, c7, c8, c9, c10) |
||
254 | CandyBar:argCheck(name, 2, "string") |
||
255 | |||
256 | CandyBar:argCheck(c1, 3, "string") |
||
257 | CandyBar:argCheck(c2, 4, "string") |
||
258 | |||
259 | if not CandyBar.var.handlers[name] then return end |
||
260 | if not c1 or not c2 then return end |
||
261 | |||
262 | |||
263 | local gtable = {} |
||
264 | |||
265 | gtable[1] = {} |
||
266 | gtable[2] = {} |
||
267 | |||
268 | if not paint:GetRGBPercent(c1) then c1 = "green" end |
||
269 | if not paint:GetRGBPercent(c2) then c2 = "green" end |
||
270 | if c3 and not paint:GetRGBPercent(c3) then c3 = "green" end |
||
271 | if c4 and not paint:GetRGBPercent(c4) then c4 = "green" end |
||
272 | if c5 and not paint:GetRGBPercent(c5) then c5 = "green" end |
||
273 | if c6 and not paint:GetRGBPercent(c6) then c6 = "green" end |
||
274 | if c7 and not paint:GetRGBPercent(c7) then c7 = "green" end |
||
275 | if c8 and not paint:GetRGBPercent(c8) then c8 = "green" end |
||
276 | if c9 and not paint:GetRGBPercent(c9) then c9 = "green" end |
||
277 | if c10 and not paint:GetRGBPercent(c10) then c10 = "green" end |
||
278 | |||
279 | _, gtable[1][1], gtable[1][2], gtable[1][3] = paint:GetRGBPercent(c1) |
||
280 | _, gtable[2][1], gtable[2][2], gtable[2][3] = paint:GetRGBPercent(c2) |
||
281 | if c3 then gtable[3] = {} _, gtable[3][1], gtable[3][2], gtable[3][3] = paint:GetRGBPercent(c3) end |
||
282 | if c4 then gtable[4] = {} _, gtable[4][1], gtable[4][2], gtable[4][3] = paint:GetRGBPercent(c4) end |
||
283 | if c5 then gtable[5] = {} _, gtable[5][1], gtable[5][2], gtable[5][3] = paint:GetRGBPercent(c5) end |
||
284 | if c6 then gtable[6] = {} _, gtable[6][1], gtable[6][2], gtable[6][3] = paint:GetRGBPercent(c6) end |
||
285 | if c7 then gtable[7] = {} _, gtable[7][1], gtable[3][2], gtable[7][3] = paint:GetRGBPercent(c7) end |
||
286 | if c8 then gtable[8] = {} _, gtable[8][1], gtable[8][2], gtable[8][3] = paint:GetRGBPercent(c8) end |
||
287 | if c9 then gtable[9] = {} _, gtable[9][1], gtable[9][2], gtable[9][3] = paint:GetRGBPercent(c9) end |
||
288 | if c10 then gtable[10] = {} _, gtable[10][1], gtable[10][2], gtable[10][3] = paint:GetRGBPercent(c10) end |
||
289 | |||
290 | |||
291 | |||
292 | local max = table.getn(gtable) |
||
293 | |||
294 | for i = 1, max do |
||
295 | if not gtable[i][4] then gtable[i][4] = 1 end |
||
296 | gtable[i][5] = (i-1) / (max-1) |
||
297 | end |
||
298 | |||
299 | self.var.handlers[name].gradienttable = gtable |
||
300 | self.var.handlers[name].gradient = true |
||
301 | |||
302 | CandyBar.var.handlers[name].frame.statusbar:SetStatusBarColor( gtable[1][1], gtable[1][2], gtable[1][3], gtable[1][4]) |
||
303 | |||
304 | return true |
||
305 | end |
||
306 | |||
307 | -- Set the color of the bar |
||
308 | -- Args: name - the candybar name |
||
309 | -- color - new color of the bar |
||
310 | -- alpha - new alpha of the bar |
||
311 | -- Setting the color will override smooth settings. |
||
312 | function CandyBar:SetColor(name, color, alpha) |
||
313 | CandyBar:argCheck(name, 2, "string") |
||
314 | CandyBar:argCheck(color, 3, "string") |
||
315 | |||
316 | if not CandyBar.var.handlers[name] then return end |
||
317 | |||
318 | if not paint:GetRGBPercent(color) then return end |
||
319 | |||
320 | local ctable = {} |
||
321 | |||
322 | _, ctable[1], ctable[2], ctable[3] = paint:GetRGBPercent(color) |
||
323 | |||
324 | if alpha then ctable[4] = alpha else ctable[4] = 1 end |
||
325 | |||
326 | CandyBar.var.handlers[name].color = ctable |
||
327 | CandyBar.var.handlers[name].gradient = nil |
||
328 | |||
329 | CandyBar.var.handlers[name].frame.statusbar:SetStatusBarColor( ctable[1], ctable[2], ctable[3], ctable[4] ) |
||
330 | |||
331 | return true |
||
332 | end |
||
333 | |||
334 | -- Set the color of background of the bar |
||
335 | -- Args: name - the candybar name |
||
336 | -- color - new color of the bar |
||
337 | -- alpha - new alpha of the bar |
||
338 | -- Setting the color will override smooth settings. |
||
339 | function CandyBar:SetBackgroundColor(name, color, alpha) |
||
340 | CandyBar:argCheck(name, 2, "string") |
||
341 | CandyBar:argCheck(color, 3, "string") |
||
342 | |||
343 | if not CandyBar.var.handlers[name] then return end |
||
344 | |||
345 | if not paint:GetRGBPercent(color) then return end |
||
346 | |||
347 | local ctable = {} |
||
348 | |||
349 | _, ctable[1], ctable[2], ctable[3] = paint:GetRGBPercent(color) |
||
350 | |||
351 | if alpha then ctable[4] = alpha else ctable[4] = 1 end |
||
352 | |||
353 | CandyBar.var.handlers[name].bgcolor = ctable |
||
354 | |||
355 | CandyBar.var.handlers[name].frame.statusbarbg:SetStatusBarColor( ctable[1], ctable[2], ctable[3], ctable[4] ) |
||
356 | |||
357 | return true |
||
358 | end |
||
359 | |||
360 | -- Set the color for the bar text |
||
361 | -- Args: name - name of the candybar |
||
362 | -- color - new color of the text |
||
363 | -- alpha - new alpha of the text |
||
364 | -- returns true when succesful |
||
365 | function CandyBar:SetTextColor(name, color, alpha) |
||
366 | CandyBar:argCheck(name, 2, "string") |
||
367 | CandyBar:argCheck(color, 3, "string") |
||
368 | |||
369 | if not CandyBar.var.handlers[name] then return end |
||
370 | |||
371 | if not paint:GetRGBPercent(color) then return end |
||
372 | |||
373 | local ctable = {} |
||
374 | |||
375 | _, ctable[1], ctable[2], ctable[3] = paint:GetRGBPercent(color) |
||
376 | |||
377 | if alpha then ctable[4] = alpha else ctable[4] = 1 end |
||
378 | |||
379 | |||
380 | CandyBar.var.handlers[name].textcolor = ctable |
||
381 | |||
382 | CandyBar.var.handlers[name].frame.text:SetTextColor( ctable[1], ctable[2], ctable[3], ctable[4] ) |
||
383 | |||
384 | return true |
||
385 | end |
||
386 | |||
387 | -- Set the color for the timer text |
||
388 | -- Args: name - name of the candybar |
||
389 | -- color - new color of the text |
||
390 | -- alpha - new alpha of the text |
||
391 | -- returns true when succesful |
||
392 | function CandyBar:SetTimerTextColor(name, color, alpha) |
||
393 | CandyBar:argCheck(name, 2, "string") |
||
394 | CandyBar:argCheck(color, 3, "string") |
||
395 | if not CandyBar.var.handlers[name] then return end |
||
396 | |||
397 | if not paint:GetRGBPercent(color) then return end |
||
398 | |||
399 | local ctable = {} |
||
400 | |||
401 | _, ctable[1], ctable[2], ctable[3] = paint:GetRGBPercent(color) |
||
402 | |||
403 | if alpha then ctable[4] = alpha else ctable[4] = 1 end |
||
404 | |||
405 | CandyBar.var.handlers[name].timertextcolor = ctable |
||
406 | |||
407 | CandyBar.var.handlers[name].frame.timertext:SetTextColor( ctable[1], ctable[2], ctable[3], ctable[4] ) |
||
408 | |||
409 | return true |
||
410 | end |
||
411 | |||
412 | -- Set the text for the bar |
||
413 | -- Args: name - name of the candybar |
||
414 | -- text - text to set it to |
||
415 | -- returns true when succesful |
||
416 | function CandyBar:SetText(name, text) |
||
417 | CandyBar:argCheck(name, 2, "string") |
||
418 | CandyBar:argCheck(text, 2, "string") |
||
419 | if not CandyBar.var.handlers[name] then return end |
||
420 | |||
421 | CandyBar.var.handlers[name].text = text |
||
422 | CandyBar.var.handlers[name].frame.text:SetText(text) |
||
423 | |||
424 | return true |
||
425 | end |
||
426 | |||
427 | -- Set the fontsize |
||
428 | -- Args: name - name of the candybar |
||
429 | -- fontsize - new fontsize |
||
430 | -- returns true when succesful |
||
431 | function CandyBar:SetFontSize(name, fontsize) |
||
432 | CandyBar:argCheck(name, 2, "string") |
||
433 | CandyBar:argCheck(fontsize, 3, "number") |
||
434 | |||
435 | if not CandyBar.var.handlers[name] then return end |
||
436 | |||
437 | local font, _, _ = GameFontHighlight:GetFont() |
||
438 | local timertextwidth = fontsize * 3 |
||
439 | local width = CandyBar.var.handlers[name].width or CandyBar.var.defaults.width |
||
440 | local f = CandyBar.var.handlers[name].frame |
||
441 | |||
442 | CandyBar.var.handlers[name].fontsize = fontsize |
||
443 | f.timertext:SetFont(font, fontsize) |
||
444 | f.text:SetFont(font, fontsize) |
||
445 | f.timertext:SetWidth( timertextwidth ) |
||
446 | f.text:SetWidth( ( width - timertextwidth ) * .9 ) |
||
447 | |||
448 | return true |
||
449 | end |
||
450 | |||
451 | |||
452 | -- Set the point where a bar should be anchored |
||
453 | -- Args: name -- name of the bar |
||
454 | -- point -- anchor point |
||
455 | -- rframe -- relative frame |
||
456 | -- rpoint -- relative point |
||
457 | -- xoffset -- x offset |
||
458 | -- yoffset -- y offset |
||
459 | -- returns true when succesful |
||
460 | function CandyBar:SetPoint(name, point, rframe, rpoint, xoffset, yoffset) |
||
461 | CandyBar:argCheck(name, 2, "string") |
||
462 | |||
463 | if not CandyBar.var.handlers[name] then return end |
||
464 | |||
465 | CandyBar.var.handlers[name].point = point |
||
466 | CandyBar.var.handlers[name].rframe = rframe |
||
467 | CandyBar.var.handlers[name].rpoint = rpoint |
||
468 | CandyBar.var.handlers[name].xoffset = xoffset |
||
469 | CandyBar.var.handlers[name].yoffset = yoffset |
||
470 | |||
471 | CandyBar.var.handlers[name].frame:ClearAllPoints() |
||
472 | CandyBar.var.handlers[name].frame:SetPoint(point, rframe,rpoint,xoffset,yoffset) |
||
473 | |||
474 | return true |
||
475 | end |
||
476 | |||
477 | -- Set the width for a bar |
||
478 | -- Args: name - name of the candybar |
||
479 | -- width - new width of the candybar |
||
480 | -- returns true when succesful |
||
481 | function CandyBar:SetWidth(name, width) |
||
482 | CandyBar:argCheck(name, 2, "string") |
||
483 | CandyBar:argCheck(width, 3, "number") |
||
484 | |||
485 | if not CandyBar.var.handlers[name] then return end |
||
486 | |||
487 | local height = CandyBar.var.handlers[name].height or CandyBar.var.defaults.height |
||
488 | local fontsize = CandyBar.var.handlers[name].fontsize or CandyBar.var.defaults.fontsize |
||
489 | local timertextwidth = fontsize * 3 |
||
490 | local f = CandyBar.var.handlers[name].frame |
||
491 | f:SetWidth( width + height ) |
||
492 | f.statusbar:SetWidth( width ) |
||
493 | f.statusbarbg:SetWidth( width ) |
||
494 | |||
495 | f.timertext:SetWidth( timertextwidth ) |
||
496 | f.text:SetWidth( ( width - timertextwidth ) * .9 ) |
||
497 | |||
498 | CandyBar.var.handlers[name].width = width |
||
499 | |||
500 | return true |
||
501 | end |
||
502 | |||
503 | -- Set the height for a bar |
||
504 | -- Args: name - name of the candybar |
||
505 | -- height - new height for the bar |
||
506 | -- returs true when succesful |
||
507 | function CandyBar:SetHeight(name, height) |
||
508 | CandyBar:argCheck(name, 2, "string") |
||
509 | CandyBar:argCheck(height, 3, "number") |
||
510 | |||
511 | if not CandyBar.var.handlers[name] then return end |
||
512 | |||
513 | local width = CandyBar.var.handlers[name].width or CandyBar.var.defaults.width |
||
514 | local f = CandyBar.var.handlers[name].frame |
||
515 | |||
516 | f:SetWidth( width + height ) |
||
517 | f:SetHeight( height ) |
||
518 | f.icon:SetWidth( height ) |
||
519 | f.icon:SetHeight( height ) |
||
520 | f.statusbar:SetHeight( height ) |
||
521 | f.statusbarbg:SetHeight( height ) |
||
522 | f.spark:SetHeight( height + 25 ) |
||
523 | |||
524 | f.statusbarbg:SetPoint( "TOPLEFT", f, "TOPLEFT", height, 0) |
||
525 | f.statusbar:SetPoint("TOPLEFT", f, "TOPLEFT", height, 0) |
||
526 | |||
527 | CandyBar.var.handlers[name].height = height |
||
528 | |||
529 | |||
530 | return true |
||
531 | end |
||
532 | |||
533 | -- Set the scale for a bar |
||
534 | -- Args: name - name of the candybar |
||
535 | -- scale - new scale of the bar |
||
536 | -- returns true when succesful |
||
537 | function CandyBar:SetScale(name, scale) |
||
538 | CandyBar:argCheck(name, 2, "string") |
||
539 | CandyBar:argCheck(scale, 3, "number") |
||
540 | |||
541 | if not CandyBar.var.handlers[name] then return end |
||
542 | |||
543 | CandyBar.var.handlers[name].scale = scale |
||
544 | |||
545 | CandyBar.var.handlers[name].frame:SetScale( scale ) |
||
546 | |||
547 | return true |
||
548 | end |
||
549 | |||
550 | -- Set the time formatting function for a bar |
||
551 | -- Args: name - name of the candybar |
||
552 | -- func - function that returns the formatted string |
||
553 | -- a1-a10 - optional arguments to that function |
||
554 | -- returns true when succesful |
||
555 | |||
556 | function CandyBar:SetTimeFormat(name, func, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) |
||
557 | CandyBar:argCheck(name, 2, "string") |
||
558 | CandyBar:argCheck(func, 3, "function") |
||
559 | |||
560 | if not CandyBar.var.handlers[name] then return end |
||
561 | CandyBar.var.handlers[name].timeformat = func |
||
562 | CandyBar.var.handlers[name].timeformat1 = a1 |
||
563 | CandyBar.var.handlers[name].timeformat2 = a2 |
||
564 | CandyBar.var.handlers[name].timeformat3 = a3 |
||
565 | CandyBar.var.handlers[name].timeformat4 = a4 |
||
566 | CandyBar.var.handlers[name].timeformat5 = a5 |
||
567 | CandyBar.var.handlers[name].timeformat6 = a6 |
||
568 | CandyBar.var.handlers[name].timeformat7 = a7 |
||
569 | CandyBar.var.handlers[name].timeformat8 = a8 |
||
570 | CandyBar.var.handlers[name].timeformat9 = a9 |
||
571 | CandyBar.var.handlers[name].timeformat10 = a10 |
||
572 | |||
573 | return true |
||
574 | end |
||
575 | |||
576 | -- Set the completion function for a bar |
||
577 | -- Args: name - name of the candybar |
||
578 | -- func - function to call upon ending of the bar |
||
579 | -- a1 - a10 - arguments to pass to the function |
||
580 | -- returns true when succesful |
||
581 | function CandyBar:SetCompletion(name, func, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) |
||
582 | CandyBar:argCheck(name, 2, "string") |
||
583 | CandyBar:argCheck(func, 3, "function") |
||
584 | |||
585 | if not CandyBar.var.handlers[name] then return end |
||
586 | CandyBar.var.handlers[name].completion = func |
||
587 | CandyBar.var.handlers[name].completion1 = a1 |
||
588 | CandyBar.var.handlers[name].completion2 = a2 |
||
589 | CandyBar.var.handlers[name].completion3 = a3 |
||
590 | CandyBar.var.handlers[name].completion4 = a4 |
||
591 | CandyBar.var.handlers[name].completion5 = a5 |
||
592 | CandyBar.var.handlers[name].completion6 = a6 |
||
593 | CandyBar.var.handlers[name].completion7 = a7 |
||
594 | CandyBar.var.handlers[name].completion8 = a8 |
||
595 | CandyBar.var.handlers[name].completion9 = a9 |
||
596 | CandyBar.var.handlers[name].completion10 = a10 |
||
597 | |||
598 | return true |
||
599 | |||
600 | end |
||
601 | |||
602 | -- Set the on click function for a bar |
||
603 | -- Args: name - name of the candybar |
||
604 | -- func - function to call when the bar is clicked |
||
605 | -- a1 - a10 - arguments to pass to the function |
||
606 | -- returns true when succesful |
||
607 | function CandyBar:SetOnClick(name, func, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) |
||
608 | CandyBar:argCheck(name, 2, "string") |
||
609 | if func then CandyBar:argCheck(func, 3, "function") end |
||
610 | |||
611 | if not CandyBar.var.handlers[name] then return end |
||
612 | CandyBar.var.handlers[name].onclick = func |
||
613 | CandyBar.var.handlers[name].onclick1 = a1 |
||
614 | CandyBar.var.handlers[name].onclick2 = a2 |
||
615 | CandyBar.var.handlers[name].onclick3 = a3 |
||
616 | CandyBar.var.handlers[name].onclick4 = a4 |
||
617 | CandyBar.var.handlers[name].onclick5 = a5 |
||
618 | CandyBar.var.handlers[name].onclick6 = a6 |
||
619 | CandyBar.var.handlers[name].onclick7 = a7 |
||
620 | CandyBar.var.handlers[name].onclick8 = a8 |
||
621 | CandyBar.var.handlers[name].onclick9 = a9 |
||
622 | CandyBar.var.handlers[name].onclick10 = a10 |
||
623 | |||
624 | if func then |
||
625 | -- enable mouse |
||
626 | CandyBar.var.handlers[name].frame:EnableMouse(true) |
||
627 | CandyBar.var.handlers[name].frame:RegisterForClicks("LeftButtonUp", "RightButtonUp", "MiddleButtonUp", "Button4Up", "Button5Up") |
||
628 | CandyBar.var.handlers[name].frame:SetScript("OnClick", function() CandyBar:OnClick() end ) |
||
629 | CandyBar.var.handlers[name].frame.icon:EnableMouse(true) |
||
630 | CandyBar.var.handlers[name].frame.icon:RegisterForClicks("LeftButtonUp", "RightButtonUp", "MiddleButtonUp", "Button4Up", "Button5Up") |
||
631 | CandyBar.var.handlers[name].frame.icon:SetScript("OnClick", function() CandyBar:OnClick() end ) |
||
632 | else |
||
633 | CandyBar.var.handlers[name].frame:EnableMouse(false) |
||
634 | CandyBar.var.handlers[name].frame:RegisterForClicks() |
||
635 | CandyBar.var.handlers[name].frame:SetScript("OnClick", nil ) |
||
636 | CandyBar.var.handlers[name].frame.icon:EnableMouse(false) |
||
637 | CandyBar.var.handlers[name].frame.icon:RegisterForClicks() |
||
638 | CandyBar.var.handlers[name].frame.icon:SetScript("OnClick", nil ) |
||
639 | end |
||
640 | |||
641 | return true |
||
642 | |||
643 | end |
||
644 | -- Set the texture for a bar |
||
645 | -- Args: name - name of the candybar |
||
646 | -- texture - new texture, if passed nil, the texture is reset to default |
||
647 | -- returns true when succesful |
||
648 | function CandyBar:SetTexture(name, texture) |
||
649 | CandyBar:argCheck(name, 2, "string") |
||
650 | if texture then CandyBar:argCheck(texture, 3, "string") end |
||
651 | |||
652 | if not CandyBar.var.handlers[name] then return end |
||
653 | if not texture then texture = CandyBar.var.defaults.texture end |
||
654 | |||
655 | CandyBar.var.handlers[name].texture = texture |
||
656 | |||
657 | CandyBar.var.handlers[name].frame.statusbar:SetStatusBarTexture(texture) |
||
658 | CandyBar.var.handlers[name].frame.statusbarbg:SetStatusBarTexture(texture) |
||
659 | |||
660 | return true |
||
661 | end |
||
662 | |||
663 | -- Set the icon on a bar |
||
664 | -- Args: name - name of the candybar |
||
665 | -- icon - icon path, nil removes the icon |
||
666 | -- returns true when succesful |
||
667 | function CandyBar:SetIcon(name, icon) |
||
668 | CandyBar:argCheck(name, 2, "string") |
||
669 | CandyBar:argCheck(icon, 3, "string") |
||
670 | |||
671 | if not CandyBar.var.handlers[name] then return end |
||
672 | CandyBar.var.handlers[name].icon = icon |
||
673 | |||
674 | if not icon then |
||
675 | CandyBar.var.hanlders[name].frame.icon:Hide() |
||
676 | else |
||
677 | CandyBar.var.handlers[name].frame.icon:SetNormalTexture( icon ) |
||
678 | CandyBar.var.handlers[name].frame.icon:Show() |
||
679 | end |
||
680 | |||
681 | return true |
||
682 | end |
||
683 | |||
684 | -- Sets the fading style of a candybar |
||
685 | -- args: name - name of the candybar |
||
686 | -- time - duration of the fade (default .5 seconds), negative to keep the bar on screen |
||
687 | -- returns true when succesful |
||
688 | function CandyBar:SetFade(name, time, fade) |
||
689 | CandyBar:argCheck(name, 2, "string") |
||
690 | CandyBar:argCheck(time, 3, "number") |
||
691 | if not CandyBar.var.handlers[name] then return end |
||
692 | |||
693 | CandyBar.var.handlers[name].fadetime = time |
||
694 | CandyBar.var.handlers[name].fadeout = true |
||
695 | |||
696 | return true |
||
697 | end |
||
698 | |||
699 | |||
700 | function CandyBar:SetReversed(name, reversed) |
||
701 | CandyBar:argCheck(name, 2, "string") |
||
702 | CandyBar:argCheck(reversed, 3, "boolean") |
||
703 | if not CandyBar.var.handlers[name] then return end |
||
704 | |||
705 | CandyBar.var.handlers[name].reversed = reversed |
||
706 | return true |
||
707 | end |
||
708 | |||
709 | function CandyBar:IsReversed(name) |
||
710 | CandyBar:argCheck(name, 2, "string") |
||
711 | if not CandyBar.var.handlers[name] then return end |
||
712 | |||
713 | return CandyBar.var.handlers[name].reversed |
||
714 | end |
||
715 | |||
716 | |||
717 | -- Registers a candybar with a certain candybar group |
||
718 | -- args: name - name of the candybar |
||
719 | -- group - group to register the bar with |
||
720 | -- returns true when succesful |
||
721 | function CandyBar:RegisterWithGroup( name, group ) |
||
722 | CandyBar:argCheck(name, 2, "string") |
||
723 | CandyBar:argCheck(group, 3, "string") |
||
724 | |||
725 | if not CandyBar.var.handlers[name] or not CandyBar.var.groups[group] then return end |
||
726 | |||
727 | CandyBar:UnregisterWithGroup(name) |
||
728 | |||
729 | table.insert( CandyBar.var.groups[group].bars, name) |
||
730 | -- CandyBar.var.groups[group].bars[name] = name |
||
731 | CandyBar.var.handlers[name].group = group |
||
732 | CandyBar:UpdateGroup(group) |
||
733 | |||
734 | return true |
||
735 | end |
||
736 | |||
737 | -- Unregisters a candybar from its group |
||
738 | -- args: name - name of the candybar |
||
739 | -- returns true when succesful |
||
740 | |||
741 | function CandyBar:UnregisterWithGroup( name ) |
||
742 | CandyBar:argCheck(name, 2, "string") |
||
743 | if not CandyBar.var.handlers[name] then return end |
||
744 | --if not CandyBar.var.handlers[name].group then return end |
||
745 | |||
746 | local group = CandyBar.var.handlers[name].group |
||
747 | if not CandyBar.var.groups[group] then return end |
||
748 | |||
749 | for k,v in pairs( CandyBar.var.groups[group].bars ) do |
||
750 | if v == name then |
||
751 | table.remove( CandyBar.var.groups[group].bars, k) |
||
752 | end |
||
753 | end |
||
754 | -- CandyBar.var.groups[group].bars[name] = nil |
||
755 | CandyBar.var.handlers[name].group = nil |
||
756 | |||
757 | CandyBar:UpdateGroup(group) |
||
758 | |||
759 | return true |
||
760 | |||
761 | end |
||
762 | |||
763 | |||
764 | |||
765 | -- Register a Candybar group |
||
766 | -- Args: name - name of the candybar group |
||
767 | -- returns true when succesful |
||
768 | function CandyBar:RegisterGroup( name ) |
||
769 | CandyBar:argCheck(name, 2, "string") |
||
770 | if CandyBar.var.groups[name] then return end |
||
771 | |||
772 | local t = getnewtable() |
||
773 | |||
774 | t.point = "CENTER" |
||
775 | t.rframe = UIParent |
||
776 | t.rpoint = "CENTER" |
||
777 | t.xoffset = 0 |
||
778 | t.yoffset = 0 |
||
779 | t.bars = {} |
||
780 | |||
781 | CandyBar.var.groups[name] = t |
||
782 | return true |
||
783 | end |
||
784 | |||
785 | -- Unregister a candybar group |
||
786 | -- Args: a1-a2 candybar group ids |
||
787 | -- returns true when succesful |
||
788 | |||
789 | function CandyBar:UnregisterGroup( a1, a2, a3, a4, a5, a6, a7, a8, a9, a10 ) |
||
790 | CandyBar:argCheck(a1, 2, "string") |
||
791 | if not CandyBar.var.groups[a1] then return end |
||
792 | reclaimtable(CandyBar.var.groups[a1]) |
||
793 | CandyBar.var.groups[a1] = nil |
||
794 | |||
795 | if a2 then CandyBar:UnregisterGroup( a2, a3,a4, a5, a6, a7, a8, a9, a10 ) end |
||
796 | |||
797 | return true |
||
798 | end |
||
799 | |||
800 | -- Checks if a group is registered |
||
801 | -- Args: name - Candybar group |
||
802 | -- returns true if the candybar group is registered |
||
803 | function CandyBar:IsGroupRegistered( name ) |
||
804 | CandyBar:argCheck(name, 2, "string") |
||
805 | if not CandyBar.var.groups[name] then return false end |
||
806 | return true |
||
807 | end |
||
808 | |||
809 | -- Checks if a bar is registered with a group |
||
810 | -- Args: name - Candybar name |
||
811 | -- group - group id [optional] |
||
812 | -- returns true is the candybar is registered with a/the group |
||
813 | function CandyBar:IsRegisteredWithGroup( name, group ) |
||
814 | CandyBar:argCheck(name, 2, "string") |
||
815 | if not CandyBar.var.handlers[name] then return end |
||
816 | |||
817 | if group then |
||
818 | if not CandyBar.var.groups[group] then return false end |
||
819 | if CandyBar.var.handlers[name].group == group then return true end |
||
820 | elseif CandyBar.var.handlers[name].group then |
||
821 | return true |
||
822 | end |
||
823 | return false |
||
824 | end |
||
825 | |||
826 | |||
827 | -- Set the point for a CanyBargroup |
||
828 | -- point -- anchor point |
||
829 | -- rframe -- relative frame |
||
830 | -- rpoint -- relative point |
||
831 | -- xoffset [optional] -- x offset |
||
832 | -- yoffset [optional] -- y offset |
||
833 | -- The first bar of the group will be anchored at the anchor. |
||
834 | -- returns true when succesful |
||
835 | |||
836 | function CandyBar:SetGroupPoint(name, point, rframe, rpoint, xoffset, yoffset ) |
||
837 | CandyBar:argCheck(name, 2, "string") |
||
838 | if not CandyBar.var.groups[name] then return end |
||
839 | |||
840 | CandyBar.var.groups[name].point = point |
||
841 | CandyBar.var.groups[name].rframe = rframe |
||
842 | CandyBar.var.groups[name].rpoint = rpoint |
||
843 | CandyBar.var.groups[name].xoffset = xoffset |
||
844 | CandyBar.var.groups[name].yoffset = yoffset |
||
845 | CandyBar:UpdateGroup(name) |
||
846 | return true |
||
847 | end |
||
848 | |||
849 | |||
850 | -- SetGroupGrowth - sets the group to grow up or down |
||
851 | -- Args: name - name of the candybar group |
||
852 | -- growup - true if growing up, false for growing down |
||
853 | -- returns true when succesful |
||
854 | function CandyBar:SetGroupGrowth( name, growup ) |
||
855 | CandyBar:argCheck(name, 2, "string") |
||
856 | CandyBar:argCheck(growup, 3, "boolean") |
||
857 | |||
858 | if not CandyBar.var.groups[name] then return end |
||
859 | |||
860 | CandyBar.var.groups[name].growup = growup |
||
861 | |||
862 | CandyBar:UpdateGroup(name) |
||
863 | |||
864 | return true |
||
865 | end |
||
866 | |||
867 | function CandyBar:SortGroup( name ) |
||
868 | if not CandyBar.var.groups[name] then return end |
||
869 | table.sort( CandyBar.var.groups[name].bars, |
||
870 | function( a, b ) |
||
871 | return CandyBar.var.handlers[a].endtime < CandyBar.var.handlers[b].endtime |
||
872 | end |
||
873 | ) |
||
874 | end |
||
875 | |||
876 | -- internal method |
||
877 | -- UpdateGroup - updates the location of bars in a group |
||
878 | -- Args: name - name of the candybar group |
||
879 | -- returns true when succesful |
||
880 | |||
881 | function CandyBar:UpdateGroup( name ) |
||
882 | if not CandyBar.var.groups[name] then return end |
||
883 | |||
884 | local point = CandyBar.var.groups[name].point |
||
885 | local rframe = CandyBar.var.groups[name].rframe |
||
886 | local rpoint = CandyBar.var.groups[name].rpoint |
||
887 | local xoffset = CandyBar.var.groups[name].xoffset |
||
888 | local yoffset = CandyBar.var.groups[name].yoffset |
||
889 | local m = -1 |
||
890 | if CandyBar.var.groups[name].growup then m = 1 end |
||
891 | |||
892 | local bar = 0 |
||
893 | local barh = 0 |
||
894 | |||
895 | CandyBar:SortGroup( name ) |
||
896 | |||
897 | for c,n in pairs(CandyBar.var.groups[name].bars) do |
||
898 | if CandyBar.var.handlers[n] then |
||
899 | if CandyBar.var.handlers[n].frame:IsShown() then |
||
900 | CandyBar:SetPoint(n, point, rframe, rpoint, xoffset, yoffset + (m * bar)) |
||
901 | barh = CandyBar.var.handlers[n].height or CandyBar.var.defaults.height |
||
902 | bar = bar + barh |
||
903 | end |
||
904 | end |
||
905 | end |
||
906 | return true |
||
907 | end |
||
908 | |||
909 | -- Internal Method |
||
910 | -- Update a bar on screen |
||
911 | function CandyBar:Update( name ) |
||
912 | |||
913 | if not CandyBar.var.handlers[name] then return end |
||
914 | |||
915 | local t = CandyBar.var.handlers[name].time - CandyBar.var.handlers[name].elapsed |
||
916 | |||
917 | local timetext |
||
918 | |||
919 | local reversed = CandyBar.var.handlers[name].reversed |
||
920 | |||
921 | if CandyBar.var.handlers[name].timeformat then |
||
922 | local c = CandyBar.var.handlers[name] |
||
923 | timetext = CandyBar.var.handlers[name].timeformat(t, c.timeformat1, c.timeformat2, c.timeformat3, c.timeformat4, c.timeformat5, c.timeformat6, c.timeformat7, c.timeformat8, c.timeformat9, c.timeformat10 ) |
||
924 | else |
||
925 | local h = floor(t/3600) |
||
926 | local m = t - (h*3600) |
||
927 | m = floor(m/60) |
||
928 | local s = t - ((h*3600) + (m*60)) |
||
929 | if h > 0 then |
||
930 | timetext = string.format("%d:%02d", h, m) |
||
931 | elseif m > 0 then |
||
932 | timetext = string.format("%d:%02d", m, s) |
||
933 | elseif s < 10 then |
||
934 | timetext = string.format("%1.1f", s) |
||
935 | else |
||
936 | timetext = string.format("%d", floor(s)) |
||
937 | end |
||
938 | end |
||
939 | CandyBar.var.handlers[name].frame.timertext:SetText(timetext) |
||
940 | |||
941 | local perc = t / CandyBar.var.handlers[name].time |
||
942 | |||
943 | CandyBar.var.handlers[name].frame.statusbar:SetValue(reversed and 1-perc or perc) |
||
944 | |||
945 | local width = CandyBar.var.handlers[name].width or CandyBar.var.defaults.width |
||
946 | |||
947 | local sp = width * perc |
||
948 | sp = reversed and -sp or sp |
||
949 | CandyBar.var.handlers[name].frame.spark:SetPoint("CENTER", CandyBar.var.handlers[name].frame.statusbar, reversed and "RIGHT" or "LEFT", sp, 0) |
||
950 | |||
951 | if CandyBar.var.handlers[name].gradient then |
||
952 | local p = CandyBar.var.handlers[name].elapsed / CandyBar.var.handlers[name].time |
||
953 | local gstart, gend, gp |
||
954 | -- find the appropriate start/end |
||
955 | for i = 1, table.getn(CandyBar.var.handlers[name].gradienttable)-1 do |
||
956 | if CandyBar.var.handlers[name].gradienttable[i][5] < p and p <= CandyBar.var.handlers[name].gradienttable[i+1][5] then |
||
957 | -- the bounds are to assure no divide by zero error here. |
||
958 | |||
959 | gstart = self.var.handlers[name].gradienttable[i] |
||
960 | gend = self.var.handlers[name].gradienttable[i+1] |
||
961 | gp = (p - gstart[5]) / (gend[5] - gstart[5]) |
||
962 | end |
||
963 | end |
||
964 | if gstart and gend then |
||
965 | local color = getnewtable() |
||
966 | -- calculate new gradient |
||
967 | local i |
||
968 | for i = 1, 4 do |
||
969 | -- these may be the same.. but I'm lazy to make sure. |
||
970 | color[i] = gstart[i]*(1-gp) + gend[i]*(gp) |
||
971 | end |
||
972 | CandyBar.var.handlers[name].frame.statusbar:SetStatusBarColor( color[1], color[2], color[3], color[4]) |
||
973 | |||
974 | reclaimtable(color) |
||
975 | color = nil |
||
976 | end |
||
977 | end |
||
978 | end |
||
979 | |||
980 | -- Intenal Method |
||
981 | -- Fades the bar out when it's complete. |
||
982 | function CandyBar:UpdateFade( name ) |
||
983 | if not CandyBar.var.handlers[name] then return end |
||
984 | if not CandyBar.var.handlers[name].fading then return end |
||
985 | |||
986 | -- if the fade is done go and keel the bar. |
||
987 | if CandyBar.var.handlers[name].fadeelapsed > CandyBar.var.handlers[name].fadetime then |
||
988 | CandyBar.var.handlers[name].fading = nil |
||
989 | CandyBar.var.handlers[name].starttime = nil |
||
990 | CandyBar.var.handlers[name].endtime = 0 |
||
991 | CandyBar.var.handlers[name].frame:Hide() |
||
992 | if CandyBar.var.handlers[name].group then CandyBar:UpdateGroup(CandyBar.var.handlers[name].group) end |
||
993 | if CandyBar.var.handlers[name].fireforget then |
||
994 | return CandyBar:Unregister(name) |
||
995 | end |
||
996 | else -- we're fading, set the alpha for the texts, statusbar and background. fade from default to 0 in the time given. |
||
997 | local t = CandyBar.var.handlers[name].fadetime - CandyBar.var.handlers[name].fadeelapsed |
||
998 | local p = t / CandyBar.var.handlers[name].fadetime |
||
999 | local color = CandyBar.var.handlers[name].color or CandyBar.var.defaults.color |
||
1000 | local bgcolor = CandyBar.var.handlers[name].bgcolor or CandyBar.var.defaults.bgcolor |
||
1001 | local textcolor = CandyBar.var.handlers[name].textcolor or CandyBar.var.defaults.textcolor |
||
1002 | local timertextcolor = CandyBar.var.handlers[name].timertextcolor or CandyBar.var.defaults.timertextcolor |
||
1003 | local colora = color[4] * p |
||
1004 | local bgcolora = bgcolor[4] * p |
||
1005 | local textcolora = textcolor[4] * p |
||
1006 | local timertextcolora = timertextcolor[4] * p |
||
1007 | |||
1008 | CandyBar.var.handlers[name].frame.statusbarbg:SetStatusBarColor( bgcolor[1], bgcolor[2], bgcolor[3], bgcolora) |
||
1009 | CandyBar.var.handlers[name].frame.statusbar:SetStatusBarColor( color[1], color[2], color[3], colora) |
||
1010 | CandyBar.var.handlers[name].frame.text:SetTextColor( textcolor[1], textcolor[2], textcolor[3], textcolora ) |
||
1011 | CandyBar.var.handlers[name].frame.timertext:SetTextColor( timertextcolor[1], timertextcolor[2], timertextcolor[3], timertextcolora ) |
||
1012 | CandyBar.var.handlers[name].frame.icon:SetAlpha(p) |
||
1013 | end |
||
1014 | return true |
||
1015 | end |
||
1016 | |||
1017 | -- Internal Method |
||
1018 | -- Create and return a new bar frame, recycles where needed |
||
1019 | -- Name - which candybar is this for |
||
1020 | -- Returns the frame |
||
1021 | function CandyBar:AcquireBarFrame( name ) |
||
1022 | if not CandyBar.var.handlers[name] then return end |
||
1023 | |||
1024 | local f = CandyBar.var.handlers[name].frame |
||
1025 | |||
1026 | local color = CandyBar.var.handlers[name].color or CandyBar.var.defaults.color |
||
1027 | local bgcolor = CandyBar.var.handlers[name].bgcolor or CandyBar.var.defaults.bgcolor |
||
1028 | local icon = CandyBar.var.handlers[name].icon or nil |
||
1029 | local texture = CandyBar.var.handlers[name].texture or CandyBar.var.defaults.texture |
||
1030 | local width = CandyBar.var.handlers[name].width or CandyBar.var.defaults.width |
||
1031 | local height = CandyBar.var.handlers[name].height or CandyBar.var.defaults.height |
||
1032 | local point = CandyBar.var.handlers[name].point or CandyBar.var.defaults.point |
||
1033 | local rframe = CandyBar.var.handlers[name].rframe or CandyBar.var.defaults.rframe |
||
1034 | local rpoint = CandyBar.var.handlers[name].rpoint or CandyBar.var.defaults.rpoint |
||
1035 | local xoffset = CandyBar.var.handlers[name].xoffset or CandyBar.var.defaults.xoffset |
||
1036 | local yoffset = CandyBar.var.handlers[name].yoffset or CandyBar.var.defaults.yoffset |
||
1037 | local text = CandyBar.var.handlers[name].text or CandyBar.var.defaults.text |
||
1038 | local fontsize = CandyBar.var.handlers[name].fontsize or CandyBar.var.defaults.fontsize |
||
1039 | local textcolor = CandyBar.var.handlers[name].textcolor or CandyBar.var.defaults.textcolor |
||
1040 | local timertextcolor = CandyBar.var.handlers[name].timertextcolor or CandyBar.var.defaults.timertextcolor |
||
1041 | local scale = CandyBar.var.handlers[name].scale or CandyBar.var.defaults.scale |
||
1042 | if not scale then scale = 1 end |
||
1043 | local timertextwidth = fontsize * 3 |
||
1044 | local font, _, _ = GameFontHighlight:GetFont() |
||
1045 | |||
1046 | |||
1047 | if not f and table.getn(CandyBar.var.framepool) > 0 then |
||
1048 | f = table.remove(CandyBar.var.framepool) |
||
1049 | end |
||
1050 | |||
1051 | if not f then f = CreateFrame("Button", nil, UIParent) end |
||
1052 | f:Hide() |
||
1053 | f.owner = name |
||
1054 | -- yes we add the height to the width for the icon. |
||
1055 | f:SetWidth( width + height ) |
||
1056 | f:SetHeight( height ) |
||
1057 | f:ClearAllPoints() |
||
1058 | f:SetPoint( point, rframe, rpoint, xoffset, yoffset) |
||
1059 | -- disable mouse |
||
1060 | f:EnableMouse(false) |
||
1061 | f:RegisterForClicks() |
||
1062 | f:SetScript("OnClick", nil) |
||
1063 | f:SetScale( scale ) |
||
1064 | |||
1065 | if not f.icon then f.icon = CreateFrame("Button", nil, f) end |
||
1066 | f.icon:ClearAllPoints() |
||
1067 | f.icon.owner = name |
||
1068 | f.icon:EnableMouse(false) |
||
1069 | f.icon:RegisterForClicks() |
||
1070 | f.icon:SetScript("OnClick", nil) |
||
1071 | -- an icno is square and the height of the bar, so yes 2x height there |
||
1072 | f.icon:SetHeight( height) |
||
1073 | f.icon:SetWidth( height) |
||
1074 | f.icon:SetPoint("LEFT", f, "LEFT", 0, 0) |
||
1075 | f.icon:SetNormalTexture(icon) |
||
1076 | f.icon:SetAlpha(1) |
||
1077 | f.icon:Show() |
||
1078 | |||
1079 | if not f.statusbarbg then |
||
1080 | f.statusbarbg = CreateFrame("StatusBar", nil, f ) |
||
1081 | f.statusbarbg:SetFrameLevel(f.statusbarbg:GetFrameLevel() - 1) |
||
1082 | end |
||
1083 | f.statusbarbg:ClearAllPoints() |
||
1084 | f.statusbarbg:SetHeight( height ) |
||
1085 | f.statusbarbg:SetWidth( width ) |
||
1086 | -- offset the height of the frame on the x-axis for the icon. |
||
1087 | f.statusbarbg:SetPoint( "TOPLEFT", f, "TOPLEFT", height, 0) |
||
1088 | f.statusbarbg:SetStatusBarTexture( texture ) |
||
1089 | f.statusbarbg:SetStatusBarColor( bgcolor[1],bgcolor[2],bgcolor[3],bgcolor[4]) |
||
1090 | f.statusbarbg:SetMinMaxValues(0,100) |
||
1091 | f.statusbarbg:SetValue(100) |
||
1092 | |||
1093 | if not f.statusbar then f.statusbar = CreateFrame("StatusBar", nil, f ) end |
||
1094 | f.statusbar:ClearAllPoints() |
||
1095 | f.statusbar:SetHeight( height ) |
||
1096 | f.statusbar:SetWidth( width ) |
||
1097 | -- offset the height of the frame on the x-axis for the icon. |
||
1098 | f.statusbar:SetPoint( "TOPLEFT", f, "TOPLEFT", height, 0) |
||
1099 | f.statusbar:SetStatusBarTexture( texture ) |
||
1100 | f.statusbar:SetStatusBarColor( color[1], color[2], color[3], color[4] ) |
||
1101 | f.statusbar:SetMinMaxValues(0,1) |
||
1102 | f.statusbar:SetValue(1) |
||
1103 | |||
1104 | |||
1105 | if not f.spark then f.spark = f.statusbar:CreateTexture(nil, "OVERLAY") end |
||
1106 | f.spark:SetTexture("Interface\\CastingBar\\UI-CastingBar-Spark") |
||
1107 | f.spark:SetWidth(16) |
||
1108 | f.spark:SetHeight( height + 25 ) |
||
1109 | f.spark:SetBlendMode("ADD") |
||
1110 | f.spark:Show() |
||
1111 | |||
1112 | if not f.timertext then f.timertext = f.statusbar:CreateFontString(nil, "OVERLAY") end |
||
1113 | f.timertext:SetFontObject(GameFontHighlight) |
||
1114 | f.timertext:SetFont( font, fontsize ) |
||
1115 | f.timertext:SetHeight( height) |
||
1116 | f.timertext:SetWidth( timertextwidth ) |
||
1117 | f.timertext:SetPoint( "LEFT", f.statusbar, "LEFT", 0, 0) |
||
1118 | f.timertext:SetJustifyH("RIGHT") |
||
1119 | f.timertext:SetText("0") |
||
1120 | f.timertext:SetTextColor(timertextcolor[1], timertextcolor[2], timertextcolor[3], timertextcolor[4]) |
||
1121 | |||
1122 | if not f.text then f.text = f.statusbar:CreateFontString(nil, "OVERLAY") end |
||
1123 | f.text:SetFontObject(GameFontHighlight) |
||
1124 | f.text:SetFont( font, fontsize) |
||
1125 | f.text:SetHeight(height) |
||
1126 | f.text:SetWidth( (width - timertextwidth) *.9 ) |
||
1127 | f.text:SetPoint( "RIGHT", f.statusbar, "RIGHT", 0, 0) |
||
1128 | f.text:SetJustifyH("LEFT") |
||
1129 | f.text:SetText(text) |
||
1130 | f.text:SetTextColor(textcolor[1], textcolor[2], textcolor[3], textcolor[4]) |
||
1131 | |||
1132 | if CandyBar.var.handlers[name].onclick then |
||
1133 | f:EnableMouse(true) |
||
1134 | f:RegisterForClicks("LeftButtonUp", "RightButtonUp", "MiddleButtonUp", "Button4Up", "Button5Up") |
||
1135 | f:SetScript("OnClick", function() CandyBar:OnClick() end ) |
||
1136 | f.icon:EnableMouse(true) |
||
1137 | f.icon:RegisterForClicks("LeftButtonUp", "RightButtonUp", "MiddleButtonUp", "Button4Up", "Button5Up") |
||
1138 | f.icon:SetScript("OnClick", function() CandyBar:OnClick() end ) |
||
1139 | end |
||
1140 | |||
1141 | |||
1142 | return f |
||
1143 | end |
||
1144 | |||
1145 | |||
1146 | -- Internal Method |
||
1147 | -- Releases a bar frame into the pool |
||
1148 | -- Name - which candybar's frame are we're releasing |
||
1149 | -- Returns true when succesful |
||
1150 | function CandyBar:ReleaseBarFrame( name ) |
||
1151 | if not CandyBar.var.handlers[name] then return end |
||
1152 | if not CandyBar.var.handlers[name].frame then return end |
||
1153 | CandyBar.var.handlers[name].frame:Hide() |
||
1154 | table.insert(CandyBar.var.framepool, CandyBar.var.handlers[name].frame) |
||
1155 | return true |
||
1156 | end |
||
1157 | |||
1158 | |||
1159 | -- Internal Method |
||
1160 | -- Executes the OnClick function of a bar |
||
1161 | |||
1162 | function CandyBar:OnClick() |
||
1163 | if not this.owner then return end |
||
1164 | if not CandyBar.var.handlers[this.owner] then return end |
||
1165 | if not CandyBar.var.handlers[this.owner].onclick then return end |
||
1166 | -- pass the name of the handlers first, and the button clicked as the second argument |
||
1167 | local c = CandyBar.var.handlers[this.owner] |
||
1168 | local button = arg1 |
||
1169 | CandyBar.var.handlers[this.owner].onclick( this.owner, button, c.onclick1, c.onclick2, c.onclick3, c.onclick4, c.onclick5, c.onclick6, c.onclick7, c.onclick8, c.onclick9, c.onclick10) |
||
1170 | return true |
||
1171 | end |
||
1172 | |||
1173 | |||
1174 | -- Internal Method |
||
1175 | -- on update handler |
||
1176 | function CandyBar:OnUpdate() |
||
1177 | local t = GetTime() |
||
1178 | for i,v in pairs(this.owner.var.handlers) do |
||
1179 | if v.running then |
||
1180 | v.elapsed = t - v.starttime |
||
1181 | if v.endtime <= t then |
||
1182 | if this.owner.var.handlers[i].completion then |
||
1183 | local c = this.owner.var.handlers[i] |
||
1184 | this.owner.var.handlers[i].completion( c.completion1, c.completion2, c.completion3, c.completion4, c.completion5, c.completion6, c.completion7, c.completion8, c.completion9, c.completion10 ) |
||
1185 | end |
||
1186 | this.owner:Stop(i) |
||
1187 | else |
||
1188 | this.owner:Update(i) |
||
1189 | end |
||
1190 | elseif v.fading then |
||
1191 | v.fadeelapsed = (t - v.endtime) |
||
1192 | this.owner:UpdateFade(i) |
||
1193 | end |
||
1194 | end |
||
1195 | end |
||
1196 | |||
1197 | -- Internal Method |
||
1198 | -- returns true if we have any handlers |
||
1199 | function CandyBar:HasHandlers() |
||
1200 | for i in pairs(CandyBar.var.handlers) do return true end |
||
1201 | end |
||
1202 | |||
1203 | |||
1204 | ------------------------------ |
||
1205 | -- Mixins Methods -- |
||
1206 | ------------------------------ |
||
1207 | |||
1208 | CandyBar.IsCandyBarRegistered = CandyBar.IsRegistered |
||
1209 | CandyBar.StartCandyBar = CandyBar.Start |
||
1210 | CandyBar.StopCandyBar = CandyBar.Stop |
||
1211 | CandyBar.PauseCandyBar = CandyBar.Pause |
||
1212 | CandyBar.CandyBarStatus = CandyBar.Status |
||
1213 | CandyBar.SetCandyBarTexture = CandyBar.SetTexture |
||
1214 | CandyBar.SetCandyBarTime = CandyBar.SetTime |
||
1215 | CandyBar.SetCandyBarColor = CandyBar.SetColor |
||
1216 | CandyBar.SetCandyBarText = CandyBar.SetText |
||
1217 | CandyBar.SetCandyBarIcon = CandyBar.SetIcon |
||
1218 | CandyBar.SetCandyBarBackgroundColor = CandyBar.SetBackgroundColor |
||
1219 | CandyBar.SetCandyBarTextColor = CandyBar.SetTextColor |
||
1220 | CandyBar.SetCandyBarTimerTextColor = CandyBar.SetTimerTextColor |
||
1221 | CandyBar.SetCandyBarFontSize = CandyBar.SetFontSize |
||
1222 | CandyBar.SetCandyBarPoint = CandyBar.SetPoint |
||
1223 | CandyBar.SetCandyBarScale = CandyBar.SetScale |
||
1224 | CandyBar.SetCandyBarTimeFormat = CandyBar.SetTimeFormat |
||
1225 | CandyBar.SetCandyBarTimeLeft = CandyBar.SetTimeLeft |
||
1226 | CandyBar.SetCandyBarCompletion = CandyBar.SetCompletion |
||
1227 | CandyBar.RegisterCandyBarGroup = CandyBar.RegisterGroup |
||
1228 | CandyBar.UnregisterCandyBarGroup = CandyBar.UnregisterGroup |
||
1229 | CandyBar.IsCandyBarGroupRegistered = CandyBar.IsGroupRegistered |
||
1230 | CandyBar.SetCandyBarGroupPoint = CandyBar.SetGroupPoint |
||
1231 | CandyBar.SetCandyBarGroupGrowth = CandyBar.SetGroupGrowth |
||
1232 | CandyBar.UpdateCandyBarGroup = CandyBar.UpdateGroup |
||
1233 | CandyBar.SetCandyBarOnClick = CandyBar.SetOnClick |
||
1234 | CandyBar.SetCandyBarFade = CandyBar.SetFade |
||
1235 | CandyBar.RegisterCandyBarWithGroup = CandyBar.RegisterWithGroup |
||
1236 | CandyBar.UnregisterCandyBarWithGroup = CandyBar.UnregisterWithGroup |
||
1237 | CandyBar.IsCandyBarRegisteredWithGroup = CandyBar.IsRegisteredWithGroup |
||
1238 | CandyBar.SetCandyBarReversed = CandyBar.SetReversed |
||
1239 | CandyBar.IsCandyBarReversed = CandyBar.IsReversed |
||
1240 | CandyBar.SetCandyBarOnClick = CandyBar.SetOnClick |
||
1241 | CandyBar.SetCandyBarHeight = CandyBar.SetHeight |
||
1242 | CandyBar.SetCandyBarWidth = CandyBar.SetWidth |
||
1243 | |||
1244 | function CandyBar:RegisterCandyBar(name, time, text, icon, c1, c2, c3, c4, c5, c6, c7, c8, c9, c10) |
||
1245 | if not CandyBar.var.addons[self] then CandyBar.var.addons[self] = getnewtable() end |
||
1246 | CandyBar.var.addons[self][name] = CandyBar:Register(name, time, text, icon, c1, c2, c3, c4, c5, c6, c7, c8, c9, c10) |
||
1247 | end |
||
1248 | |||
1249 | function CandyBar:UnregisterCandyBar( a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) |
||
1250 | CandyBar:argCheck(a1, 2, "string") |
||
1251 | if CandyBar.var.addons[self] then CandyBar.var.addons[self][a1] = nil end |
||
1252 | CandyBar:Unregister(a1) |
||
1253 | if a2 then self:UnregisterCandyBar( a2, a3, a4, a5, a6, a7, a8, a9, a10) end |
||
1254 | end |
||
1255 | |||
1256 | |||
1257 | function CandyBar:OnEmbedDisable(target) |
||
1258 | if self.var.addons[target] then |
||
1259 | for i in pairs(self.var.addons[target]) do |
||
1260 | self:Unregister(i) |
||
1261 | end |
||
1262 | end |
||
1263 | end |
||
1264 | |||
1265 | |||
1266 | |||
1267 | -------------------------------- |
||
1268 | -- Load this bitch! -- |
||
1269 | -------------------------------- |
||
1270 | |||
1271 | |||
1272 | function CandyBar:activate(oldLib, oldDeactivate) |
||
1273 | CandyBar = self |
||
1274 | |||
1275 | if oldLib then self.var = oldLib.var |
||
1276 | else |
||
1277 | local _,_,ourpath = string.find(debugstack(), "\\AddOns\\(.-)CandyBar%-2%.0%.lua") |
||
1278 | ourpath = "Interface\\AddOns\\"..ourpath .. "bar.tga" |
||
1279 | self.var = { -- "Local" variables go here |
||
1280 | frame = CreateFrame("Frame"), |
||
1281 | handlers = {}, |
||
1282 | groups = {}, |
||
1283 | framepool = {}, |
||
1284 | addons = {}, |
||
1285 | defaults = { |
||
1286 | texture = "Interface\\TargetingFrame\\UI-StatusBar", |
||
1287 | width = 200, |
||
1288 | height = 16, |
||
1289 | scale = 1, |
||
1290 | point = "CENTER", |
||
1291 | rframe = UIParent, |
||
1292 | rpoint = "CENTER", |
||
1293 | xoffset = 0, |
||
1294 | yoffset = 0, |
||
1295 | fontsize = 11, |
||
1296 | color = { 1, 0, 1, 1 }, |
||
1297 | bgcolor = { 0, .5, .5, .5}, |
||
1298 | textcolor = {1, 1, 1, 1}, |
||
1299 | timertextcolor = {1, 1, 1, 1}, |
||
1300 | } |
||
1301 | } |
||
1302 | self.var.frame:Hide() |
||
1303 | self.var.frame.name = "CandyBar-2.0 Frame" |
||
1304 | end |
||
1305 | self.var.frame:SetScript("OnUpdate", self.OnUpdate) |
||
1306 | self.var.frame.owner = self |
||
1307 | |||
1308 | if oldDeactivate then oldDeactivate(oldLib) end |
||
1309 | end |
||
1310 | |||
1311 | |||
1312 | local function external(self, major, instance) |
||
1313 | if major == "Compost-2.0" then compost = instance end |
||
1314 | end |
||
1315 | |||
1316 | |||
1317 | AceLibrary:Register(CandyBar, vmajor, vminor, CandyBar.activate, nil, external) |