?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
revert 213 commits (to 56092) from the last month. 10 still need work to resolve...
[AROS.git] / workbench / system / SysMon / tasks.c
blob37f169c483b7d8c610d0e45d62f988b97e2f849d
1 /*
2 Copyright ©2010-2017, The AROS Development Team. All rights reserved.
3 $Id$
4 */
5
6 #include <aros/config.h>
7
8 #define DEBUG 0
9 #include <aros/debug.h>
10
11 #include <proto/utility.h>
12 #include <proto/intuition.h>
13 #include <proto/muimaster.h>
14 #include <proto/task.h>
15 #include <proto/dos.h>
16
17 #include <exec/execbase.h>
18 #include <exec/rawfmt.h>
19
20 #include <libraries/mui.h>
21 #include <resources/task.h>
22
23 #include "locale.h"
24
25 #include "tasks.h"
26
27 #define DLIST(x)
28
29 /* uncomment the following line to force full-refresh */
30 //#define TASKLIST_FLUSHUPDATE
31 /* uncomment the following line to prevent updating */
32 //#define TASKLIST_NOTIMER
33
34 /* Task information handling*/
35 struct TaskInfo
36 {
37 struct Node ti_Node;
38 struct Task *ti_Task;
39 #if defined(__AROSPLATFORM_SMP__)
40 cpuid_t ti_CPU;
41 #endif
42 struct timeval ti_TimeCurrent;
43 struct timeval ti_TimeLast;
44 ULONG ti_CPUUsage;
45 ULONG ti_Flags;
46 };
47
48 #define TIF_ENABLED (1 << 0)
49 #define TIF_VALID (1 << 1)
50
51 struct Tasklist_DATA
52 {
53 APTR tld_taskresBase;
54
55 struct MUI_EventHandlerNode tld_InputEvent;
56 struct MUI_InputHandlerNode tld_TimerEvent;
57
58 struct Hook tld_ConstructHook;
59 struct Hook tld_DestructHook;
60 struct Hook tld_DisplayHook;
61 struct Hook tld_CompareHook;
62
63 #ifdef TASKLIST_FLUSHUPDATE
64 struct Hook tld_SelectedHook;
65 struct Task *tld_TaskSelected;
66 #endif
67 struct List tld_TaskList;
68
69 ULONG tld_TasksTotal;
70
71 ULONG tld_TasksWaiting;
72 ULONG tld_TasksReady;
73 ULONG tld_TaskTotalRuntime;
74
75 STRPTR msg_task;
76 STRPTR msg_process;
77 STRPTR msg_task_name;
78 STRPTR msg_task_priority;
79 STRPTR msg_task_type;
80 STRPTR msg_task_tombstoned;
81 STRPTR msg_task_unknown;
82
83 #if defined(__AROSPLATFORM_SMP__)
84 TEXT tld_BufCPU[5];
85 #endif
86 TEXT tld_BufUsage[10];
87 TEXT tld_BufTime[20];
88 TEXT tld_BufName[100];
89 TEXT tld_BufType[20];
90 TEXT tld_BufPrio[20];
91 TEXT tld_BufSortCol[20];
92 ULONG tasklistSortColumn;
93 ULONG tasklistSortMode;
94 ULONG updateSpeed;
95 };
96
97 #define SETUP_TASKLIST_INST_DATA struct Tasklist_DATA *data = INST_DATA(CLASS, self)
98 #define TaskResBase data->tld_taskresBase
99
100 CONST_STRPTR badstr_tmpl = " " MUIX_PH MUIX_B "%s";
101 CONST_STRPTR badval_tmpl = MUIX_PH MUIX_B "%d ";
102
103 static inline int refreshRetVal(int val, int a, int b)
104 {
105 if ((val < 0) || (a == b))
106 return -1;
107 return 1;
108 }
109
110 int Tasklist__Refresh(struct Tasklist_DATA *data, struct TaskInfo *ti, int col)
111 {
112 struct TagItem QueryTaskTags[] =
113 {
114 {TaskTag_CPUTime, 0 },
115 {TaskTag_CPUUsage, 0 },
116 #if defined(__AROSPLATFORM_SMP__)
117 {TaskTag_CPUNumber, 0 },
118 #endif
119 {TAG_DONE, 0 }
120 };
121 #if defined(__AROSPLATFORM_SMP__)
122 IPTR cpuNum;
123 #endif
124 int retVal = 0, startcol = 1;
125 ULONG cpuusage = 0;
126
127 /* Cache values we need incase something happens to the task .. */
128 ti->ti_TimeLast.tv_secs = ti->ti_TimeCurrent.tv_secs;
129 QueryTaskTags[0].ti_Data = (IPTR)&ti->ti_TimeCurrent;
130 QueryTaskTags[1].ti_Data = (IPTR)&cpuusage;
131 #if defined(__AROSPLATFORM_SMP__)
132 QueryTaskTags[2].ti_Data = (IPTR)&cpuNum;
133 #endif
134
135 if (ti->ti_Task)
136 {
137 switch (ti->ti_Task->tc_State)
138 {
139 case TS_RUN:
140 case TS_READY:
141 case TS_SPIN:
142 case TS_WAIT:
143 QueryTaskTagList(ti->ti_Task, QueryTaskTags);
144 cpuusage = ((cpuusage >> 16) * 10000) >> 16;
145 #if defined(__AROSPLATFORM_SMP__)
146 if (ti->ti_CPU != (cpuid_t)cpuNum)
147 retVal = refreshRetVal(retVal, col, startcol);
148 ti->ti_CPU = (cpuid_t)cpuNum;
149 startcol++;
150 #endif
151
152 if (ti->ti_CPUUsage != cpuusage)
153 retVal = refreshRetVal(retVal, col, startcol);
154 ti->ti_CPUUsage = cpuusage;
155 startcol++;
156
157 if (ti->ti_TimeLast.tv_secs != ti->ti_TimeCurrent.tv_secs)
158 retVal = refreshRetVal(retVal, col, startcol);
159 startcol++;
160
161 if (ti->ti_Node.ln_Pri != ti->ti_Task->tc_Node.ln_Pri)
162 retVal = refreshRetVal(retVal, col, startcol);
163 ti->ti_Node.ln_Pri = ti->ti_Task->tc_Node.ln_Pri;
164 startcol++;
165
166 if (ti->ti_Node.ln_Type != ti->ti_Task->tc_Node.ln_Type)
167 retVal = refreshRetVal(retVal, col, startcol);
168 ti->ti_Node.ln_Type = ti->ti_Task->tc_Node.ln_Type;
169
170 if (!(ti->ti_Flags & TIF_ENABLED))
171 retVal = refreshRetVal(retVal, 1, 0);
172 ti->ti_Flags |= TIF_ENABLED;
173
174 break;
175
176 default:
177 if (!(ti->ti_Flags & TIF_ENABLED))
178 retVal = refreshRetVal(retVal, 1, 0);
179 ti->ti_Flags &= ~TIF_ENABLED;
180 break;
181 }
182 }
183 return retVal;
184 }
185
186 #ifndef TASKLIST_FLUSHUPDATE
187 IPTR Tasklist__DeleteTaskEntry(Class *CLASS, Object *self, struct TaskInfo *ti)
188 {
189 int i;
190
191 for (i=0;;i++)
192 {
193 struct TaskInfo *le_ti = NULL;
194
195 DoMethod(self, MUIM_List_GetEntry, i, &le_ti);
196 if (!le_ti) break;
197
198 if (ti == le_ti)
199 {
200 D(bug("[SysMon:TaskList] deleting entry ...\n"));
201 DoMethod(self, MUIM_List_Remove, i);
202 break;
203 }
204 }
205 return (IPTR)NULL;
206 }
207 #endif
208
209 AROS_UFH3(struct TaskInfo *, TasksListConstructFunction,
210 AROS_UFHA(struct Hook *, h, A0),
211 AROS_UFHA(APTR, pool, A2),
212 AROS_UFHA(struct Task *, curTask, A1))
213 {
214 AROS_USERFUNC_INIT
215
216 struct Tasklist_DATA *data = h->h_Data;
217 struct TaskInfo *ti = NULL;
218
219 DLIST(bug("[SysMon:TaskList] %s()\n", __func__));
220
221 if ((ti = AllocVecPooled(pool, sizeof(struct TaskInfo))) != NULL)
222 {
223 ti->ti_Task = curTask;
224 ti->ti_Flags = 0;
225
226 Tasklist__Refresh(data, ti, data->tasklistSortColumn);
227
228 switch (curTask->tc_State)
229 {
230 case TS_REMOVED:
231 ti->ti_Node.ln_Name = StrDup(data->msg_task_tombstoned);
232 break;
233 case TS_RUN:
234 case TS_READY:
235 case TS_SPIN:
236 case TS_WAIT:
237 ti->ti_Flags |= TIF_VALID;
238 if (curTask->tc_Node.ln_Name)
239 {
240 ti->ti_Node.ln_Name = StrDup(curTask->tc_Node.ln_Name);
241 break;
242 }
243 default:
244 ti->ti_Node.ln_Name = StrDup(data->msg_task_unknown);
245 break;
246 }
247
248 data->tld_TasksTotal++;
249 AddTail(&data->tld_TaskList, &ti->ti_Node);
250 }
251 return ti;
252
253 AROS_USERFUNC_EXIT
254 }
255
256 AROS_UFH3(VOID, TasksListDestructFunction,
257 AROS_UFHA(struct Hook *, h, A0),
258 AROS_UFHA(APTR, pool, A2),
259 AROS_UFHA(struct TaskInfo *, ti, A1))
260 {
261 AROS_USERFUNC_INIT
262
263 struct Tasklist_DATA *data = h->h_Data;
264
265 DLIST(bug("[SysMon:TaskList] %s()\n", __func__));
266
267 Remove(&ti->ti_Node);
268 data->tld_TasksTotal--;
269
270 FreeVec(ti->ti_Node.ln_Name);
271 FreeVecPooled(pool, ti);
272
273 AROS_USERFUNC_EXIT
274 }
275
276 #ifdef TASKLIST_FLUSHUPDATE
277 AROS_UFH3(VOID, TaskSelectedFunction,
278 AROS_UFHA(struct Hook *, h, A0),
279 AROS_UFHA(Object *, obj, A2),
280 AROS_UFHA(APTR, msg, A1))
281 {
282 AROS_USERFUNC_INIT
283
284 struct Tasklist_DATA *data = h->h_Data;
285 struct TaskInfo *ti = NULL;
286
287 DoMethod(obj, MUIM_List_GetEntry, MUIV_List_GetEntry_Active, &ti);
288 DLIST(bug("[SysMon:TaskList] ti @ 0x%p\n", ti);)
289
290 if (ti != NULL)
291 {
292 data->tld_TaskSelected = ti->ti_Task;
293 }
294 else
295 data->tld_TaskSelected = NULL;
296
297 AROS_USERFUNC_EXIT
298 }
299 #endif
300
301 AROS_UFH3(LONG, TaskCompareFunction,
302 AROS_UFHA(struct Hook *, h, A0),
303 AROS_UFHA(struct TaskInfo *, ti2, A2),
304 AROS_UFHA(struct TaskInfo *, ti1, A1))
305 {
306 AROS_USERFUNC_INIT
307
308 struct Tasklist_DATA *data = h->h_Data;
309 LONG retval;
310
311 DLIST(bug("[SysMon:TaskList] %s()\n", __func__));
312
313 switch (data->tasklistSortColumn)
314 {
315 #if defined(__AROSPLATFORM_SMP__)
316 #define COLUMNOFFSET 1
317 case 1:
318 if (!data->tasklistSortMode)
319 {
320 retval = (LONG)(ti2->ti_CPU - ti1->ti_CPU);
321 if (retval == 0)
322 {
323 retval = (LONG)(stricmp(ti1->ti_Node.ln_Name, ti2->ti_Node.ln_Name));
324 }
325 }
326 else
327 {
328 retval = (LONG)(ti1->ti_CPU - ti2->ti_CPU);
329 if (retval == 0)
330 {
331 retval = (LONG)(stricmp(ti2->ti_Node.ln_Name, ti1->ti_Node.ln_Name));
332 }
333 }
334 break;
335 #else
336 #define COLUMNOFFSET 0
337 #endif
338 case (COLUMNOFFSET + 1):
339 if (!data->tasklistSortMode)
340 {
341 retval = (LONG)(ti2->ti_CPUUsage - ti1->ti_CPUUsage);
342 if (retval == 0)
343 {
344 retval = (LONG)(ti2->ti_TimeCurrent.tv_usec - ti1->ti_TimeCurrent.tv_usec);
345 if (retval == 0)
346 retval = (LONG)(stricmp(ti1->ti_Node.ln_Name, ti2->ti_Node.ln_Name));
347 }
348 }
349 else
350 {
351 retval = (LONG)(ti1->ti_CPUUsage - ti2->ti_CPUUsage);
352 if (retval == 0)
353 {
354 retval = (LONG)(ti1->ti_TimeCurrent.tv_usec - ti2->ti_TimeCurrent.tv_usec);
355 if (retval == 0)
356 retval = (LONG)(stricmp(ti2->ti_Node.ln_Name, ti1->ti_Node.ln_Name));
357 }
358 }
359 break;
360
361
362 case (COLUMNOFFSET + 2):
363 if (!data->tasklistSortMode)
364 {
365 retval = (LONG)(ti2->ti_TimeCurrent.tv_secs - ti1->ti_TimeCurrent.tv_secs);
366 if (retval == 0)
367 {
368 retval = (LONG)(ti2->ti_TimeCurrent.tv_usec - ti1->ti_TimeCurrent.tv_usec);
369 if (retval == 0)
370 retval = (LONG)(stricmp(ti1->ti_Node.ln_Name, ti2->ti_Node.ln_Name));
371 }
372 }
373 else
374 {
375 retval = (LONG)(ti1->ti_TimeCurrent.tv_secs - ti2->ti_TimeCurrent.tv_secs);
376 if (retval == 0)
377 {
378 retval = (LONG)(ti1->ti_TimeCurrent.tv_usec - ti2->ti_TimeCurrent.tv_usec);
379 if (retval == 0)
380 retval = (LONG)(stricmp(ti2->ti_Node.ln_Name, ti1->ti_Node.ln_Name));
381 }
382 }
383 break;
384
385 case (COLUMNOFFSET + 3):
386 if (!data->tasklistSortMode)
387 {
388 retval = (LONG)(ti2->ti_Node.ln_Pri - ti1->ti_Node.ln_Pri);
389 if (retval == 0)
390 {
391 retval = (LONG)(stricmp(ti1->ti_Node.ln_Name, ti2->ti_Node.ln_Name));
392 }
393 }
394 else
395 {
396 retval = (LONG)(ti1->ti_Node.ln_Pri - ti2->ti_Node.ln_Pri);
397 if (retval == 0)
398 {
399 retval = (LONG)(stricmp(ti2->ti_Node.ln_Name, ti1->ti_Node.ln_Name));
400 }
401 }
402 break;
403 case (COLUMNOFFSET + 4):
404 if (!data->tasklistSortMode)
405 {
406 retval = (LONG)(ti1->ti_Node.ln_Type - ti2->ti_Node.ln_Type);
407 if (retval == 0)
408 {
409 retval = (LONG)(stricmp(ti1->ti_Node.ln_Name, ti2->ti_Node.ln_Name));
410 }
411 }
412 else
413 {
414 retval = (LONG)(ti2->ti_Node.ln_Type - ti1->ti_Node.ln_Type);
415 if (retval == 0)
416 {
417 retval = (LONG)(stricmp(ti2->ti_Node.ln_Name, ti1->ti_Node.ln_Name));
418 }
419 }
420 break;
421 default:
422 if (!data->tasklistSortMode)
423 retval = (LONG)(stricmp(ti1->ti_Node.ln_Name, ti2->ti_Node.ln_Name));
424 else
425 retval = (LONG)(stricmp(ti2->ti_Node.ln_Name, ti1->ti_Node.ln_Name));
426 break;
427 }
428
429 return retval;
430
431 AROS_USERFUNC_EXIT
432 }
433
434 AROS_UFH3(APTR, TasksListDisplayFunction,
435 AROS_UFHA(struct Hook *, h, A0),
436 AROS_UFHA(STRPTR *, strings, A2),
437 AROS_UFHA(struct TaskInfo *, ti, A1))
438 {
439 AROS_USERFUNC_INIT
440
441 struct Tasklist_DATA *data = h->h_Data;
442 IPTR fmtdata[] =
443 {
444 0,
445 0,
446 0,
447 0,
448 0
449 };
450 char *type;
451 int col= 0;
452
453 DLIST(bug("[SysMon:TaskList] %s()\n", __func__));
454
455 if (ti)
456 {
457 type = (ti->ti_Node.ln_Type == NT_TASK) ? data->msg_task : data->msg_process;
458
459 if (!(ti->ti_Flags & TIF_VALID))
460 {
461 fmtdata[0] = (IPTR)ti->ti_Node.ln_Name;
462 RawDoFmt(badstr_tmpl, (RAWARG)&fmtdata, RAWFMTFUNC_STRING, data->tld_BufName);
463 fmtdata[0] = (IPTR)ti->ti_Node.ln_Pri;
464 RawDoFmt(badval_tmpl, (RAWARG)&fmtdata, RAWFMTFUNC_STRING, data->tld_BufPrio);
465 fmtdata[0] = (IPTR)type;
466 RawDoFmt(badstr_tmpl, (RAWARG)&fmtdata, RAWFMTFUNC_STRING, data->tld_BufType);
467 strings[col++] = data->tld_BufName;
468 #if defined(__AROSPLATFORM_SMP__)
469 strings[col++] = "---";
470 strings[col++] = "---.--.--";
471 #endif
472 strings[col++] = data->tld_BufPrio;
473 strings[col++] = data->tld_BufType;
474 }
475 else
476 {
477 fmtdata[0] = (IPTR)ti->ti_Node.ln_Pri;
478 RawDoFmt("%id ", (RAWARG)&fmtdata, RAWFMTFUNC_STRING, data->tld_BufPrio);
479 strings[col++] = ti->ti_Node.ln_Name;
480 #if defined(__AROSPLATFORM_SMP__)
481 fmtdata[0] = (IPTR)ti->ti_CPU;
482 RawDoFmt("%03iu ", (RAWARG)&fmtdata, RAWFMTFUNC_STRING, data->tld_BufCPU);
483 strings[col++] = data->tld_BufCPU;
484 #endif
485 fmtdata[0] = (IPTR)ti->ti_CPUUsage / 100;
486 fmtdata[1] = (IPTR)ti->ti_CPUUsage % 100;
487 RawDoFmt("%3id.%02id%% ", (RAWARG)&fmtdata, RAWFMTFUNC_STRING, data->tld_BufUsage);
488 strings[col++] = data->tld_BufUsage;
489
490 fmtdata[0] = (IPTR)(ti->ti_TimeCurrent.tv_secs / 60 / 60);
491 fmtdata[1] = (IPTR)((ti->ti_TimeCurrent.tv_secs / 60) % 60);
492 fmtdata[2] = (IPTR)(ti->ti_TimeCurrent.tv_secs % 60);
493 fmtdata[3] = (IPTR)((ti->ti_TimeCurrent.tv_usec + 500) / 10000);
494 RawDoFmt("%3id:%02id:%02id.%02id", (RAWARG)&fmtdata, RAWFMTFUNC_STRING, data->tld_BufTime);
495 strings[col++] = data->tld_BufTime;
496 strings[col++] = data->tld_BufPrio;
497 strings[col++] = type;
498 }
499 }
500 else
501 {
502 char *dir;
503
504 if (data->tasklistSortMode == 0)
505 dir = "+";
506 else
507 dir = "-";
508
509 fmtdata[1] = (IPTR)dir;
510 if (data->tasklistSortColumn == col)
511 {
512 fmtdata[0] = (IPTR)data->msg_task_name;
513 RawDoFmt(MUIX_B "%s %s", (RAWARG)&fmtdata, RAWFMTFUNC_STRING, data->tld_BufSortCol);
514 strings[col++] = data->tld_BufSortCol;
515 }
516 else
517 strings[col++] = data->msg_task_name;
518
519 #if defined(__AROSPLATFORM_SMP__)
520 if (data->tasklistSortColumn == col)
521 {
522 fmtdata[0] = (IPTR)"CPU";
523 RawDoFmt(MUIX_B "%s %s", (RAWARG)&fmtdata, RAWFMTFUNC_STRING, data->tld_BufSortCol);
524 strings[col++] = data->tld_BufSortCol;
525 }
526 else
527 strings[col++] = "CPU";
528 #endif
529
530 if (data->tasklistSortColumn == col)
531 {
532 fmtdata[0] = (IPTR)"CPU %";
533 RawDoFmt(MUIX_B "%s %s", (RAWARG)&fmtdata, RAWFMTFUNC_STRING, data->tld_BufSortCol);
534 strings[col++] = data->tld_BufSortCol;
535 }
536 else
537 strings[col++] = "CPU %";
538
539 if (data->tasklistSortColumn == col)
540 {
541 fmtdata[0] = (IPTR)"CPU Time";
542 RawDoFmt(MUIX_B "%s %s", (RAWARG)&fmtdata, RAWFMTFUNC_STRING, data->tld_BufSortCol);
543 strings[col++] = data->tld_BufSortCol;
544 }
545 else
546 strings[col++] = "CPU Time";
547
548 if (data->tasklistSortColumn == col)
549 {
550 fmtdata[0] = (IPTR)data->msg_task_priority;
551 RawDoFmt(MUIX_B "%s %s", (RAWARG)&fmtdata, RAWFMTFUNC_STRING, data->tld_BufSortCol);
552 strings[col++] = data->tld_BufSortCol;
553 }
554 else
555 strings[col++] = data->msg_task_priority;
556
557 if (data->tasklistSortColumn == col)
558 {
559 fmtdata[0] = (IPTR)data->msg_task_type;
560 RawDoFmt(MUIX_B "%s %s", (RAWARG)&fmtdata, RAWFMTFUNC_STRING, data->tld_BufSortCol);
561 strings[col++] = data->tld_BufSortCol;
562 }
563 else
564 strings[col++] = data->msg_task_type;
565 }
566
567 return NULL;
568
569 AROS_USERFUNC_EXIT
570 }
571
572 Object *Tasklist__OM_NEW(Class *CLASS, Object *self, struct opSet *message)
573 {
574 D(bug("[SysMon:TaskList] %s()\n", __func__));
575
576 self = (Object *) DoSuperNewTags(CLASS, self, NULL,
577 ReadListFrame,
578 MUIA_List_Format,
579 #if !defined(__AROSPLATFORM_SMP__)
580 "MIW=50 BAR,BAR,BAR,BAR P=\033r,",
581 #else
582 "MIW=50 BAR,BAR,BAR,BAR,BAR P=\033r,",
583 #endif
584 MUIA_List_Title, (IPTR)TRUE,
585 TAG_MORE, (IPTR) message->ops_AttrList
586 );
587
588 if (self != NULL)
589 {
590 SETUP_TASKLIST_INST_DATA;
591
592 data->tld_taskresBase = OpenResource("task.resource");
593 if (data->tld_taskresBase)
594 {
595 NewList(&data->tld_TaskList);
596
597 data->updateSpeed = (ULONG)GetTagData(MUIA_Tasklist_RefreshMSecs, MUIV_Tasklist_Refresh_Normal, message->ops_AttrList);
598
599 data->tld_TaskTotalRuntime = 0;
600 data->tasklistSortColumn = 1;
601
602 data->msg_task = (STRPTR)_(MSG_TASK);
603 data->msg_process = (STRPTR)_(MSG_PROCESS);
604 data->msg_task_name = (STRPTR)_(MSG_TASK_NAME);
605 data->msg_task_priority = (STRPTR)_(MSG_TASK_PRIORITY);
606 data->msg_task_type = (STRPTR)_(MSG_TASK_TYPE);
607 data->msg_task_tombstoned = (STRPTR)_(MSG_TASK_TOMBSTONE);
608 data->msg_task_unknown = (STRPTR)_(MSG_TASK_UNKNOWN);
609
610 data->tld_ConstructHook.h_Entry = (APTR)TasksListConstructFunction;
611 data->tld_ConstructHook.h_Data = (APTR)data;
612 data->tld_DestructHook.h_Entry = (APTR)TasksListDestructFunction;
613 data->tld_DestructHook.h_Data = (APTR)data;
614 data->tld_DisplayHook.h_Entry = (APTR)TasksListDisplayFunction;
615 data->tld_DisplayHook.h_Data = (APTR)data;
616 data->tld_CompareHook.h_Entry = (APTR)TaskCompareFunction;
617 data->tld_CompareHook.h_Data = (APTR)data;
618
619 SET(self, MUIA_List_ConstructHook, &data->tld_ConstructHook);
620 SET(self, MUIA_List_DestructHook, &data->tld_DestructHook);
621 SET(self, MUIA_List_DisplayHook, &data->tld_DisplayHook);
622 SET(self, MUIA_List_CompareHook, &data->tld_CompareHook);
623
624 #ifdef TASKLIST_FLUSHUPDATE
625 data->tld_TaskSelected = NULL;
626 data->tld_SelectedHook.h_Entry = (APTR)TaskSelectedFunction;
627 data->tld_SelectedHook.h_Data = (APTR)data;
628 DoMethod(self, MUIM_Notify, MUIA_List_Active, MUIV_EveryTime,
629 self, 2, MUIM_CallHook, (IPTR)&data->tld_SelectedHook);
630 #endif
631 }
632 else
633 {
634 FPuts(Output(), (STRPTR)_(MSG_CANT_OPEN_TASK_RESOURCE));
635
636 CoerceMethod(CLASS, self, OM_DISPOSE);
637
638 self = NULL;
639 }
640 }
641
642 return self;
643 }
644
645 IPTR Tasklist__OM_DISPOSE(Class *CLASS, Object *self, Msg message)
646 {
647 D(bug("[SysMon:TaskList] %s()\n", __func__));
648
649 return DoSuperMethodA(CLASS, self, message);
650 }
651
652 IPTR Tasklist__OM_SET(Class *CLASS, Object *self, struct opSet *message)
653 {
654 SETUP_TASKLIST_INST_DATA;
655 struct TagItem *tstate = message->ops_AttrList, *tag;
656
657 D(bug("[SysMon:TaskList] %s()\n", __func__));
658
659 while ((tag = NextTagItem((struct TagItem **)&tstate)) != NULL)
660 {
661 switch (tag->ti_Tag)
662 {
663 case MUIA_Tasklist_RefreshMSecs:
664 data->updateSpeed = (ULONG)tag->ti_Data;
665 #ifndef TASKLIST_NOTIMER
666 if (data->tld_TimerEvent.ihn_Method != 0)
667 {
668 DoMethod(_app(self), MUIM_Application_RemInputHandler, (IPTR) &data->tld_TimerEvent);
669 data->tld_TimerEvent.ihn_Millis = data->updateSpeed;
670 DoMethod(_app(self), MUIM_Application_AddInputHandler, (IPTR) &data->tld_TimerEvent);
671 }
672 #endif
673 break;
674 case MUIA_Tasklist_Refreshed:
675 break;
676 }
677 }
678 return DoSuperMethodA(CLASS, self, (Msg) message);
679 }
680
681 IPTR Tasklist__OM_GET(Class *CLASS, Object *self, struct opGet *message)
682 {
683 SETUP_TASKLIST_INST_DATA;
684 IPTR *store = message->opg_Storage;
685 IPTR retval = 0;
686
687 D(bug("[SysMon:TaskList] %s()\n", __func__));
688
689 switch (message->opg_AttrID)
690 {
691 case MUIA_Tasklist_Refreshed:
692 *store = (IPTR)TRUE;
693 retval = 1;
694 break;
695 case MUIA_Tasklist_RefreshMSecs:
696 *store = (IPTR)data->updateSpeed;
697 retval = 1;
698 break;
699 case MUIA_Tasklist_ReadyCount:
700 *store = (IPTR)data->tld_TasksReady;
701 retval = 1;
702 break;
703 case MUIA_Tasklist_WaitingCount:
704 *store = (IPTR)data->tld_TasksWaiting;
705 retval = 1;
706 break;
707 }
708
709 if (!retval)
710 retval = DoSuperMethodA(CLASS, self, (Msg) message);
711
712 return retval;
713 }
714
715 IPTR Tasklist__MUIM_Show(Class *CLASS, Object *self, struct MUIP_Show *message)
716 {
717 IPTR retval;
718
719 SETUP_TASKLIST_INST_DATA;
720
721 D(bug("[SysMon:TaskList] %s()\n", __func__));
722
723 retval = DoSuperMethodA(CLASS, self, (Msg) message);
724
725 data->tld_InputEvent.ehn_Events = IDCMP_MOUSEBUTTONS;
726 data->tld_InputEvent.ehn_Priority = 10;
727 data->tld_InputEvent.ehn_Flags = 0;
728 data->tld_InputEvent.ehn_Object = self;
729 data->tld_InputEvent.ehn_Class = CLASS;
730 DoMethod(_win(self), MUIM_Window_AddEventHandler, (IPTR)&data->tld_InputEvent);
731
732 #ifndef TASKLIST_NOTIMER
733 data->tld_TimerEvent.ihn_Flags = MUIIHNF_TIMER;
734 data->tld_TimerEvent.ihn_Millis = data->updateSpeed;
735 data->tld_TimerEvent.ihn_Object = self;
736 data->tld_TimerEvent.ihn_Method = MUIM_Tasklist_HandleTimer;
737
738 DoMethod( _app(self), MUIM_Application_AddInputHandler, (IPTR) &data->tld_TimerEvent);
739 #endif
740
741 DoMethod(self, MUIM_Tasklist_Refresh);
742
743 return retval;
744 }
745
746 IPTR Tasklist__MUIM_Hide(Class *CLASS, Object *self, struct MUIP_Hide *message)
747 {
748 SETUP_TASKLIST_INST_DATA;
749
750 D(bug("[SysMon:TaskList] %s()\n", __func__));
751
752 #ifndef TASKLIST_NOTIMER
753 DoMethod(_app(self), MUIM_Application_RemInputHandler, (IPTR) &data->tld_TimerEvent);
754 data->tld_TimerEvent.ihn_Method = 0;
755 #endif
756
757 DoMethod(_win(self), MUIM_Window_RemEventHandler, (IPTR)&data->tld_InputEvent);
758
759 return DoSuperMethodA(CLASS, self, (Msg) message);
760 }
761
762 IPTR Tasklist__MUIM_HandleEvent(Class *CLASS, Object *self, struct MUIP_HandleEvent *message)
763 {
764 SETUP_TASKLIST_INST_DATA;
765 struct MUI_List_TestPos_Result selectres;
766
767 D(bug("[SysMon:TaskList] %s()\n", __func__));
768
769 if ((message->imsg->MouseX > _mleft(self)) &&
770 (message->imsg->MouseY > _mtop(self)) &&
771 (message->imsg->MouseX < _mright(self)) &&
772 (message->imsg->MouseY < _mbottom(self)))
773 {
774 if ((message->imsg) && (message->imsg->Class == IDCMP_MOUSEBUTTONS))
775 {
776 if (message->imsg->Code == SELECTUP)
777 {
778 D(bug("[SysMon:TaskList] %s: Click @ %d, %d\n", __func__, message->imsg->MouseX, message->imsg->MouseY));
779 DoMethod(self, MUIM_List_TestPos, message->imsg->MouseX, message->imsg->MouseY, &selectres);
780 if ((selectres.entry == -1) && (selectres.column != -1) && (message->imsg->MouseY < (_mtop(self) + _font(self)->tf_YSize + 4)))
781 {
782 if (data->tasklistSortColumn == selectres.column)
783 data->tasklistSortMode = ~data->tasklistSortMode;
784 else
785 data->tasklistSortMode = 0;
786 data->tasklistSortColumn = selectres.column;
787 SET(self, MUIA_List_Quiet, TRUE);
788 DoMethod(self, MUIM_List_Sort);
789 DoMethod(self, MUIM_List_Redraw, MUIV_List_Redraw_All);
790 SET(self, MUIA_List_Quiet, FALSE);
791 }
792 }
793 }
794 }
795
796 return DoSuperMethodA(CLASS, self, (Msg) message);
797 }
798
799 IPTR Tasklist__MUIM_Tasklist_Refresh(Class *CLASS, Object *self, Msg message)
800 {
801 SETUP_TASKLIST_INST_DATA;
802
803 D(bug("[SysMon:TaskList] %s()\n", __func__));
804
805 struct TaskList *systasklist;
806 struct Task * task;
807 #ifndef TASKLIST_FLUSHUPDATE
808 struct TaskInfo *ti = NULL, *titmp;
809 #else
810 struct Task *selected = data->tld_TaskSelected;
811 IPTR firstvis = 0;
812 IPTR entryid = 0;
813 #endif
814 BOOL doSort = FALSE;
815
816 SET(self, MUIA_List_Quiet, TRUE);
817
818 #ifdef TASKLIST_FLUSHUPDATE
819 get(self, MUIA_List_First, &firstvis);
820 DoMethod(self, MUIM_List_Clear);
821 #else
822 ForeachNode(&data->tld_TaskList, ti)
823 {
824 ti->ti_Flags &= ~TIF_ENABLED;
825 }
826 #endif
827
828 data->tld_TasksWaiting = 0;
829 data->tld_TasksReady = 0;
830 data->tld_TaskTotalRuntime = 0;
831
832 systasklist = LockTaskList(LTF_ALL);
833 while ((task = NextTaskEntry(systasklist, LTF_ALL)) != NULL)
834 {
835 D(bug("[SysMon:TaskList] task %s state %d\n", task->tc_Node.ln_Name, task->tc_State));
836
837 if (task->tc_State == TS_READY)
838 {
839 data->tld_TasksReady++;
840 }
841 if ((task->tc_State == TS_WAIT) || (task->tc_State == TS_SPIN))
842 {
843 data->tld_TasksWaiting++;
844 }
845
846 #ifndef TASKLIST_FLUSHUPDATE
847 ti = NULL;
848 ForeachNode(&data->tld_TaskList, ti)
849 {
850 if (ti->ti_Task == task)
851 {
852 int taskUpdate;
853
854 D(bug("[SysMon:TaskList] updating entry @ 0x%p\n", ti));
855
856 if ((taskUpdate = Tasklist__Refresh(data, ti, data->tasklistSortColumn)) != 0)
857 {
858 DoMethod(self, MUIM_List_Redraw, MUIV_List_Redraw_Entry, ti);
859 if (taskUpdate < 0)
860 doSort = TRUE;
861 }
862
863 task = NULL;
864 break;
865 }
866 }
867 #endif
868 if (task)
869 {
870 D(bug("[SysMon:TaskList] creating new entry ...\n"));
871 #ifdef TASKLIST_FLUSHUPDATE
872 entryid =
873 #endif
874 DoMethod(self, MUIM_List_InsertSingle, task, MUIV_List_Insert_Sorted);
875 #ifdef TASKLIST_FLUSHUPDATE
876 if (task == selected)
877 {
878 SET(self, MUIA_List_Active, entryid);
879 }
880 #endif
881 }
882 }
883 UnLockTaskList(systasklist, LTF_ALL);
884
885 #ifndef TASKLIST_FLUSHUPDATE
886 ti = NULL;
887 ForeachNodeSafe(&data->tld_TaskList, ti, titmp)
888 {
889 if (!(ti->ti_Flags & TIF_ENABLED))
890 {
891 Tasklist__DeleteTaskEntry(CLASS, self, ti);
892 }
893 }
894 #else
895 if (XGET(self, MUIA_List_Active) == 0)
896 data->tld_TaskSelected = NULL;
897
898 /* Keep the "pre-refresh" view on List as much as possible */
899 LONG v = (LONG)firstvis;
900 if (firstvis + XGET(self, MUIA_List_Visible) >= XGET(self, MUIA_List_Entries))
901 {
902 v = XGET(self, MUIA_List_Entries) - XGET(self, MUIA_List_Visible);
903 if (v < 0) v = 0;
904 }
905
906 SET(self, MUIA_List_First, v);
907 #endif
908
909 if (doSort)
910 DoMethod(self, MUIM_List_Sort);
911
912 SET(self, MUIA_List_Quiet, FALSE);
913 SET(self, MUIA_Tasklist_Refreshed, TRUE);
914
915 return (IPTR)TRUE;
916 }
917
918 IPTR Tasklist__MUIM_Tasklist_HandleTimer(Class *CLASS, Object *self, Msg message)
919 {
920 D(bug("[SysMon:TaskList] %s()\n", __func__));
921
922 DoMethod(self, MUIM_Tasklist_Refresh);
923
924 return (IPTR)FALSE;
925 }
926
927 /*** Setup ******************************************************************/
928 TASKLIST_CUSTOMCLASS
929 (
930 Tasklist, NULL, MUIC_List, NULL,
931 OM_NEW, struct opSet *,
932 OM_DISPOSE, Msg,
933 OM_SET, struct opSet *,
934 OM_GET, struct opGet *,
935 MUIM_Show, struct MUIP_Show *,
936 MUIM_Hide, struct MUIP_Hide *,
937 MUIM_HandleEvent, struct MUIP_HandleEvent *,
938 MUIM_Tasklist_Refresh, Msg,
939 MUIM_Tasklist_HandleTimer, Msg
940 );
Mirror of AROS' svn.