![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to Clock.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 / oldXtk|
Return to Clock.c CVS log | Up to [Research Unix] / researchv9 / X11 / src / X.V11R1 / lib / oldXtk |
1.1 root 1: /* $Header: Clock.c,v 1.3 87/09/12 12:42:42 swick Exp $ */
2: #ifndef lint
3: static char *sccsid = "@(#)Clock.c 1.0 2/25/87";
4: #endif lint
5:
6: /*
7: * Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
8: *
9: * All Rights Reserved
10: *
11: * Permission to use, copy, modify, and distribute this software and its
12: * documentation for any purpose and without fee is hereby granted,
13: * provided that the above copyright notice appear in all copies and that
14: * both that copyright notice and this permission notice appear in
15: * supporting documentation, and that the name of Digital Equipment
16: * Corporation not be used in advertising or publicity pertaining to
17: * distribution of the software without specific, written prior permission.
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:
28:
29: #include <stdio.h>
30: #include <strings.h>
31: #include "Xlib.h"
32: #include "Xutil.h"
33: #include "Intrinsic.h"
34: #include "Clock.h"
35: #include "Atoms.h"
36: #include <sys/time.h>
37: #include <sys/file.h>
38: #include <sys/param.h>
39: #include <math.h>
40:
41: extern long time();
42:
43: /* Private Definitions */
44:
45:
46: #define VERTICES_IN_HANDS 6 /* to draw triangle */
47: #define PHI (PI / 16.) /* half angle of hand tip */
48: #define PI 3.14159265358979
49: #define PI4 (PI / 4.)
50: #define SINPHI 0.19509032201613
51: #define TWOPI (2. * PI)
52:
53: #define SEG_BUFF_SIZE 128
54:
55: #define SECOND_HAND_FRACT 90
56: #define MINUTE_HAND_FRACT 70
57: #define HOUR_HAND_FRACT 40
58: #define HAND_WIDTH_FRACT 7
59: #define SECOND_WIDTH_FRACT 5
60: #define SECOND_HAND_TIME 30
61:
62: #define DEF_UPDATE 60
63:
64: #define DEF_BORDER 2
65: #define DEF_VECTOR_HEIGHT 1
66: #define DEF_VECTOR_WIDTH 1
67:
68: #define DEF_DIGITAL_PADDING 10
69: #define DEF_DIGITAL_FONT "6x10"
70: #define DEF_ANALOG_PADDING 8
71: #define DEF_ANALOG_WIDTH 164
72: #define DEF_ANALOG_HEIGHT 164
73:
74: #define UNINIT -1
75: #define FAILURE 0
76:
77: #define max(a, b) ((a) > (b) ? (a) : (b))
78: #define min(a, b) ((a) < (b) ? (a) : (b))
79: #define abs(a) ((a) < 0 ? -(a) : (a))
80:
81:
82: typedef struct WidgetDataRec {
83: Display *dpy; /* widget display connection */
84: Window mywin; /* widget window */
85: Dimension brwidth; /* border width in pixels */
86: Dimension width, height; /* width/height in pixels */
87: Position x, y;
88: Pixel fgpixel; /* color index for text */
89: Pixel bgpixel; /* color index for background */
90: Pixel Hipixel; /* color index for Highlighting */
91: Pixel Hdpixel; /* color index for hands */
92: Pixel brpixel; /* pixel for border */
93: XFontStruct *fontstruct; /* font for text */
94: GC myGC; /* pointer to GraphicsContext */
95: GC EraseGC; /* eraser GC */
96: GC HandGC; /* Hand GC */
97: GC HighGC; /* Highlighting GC */
98: /* start of graph stuff */
99: int update; /* update frequence */
100: Dimension radius; /* radius factor */
101: int chime;
102: int beeped;
103: int analog;
104: int show_second_hand;
105: Dimension second_hand_length;
106: Dimension minute_hand_length;
107: Dimension hour_hand_length;
108: Dimension hand_width;
109: Dimension second_hand_width;
110: Position centerX;
111: Position centerY;
112: int numseg;
113: int mapped; /* is exposed */
114: int padding;
115: XPoint segbuff[SEG_BUFF_SIZE];
116: XPoint *segbuffptr;
117: XPoint *hour, *sec;
118: struct tm otm ;
119: caddr_t cookie;
120: } WidgetDataRec, *WidgetData;
121:
122:
123: /* Private Data */
124:
125: static WidgetDataRec globaldata;
126:
127: /* !!! STATIC !!! */
128: static int initDone = 0; /* initialization flag */
129:
130: static XContext widgetContext;
131:
132: /* bogus static's */
133: static int def_brwidth = DEF_BORDER;
134: static int def_width = 164;
135: static int def_height = 164;
136: static int def_x = 0;
137: static int def_y = 0;
138: static int def_update = DEF_UPDATE;
139: static int def_analog = 1;
140: static int def_chime = 0;
141: static int def_padding = DEF_ANALOG_PADDING;
142:
143: static Resource resourcelist[] = {
144: {XtNwindow, XtCWindow, XrmRWindow,
145: sizeof(Window), (caddr_t)&globaldata.mywin, (caddr_t)NULL},
146: {XtNborderWidth, XtCBorderWidth, XrmRInt,
147: sizeof(int), (caddr_t)&globaldata.brwidth, (caddr_t) &def_brwidth},
148: {XtNwidth, XtCWidth, XrmRInt,
149: sizeof(int), (caddr_t)&globaldata.width, (caddr_t) &def_width},
150: {XtNheight, XtCHeight, XrmRInt,
151: sizeof(int), (caddr_t)&globaldata.height, (caddr_t) &def_height },
152: {XtNx, XtCX, XrmRInt,
153: sizeof(int), (caddr_t)&globaldata.x, (caddr_t) &def_x },
154: {XtNy, XtCY, XrmRInt,
155: sizeof(int), (caddr_t)&globaldata.y, (caddr_t) &def_y },
156: {XtNupdate, XtCInterval, XrmRInt,
157: sizeof(int), (caddr_t)&globaldata.update, (caddr_t) &def_update },
158: {XtNchime, XtCChime, XrmRInt,
159: sizeof(int), (caddr_t)&globaldata.chime, (caddr_t) &def_chime },
160: {XtNhand, XtCColor, XrmRPixel,
161: sizeof(int), (caddr_t)&globaldata.Hdpixel, (caddr_t)&XtDefaultFGPixel},
162: {XtNhigh, XtCColor, XrmRPixel,
163: sizeof(int), (caddr_t)&globaldata.Hipixel, (caddr_t)&XtDefaultFGPixel},
164: {XtNforeground, XtCColor, XrmRPixel,
165: sizeof(int), (caddr_t)&globaldata.fgpixel, (caddr_t)&XtDefaultFGPixel},
166: {XtNbackground, XtCColor, XrmRPixel,
167: sizeof(int), (caddr_t)&globaldata.bgpixel, (caddr_t)&XtDefaultBGPixel},
168: {XtNpadding, XtCPadding, XrmRInt,
169: sizeof(int), (caddr_t)&globaldata.padding, (caddr_t) &def_padding },
170: {XtNborder, XtCColor, XrmRPixel,
171: sizeof(int),(caddr_t)&globaldata.brpixel, (caddr_t)&XtDefaultFGPixel}
172: };
173:
174: static Resource resourcelist1[] = {
175: {XtNfont, XtCFont, XrmRFontStruct,
176: sizeof(XFontStruct *), (caddr_t)&globaldata.fontstruct, (caddr_t)NULL},
177: {XtNanalog, XtCAnalog, XrmRInt,
178: sizeof(int), (caddr_t) &globaldata.analog, (caddr_t) &def_analog }
179: };
180:
181: /****************************************************************
182: *
183: * Private Procedures
184: *
185: ****************************************************************/
186:
187: static void ClockInitialize (dpy)
188: Display *dpy;
189: {
190: if (initDone) return;
191:
192: widgetContext = XUniqueContext();
193: globaldata.fontstruct = XLoadQueryFont(dpy,"fixed");
194:
195: initDone = 1;
196: }
197:
198: /*
199: * Given a display and window, get the widget data.
200: */
201:
202: static WidgetData DataFromWindow(dpy, window)
203: Display *dpy;
204: Window window;
205: {
206: WidgetData result;
207: if (XFindContext(dpy, window, widgetContext, (caddr_t *)&result))
208: return NULL;
209: return result;
210: }
211:
212: static void Destroy();
213:
214: /*
215: *
216: * Generic widget event handler
217: *
218: */
219:
220: static XtEventReturnCode EventHandler(event, eventdata)
221: XEvent *event;
222: caddr_t eventdata;
223: {
224: WidgetData data = (WidgetData ) eventdata;
225: void clock_tic();
226:
227: switch (event->type) {
228: case ConfigureNotify:
229: data->height = event->xconfigure.height;
230: data->width = event->xconfigure.width;
231: break;
232:
233: case DestroyNotify:
234: Destroy(data);
235: break;
236:
237: case ClientMessage:
238: if (((XClientMessageEvent *)event)->message_type ==
239: (unsigned long) XtTimerExpired)
240: clock_tic(data);
241: break;
242:
243: case Expose:
244: data->mapped = 1;
245: if( ((XExposeEvent *)event)->count == 0)
246: redisplay_clock(data);
247: break;
248:
249: case NoExpose:
250: data->mapped = 0;
251: break;
252: }
253:
254: return (XteventHandled);
255: }
256:
257: static redisplay_clock(data)
258: WidgetData data;
259: {
260: if(data->analog) {
261: data->radius = (min(data->width, data->height)-(2 * data->padding)) / 2;
262: data->second_hand_length = ((SECOND_HAND_FRACT * data->radius) / 100);
263: data->minute_hand_length = ((MINUTE_HAND_FRACT * data->radius) / 100);
264: data->hour_hand_length = ((HOUR_HAND_FRACT * data->radius) / 100);
265: data->hand_width = ((HAND_WIDTH_FRACT * data->radius) / 100);
266: data->second_hand_width = ((SECOND_WIDTH_FRACT * data->radius) / 100);
267: data->centerX = data->width / 2;
268: data->centerY = data->height / 2;
269: DrawClockFace(data, data->second_hand_length, data->radius);
270: }
271: clock_tic(data);
272: }
273:
274: /*
275: *
276: * Destroy the widget
277: *
278: */
279:
280: static void Destroy(data)
281: WidgetData data;
282: {
283:
284: XtClearEventHandlers(data->dpy, data->mywin);
285: (void) XtClearTimeOut(data->mywin, data->cookie);
286: XtFree ((char *) data);
287: }
288:
289: /****************************************************************
290: *
291: * Public Procedures
292: *
293: ****************************************************************/
294:
295: Window XtCreateClock(dpy, pw, arglist, argCount)
296: Display *dpy;
297: Window pw; /* parent window */
298: ArgList arglist;
299: int argCount;
300: {
301: WidgetData data;
302: unsigned long eventmask;
303: GCMask valuemask;
304: XrmNameList names;
305: XrmClassList classes;
306: XGCValues myXGCV;
307: char *str;
308: struct tm tm, *localtime();
309: long time_value;
310:
311: if (!initDone)ClockInitialize (dpy);
312:
313: data = (WidgetData ) XtMalloc (sizeof (WidgetDataRec));
314: globaldata.dpy = dpy;
315:
316: /* Set Some Default Values */
317: XtGetResources(dpy, resourcelist1, XtNumber(resourcelist1), arglist,
318: argCount, pw, "clock", "Clock", &names, &classes);
319: if(!globaldata.analog) {
320: (void) time(&time_value);
321: tm = *localtime(&time_value);
322: str = asctime(&tm);
323: def_width = XTextWidth( globaldata.fontstruct, str, strlen(str)) +
324: 2 * 10;
325: def_height = globaldata.fontstruct->ascent +
326: globaldata.fontstruct->descent + 2 * 10;
327: def_padding = 10;
328: }
329: /* Set Default Values */
330: XtGetResources(dpy, resourcelist, XtNumber(resourcelist), arglist,
331: argCount, pw, "clock", "Clock", &names, &classes);
332: if(!globaldata.analog && globaldata.padding != def_padding) {
333: def_width = XTextWidth( globaldata.fontstruct, str, strlen(str)) +
334: 2 * globaldata.padding;
335: def_height = globaldata.fontstruct->ascent +
336: globaldata.fontstruct->descent + 2 * globaldata.padding;
337: XtGetResources(dpy, resourcelist, XtNumber(resourcelist), arglist,
338: argCount, pw, "clock", "Clock", &names, &classes);
339: }
340: *data = globaldata;
341: valuemask = GCForeground | GCFont | GCBackground | GCLineWidth;
342: myXGCV.foreground = (*data).fgpixel;
343: myXGCV.font = (*data).fontstruct->fid;
344: myXGCV.background = data->bgpixel;
345: myXGCV.line_width = 0;
346: (*data).myGC = XtGetGC(dpy, (XContext) XtNclock, pw, valuemask, &myXGCV);
347: valuemask = GCForeground | GCLineWidth ;
348: myXGCV.foreground = (*data).bgpixel;
349: (*data).EraseGC = XtGetGC(dpy, (XContext) XtNclock, pw, valuemask, &myXGCV);
350: myXGCV.foreground = (*data).Hdpixel;
351: (*data).HandGC = XtGetGC(dpy, (XContext) XtNclock, pw, valuemask, &myXGCV);
352: valuemask = GCForeground | GCLineWidth ;
353: myXGCV.foreground = (*data).Hipixel;
354: (*data).HighGC = XtGetGC(dpy, (XContext) XtNclock, pw, valuemask, &myXGCV);
355:
356: if (data->mywin != NULL) {
357: XWindowAttributes wi;
358: /* set global data from window parameters */
359: if (! XGetWindowAttributes(data->dpy,data->mywin, &wi)) {
360: data->mywin = NULL;
361: } else {
362: data->brwidth = wi.border_width;
363: data->width = wi.width;
364: data->height = wi.height;
365: }
366: }
367: if (data->mywin == NULL) {
368: /* create the Clock window */
369: data->mywin = XCreateSimpleWindow(data->dpy, pw, data->x, data->y,
370: data->width, data->height,
371: data->brwidth, data->brpixel, data->bgpixel);
372: }
373:
374: XtSetNameAndClass(data->dpy, data->mywin, names, classes);
375: XrmFreeNameList(names);
376: XrmFreeClassList(classes);
377:
378: /* set handler for expose, resize, and message events */
379:
380: eventmask = ExposureMask+StructureNotifyMask;
381: XtSetEventHandler (
382: data->dpy, data->mywin,
383: (XtEventHandler)EventHandler, eventmask, (caddr_t)data);
384:
385: XtSetTimeOut(data->mywin, XtNclock, data->update*1000);
386: if (data->update <= SECOND_HAND_TIME)
387: data->show_second_hand = TRUE;
388: return (data->mywin);
389: }
390:
391:
392: static void clock_tic(data)
393: WidgetData data;
394: {
395:
396: struct tm *localtime();
397: struct tm tm;
398: long time_value;
399: char time_string[28];
400: char *time_ptr = time_string;
401:
402: (void) time(&time_value);
403: tm = *localtime(&time_value);
404: /*
405: * Beep on the half hour; double-beep on the hour.
406: */
407: if (data->chime == TRUE) {
408: if (data->beeped && (tm.tm_min != 30) &&
409: (tm.tm_min != 0))
410: data->beeped = 0;
411: if (((tm.tm_min == 30) || (tm.tm_min == 0))
412: && (!data->beeped)) {
413: data->beeped = 1;
414: XBell(data->dpy, 50);
415: if (tm.tm_min == 0)
416: XBell(data->dpy, 50);
417: }
418: }
419: if( data->analog == FALSE ) {
420: time_ptr = asctime(&tm);
421: time_ptr[strlen(time_ptr) - 1] = 0;
422: XDrawImageString(data->dpy, data->mywin, data->myGC,
423: 2+data->padding
424: , 2+data->fontstruct->ascent+data->padding,
425: time_ptr, strlen(time_ptr));
426: } else {
427: /*
428: * The second (or minute) hand is sec (or min)
429: * sixtieths around the clock face. The hour hand is
430: * (hour + min/60) twelfths of the way around the
431: * clock-face. The derivation is left as an excercise
432: * for the reader.
433: */
434:
435: /*
436: * 12 hour clock.
437: */
438: if(tm.tm_hour > 12)
439: tm.tm_hour -= 12;
440:
441: /*
442: * Erase old hands.
443: */
444: if(data->numseg > 0) {
445: if (data->show_second_hand == TRUE) {
446: XDrawLines(data->dpy, data->mywin,
447: data->EraseGC,
448: data->sec,
449: VERTICES_IN_HANDS-1,
450: CoordModeOrigin);
451: if(data->Hdpixel != data->bgpixel) {
452: XFillPolygon(data->dpy,
453: data->mywin, data->EraseGC,
454: data->sec,
455: VERTICES_IN_HANDS-2,
456: Convex, CoordModeOrigin
457: );
458: }
459: }
460: if( tm.tm_min != data->otm.tm_min ||
461: tm.tm_hour != data->otm.tm_hour ) {
462: XDrawLines( data->dpy,
463: data->mywin,
464: data->EraseGC,
465: data->segbuff,
466: VERTICES_IN_HANDS,
467: CoordModeOrigin);
468: XDrawLines( data->dpy,
469: data->mywin,
470: data->EraseGC,
471: data->hour,
472: VERTICES_IN_HANDS,
473: CoordModeOrigin);
474: if(data->Hdpixel != data->bgpixel) {
475: XFillPolygon( data->dpy,
476: data->mywin, data->EraseGC,
477: data->segbuff, VERTICES_IN_HANDS,
478: Convex, CoordModeOrigin
479: );
480: XFillPolygon(data->dpy,
481: data->mywin, data->EraseGC,
482: data->hour,
483: VERTICES_IN_HANDS,
484: Convex, CoordModeOrigin
485: );
486: }
487: }
488: }
489:
490: if (data->numseg == 0 ||
491: tm.tm_min != data->otm.tm_min ||
492: tm.tm_hour != data->otm.tm_hour) {
493: data->segbuffptr = data->segbuff;
494: data->numseg = 0;
495: /*
496: * Calculate the hour hand, fill it in with its
497: * color and then outline it. Next, do the same
498: * with the minute hand. This is a cheap hidden
499: * line algorithm.
500: */
501: DrawHand(data,
502: data->minute_hand_length, data->hand_width,
503: ((double) tm.tm_min)/60.0
504: );
505: if(data->Hdpixel != data->bgpixel)
506: XFillPolygon( data->dpy,
507: data->mywin, data->HandGC,
508: data->segbuff, VERTICES_IN_HANDS,
509: Convex, CoordModeOrigin
510: );
511: XDrawLines( data->dpy,
512: data->mywin, data->HighGC,
513: data->segbuff, VERTICES_IN_HANDS,
514: CoordModeOrigin);
515: data->hour = data->segbuffptr;
516: DrawHand(data,
517: data->hour_hand_length, data->hand_width,
518: ((((double)tm.tm_hour) +
519: (((double)tm.tm_min)/60.0)) / 12.0)
520: );
521: if(data->Hdpixel != data->bgpixel) {
522: XFillPolygon( data->dpy,
523: data->mywin, data->HandGC,
524: data->hour,
525: VERTICES_IN_HANDS,
526: Convex, CoordModeOrigin
527: );
528: }
529: XDrawLines( data->dpy,
530: data->mywin, data->HighGC,
531: data->hour, VERTICES_IN_HANDS,
532: CoordModeOrigin );
533:
534: data->sec = data->segbuffptr;
535: }
536: if (data->show_second_hand == TRUE) {
537: data->segbuffptr = data->sec;
538: DrawSecond(data,
539: data->second_hand_length - 2,
540: data->second_hand_width,
541: data->minute_hand_length + 2,
542: ((double) tm.tm_sec)/60.0
543: );
544: if(data->Hdpixel != data->bgpixel)
545: XFillPolygon( data->dpy,
546: data->mywin, data->HandGC,
547: data->sec,
548: VERTICES_IN_HANDS -2,
549: Convex, CoordModeOrigin
550: );
551: XDrawLines( data->dpy,
552: data->mywin, data->HighGC,
553: data->sec,
554: VERTICES_IN_HANDS-1,
555: CoordModeOrigin
556: );
557: /*
558: * keep the pointer from walking too far.
559: */
560: data->segbuffptr = data->sec;
561: data->numseg = data->segbuffptr-data->segbuff;
562: }
563: data->otm = tm;
564:
565: }
566: }
567:
568: /*
569: * DrawLine - Draws a line.
570: *
571: * blank_length is the distance from the center which the line begins.
572: * length is the maximum length of the hand.
573: * Fraction_of_a_circle is a fraction between 0 and 1 (inclusive) indicating
574: * how far around the circle (clockwise) from high noon.
575: *
576: * The blank_length feature is because I wanted to draw tick-marks around the
577: * circle (for seconds). The obvious means of drawing lines from the center
578: * to the perimeter, then erasing all but the outside most pixels doesn't
579: * work because of round-off error (sigh).
580: */
581: static DrawLine(data, blank_length, length, fraction_of_a_circle)
582: WidgetData data;
583: Dimension blank_length;
584: Dimension length;
585: double fraction_of_a_circle;
586: {
587: register double angle, cosangle, sinangle;
588: double cos();
589: double sin();
590:
591: /*
592: * A full circle is 2 PI radians.
593: * Angles are measured from 12 o'clock, clockwise increasing.
594: * Since in X, +x is to the right and +y is downward:
595: *
596: * x = x0 + r * sin(theta)
597: * y = y0 - r * cos(theta)
598: *
599: */
600: angle = TWOPI * fraction_of_a_circle;
601: cosangle = cos(angle);
602: sinangle = sin(angle);
603:
604: SetSeg( data,
605: data->centerX + (int)(blank_length * sinangle),
606: data->centerY - (int)(blank_length * cosangle),
607: data->centerX + (int)(length * sinangle),
608: data->centerY - (int)(length * cosangle));
609: }
610:
611: /*
612: * DrawHand - Draws a hand.
613: *
614: * length is the maximum length of the hand.
615: * width is the half-width of the hand.
616: * Fraction_of_a_circle is a fraction between 0 and 1 (inclusive) indicating
617: * how far around the circle (clockwise) from high noon.
618: *
619: */
620: static DrawHand(data, length, width, fraction_of_a_circle)
621: WidgetData data;
622: Dimension length, width;
623: double fraction_of_a_circle;
624: {
625:
626: register double angle, cosangle, sinangle;
627: register double ws, wc;
628: Position x, y, x1, y1, x2, y2;
629: double cos();
630: double sin();
631:
632: /*
633: * A full circle is 2 PI radians.
634: * Angles are measured from 12 o'clock, clockwise increasing.
635: * Since in X, +x is to the right and +y is downward:
636: *
637: * x = x0 + r * sin(theta)
638: * y = y0 - r * cos(theta)
639: *
640: */
641: angle = TWOPI * fraction_of_a_circle;
642: cosangle = cos(angle);
643: sinangle = sin(angle);
644: /*
645: * Order of points when drawing the hand.
646: *
647: * 1,4
648: * / \
649: * / \
650: * / \
651: * 2 ------- 3
652: */
653: wc = width * cosangle;
654: ws = width * sinangle;
655: SetSeg( data,
656: x = data->centerX + round(length * sinangle),
657: y = data->centerY - round(length * cosangle),
658: x1 = data->centerX - round(ws + wc),
659: y1 = data->centerY + round(wc - ws)); /* 1 ---- 2 */
660: /* 2 */
661: SetSeg( data, x1, y1,
662: x2 = data->centerX - round(ws - wc),
663: y2 = data->centerY + round(wc + ws)); /* 2 ----- 3 */
664:
665: SetSeg( data, x2, y2, x, y); /* 3 ----- 1(4) */
666: }
667:
668: /*
669: * DrawSecond - Draws the second hand (diamond).
670: *
671: * length is the maximum length of the hand.
672: * width is the half-width of the hand.
673: * offset is direct distance from center to tail end.
674: * Fraction_of_a_circle is a fraction between 0 and 1 (inclusive) indicating
675: * how far around the circle (clockwise) from high noon.
676: *
677: */
678: static DrawSecond(data, length, width, offset, fraction_of_a_circle)
679: WidgetData data;
680: Dimension length, width, offset;
681: double fraction_of_a_circle;
682: {
683:
684: register double angle, cosangle, sinangle;
685: register double ms, mc, ws, wc;
686: register int mid;
687: Position x, y;
688: double cos();
689: double sin();
690:
691: /*
692: * A full circle is 2 PI radians.
693: * Angles are measured from 12 o'clock, clockwise increasing.
694: * Since in X, +x is to the right and +y is downward:
695: *
696: * x = x0 + r * sin(theta)
697: * y = y0 - r * cos(theta)
698: *
699: */
700: angle = TWOPI * fraction_of_a_circle;
701: cosangle = cos(angle);
702: sinangle = sin(angle);
703: /*
704: * Order of points when drawing the hand.
705: *
706: * 1,5
707: * / \
708: * / \
709: * / \
710: * 2< >4
711: * \ /
712: * \ /
713: * \ /
714: * - 3
715: * |
716: * |
717: * offset
718: * |
719: * |
720: * - + center
721: */
722:
723: mid = (length + offset) / 2;
724: mc = mid * cosangle;
725: ms = mid * sinangle;
726: wc = width * cosangle;
727: ws = width * sinangle;
728: /*1 ---- 2 */
729: SetSeg( data,
730: x = data->centerX + round(length * sinangle),
731: y = data->centerY - round(length * cosangle),
732: data->centerX + round(ms - wc),
733: data->centerY - round(mc + ws) );
734: SetSeg( data, data->centerX + round(offset *sinangle),
735: data->centerY - round(offset * cosangle), /* 2-----3 */
736: data->centerX + round(ms + wc),
737: data->centerY - round(mc - ws));
738: data->segbuffptr->x = x;
739: data->segbuffptr++->y = y;
740: data->numseg ++;
741: }
742:
743: static SetSeg( data, x1, y1, x2, y2)
744: WidgetData data;
745: int x1, y1, x2, y2;
746: {
747: data->segbuffptr->x = x1;
748: data->segbuffptr++->y = y1;
749: data->segbuffptr->x = x2;
750: data->segbuffptr++->y = y2;
751: data->numseg += 2;
752: }
753:
754: /*
755: * Draw the clock face (every fifth tick-mark is longer
756: * than the others).
757: */
758: static DrawClockFace(data, second_hand, radius)
759: WidgetData data;
760: Dimension second_hand;
761: Dimension radius;
762: {
763: register int i;
764: register int delta = (radius - second_hand) / 3;
765:
766: XClearWindow(data->dpy, data->mywin);
767: data->segbuffptr = data->segbuff;
768: data->numseg = 0;
769: for (i = 0; i < 60; i++)
770: DrawLine(data, (i % 5) == 0 ? second_hand : (radius - delta), radius,
771: ((double) i)/60.);
772: /*
773: * Go ahead and draw it.
774: */
775: XDrawSegments(data->dpy, data->mywin,
776: data->myGC, (XSegment *) &(data->segbuff[0]),
777: data->numseg/2);
778:
779: data->segbuffptr = data->segbuff;
780: data->numseg = 0;
781: }
782:
783: static round(x)
784: double x;
785: {
786: return(x >= 0 ? (int)(x + .5) : (int)(x - .5));
787: }
788:
789:
790: /*
791: *
792: * Get Attributes
793: *
794: */
795:
796: void XtClockGetValues (dpy, window, arglist, argCount)
797: Display *dpy;
798: Window window;
799: ArgList arglist;
800: int argCount;
801: {
802: WidgetData data;
803: data = DataFromWindow(dpy, window);
804: if (data == NULL) return;
805: globaldata = *data;
806: XtGetValues(resourcelist, XtNumber(resourcelist), arglist, argCount);
807: }
808:
809: /*
810: *
811: * Set Attributes
812: *
813: */
814:
815: void XtClockSetValues (dpy, window, arglist, argCount)
816: Display *dpy;
817: Window window;
818: ArgList arglist;
819: int argCount;
820: {
821: WidgetData data;
822: int redisplay = FALSE;
823: GCMask valuemask;
824: XGCValues myXGCV;
825:
826:
827: data = DataFromWindow(dpy, window);
828: if (data == NULL) return;
829: globaldata = *data;
830: XtSetValues(resourcelist, XtNumber(resourcelist), arglist, argCount);
831:
832: if(globaldata.update != data->update) {
833: (void) XtClearTimeOut(data->mywin, data->cookie);
834: XtSetTimeOut(data->mywin, data->cookie, globaldata.update*1000);
835: data->update = globaldata.update;
836: if (data->update <= SECOND_HAND_TIME)
837: data->show_second_hand = TRUE;
838:
839: }
840: if (globaldata.brpixel != data->brpixel) {
841: data->brpixel = globaldata.brpixel;
842: if (data->brwidth != 0)
843: XSetWindowBorder(data->dpy, data->mywin, data->brpixel);
844: redisplay = TRUE;
845: }
846: if ((globaldata.bgpixel != data->bgpixel) ||
847: (globaldata.fgpixel != data->fgpixel) ||
848: (globaldata.Hdpixel != data->Hdpixel) ||
849: (globaldata.Hipixel != data->Hipixel)) {
850: redisplay = TRUE;
851: if((globaldata.bgpixel != data->bgpixel) ||
852: (globaldata.fgpixel != data->fgpixel)) {
853: valuemask = GCForeground | GCFont | GCBackground | GCLineWidth;
854: myXGCV.foreground = (*data).fgpixel;
855: myXGCV.font = (*data).fontstruct->fid;
856: myXGCV.background = data->bgpixel;
857: data->myGC = XtGetGC(
858: data->dpy, (XContext) XtNclock, data->mywin, valuemask, &myXGCV);
859: }
860: if (globaldata.bgpixel != data->bgpixel) {
861: valuemask = GCForeground | GCLineWidth;
862: myXGCV.foreground = (*data).bgpixel;
863: data->EraseGC = XtGetGC(
864: data->dpy, (XContext) XtNclock, data->mywin, valuemask, &myXGCV);
865: }
866: if (globaldata.Hdpixel != data->Hdpixel) {
867: valuemask = GCForeground | GCLineWidth;
868: myXGCV.foreground = (*data).Hdpixel;
869: data->HandGC = XtGetGC(
870: data->dpy, (XContext) XtNclock, data->mywin, valuemask, &myXGCV);
871: }
872: if (globaldata.Hipixel != data->Hipixel) {
873: valuemask = GCForeground | GCLineWidth;
874: myXGCV.foreground = (*data).Hipixel;
875: data->HighGC = XtGetGC(
876: data->dpy, (XContext) XtNclock, data->mywin, valuemask, &myXGCV);
877: }
878: }
879: *data = globaldata;
880: if(redisplay == TRUE) {
881: XClearWindow(data->dpy, data->mywin);
882: redisplay_clock(data);
883: }
884: }
885:
886:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.