![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to Load.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv9 / X11 / src / X.V11R1 / lib / Xtk|
Return to Load.c CVS log | Up to [Research Unix] / researchv9 / X11 / src / X.V11R1 / lib / Xtk |
1.1 root 1: #ifndef lint
2: static char rcsid[] = "$Header: Load.c,v 1.12 87/09/13 22:50:22 newman Exp $";
3: #endif lint
4:
5: /*
6: * Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
7: *
8: * All Rights Reserved
9: *
10: * Permission to use, copy, modify, and distribute this software and its
11: * documentation for any purpose and without fee is hereby granted,
12: * provided that the above copyright notice appear in all copies and that
13: * both that copyright notice and this permission notice appear in
14: * supporting documentation, and that the name of Digital Equipment
15: * Corporation not be used in advertising or publicity pertaining to
16: * distribution of the software without specific, written prior permission.
17: *
18: *
19: * DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
20: * ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
21: * DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
22: * ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
23: * WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
24: * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
25: * SOFTWARE.
26: */
27: #ifndef lint
28: static char *sccsid = "@(#)Load.c 1.15 2/25/87";
29: #endif lint
30:
31: #include <stdio.h>
32: #include <string.h>
33: #include "Xlib.h"
34: #include "Xutil.h"
35: #include "Intrinsic.h"
36: #include "Load.h"
37: #include "LoadP.h"
38: #include "Atoms.h"
39: #include <nlist.h>
40: #include <sys/time.h>
41: #include <sys/file.h>
42: #include <sys/param.h>
43:
44: extern long lseek();
45: extern void exit();
46:
47: /* Private Data */
48:
49: #define offset(field) XtOffset(LoadWidget,load.field)
50: #define goffset(field) XtOffset(Widget,core.field)
51:
52: static XtResource resources[] = {
53: {XtNwidth, XtCWidth, XrmRInt, sizeof(int),
54: goffset(width), XrmRString, "120"},
55: {XtNheight, XtCHeight, XrmRInt, sizeof(int),
56: goffset(height), XrmRString, "120"},
57: {XtNupdate, XtCInterval, XrmRInt, sizeof(int),
58: offset(update), XrmRString, "5"},
59: {XtNscale, XtCScale, XrmRInt, sizeof(int),
60: offset(scale), XrmRString, "1"},
61: {XtNminScale, XtCScale, XrmRInt, sizeof(int),
62: offset(min_scale), XrmRString, "1"},
63: {XtNlabel, XtCLabel, XrmRString, sizeof(char *),
64: offset(text), XrmRString, "Amnesia"},
65: {XtNforeground, XtCForeground, XrmRPixel, sizeof(Pixel),
66: offset(fgpixel), XrmRString, "Black"},
67: {XtNfont, XtCFont, XrmRFontStruct, sizeof(XFontStruct *),
68: offset(font), XrmRString, "fixed"},
69: };
70:
71: #undef offset
72: #undef goffset
73:
74: static void Initialize(), Realize(), Destroy(), Redisplay();
75: static Boolean SetValues();
76: static int repaint_window();
77:
78: LoadClassRec loadClassRec = {
79: { /* core fields */
80: /* superclass */ &widgetClassRec,
81: /* class_name */ "Load",
82: /* size */ sizeof(LoadRec),
83: /* class_initialize */ NULL,
84: /* class_inited */ FALSE,
85: /* initialize */ Initialize,
86: /* realize */ Realize,
87: /* actions */ NULL,
88: /* num_actions */ 0,
89: /* resources */ resources,
90: /* resource_count*/ XtNumber(resources),
91: /* xrm_class */ NULL,
92: /* compress_motion */ TRUE,
93: /* compress_exposure*/ TRUE,
94: /* visible_interest */ FALSE,
95: /* destroy */ Destroy,
96: /* resize */ NULL,
97: /* expose */ Redisplay,
98: /* set_values */ SetValues,
99: /* accept_focus */ NULL,
100: }
101: };
102:
103: WidgetClass loadWidgetClass = (WidgetClass) &loadClassRec;
104:
105: /****************************************************************
106: *
107: * Private Procedures
108: *
109: ****************************************************************/
110:
111: static void draw_it();
112:
113: static void EventHandler(gw, closure, event)
114: Widget gw;
115: char *closure;
116: XEvent *event;
117: {
118: if (event->type == ClientMessage && event->xclient.message_type == XtTimerExpired)
119: draw_it ((LoadWidget)gw);
120: }
121:
122: static void Initialize (greq, gnew)
123: Widget greq, gnew;
124: {
125: LoadWidget w = (LoadWidget)gnew;
126: XtGCMask valuemask;
127: XGCValues myXGCV;
128:
129: valuemask = GCForeground | GCFont | GCBackground;
130: myXGCV.foreground = w->load.fgpixel;
131: myXGCV.font = w->load.font->fid;
132: myXGCV.background = w->core.background_pixel;
133: w->load.myGC = XtGetGC(w, valuemask, &myXGCV);
134:
135: XtAddEventHandler (gnew, 0, TRUE, EventHandler, NULL);
136:
137: w->load.interval_id = XtAddTimeOut(gnew, w->load.update*1000);
138: w->load.interval = 0;
139: w->load.max_value = 0.0;
140: }
141:
142: static void Realize (gw, valueMask, attrs)
143: Widget gw;
144: XtValueMask valueMask;
145: XSetWindowAttributes *attrs;
146: {
147: gw->core.window = XCreateWindow (XtDisplay(gw), gw->core.parent->core.window,
148: gw->core.x, gw->core.y, gw->core.width, gw->core.height, gw->core.border_width,
149: gw->core.depth, InputOutput, /* visualID */ CopyFromParent, valueMask, attrs);
150: }
151:
152: static void Destroy (gw)
153: Widget gw;
154: {
155: LoadWidget w = (LoadWidget)gw;
156: XtRemoveTimeOut (w->load.interval_id);
157: XtDestroyGC (w->load.myGC);
158: }
159:
160: static void Redisplay(gw)
161: Widget gw;
162: {
163: (void) repaint_window ((LoadWidget)gw);
164: }
165:
166: static void draw_it(w)
167: LoadWidget w;
168: {
169: double value, GetLoadPoint();
170:
171: if (w->load.interval >= w->core.width)
172: w->load.interval =
173: repaint_window(w);
174: /* Get the value, stash the point and draw corresponding line. */
175:
176: value = GetLoadPoint();
177: /* Keep w->load.max_value up to date, and if this data point is off the
178: graph, change the scale to make it fit. */
179: if (value > w->load.max_value) {
180: w->load.max_value = value;
181: if (w->load.max_value > w->load.scale) {
182: w->load.scale = ((int)w->load.max_value) + 1;
183: w->load.interval =
184: repaint_window(w);
185: }
186: }
187:
188: w->load.valuedata[w->load.interval] = value;
189: if (XtIsRealized(w)) {
190: XDrawLine(XtDisplay(w), XtWindow(w), w->load.myGC,
191: w->load.interval, w->core.height, w->load.interval,
192: (int)(w->core.height - (w->core.height * value) /w->load.scale));
193: XFlush(XtDisplay(w)); /* Flush output buffers */
194: }
195: w->load.interval++; /* Next point */
196: } /* draw_it */
197:
198: /* Blts data according to current size, then redraws the load average window.
199: * Next represents the number of valid points in data. Returns the (possibly)
200: * adjusted value of next. If next is 0, this routine draws an empty window
201: * (scale - 1 lines for graph). If next is less than the current window width,
202: * the returned value is identical to the initial value of next and data is
203: * unchanged. Otherwise keeps half a window's worth of data. If data is
204: * changed, then w->load.max_value is updated to reflect the largest data point.
205: */
206:
207: static int repaint_window(w)
208: LoadWidget w;
209: {
210: register int i, j;
211: register int next = w->load.interval;
212: extern void bcopy();
213:
214: if (next >= w->core.width) {
215: j = w->core.width >> 1;
216: bcopy((char *)(w->load.valuedata + next - j),
217: (char *)(w->load.valuedata), j * sizeof(double));
218: next = j;
219: /* Since we just lost some data, recompute the w->load.max_value. */
220: w->load.max_value = 0.0;
221: for (i = 0; i < next; i++) {
222: if (w->load.valuedata[i] > w->load.max_value)
223: w->load.max_value = w->load.valuedata[i];
224: }
225: }
226:
227: /* Compute the minimum scale required to graph the data, but don't go
228: lower than min_scale. */
229: if (w->load.max_value > w->load.min_scale)
230: w->load.scale = ((int)w->load.max_value) + 1;
231: else
232: w->load.scale = w->load.min_scale;
233:
234: if (XtIsRealized(w)) {
235: Display *dpy = XtDisplay(w);
236: Window win = XtWindow(w);
237:
238: XClearWindow(dpy, win);
239:
240: /* Print hostname */
241: XDrawString(dpy, win, w->load.myGC, 2,
242: 2 + w->load.font->ascent, w->load.text, strlen(w->load.text));
243:
244: /* Draw graph reference lines */
245: for (i = 1; i < w->load.scale; i++) {
246: j = (i * w->core.height) / w->load.scale;
247: XDrawLine(dpy, win, w->load.myGC, 0, j,
248: (int)w->core.width, j);
249: }
250:
251: /* Draw data point lines. */
252: for (i = 0; i < next; i++)
253: XDrawLine(dpy, win, w->load.myGC, i, w->core.height,
254: i, (int)(w->core.height-(w->load.valuedata[i] * w->core.height)
255: /w->load.scale));
256: }
257:
258: return(next);
259: }
260:
261: #define KMEM_FILE "/dev/kmem"
262: #define KMEM_ERROR "cannot open /dev/kmem"
263:
264: static struct nlist namelist[] = { /* namelist for vmunix grubbing */
265: #define LOADAV 0
266: {"_avenrun"},
267: {0}
268: };
269:
270: static double GetLoadPoint()
271: {
272: double loadavg;
273: static int init = 0;
274: static kmem;
275: static long loadavg_seek;
276: extern void nlist();
277:
278: if(!init) {
279: nlist( "/vmunix", namelist);
280: if (namelist[LOADAV].n_type == 0){
281: xload_error("xload: cannot get name list");
282: exit(-1);
283: }
284: loadavg_seek = namelist[LOADAV].n_value;
285: kmem = open(KMEM_FILE, O_RDONLY);
286: if (kmem < 0) xload_error(KMEM_ERROR);
287: init = 1;
288: }
289:
290:
291: (void) lseek(kmem, loadavg_seek, 0);
292: #ifdef sun
293: {
294: long temp;
295: (void) read(kmem, (char *)&temp, sizeof(long));
296: loadavg = (double)temp/FSCALE;
297: }
298: #else
299: (void) read(kmem, (char *)&loadavg, sizeof(double));
300: #endif
301: return(loadavg);
302: }
303:
304: static xload_error(str)
305: char *str;
306: {
307: (void) fprintf(stderr,"xload: %s\n",str);
308: exit(-1);
309: }
310:
311: static Boolean SetValues (w, newvals)
312: Widget w, newvals;
313: {
314: return (FALSE);
315: }
316:
317: #ifdef notdef
318: void XtLoadSetValues (dpy, window, arglist, argCount)
319: Display *dpy;
320: Window window;
321: ArgList arglist;
322: int argCount;
323: {
324: WidgetData data;
325: data = DataFromWindow(dpy, window);
326: globaldata = *data;
327: if (data == NULL) return;
328:
329: XtSetValues(resourcelist, XtNumber(resourcelist), arglist, argCount);
330:
331: if (globaldata.update != data->update) {
332: (void) XtClearTimeOut(data->window, data->cookie);
333: XtSetTimeOut(data->window, data->cookie, globaldata.update*1000);
334: data->update = globaldata.update;
335: }
336: if (globaldata.brpixel != data->brpixel) {
337: data->brpixel = globaldata.brpixel;
338: if (data->brwidth != 0)
339: XSetWindowBorder(data->dpy, data->window, data->brpixel);
340: }
341: if(!strcmp(globaldata.text, data->text)) {
342: data->interval = repaint_window(data);
343: }
344: if(w->core.width >= 2048) w->core.width = 2047;
345:
346: *data = globaldata;
347: }
348: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.