?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
starting preparing the graph class for a slight rework.
[AROS.git] / workbench / classes / zune / graph / graph.c
blob6023ba1f2a5a233ca685f2261ce130a32fd0d9ff
1 /*
2 Copyright © 2017, The AROS Development Team. All rights reserved.
3 $Id$
4 */
5
6 #define DEBUG 0
7 #include <aros/debug.h>
8
9 #define MUIMASTER_YES_INLINE_STDARG
10
11 #include <exec/types.h>
12 #include <utility/date.h>
13
14 #include <aros/asmcall.h>
15
16 #include <proto/alib.h>
17 #include <proto/muimaster.h>
18 #include <proto/graphics.h>
19 #include <proto/intuition.h>
20 #include <proto/utility.h>
21 #include <proto/timer.h>
22
23 #include <string.h>
24 #include <stdio.h>
25 #include <math.h>
26
27 #include "graph.h"
28 #include "graph_intern.h"
29
30 IPTR Graph__UpdateSourceArray(struct Graph_DATA *data, IPTR count)
31 {
32 struct Graph_SourceDATA *newSourceArray = data->graph_Sources;
33
34 D(bug("[Graph] %s(%d)\n", __func__, count);)
35
36 if (data->graph_SourceCount != count)
37 {
38 IPTR copycnt;
39
40 if (count > data->graph_SourceCount)
41 copycnt = data->graph_SourceCount;
42 else
43 copycnt = count;
44
45 newSourceArray = AllocMem(sizeof(struct Graph_SourceDATA) * count, MEMF_ANY);
46 if (newSourceArray)
47 {
48
49 if (data->graph_Sources)
50 {
51 CopyMem(data->graph_Sources, newSourceArray, sizeof(struct Graph_SourceDATA) * copycnt);
52 FreeMem(data->graph_Sources, sizeof(struct Graph_SourceDATA) * data->graph_SourceCount);
53 }
54
55 if (count > data->graph_SourceCount)
56 {
57 D(bug("[Graph] %s: initializing new source\n", __func__);)
58 memset(&newSourceArray[count - 1], 0, sizeof(struct Graph_SourceDATA));
59 newSourceArray[count - 1].gs_PlotPen = -1;
60 newSourceArray[count - 1].gs_PlotFillPen = -1;
61 if (data->graph_EntryCount > 0)
62 newSourceArray[count - 1].gs_Entries = AllocMem(sizeof(IPTR) * data->graph_EntryCount, MEMF_CLEAR|MEMF_ANY);
63 }
64
65 data->graph_Sources = newSourceArray;
66 data->graph_SourceCount = count;
67 }
68 }
69
70 return (IPTR)newSourceArray;
71 }
72
73 IPTR Graph__UpdateSourceEntries(struct Graph_DATA *data, IPTR sourceNo, IPTR count)
74 {
75 struct Graph_SourceDATA *dataSource = NULL;
76
77 D(bug("[Graph] %s(%d:%d)\n", __func__, sourceNo, count);)
78
79 if (count > data->graph_EntryCount)
80 {
81 IPTR *newEntries;
82
83 dataSource = &data->graph_Sources[sourceNo];
84
85 newEntries = AllocMem(sizeof(IPTR) * count, MEMF_ANY);
86 if (newEntries)
87 {
88 if (dataSource->gs_Entries)
89 {
90 CopyMem(dataSource->gs_Entries, newEntries, sizeof(IPTR) * data->graph_EntryCount);
91 FreeMem(dataSource->gs_Entries, sizeof(IPTR) * data->graph_EntryCount);
92 }
93 dataSource->gs_Entries = newEntries;
94 }
95 }
96
97 return (IPTR)dataSource;
98 }
99
100 void Graph__FreeInfoText(Class *cl, Object *obj)
101 {
102 struct Graph_DATA *data = INST_DATA(cl, obj);
103 struct Node *infoLine, *tmp;
104
105 D(bug("[Graph] %s()\n", __func__);)
106
107 ForeachNodeSafe(&data->graph_InfoText, infoLine, tmp)
108 {
109 D(bug("[Graph] %s: Deleting old infotext line @ 0x%p - '%s'\n", __func__, infoLine, infoLine->ln_Name);)
110 Remove(infoLine);
111 FreeVec(infoLine);
112 }
113 data->graph_ITHeight = 0;
114 }
115
116 IPTR Graph__ParseInfoText(Class *cl, Object *obj, char *infoTxt)
117 {
118 struct Graph_DATA *data = INST_DATA(cl, obj);
119
120 int i, srcLen, start = 0;
121 struct Node *infoLine;
122
123 D(bug("[Graph] %s(0x%p)\n", __func__, infoTxt);)
124
125 Graph__FreeInfoText(cl, obj);
126
127 if (infoTxt)
128 {
129 srcLen = strlen(infoTxt);
130
131 for (i = 0; i < (srcLen + 1); i ++)
132 {
133 if (((i - start) > 0) && (infoTxt[i] == '\n') || (infoTxt[i] == '\0'))
134 {
135 infoLine = (struct Node *)AllocVec(sizeof(struct Node) + 1 + (i - start), MEMF_ANY|MEMF_CLEAR);
136 infoLine->ln_Name = (char *)&infoLine[1];
137
138 CopyMem(&infoTxt[start], infoLine->ln_Name, (i - start));
139
140 D(bug("[Graph] %s: New infotext line @ 0x%p - '%s'\n", __func__, infoLine, infoLine->ln_Name);)
141 AddTail(&data->graph_InfoText, infoLine);
142
143 data->graph_ITHeight += 1;
144 start = i + 1;
145 }
146 }
147 }
148 D(bug("[Graph] %s: InfoText> %d lines\n", __func__, data->graph_ITHeight);)
149 return data->graph_ITHeight;
150 }
151
152 /*** Methods ****************************************************************/
153 IPTR Graph__OM_NEW(Class *cl, Object *obj, struct opSet *msg)
154 {
155 struct Graph_DATA *data;
156
157 D(bug("[Graph] %s()\n", __func__);)
158
159 obj = (Object *) DoSuperNewTags
160 (
161 cl, obj, NULL,
162
163 MUIA_InnerLeft, 4,
164 MUIA_InnerTop, 4,
165 MUIA_InnerRight, 4,
166 MUIA_InnerBottom, 4,
167
168 TAG_MORE, (IPTR) msg->ops_AttrList
169 );
170
171 if (obj)
172 {
173 data = INST_DATA(cl, obj);
174
175 NEWLIST(&data->graph_InfoText);
176 data->graph_ITHeight = 0;
177
178 data->graph_RastPort = NULL;
179
180 data->graph_Flags = 0;
181 data->graph_BackPen = -1;
182 data->graph_AxisPen = -1;
183 data->graph_SegmentPen = -1;
184
185 /* default segment size ... */
186 data->graph_SegmentSize = 10;
187
188 /* We always have atleast one source .. */
189 Graph__UpdateSourceArray(data, 1);
190
191 data->ihn.ihn_Flags = MUIIHNF_TIMER;
192 data->ihn.ihn_Method = MUIM_Graph_Timer;
193 data->ihn.ihn_Object = obj;
194 data->ihn.ihn_Millis = 1000;
195
196 SetAttrsA(obj, msg->ops_AttrList);
197 }
198
199 return (IPTR)obj;
200 }
201
202 IPTR Graph__OM_DISPOSE(Class *cl, Object *obj, Msg msg)
203 {
204 struct Graph_DATA *data = INST_DATA(cl, obj);
205 int i;
206
207 D(bug("[Graph] %s()\n", __func__);)
208
209 if (data->graph_SourceCount > 0)
210 {
211 if (data->graph_EntryCount > 0)
212 {
213 for (i = 0; i < data->graph_SourceCount; i ++)
214 {
215 FreeMem(data->graph_Sources[i].gs_Entries, sizeof(IPTR) * data->graph_EntryCount);
216 }
217 }
218 FreeMem(data->graph_Sources, sizeof(struct Graph_SourceDATA) * data->graph_SourceCount);
219 }
220
221 Graph__FreeInfoText(cl, obj);
222
223 return DoSuperMethodA(cl, obj, msg);
224 }
225
226
227 IPTR Graph__OM_SET(Class *cl, Object *obj, struct opSet *msg)
228 {
229 struct Graph_DATA *data = INST_DATA(cl, obj);
230 struct TagItem *tags = msg->ops_AttrList;
231 struct TagItem *tag;
232 BOOL redraw = FALSE;
233
234 D(bug("[Graph] %s()\n", __func__);)
235
236 while ((tag = NextTagItem(&tags)) != NULL)
237 {
238 switch(tag->ti_Tag)
239 {
240 /* Aggreagte mode plots the sum of source entries/no of sources */
241 case MUIA_Graph_Aggregate:
242 data->graph_Flags &= ~GRAPHF_AGGR;
243 if (tag->ti_Data)
244 data->graph_Flags |= GRAPHF_AGGR;
245 break;
246
247 /* Set the info text to display */
248 case MUIA_Graph_InfoText:
249 Graph__ParseInfoText(cl, obj, (char *)tag->ti_Data);
250 redraw = TRUE;
251 break;
252
253 /* Set the input value ceiling and stepping */
254 case MUIA_Graph_ValueCeiling:
255 data->graph_ValCeiling = tag->ti_Data;
256 break;
257
258 case MUIA_Graph_ValueStep:
259 data->graph_ValStepping = tag->ti_Data;
260 break;
261
262 /* Set the period ceiling and stepping */
263 case MUIA_Graph_PeriodCeiling:
264 data->graph_PeriodCeiling = tag->ti_Data;
265 break;
266
267 case MUIA_Graph_PeriodStep:
268 data->graph_PeriodStepping = tag->ti_Data;
269 break;
270
271 /* Set or turn off periodic update mode */
272 case MUIA_Graph_PeriodInterval:
273 if (tag->ti_Data)
274 {
275 data->graph_Flags |= GRAPHF_PERIODIC;
276 data->ihn.ihn_Millis = tag->ti_Data;
277 if ((data->graph_Flags & GRAPHF_SETUP) && !(data->graph_Flags & GRAPHF_HANDLER))
278 {
279 data->graph_Flags |= GRAPHF_HANDLER;
280 DoMethod(_app(obj), MUIM_Application_AddInputHandler, (IPTR) &data->ihn);
281 }
282 }
283 else
284 {
285 data->graph_Flags &= ~GRAPHF_PERIODIC;
286 if ((data->graph_Flags & GRAPHF_SETUP) && (data->graph_Flags & GRAPHF_HANDLER))
287 {
288 DoMethod(_app(obj), MUIM_Application_RemInputHandler, (IPTR) &data->ihn);
289 data->graph_Flags &= ~GRAPHF_HANDLER;
290 }
291 }
292 break;
293
294 /* Set or turn off Fixed entry count mode */
295 case MUIA_Graph_EntryCount:
296 if (tag->ti_Data)
297 {
298 int i;
299 for (i = 0; i < data->graph_SourceCount; i ++)
300 {
301 Graph__UpdateSourceEntries(data, i, tag->ti_Data);
302 }
303 data->graph_EntryCount = tag->ti_Data;
304 data->graph_Flags |= GRAPHF_FIXEDLEN;
305 }
306 else
307 {
308 data->graph_Flags &= ~GRAPHF_FIXEDLEN;
309 }
310 break;
311 }
312 }
313
314 if (redraw)
315 MUI_Redraw(obj, MADF_DRAWUPDATE);
316
317 return DoSuperMethodA(cl, obj, (Msg)msg);
318 }
319
320
321 IPTR Graph__OM_GET(Class *cl, Object *obj, struct opGet *msg)
322 {
323 struct Graph_DATA *data = INST_DATA(cl, obj);
324 IPTR retval = TRUE;
325
326 D(bug("[Graph] %s()\n", __func__);)
327
328 switch(msg->opg_AttrID)
329 {
330 case MUIA_Graph_ValueCeiling:
331 *(msg->opg_Storage) = data->graph_ValCeiling;
332 break;
333
334 case MUIA_Graph_EntryCount:
335 *(msg->opg_Storage) = data->graph_EntryCount;
336 break;
337
338 case MUIA_Graph_PeriodInterval:
339 *(msg->opg_Storage) = data->ihn.ihn_Millis;
340 break;
341
342 default:
343 retval = DoSuperMethodA(cl, obj, (Msg)msg);
344 break;
345 }
346
347 return retval;
348 }
349
350 IPTR Graph__MUIM_Setup(Class *cl, Object *obj, struct MUIP_Setup *msg)
351 {
352 struct Graph_DATA *data = INST_DATA(cl, obj);
353
354 D(bug("[Graph] %s()\n", __func__);)
355
356 if (!DoSuperMethodA(cl, obj, (Msg)msg)) return FALSE;
357
358 if ((data->graph_Flags & GRAPHF_PERIODIC) && !(data->graph_Flags & GRAPHF_HANDLER))
359 {
360 data->graph_Flags |= GRAPHF_HANDLER;
361 DoMethod(_app(obj), MUIM_Application_AddInputHandler, (IPTR) &data->ihn);
362 }
363
364 data->graph_BackPen = ObtainBestPen(_screen(obj)->ViewPort.ColorMap,
365 0xF2F2F2F2,
366 0xF8F8F8F8,
367 0xFAFAFAFA,
368 OBP_Precision, PRECISION_GUI,
369 OBP_FailIfBad, FALSE,
370 TAG_DONE);
371
372 data->graph_AxisPen = ObtainBestPen(_screen(obj)->ViewPort.ColorMap,
373 0x7A7A7A7A,
374 0xC5C5C5C5,
375 0xDEDEDEDE,
376 OBP_Precision, PRECISION_GUI,
377 OBP_FailIfBad, FALSE,
378 TAG_DONE);
379
380 data->graph_SegmentPen = ObtainBestPen(_screen(obj)->ViewPort.ColorMap,
381 0x85858585,
382 0xD3D3D3D3,
383 0xEDEDEDED,
384 OBP_Precision, PRECISION_GUI,
385 OBP_FailIfBad, FALSE,
386 TAG_DONE);
387
388 data->graph_Flags |= GRAPHF_SETUP;
389
390 return TRUE;
391 }
392
393
394 IPTR Graph__MUIM_Cleanup(Class *cl, Object *obj, struct MUIP_Cleanup *msg)
395 {
396 struct Graph_DATA *data = INST_DATA(cl, obj);
397
398 D(bug("[Graph] %s()\n", __func__);)
399
400 data->graph_Flags &= ~GRAPHF_SETUP;
401
402 if (data->graph_SegmentPen != -1)
403 {
404 ReleasePen(_screen(obj)->ViewPort.ColorMap, data->graph_SegmentPen);
405 data->graph_SegmentPen = -1;
406 }
407
408 if (data->graph_AxisPen != -1)
409 {
410 ReleasePen(_screen(obj)->ViewPort.ColorMap, data->graph_AxisPen);
411 data->graph_AxisPen = -1;
412 }
413
414 if (data->graph_BackPen != -1)
415 {
416 ReleasePen(_screen(obj)->ViewPort.ColorMap, data->graph_BackPen);
417 data->graph_BackPen = -1;
418 }
419
420 if ((data->graph_Flags & GRAPHF_PERIODIC) && (data->graph_Flags & GRAPHF_HANDLER))
421 {
422 DoMethod(_app(obj), MUIM_Application_RemInputHandler, (IPTR) &data->ihn);
423 data->graph_Flags &= ~GRAPHF_HANDLER;
424 }
425
426 return DoSuperMethodA(cl, obj, (Msg)msg);
427 }
428
429
430 IPTR Graph__MUIM_AskMinMax(Class *cl, Object *obj, struct MUIP_AskMinMax *msg)
431 {
432 struct Graph_DATA *data = INST_DATA(cl, obj);
433 UWORD nominalsize = (data->graph_SegmentSize * 10);
434
435 bug("[Graph] %s()\n", __func__);
436
437 DoSuperMethodA(cl, obj, (Msg)msg);
438
439 msg->MinMaxInfo->MinWidth += nominalsize;
440 msg->MinMaxInfo->MinHeight += nominalsize;
441 msg->MinMaxInfo->DefWidth += nominalsize;
442 msg->MinMaxInfo->DefHeight += nominalsize;
443 msg->MinMaxInfo->MaxWidth = MUI_MAXMAX;
444 msg->MinMaxInfo->MaxHeight = MUI_MAXMAX;
445
446 return TRUE;
447 }
448
449 IPTR Graph__MUIM_Draw(Class *cl, Object *obj, struct MUIP_Draw *msg)
450 {
451 struct Graph_DATA *data = INST_DATA(cl, obj);
452 struct Graph_SourceDATA *sourceData;
453 struct Region *region;
454 struct Node *infoLine;
455 struct RastPort *renderPort;
456 struct Rectangle rect;
457 APTR clip = NULL;
458 UWORD pos, offset = 0, src, objHeight;
459
460 D(bug("[Graph] %s()\n", __func__);)
461
462 if (data->graph_Flags & GRAPHF_FIXEDLEN)
463 data->graph_SegmentSize = (_right(obj) - _left(obj) )/ data->graph_EntryCount;
464
465 rect.MinX = _left(obj);
466 rect.MinY = _top(obj);
467 rect.MaxX = _right(obj);
468 rect.MaxY = _bottom(obj);
469
470 region = NewRegion();
471 if (region)
472 {
473 OrRectRegion(region, &rect);
474
475 clip = MUI_AddClipRegion(muiRenderInfo(obj), region);
476 }
477
478 DoSuperMethodA(cl, obj, (Msg)msg);
479
480 /* Render our graph.. */
481 if ((msg->flags & (MADF_DRAWOBJECT | MADF_DRAWUPDATE)))
482 {
483 if (data->graph_RastPort)
484 {
485 renderPort = data->graph_RastPort;
486 rect.MinX = 0;
487 rect.MinY = 0;
488 rect.MaxX = _right(obj) - _left(obj);
489 rect.MaxY = _bottom(obj) - _top(obj);
490 }
491 else
492 renderPort = _rp(obj);
493
494 objHeight = rect.MaxY - rect.MinY;
495
496 if ((data->graph_Flags & GRAPHF_PERIODIC) && (data->graph_Flags & GRAPHF_FIXEDLEN))
497 offset = data->graph_Tick;
498
499 D(
500 bug("[Graph] %s: height %d, segemnt size %d\n", __func__, objHeight, data->graph_SegmentSize);
501 bug("[Graph] %s: offset %d\n", __func__, offset);
502 )
503
504 // First fill the background ..
505 SetAPen(renderPort, data->graph_BackPen);
506 RectFill(renderPort, rect.MinX, rect.MinY, rect.MaxX, rect.MaxY);
507
508 // Draw the segment divisions..
509 SetAPen(renderPort, data->graph_SegmentPen);
510 for (pos = rect.MinX; pos <= (rect.MaxX + data->graph_SegmentSize); pos += data->graph_SegmentSize)
511 {
512 Move(renderPort, pos - offset, rect.MinY);
513 Draw(renderPort, pos - offset, rect.MaxY);
514 }
515 for (pos = rect.MaxY; pos >= rect.MinY; pos -= data->graph_SegmentSize)
516 {
517 Move(renderPort, rect.MinX, pos);
518 Draw(renderPort, rect.MaxX, pos);
519 }
520
521 // Draw the Axis..
522 SetAPen(renderPort, data->graph_AxisPen);
523 Move(renderPort, rect.MinX, rect.MinY);
524 Draw(renderPort, rect.MaxX, rect.MinY);
525 Draw(renderPort, rect.MaxX, rect.MaxY);
526 Draw(renderPort, rect.MinX, rect.MaxY);
527 Draw(renderPort, rect.MinX, rect.MinY);
528
529 // Plot the entries..
530 if (data->graph_Sources)
531 {
532 for (src = 0; src < data->graph_SourceCount; src ++)
533 {
534 sourceData = &data->graph_Sources[src];
535
536 SetAPen(renderPort, data->graph_Sources[src].gs_PlotPen);
537 Move(renderPort, rect.MinX - offset, rect.MaxY);
538
539 for (pos = 1; pos < data->graph_EntryPtr; pos++)
540 {
541 UWORD ypos = (objHeight * sourceData->gs_Entries[pos])/ data->graph_ValCeiling;
542 D(bug("[Graph] %s: YPos = %d\n", __func__, ypos);)
543 Draw(renderPort,
544 rect.MinX + (pos * data->graph_SegmentSize) - offset,
545 rect.MaxY - ypos);
546 }
547 }
548 }
549
550 // Add the InfoText
551 pos = ((rect.MinY + rect.MaxY) /2) - ((_font(obj)->tf_YSize * data->graph_ITHeight) /2) + _font(obj)->tf_Baseline;
552
553 ForeachNode(&data->graph_InfoText, infoLine)
554 {
555 UWORD txtLen = strlen(infoLine->ln_Name);
556 UWORD textWidth = TextLength(renderPort, infoLine->ln_Name, txtLen);
557
558 D(bug("[Graph] %s: pos = %d, strlen = %d, wid = %d\n", __func__, pos, txtLen, textWidth);)
559
560 if (textWidth > 0)
561 {
562 SetAPen(renderPort, _pens(obj)[MPEN_TEXT]);
563 Move(renderPort, ((rect.MinX + rect.MaxX) /2) - (textWidth / 2), pos);
564 Text(renderPort, (CONST_STRPTR)infoLine->ln_Name, txtLen);
565 pos += _font(obj)->tf_YSize;
566 }
567 }
568 if (renderPort != _rp(obj))
569 {
570 BltBitMapRastPort(
571 renderPort->BitMap,
572 0,
573 0,
574 _rp(obj),
575 _left(obj),
576 _top(obj),
577 _right(obj) - _left(obj) + 1,
578 _bottom(obj) - _top(obj) + 1,
579 0x0C0 );
580 }
581 }
582 if (region)
583 {
584 MUI_RemoveClipRegion(muiRenderInfo(obj), clip);
585 }
586
587 D(bug("[Graph] %s: done\n", __func__);)
588
589 return 0;
590 }
591
592 IPTR Graph__MUIM_Graph_GetSourceHandle(Class *cl, Object *obj, struct MUIP_Graph_GetSourceHandle *msg)
593 {
594 struct Graph_DATA *data;
595 IPTR retVal = 0;
596
597 D(bug("[Graph] %s(%d)\n", __func__, msg->SourceNo);)
598
599 data = INST_DATA(cl, obj);
600 if (msg->SourceNo >= data->graph_SourceCount)
601 Graph__UpdateSourceArray(data, (msg->SourceNo + 1));
602
603 retVal = (IPTR)&data->graph_Sources[msg->SourceNo];
604
605 return retVal;
606 }
607
608 IPTR Graph__MUIM_Graph_SetSourceAttrib(Class *cl, Object *obj, struct MUIP_Graph_SetSourceAttrib *msg)
609 {
610 struct Graph_SourceDATA *dataSource = (struct Graph_SourceDATA *)msg->SourceHandle;
611
612 D(bug("[Graph] %s()\n", __func__);)
613
614 switch (msg->Attrib)
615 {
616 case MUIV_Graph_Source_ReadHook:
617 dataSource->gs_ReadHook = (struct Hook *)msg->AttribVal;
618 break;
619 case MUIV_Graph_Source_Pen:
620 dataSource->gs_PlotPen = (WORD)msg->AttribVal;
621 break;
622 case MUIV_Graph_Source_FillPen:
623 dataSource->gs_PlotFillPen = (WORD)msg->AttribVal;
624 break;
625 }
626
627 return 0;
628 }
629
630 IPTR Graph__MUIM_Graph_Reset(Class *cl, Object *obj, Msg msg)
631 {
632 D(bug("[Graph] %s()\n", __func__);)
633
634 return 0;
635 }
636
637 IPTR Graph__MUIM_Graph_Timer(Class *cl, Object *obj, Msg msg)
638 {
639 struct Graph_DATA *data;
640 int i;
641
642 D(bug("[Graph] %s()\n", __func__);)
643
644 data = INST_DATA(cl, obj);
645
646 if (data->graph_Tick++ == data->graph_SegmentSize)
647 data->graph_Tick = 0;
648
649 if (data->graph_Flags & GRAPHF_PERIODIC)
650 {
651 if (data->graph_SourceCount > 0)
652 {
653 BOOL updateEntries = FALSE, updated = FALSE, move = FALSE;
654
655 if (data->graph_Flags & GRAPHF_FIXEDLEN)
656 {
657 if (data->graph_EntryPtr >= data->graph_EntryCount)
658 {
659 data->graph_EntryPtr = data->graph_EntryCount - 1;
660 move = TRUE;
661 }
662 }
663 else
664 {
665 if (!(data->graph_EntryCount) || (data->graph_EntryPtr >= data->graph_EntryCount))
666 updateEntries = TRUE;
667 }
668
669 D(bug("[Graph] %s: reading entry %d\n", __func__, data->graph_EntryPtr);)
670
671 for (i = 0; i < data->graph_SourceCount; i ++)
672 {
673 if (data->graph_Sources[i].gs_ReadHook)
674 {
675 if (updateEntries)
676 {
677 Graph__UpdateSourceEntries(data, i, (data->graph_EntryPtr + 1));
678 updated = TRUE;
679 }
680
681 if (move)
682 {
683 CopyMem(&data->graph_Sources[i].gs_Entries[1], &data->graph_Sources[i].gs_Entries[0], sizeof(IPTR) * (data->graph_EntryCount - 1));
684 }
685
686 D(bug("[Graph] %s: source %d entries @ 0x%p\n", __func__, i, data->graph_Sources[i].gs_Entries);)
687 CALLHOOKPKT(data->graph_Sources[i].gs_ReadHook,
688 (APTR)&data->graph_Sources[i].gs_Entries[data->graph_EntryPtr],
689 data->graph_Sources[i].gs_ReadHook->h_Data);
690 }
691 }
692 if (updated)
693 data->graph_EntryCount++;
694 data->graph_EntryPtr++;
695 }
696
697 SET(obj, MUIA_Graph_PeriodicTick, TRUE);
698 }
699
700 return 0;
701 }
Mirror of AROS' svn.