typo
[exim.git] / src / exim_monitor / em_StripChart.c
1 /* SPDX-License-Identifier: GPL-2.0-or-later */
2 /***********************************************************
3 Copyright 1987, 1988 by Digital Equipment Corporation, Maynard, Massachusetts,
4 and the Massachusetts Institute of Technology, Cambridge, Massachusetts.
5
6                         All Rights Reserved
7
8 Permission to use, copy, modify, and distribute this software and its
9 documentation for any purpose and without fee is hereby granted,
10 provided that the above copyright notice appear in all copies and that
11 both that copyright notice and this permission notice appear in
12 supporting documentation, and that the names of Digital or MIT not be
13 used in advertising or publicity pertaining to distribution of the
14 software without specific, written prior permission.
15
16 DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
17 ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
18 DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
19 ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
20 WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
21 ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
22 SOFTWARE.
23
24 ******************************************************************/
25
26 /* This is the Athena StripChart widget, slightly hacked by
27 Philip Hazel <ph10@cus.cam.ac.uk> in order to give access to
28 its repaint_window function so that a repaint can be forced.
29
30 The repaint_window function has also been nobbled so that it only
31 ever changes scale to 10. There is probably a better way to handle
32 this - such as inventing some new resources, but I'm not up to
33 that just at the moment.
34
35 On SunOS4 there are name clashes when trying to link this with the
36 Athena library. So to avoid them, rename a few things by inserting
37 "my" at the front of "strip". */
38
39
40 #include <stdio.h>
41 #include <X11/IntrinsicP.h>
42 #include <X11/StringDefs.h>
43 #include <X11/Xaw/XawInit.h>
44 #include <X11/Xaw/StripCharP.h>
45 #include <X11/Xfuncs.h>
46
47 #define MS_PER_SEC 1000
48
49 /* Private Data */
50
51 #define offset(field) XtOffsetOf(StripChartRec, field)
52
53 static XtResource resources[] = {
54     {XtNwidth, XtCWidth, XtRDimension, sizeof(Dimension),
55         offset(core.width), XtRImmediate, (XtPointer) 120},
56     {XtNheight, XtCHeight, XtRDimension, sizeof(Dimension),
57         offset(core.height), XtRImmediate, (XtPointer) 120},
58     {XtNupdate, XtCInterval, XtRInt, sizeof(int),
59         offset(strip_chart.update), XtRImmediate, (XtPointer) 10},
60     {XtNminScale, XtCScale, XtRInt, sizeof(int),
61         offset(strip_chart.min_scale), XtRImmediate, (XtPointer) 1},
62     {XtNforeground, XtCForeground, XtRPixel, sizeof(Pixel),
63         offset(strip_chart.fgpixel), XtRString, XtDefaultForeground},
64     {XtNhighlight, XtCForeground, XtRPixel, sizeof(Pixel),
65         offset(strip_chart.hipixel), XtRString, XtDefaultForeground},
66     {XtNgetValue, XtCCallback, XtRCallback, sizeof(XtPointer),
67         offset(strip_chart.get_value), XtRImmediate, (XtPointer) NULL},
68     {XtNjumpScroll, XtCJumpScroll, XtRInt, sizeof(int),
69         offset(strip_chart.jump_val), XtRImmediate, (XtPointer) DEFAULT_JUMP},
70 };
71
72 #undef offset
73
74 /* Added argument types to these to shut picky compilers up. PH */
75
76 static void CreateGC(StripChartWidget, unsigned int);
77 static void DestroyGC(StripChartWidget, unsigned int);
78 static void Initialize(), Destroy(), Redisplay();
79 static void MoveChart(StripChartWidget, Boolean);
80 static void SetPoints(StripChartWidget);
81 static Boolean SetValues();
82
83 int repaint_window(StripChartWidget, int, int);     /* PH hack */
84 /* static int repaint_window(); */
85
86 StripChartClassRec stripChartClassRec = {
87     { /* core fields */
88     /* superclass               */      (WidgetClass) &simpleClassRec,
89     /* class_name               */      "StripChart",
90     /* size                     */      sizeof(StripChartRec),
91     /* class_initialize         */      XawInitializeWidgetSet,
92     /* class_part_initialize    */      NULL,
93     /* class_inited             */      FALSE,
94     /* initialize               */      Initialize,
95     /* initialize_hook          */      NULL,
96     /* realize                  */      XtInheritRealize,
97     /* actions                  */      NULL,
98     /* num_actions              */      0,
99     /* resources                */      resources,
100     /* num_resources            */      XtNumber(resources),
101     /* xrm_class                */      NULLQUARK,
102     /* compress_motion          */      TRUE,
103     /* compress_exposure        */      XtExposeCompressMultiple |
104                                         XtExposeGraphicsExposeMerged,
105     /* compress_enterleave      */      TRUE,
106     /* visible_interest         */      FALSE,
107     /* destroy                  */      Destroy,
108     /* resize                   */      (void (*)(Widget))SetPoints,
109     /* expose                   */      Redisplay,
110     /* set_values               */      SetValues,
111     /* set_values_hook          */      NULL,
112     /* set_values_almost        */      NULL,
113     /* get_values_hook          */      NULL,
114     /* accept_focus             */      NULL,
115     /* version                  */      XtVersion,
116     /* callback_private         */      NULL,
117     /* tm_table                 */      NULL,
118     /* query_geometry           */      XtInheritQueryGeometry,
119     /* display_accelerator      */      XtInheritDisplayAccelerator,
120     /* extension                */      NULL
121     },
122     { /* Simple class fields */
123     /* change_sensitive         */      XtInheritChangeSensitive
124     }
125 };
126
127 WidgetClass mystripChartWidgetClass = (WidgetClass) &stripChartClassRec;
128
129 /****************************************************************
130  *
131  * Private Procedures
132  *
133  ****************************************************************/
134
135 static void draw_it();
136
137 /*      Function Name: CreateGC
138  *      Description: Creates the GC's
139  *      Arguments: w - the strip chart widget.
140  *                 which - which GC's to create.
141  *      Returns: none
142  */
143
144 static void
145 CreateGC(w, which)
146 StripChartWidget w;
147 unsigned int which;
148 {
149   XGCValues     myXGCV;
150
151   if (which & FOREGROUND) {
152     myXGCV.foreground = w->strip_chart.fgpixel;
153     w->strip_chart.fgGC = XtGetGC((Widget) w, GCForeground, &myXGCV);
154   }
155
156   if (which & HIGHLIGHT) {
157     myXGCV.foreground = w->strip_chart.hipixel;
158     w->strip_chart.hiGC = XtGetGC((Widget) w, GCForeground, &myXGCV);
159   }
160 }
161
162 /*      Function Name: DestroyGC
163  *      Description: Destroys the GC's
164  *      Arguments: w - the strip chart widget.
165  *                 which - which GC's to destroy.
166  *      Returns: none
167  */
168
169 static void
170 DestroyGC(w, which)
171 StripChartWidget w;
172 unsigned int which;
173 {
174   if (which & FOREGROUND)
175     XtReleaseGC((Widget) w, w->strip_chart.fgGC);
176
177   if (which & HIGHLIGHT)
178     XtReleaseGC((Widget) w, w->strip_chart.hiGC);
179 }
180
181 /* ARGSUSED */
182 static void Initialize (greq, gnew)
183     Widget greq, gnew;
184 {
185     StripChartWidget w = (StripChartWidget)gnew;
186
187     if (w->strip_chart.update > 0)
188         w->strip_chart.interval_id = XtAppAddTimeOut(
189                                         XtWidgetToApplicationContext(gnew),
190                                         w->strip_chart.update * MS_PER_SEC,
191                                         draw_it, (XtPointer) gnew);
192     CreateGC(w, (unsigned int) ALL_GCS);
193
194     w->strip_chart.scale = w->strip_chart.min_scale;
195     w->strip_chart.interval = 0;
196     w->strip_chart.max_value = 0.0;
197     w->strip_chart.points = NULL;
198     SetPoints(w);
199 }
200
201 static void Destroy (gw)
202      Widget gw;
203 {
204      StripChartWidget w = (StripChartWidget)gw;
205
206      if (w->strip_chart.update > 0)
207          XtRemoveTimeOut (w->strip_chart.interval_id);
208      if (w->strip_chart.points)
209          XtFree((char *) w->strip_chart.points);
210      DestroyGC(w, (unsigned int) ALL_GCS);
211 }
212
213 /*
214  * NOTE: This function really needs to receive graphics exposure
215  *       events, but since this is not easily supported until R4 I am
216  *       going to hold off until then.
217  */
218
219 /* ARGSUSED */
220 static void Redisplay(w, event, region)
221      Widget w;
222      XEvent *event;
223      Region region;
224 {
225     if (event->type == GraphicsExpose)
226         (void) repaint_window ((StripChartWidget)w, event->xgraphicsexpose.x,
227                                event->xgraphicsexpose.width);
228     else
229         (void) repaint_window ((StripChartWidget)w, event->xexpose.x,
230                                event->xexpose.width);
231 }
232
233 /* ARGSUSED */
234 static void
235 draw_it(client_data, id)
236 XtPointer client_data;
237 XtIntervalId *id;               /* unused */
238 {
239    StripChartWidget w = (StripChartWidget)client_data;
240    double value;
241
242    if (w->strip_chart.update > 0)
243        w->strip_chart.interval_id =
244        XtAppAddTimeOut(XtWidgetToApplicationContext( (Widget) w),
245                        w->strip_chart.update * MS_PER_SEC,draw_it,client_data);
246
247    if (w->strip_chart.interval >= (int)w->core.width)
248        MoveChart( (StripChartWidget) w, TRUE);
249
250    /* Get the value, stash the point and draw corresponding line. */
251
252    if (w->strip_chart.get_value == NULL)
253        return;
254
255    XtCallCallbacks( (Widget)w, XtNgetValue, (XtPointer)&value );
256
257    /*
258     * Keep w->strip_chart.max_value up to date, and if this data
259     * point is off the graph, change the scale to make it fit.
260     */
261
262    if (value > w->strip_chart.max_value) {
263        w->strip_chart.max_value = value;
264        if (w->strip_chart.max_value > w->strip_chart.scale) {
265            XClearWindow( XtDisplay (w), XtWindow (w));
266            w->strip_chart.interval = repaint_window(w, 0, (int) w->core.width);
267        }
268    }
269
270    w->strip_chart.valuedata[w->strip_chart.interval] = value;
271    if (XtIsRealized((Widget)w)) {
272        int y = (int) (w->core.height
273                       - (int)(w->core.height * value) / w->strip_chart.scale);
274
275        XFillRectangle(XtDisplay(w), XtWindow(w), w->strip_chart.fgGC,
276                       w->strip_chart.interval, y,
277                       (unsigned int) 1, w->core.height - y);
278        /*
279         * Fill in the graph lines we just painted over.
280         */
281
282        if (w->strip_chart.points != NULL) {
283            w->strip_chart.points[0].x = w->strip_chart.interval;
284            XDrawPoints(XtDisplay(w), XtWindow(w), w->strip_chart.hiGC,
285                        w->strip_chart.points, w->strip_chart.scale - 1,
286                        CoordModePrevious);
287        }
288
289        XFlush(XtDisplay(w));                /* Flush output buffers */
290    }
291    w->strip_chart.interval++;               /* Next point */
292 } /* draw_it */
293
294 /* Blts data according to current size, then redraws the stripChart window.
295  * Next represents the number of valid points in data.  Returns the (possibly)
296  * adjusted value of next.  If next is 0, this routine draws an empty window
297  * (scale - 1 lines for graph).  If next is less than the current window width,
298  * the returned value is identical to the initial value of next and data is
299  * unchanged.  Otherwise keeps half a window's worth of data.  If data is
300  * changed, then w->strip_chart.max_value is updated to reflect the
301  * largest data point.
302  */
303
304 /* static int */
305 int              /* PH hack */
306 repaint_window(w, left, width)
307 StripChartWidget w;
308 int left, width;
309 {
310     register int i, j;
311     register int next = w->strip_chart.interval;
312     int scale = w->strip_chart.scale;
313     int scalewidth = 0;
314
315     /* Compute the minimum scale required to graph the data, but don't go
316        lower than min_scale. */
317     if (w->strip_chart.interval != 0 || scale <= (int)w->strip_chart.max_value)
318       scale = ((int) (w->strip_chart.max_value)) + 1;
319     if (scale < w->strip_chart.min_scale)
320       scale = w->strip_chart.min_scale;
321
322 /*    if (scale != w->strip_chart.scale) { */
323
324     if (scale != w->strip_chart.scale && scale == 10) {
325       w->strip_chart.scale = scale;
326       left = 0;
327       width = next;
328       scalewidth = w->core.width;
329
330       SetPoints(w);
331
332       if (XtIsRealized ((Widget) w))
333         XClearWindow (XtDisplay (w), XtWindow (w));
334
335     }
336
337     if (XtIsRealized((Widget)w)) {
338         Display *dpy = XtDisplay(w);
339         Window win = XtWindow(w);
340
341         width += left - 1;
342         if (!scalewidth) scalewidth = width;
343
344         if (next < ++width) width = next;
345
346         /* Draw data point lines. */
347         for (i = left; i < width; i++) {
348             int y = (int) (w->core.height -
349                            (int)(w->core.height * w->strip_chart.valuedata[i]) /
350                            w->strip_chart.scale);
351
352             XFillRectangle(dpy, win, w->strip_chart.fgGC,
353                            i, y, (unsigned int) 1,
354                            (unsigned int) (w->core.height - y));
355         }
356
357         /* Draw graph reference lines */
358         for (i = 1; i < w->strip_chart.scale; i++) {
359             j = i * ((int)w->core.height / w->strip_chart.scale);
360             XDrawLine(dpy, win, w->strip_chart.hiGC, left, j, scalewidth, j);
361         }
362     }
363     return(next);
364 }
365
366 /*      Function Name: MoveChart
367  *      Description: moves the chart over when it would run off the end.
368  *      Arguments: w - the load widget.
369  *                 blit - blit the bits? (TRUE/FALSE).
370  *      Returns: none.
371  */
372
373 static void
374 MoveChart(StripChartWidget w, Boolean blit)
375 {
376     double old_max;
377     int left, i, j;
378     register int next = w->strip_chart.interval;
379
380     if (!XtIsRealized((Widget) w)) return;
381
382     if (w->strip_chart.jump_val == DEFAULT_JUMP)
383         j = w->core.width >> 1; /* Half the window width. */
384     else {
385         j = w->core.width - w->strip_chart.jump_val;
386         if (j < 0) j = 0;
387     }
388
389     bcopy((char *)(w->strip_chart.valuedata + next - j),
390           (char *)(w->strip_chart.valuedata), j * sizeof(double));
391     next = w->strip_chart.interval = j;
392
393     /*
394      * Since we just lost some data, recompute the
395      * w->strip_chart.max_value.
396      */
397
398     old_max = w->strip_chart.max_value;
399     w->strip_chart.max_value = 0.0;
400     for (i = 0; i < next; i++) {
401       if (w->strip_chart.valuedata[i] > w->strip_chart.max_value)
402         w->strip_chart.max_value = w->strip_chart.valuedata[i];
403     }
404
405     if (!blit) return;          /* we are done... */
406
407     if ( ((int) old_max) != ( (int) w->strip_chart.max_value) ) {
408       XClearWindow(XtDisplay(w), XtWindow(w));
409       repaint_window(w, 0, (int) w->core.width);
410       return;
411     }
412
413     XCopyArea(XtDisplay((Widget)w), XtWindow((Widget)w), XtWindow((Widget)w),
414               w->strip_chart.hiGC, (int) w->core.width - j, 0,
415               (unsigned int) j, (unsigned int) w->core.height,
416               0, 0);
417
418     XClearArea(XtDisplay((Widget)w), XtWindow((Widget)w),
419                (int) j, 0,
420                (unsigned int) w->core.width - j, (unsigned int)w->core.height,
421                FALSE);
422
423     /* Draw graph reference lines */
424     left = j;
425     for (i = 1; i < w->strip_chart.scale; i++) {
426       j = i * ((int)w->core.height / w->strip_chart.scale);
427       XDrawLine(XtDisplay((Widget) w), XtWindow( (Widget) w),
428                 w->strip_chart.hiGC, left, j, (int)w->core.width, j);
429     }
430     return;
431 }
432
433 /* ARGSUSED */
434 static Boolean SetValues (current, request, new)
435     Widget current, request, new;
436 {
437     StripChartWidget old = (StripChartWidget)current;
438     StripChartWidget w = (StripChartWidget)new;
439     Boolean ret_val = FALSE;
440     unsigned int new_gc = NO_GCS;
441
442     if (w->strip_chart.update != old->strip_chart.update) {
443         if (old->strip_chart.update > 0)
444             XtRemoveTimeOut (old->strip_chart.interval_id);
445         if (w->strip_chart.update > 0)
446             w->strip_chart.interval_id =
447                 XtAppAddTimeOut(XtWidgetToApplicationContext(new),
448                                 w->strip_chart.update * MS_PER_SEC,
449                                 draw_it, (XtPointer)w);
450     }
451
452     if ( w->strip_chart.min_scale > (int) ((w->strip_chart.max_value) + 1) )
453       ret_val = TRUE;
454
455     if ( w->strip_chart.fgpixel != old->strip_chart.fgpixel ) {
456       new_gc |= FOREGROUND;
457       ret_val = True;
458     }
459
460     if ( w->strip_chart.hipixel != old->strip_chart.hipixel ) {
461       new_gc |= HIGHLIGHT;
462       ret_val = True;
463     }
464
465     DestroyGC(old, new_gc);
466     CreateGC(w, new_gc);
467
468     return( ret_val );
469 }
470
471 /*      Function Name: SetPoints
472  *      Description: Sets up the polypoint that will be used to draw in
473  *                   the graph lines.
474  *      Arguments: w - the StripChart widget.
475  *      Returns: none.
476  */
477
478 #define HEIGHT ( (unsigned int) w->core.height)
479
480 static void
481 SetPoints(w)
482 StripChartWidget w;
483 {
484     XPoint * points;
485     Cardinal size;
486     int i;
487
488     if (w->strip_chart.scale <= 1) { /* no scale lines. */
489         XtFree ((char *) w->strip_chart.points);
490         w->strip_chart.points = NULL;
491         return;
492     }
493
494     size = sizeof(XPoint) * (w->strip_chart.scale - 1);
495
496     points = (XPoint *) XtRealloc( (XtPointer) w->strip_chart.points, size);
497     w->strip_chart.points = points;
498
499     /* Draw graph reference lines into clip mask */
500
501     for (i = 1; i < w->strip_chart.scale; i++) {
502         points[i - 1].x = 0;
503         points[i - 1].y = HEIGHT / w->strip_chart.scale;
504     }
505 }