![[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 / Xtk|
Return to Clock.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: Clock.c,v 1.18 87/09/13 22:45:21 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: #include <sys/time.h>
28:
29: #include "Xlib.h"
30: #include "Xutil.h"
31: #include "Intrinsic.h"
32: #include "Clock.h"
33: #include "ClockP.h"
34: #include "Atoms.h"
35:
36: extern long time();
37: static void clock_tic(), DrawHand(), DrawSecond(), SetSeg(), DrawClockFace();
38:
39: /* Private Definitions */
40:
41: #define VERTICES_IN_HANDS 6 /* to draw triangle */
42: #define PI 3.14159265358979
43: #define TWOPI (2. * PI)
44:
45: #define SECOND_HAND_FRACT 90
46: #define MINUTE_HAND_FRACT 70
47: #define HOUR_HAND_FRACT 40
48: #define HAND_WIDTH_FRACT 7
49: #define SECOND_WIDTH_FRACT 5
50: #define SECOND_HAND_TIME 30
51:
52: #define max(a, b) ((a) > (b) ? (a) : (b))
53: #define min(a, b) ((a) < (b) ? (a) : (b))
54: #define abs(a) ((a) < 0 ? -(a) : (a))
55:
56:
57: /* Initialization of defaults */
58:
59: #define offset(field) XtOffset(ClockWidget,clock.field)
60: #define goffset(field) XtOffset(Widget,core.field)
61:
62: static XtResource resources[] = {
63: {XtNwidth, XtCWidth, XrmRInt, sizeof(int),
64: goffset(width), XrmRString, "164"},
65: {XtNheight, XtCHeight, XrmRInt, sizeof(int),
66: goffset(height), XrmRString, "164"},
67: {XtNupdate, XtCInterval, XrmRInt, sizeof(int),
68: offset(update), XrmRString, "60" },
69: {XtNforeground, XtCForeground, XrmRPixel, sizeof(Pixel),
70: offset(fgpixel), XrmRString, "Black"},
71: {XtNhand, XtCForeground, XrmRPixel, sizeof(Pixel),
72: offset(Hdpixel), XrmRString, "Black"},
73: {XtNhigh, XtCForeground, XrmRPixel, sizeof(Pixel),
74: offset(Hipixel), XrmRString, "Black"},
75: {XtNanalog, XtCBoolean, XrmRBoolean, sizeof(Boolean),
76: offset(analog), XrmRString, "TRUE"},
77: {XtNchime, XtCBoolean, XrmRBoolean, sizeof(Boolean),
78: offset(chime), XrmRString, "FALSE" },
79: {XtNpadding, XtCMargin, XrmRInt, sizeof(int),
80: offset(padding), XrmRString, "8"},
81: {XtNfont, XtCFont, XrmRFontStruct, sizeof(XFontStruct *),
82: offset(font), XrmRString, "6x10"},
83: };
84:
85: #undef offset
86: #undef goffset
87:
88: static void Initialize(), Realize(), Destroy(), Resize(), Redisplay();
89: static Boolean SetValues();
90:
91: ClockClassRec clockClassRec = {
92: { /* core fields */
93: /* superclass */ &widgetClassRec,
94: /* class_name */ "Clock",
95: /* size */ sizeof(ClockRec),
96: /* class_initialize */ NULL,
97: /* class_inited */ FALSE,
98: /* initialize */ Initialize,
99: /* realize */ Realize,
100: /* actions */ NULL,
101: /* num_actions */ 0,
102: /* resources */ resources,
103: /* resource_count*/ XtNumber(resources),
104: /* xrm_class */ NULL,
105: /* compress_motion */ TRUE,
106: /* compress_exposure */TRUE,
107: /* visible_interest */ FALSE,
108: /* destroy */ Destroy,
109: /* resize */ Resize,
110: /* expose */ Redisplay,
111: /* set_values */ SetValues,
112: /* accept_focus */ NULL,
113: }
114: };
115:
116: WidgetClass clockWidgetClass = (WidgetClass) &clockClassRec;
117:
118: /****************************************************************
119: *
120: * Private Procedures
121: *
122: ****************************************************************/
123:
124:
125: static void EventHandler(gw, closure, event)
126: Widget gw;
127: char *closure;
128: XEvent *event;
129: {
130: if (event->type == ClientMessage && event->xclient.message_type == XtTimerExpired)
131: clock_tic((ClockWidget)gw);
132: }
133:
134: static void Initialize (request, new)
135: Widget request, new;
136: {
137: ClockWidget w = (ClockWidget)new;
138: XtGCMask valuemask;
139: XGCValues myXGCV;
140:
141: if(!w->clock.analog) {
142: char *str;
143: struct tm tm, *localtime();
144: long time_value;
145: int min_height, min_width;
146: (void) time(&time_value);
147: tm = *localtime(&time_value);
148: str = asctime(&tm);
149: min_width = XTextWidth(w->clock.font, str, strlen(str)) +
150: 2 * w->clock.padding;
151: min_height = w->clock.font->ascent +
152: w->clock.font->descent + 2 * w->clock.padding;
153: if (w->core.width < min_width) w->core.width = min_width;
154: if (w->core.height < min_height) w->core.width = min_height;
155: }
156: valuemask = GCForeground | GCBackground | GCFont | GCLineWidth;
157: myXGCV.foreground = w->clock.fgpixel;
158: myXGCV.background = w->core.background_pixel;
159: myXGCV.font = w->clock.font->fid;
160: myXGCV.line_width = 0;
161: w->clock.myGC = XtGetGC(w, valuemask, &myXGCV);
162:
163: valuemask = GCForeground | GCLineWidth ;
164: myXGCV.foreground = w->core.background_pixel;
165: w->clock.EraseGC = XtGetGC(w, valuemask, &myXGCV);
166:
167: myXGCV.foreground = w->clock.Hipixel;
168: w->clock.HighGC = XtGetGC(w, valuemask, &myXGCV);
169:
170: valuemask = GCForeground;
171: myXGCV.foreground = w->clock.Hdpixel;
172: w->clock.HandGC = XtGetGC(w, valuemask, &myXGCV);
173:
174: XtAddEventHandler (w, 0, TRUE, EventHandler, NULL);
175:
176: w->clock.interval_id = XtAddTimeOut(w, w->clock.update*1000);
177: w->clock.show_second_hand = (w->clock.update <= SECOND_HAND_TIME);
178: }
179:
180: static void Realize (gw, valueMask, attrs)
181: Widget gw;
182: XtValueMask valueMask;
183: XSetWindowAttributes *attrs;
184: {
185: valueMask |= CWBitGravity;
186: attrs->bit_gravity = ForgetGravity;
187: gw->core.window = XCreateWindow (XtDisplay(gw),
188: gw->core.parent->core.window,
189: gw->core.x, gw->core.y,
190: gw->core.width, gw->core.height,
191: gw->core.border_width,
192: gw->core.depth, InputOutput,
193: /* visualID */ CopyFromParent,
194: valueMask, attrs);
195: Resize(gw);
196: }
197:
198: static void Destroy (gw)
199: Widget gw;
200: {
201: ClockWidget w = (ClockWidget) gw;
202: XtRemoveTimeOut (w->clock.interval_id);
203: XtDestroyGC (w->clock.myGC);
204: XtDestroyGC (w->clock.HighGC);
205: XtDestroyGC (w->clock.HandGC);
206: XtDestroyGC (w->clock.EraseGC);
207: }
208:
209: static void Resize (gw)
210: Widget gw;
211: {
212: ClockWidget w = (ClockWidget) gw;
213: /* don't do this computation if window hasn't been realized yet. */
214: if (XtIsRealized(gw) && w->clock.analog) {
215: w->clock.radius = (min(w->core.width, w->core.height)-(2 * w->clock.padding)) / 2;
216: w->clock.second_hand_length = ((SECOND_HAND_FRACT * w->clock.radius) / 100);
217: w->clock.minute_hand_length = ((MINUTE_HAND_FRACT * w->clock.radius) / 100);
218: w->clock.hour_hand_length = ((HOUR_HAND_FRACT * w->clock.radius) / 100);
219: w->clock.hand_width = ((HAND_WIDTH_FRACT * w->clock.radius) / 100);
220: w->clock.second_hand_width = ((SECOND_WIDTH_FRACT * w->clock.radius) / 100);
221: w->clock.centerX = w->core.width / 2;
222: w->clock.centerY = w->core.height / 2;
223: }
224: }
225:
226: static void Redisplay (gw)
227: Widget gw;
228: {
229: ClockWidget w = (ClockWidget) gw;
230: if (w->clock.analog)
231: DrawClockFace(w);
232: clock_tic(w);
233: }
234:
235:
236: static void clock_tic(w)
237: ClockWidget w;
238: {
239:
240: struct tm *localtime();
241: struct tm tm;
242: long time_value;
243: char time_string[28];
244: char *time_ptr = time_string;
245: register Display *dpy = XtDisplay(w);
246: register Window win = XtWindow(w);
247:
248: (void) time(&time_value);
249: tm = *localtime(&time_value);
250: /*
251: * Beep on the half hour; double-beep on the hour.
252: */
253: if (w->clock.chime == TRUE) {
254: if (w->clock.beeped && (tm.tm_min != 30) &&
255: (tm.tm_min != 0))
256: w->clock.beeped = FALSE;
257: if (((tm.tm_min == 30) || (tm.tm_min == 0))
258: && (!w->clock.beeped)) {
259: w->clock.beeped = TRUE;
260: XBell(dpy, 50);
261: if (tm.tm_min == 0)
262: XBell(dpy, 50);
263: }
264: }
265: if( w->clock.analog == FALSE ) {
266: time_ptr = asctime(&tm);
267: time_ptr[strlen(time_ptr) - 1] = 0;
268: XDrawImageString (dpy, win, w->clock.myGC,
269: 2+w->clock.padding, 2+w->clock.font->ascent+w->clock.padding,
270: time_ptr, strlen(time_ptr));
271: } else {
272: /*
273: * The second (or minute) hand is sec (or min)
274: * sixtieths around the clock face. The hour hand is
275: * (hour + min/60) twelfths of the way around the
276: * clock-face. The derivation is left as an excercise
277: * for the reader.
278: */
279:
280: /*
281: * 12 hour clock.
282: */
283: if(tm.tm_hour > 12)
284: tm.tm_hour -= 12;
285:
286: /*
287: * Erase old hands.
288: */
289: if(w->clock.numseg > 0) {
290: if (w->clock.show_second_hand == TRUE) {
291: XDrawLines(dpy, win,
292: w->clock.EraseGC,
293: w->clock.sec,
294: VERTICES_IN_HANDS-1,
295: CoordModeOrigin);
296: if(w->clock.Hdpixel != w->core.background_pixel) {
297: XFillPolygon(dpy,
298: win, w->clock.EraseGC,
299: w->clock.sec,
300: VERTICES_IN_HANDS-2,
301: Convex, CoordModeOrigin
302: );
303: }
304: }
305: if( tm.tm_min != w->clock.otm.tm_min ||
306: tm.tm_hour != w->clock.otm.tm_hour ) {
307: XDrawLines( dpy,
308: win,
309: w->clock.EraseGC,
310: w->clock.segbuff,
311: VERTICES_IN_HANDS,
312: CoordModeOrigin);
313: XDrawLines( dpy,
314: win,
315: w->clock.EraseGC,
316: w->clock.hour,
317: VERTICES_IN_HANDS,
318: CoordModeOrigin);
319: if(w->clock.Hdpixel != w->core.background_pixel) {
320: XFillPolygon( dpy,
321: win, w->clock.EraseGC,
322: w->clock.segbuff, VERTICES_IN_HANDS,
323: Convex, CoordModeOrigin
324: );
325: XFillPolygon(dpy,
326: win, w->clock.EraseGC,
327: w->clock.hour,
328: VERTICES_IN_HANDS,
329: Convex, CoordModeOrigin
330: );
331: }
332: }
333: }
334:
335: if (w->clock.numseg == 0 ||
336: tm.tm_min != w->clock.otm.tm_min ||
337: tm.tm_hour != w->clock.otm.tm_hour) {
338: w->clock.segbuffptr = w->clock.segbuff;
339: w->clock.numseg = 0;
340: /*
341: * Calculate the hour hand, fill it in with its
342: * color and then outline it. Next, do the same
343: * with the minute hand. This is a cheap hidden
344: * line algorithm.
345: */
346: DrawHand(w,
347: w->clock.minute_hand_length, w->clock.hand_width,
348: ((double) tm.tm_min)/60.0
349: );
350: if(w->clock.Hdpixel != w->core.background_pixel)
351: XFillPolygon( dpy,
352: win, w->clock.HandGC,
353: w->clock.segbuff, VERTICES_IN_HANDS,
354: Convex, CoordModeOrigin
355: );
356: XDrawLines( dpy,
357: win, w->clock.HighGC,
358: w->clock.segbuff, VERTICES_IN_HANDS,
359: CoordModeOrigin);
360: w->clock.hour = w->clock.segbuffptr;
361: DrawHand(w,
362: w->clock.hour_hand_length, w->clock.hand_width,
363: ((((double)tm.tm_hour) +
364: (((double)tm.tm_min)/60.0)) / 12.0)
365: );
366: if(w->clock.Hdpixel != w->core.background_pixel) {
367: XFillPolygon(dpy,
368: win, w->clock.HandGC,
369: w->clock.hour,
370: VERTICES_IN_HANDS,
371: Convex, CoordModeOrigin
372: );
373: }
374: XDrawLines( dpy,
375: win, w->clock.HighGC,
376: w->clock.hour, VERTICES_IN_HANDS,
377: CoordModeOrigin );
378:
379: w->clock.sec = w->clock.segbuffptr;
380: }
381: if (w->clock.show_second_hand == TRUE) {
382: w->clock.segbuffptr = w->clock.sec;
383: DrawSecond(w,
384: w->clock.second_hand_length - 2,
385: w->clock.second_hand_width,
386: w->clock.minute_hand_length + 2,
387: ((double) tm.tm_sec)/60.0
388: );
389: if(w->clock.Hdpixel != w->core.background_pixel)
390: XFillPolygon( dpy,
391: win, w->clock.HandGC,
392: w->clock.sec,
393: VERTICES_IN_HANDS -2,
394: Convex, CoordModeOrigin
395: );
396: XDrawLines( dpy,
397: win, w->clock.HighGC,
398: w->clock.sec,
399: VERTICES_IN_HANDS-1,
400: CoordModeOrigin
401: );
402:
403: }
404: w->clock.otm = tm;
405:
406: }
407: }
408:
409: /*
410: * DrawLine - Draws a line.
411: *
412: * blank_length is the distance from the center which the line begins.
413: * length is the maximum length of the hand.
414: * Fraction_of_a_circle is a fraction between 0 and 1 (inclusive) indicating
415: * how far around the circle (clockwise) from high noon.
416: *
417: * The blank_length feature is because I wanted to draw tick-marks around the
418: * circle (for seconds). The obvious means of drawing lines from the center
419: * to the perimeter, then erasing all but the outside most pixels doesn't
420: * work because of round-off error (sigh).
421: */
422: static void DrawLine(w, blank_length, length, fraction_of_a_circle)
423: ClockWidget w;
424: Dimension blank_length;
425: Dimension length;
426: double fraction_of_a_circle;
427: {
428: register double angle, cosangle, sinangle;
429: double cos();
430: double sin();
431:
432: /*
433: * A full circle is 2 PI radians.
434: * Angles are measured from 12 o'clock, clockwise increasing.
435: * Since in X, +x is to the right and +y is downward:
436: *
437: * x = x0 + r * sin(theta)
438: * y = y0 - r * cos(theta)
439: *
440: */
441: angle = TWOPI * fraction_of_a_circle;
442: cosangle = cos(angle);
443: sinangle = sin(angle);
444:
445: SetSeg(w,
446: w->clock.centerX + (int)(blank_length * sinangle),
447: w->clock.centerY - (int)(blank_length * cosangle),
448: w->clock.centerX + (int)(length * sinangle),
449: w->clock.centerY - (int)(length * cosangle));
450: }
451:
452: /*
453: * DrawHand - Draws a hand.
454: *
455: * length is the maximum length of the hand.
456: * width is the half-width of the hand.
457: * Fraction_of_a_circle is a fraction between 0 and 1 (inclusive) indicating
458: * how far around the circle (clockwise) from high noon.
459: *
460: */
461: static void DrawHand(w, length, width, fraction_of_a_circle)
462: ClockWidget w;
463: Dimension length, width;
464: double fraction_of_a_circle;
465: {
466:
467: register double angle, cosangle, sinangle;
468: register double ws, wc;
469: Position x, y, x1, y1, x2, y2;
470: double cos();
471: double sin();
472:
473: /*
474: * A full circle is 2 PI radians.
475: * Angles are measured from 12 o'clock, clockwise increasing.
476: * Since in X, +x is to the right and +y is downward:
477: *
478: * x = x0 + r * sin(theta)
479: * y = y0 - r * cos(theta)
480: *
481: */
482: angle = TWOPI * fraction_of_a_circle;
483: cosangle = cos(angle);
484: sinangle = sin(angle);
485: /*
486: * Order of points when drawing the hand.
487: *
488: * 1,4
489: * / \
490: * / \
491: * / \
492: * 2 ------- 3
493: */
494: wc = width * cosangle;
495: ws = width * sinangle;
496: SetSeg(w,
497: x = w->clock.centerX + round(length * sinangle),
498: y = w->clock.centerY - round(length * cosangle),
499: x1 = w->clock.centerX - round(ws + wc),
500: y1 = w->clock.centerY + round(wc - ws)); /* 1 ---- 2 */
501: /* 2 */
502: SetSeg(w, x1, y1,
503: x2 = w->clock.centerX - round(ws - wc),
504: y2 = w->clock.centerY + round(wc + ws)); /* 2 ----- 3 */
505:
506: SetSeg(w, x2, y2, x, y); /* 3 ----- 1(4) */
507: }
508:
509: /*
510: * DrawSecond - Draws the second hand (diamond).
511: *
512: * length is the maximum length of the hand.
513: * width is the half-width of the hand.
514: * offset is direct distance from center to tail end.
515: * Fraction_of_a_circle is a fraction between 0 and 1 (inclusive) indicating
516: * how far around the circle (clockwise) from high noon.
517: *
518: */
519: static void DrawSecond(w, length, width, offset, fraction_of_a_circle)
520: ClockWidget w;
521: Dimension length, width, offset;
522: double fraction_of_a_circle;
523: {
524:
525: register double angle, cosangle, sinangle;
526: register double ms, mc, ws, wc;
527: register int mid;
528: Position x, y;
529: double cos();
530: double sin();
531:
532: /*
533: * A full circle is 2 PI radians.
534: * Angles are measured from 12 o'clock, clockwise increasing.
535: * Since in X, +x is to the right and +y is downward:
536: *
537: * x = x0 + r * sin(theta)
538: * y = y0 - r * cos(theta)
539: *
540: */
541: angle = TWOPI * fraction_of_a_circle;
542: cosangle = cos(angle);
543: sinangle = sin(angle);
544: /*
545: * Order of points when drawing the hand.
546: *
547: * 1,5
548: * / \
549: * / \
550: * / \
551: * 2< >4
552: * \ /
553: * \ /
554: * \ /
555: * - 3
556: * |
557: * |
558: * offset
559: * |
560: * |
561: * - + center
562: */
563:
564: mid = (length + offset) / 2;
565: mc = mid * cosangle;
566: ms = mid * sinangle;
567: wc = width * cosangle;
568: ws = width * sinangle;
569: /*1 ---- 2 */
570: SetSeg(w,
571: x = w->clock.centerX + round(length * sinangle),
572: y = w->clock.centerY - round(length * cosangle),
573: w->clock.centerX + round(ms - wc),
574: w->clock.centerY - round(mc + ws) );
575: SetSeg(w, w->clock.centerX + round(offset *sinangle),
576: w->clock.centerY - round(offset * cosangle), /* 2-----3 */
577: w->clock.centerX + round(ms + wc),
578: w->clock.centerY - round(mc - ws));
579: w->clock.segbuffptr->x = x;
580: w->clock.segbuffptr++->y = y;
581: w->clock.numseg ++;
582: }
583:
584: static void SetSeg(w, x1, y1, x2, y2)
585: ClockWidget w;
586: int x1, y1, x2, y2;
587: {
588: w->clock.segbuffptr->x = x1;
589: w->clock.segbuffptr++->y = y1;
590: w->clock.segbuffptr->x = x2;
591: w->clock.segbuffptr++->y = y2;
592: w->clock.numseg += 2;
593: }
594:
595: /*
596: * Draw the clock face (every fifth tick-mark is longer
597: * than the others).
598: */
599: static void DrawClockFace(w)
600: ClockWidget w;
601: {
602: register int i;
603: register int delta = (w->clock.radius - w->clock.second_hand_length) / 3;
604:
605: w->clock.segbuffptr = w->clock.segbuff;
606: w->clock.numseg = 0;
607: for (i = 0; i < 60; i++)
608: DrawLine(w, (i % 5) == 0 ? w->clock.second_hand_length : (w->clock.radius - delta),
609: w->clock.radius, ((double) i)/60.);
610: /*
611: * Go ahead and draw it.
612: */
613: XDrawSegments(XtDisplay(w), XtWindow(w),
614: w->clock.myGC, (XSegment *) &(w->clock.segbuff[0]),
615: w->clock.numseg/2);
616:
617: w->clock.segbuffptr = w->clock.segbuff;
618: w->clock.numseg = 0;
619: }
620:
621: static int round(x)
622: double x;
623: {
624: return(x >= 0.0 ? (int)(x + .5) : (int)(x - .5));
625: }
626:
627: static Boolean SetValues (gcurrent, grequest, gnew, last)
628: Widget gcurrent, grequest, gnew;
629: Boolean last;
630: {
631: ClockWidget current = (ClockWidget) gcurrent;
632: ClockWidget new = (ClockWidget) gnew;
633: Boolean redisplay = FALSE;
634: XtGCMask valuemask;
635: XGCValues myXGCV;
636:
637: /* first check for changes to clock-specific resources. We'll accept all
638: the changes, but may need to do some computations first. */
639:
640: if (new->clock.update != current->clock.update) {
641: XtRemoveTimeOut (current->clock.interval_id);
642: new->clock.interval_id = XtAddTimeOut(gcurrent, new->clock.update*1000);
643: new->clock.show_second_hand = (new->clock.update <= SECOND_HAND_TIME);
644: }
645:
646: if (new->clock.analog != current->clock.analog)
647: redisplay = TRUE;
648:
649: if (new->clock.padding != current->clock.padding) {
650: Resize(gnew);
651: redisplay = TRUE;
652: }
653:
654: if (new->clock.font != current->clock.font)
655: redisplay = TRUE;
656:
657: if ((new->clock.fgpixel != current->clock.fgpixel)
658: || (new->core.background_pixel != current->core.background_pixel)) {
659: valuemask = GCForeground | GCBackground | GCFont | GCLineWidth;
660: myXGCV.foreground = new->clock.fgpixel;
661: myXGCV.background = new->core.background_pixel;
662: myXGCV.font = new->clock.font->fid;
663: myXGCV.line_width = 0;
664: XtDestroyGC (current->clock.myGC);
665: new->clock.myGC = XtGetGC(gcurrent, valuemask, &myXGCV);
666: redisplay = TRUE;
667: }
668:
669: if (new->clock.Hipixel != current->clock.Hipixel) {
670: valuemask = GCForeground | GCLineWidth;
671: myXGCV.foreground = new->clock.fgpixel;
672: myXGCV.font = new->clock.font->fid;
673: myXGCV.line_width = 0;
674: XtDestroyGC (current->clock.HighGC);
675: new->clock.HighGC = XtGetGC(gcurrent, valuemask, &myXGCV);
676: redisplay = TRUE;
677: }
678:
679: if (new->clock.Hdpixel != current->clock.Hdpixel) {
680: valuemask = GCForeground;
681: myXGCV.foreground = new->clock.fgpixel;
682: XtDestroyGC (current->clock.HandGC);
683: new->clock.HandGC = XtGetGC(gcurrent, valuemask, &myXGCV);
684: redisplay = TRUE;
685: }
686:
687: if (new->core.background_pixel != current->core.background_pixel) {
688: valuemask = GCForeground | GCLineWidth;
689: myXGCV.foreground = new->core.background_pixel;
690: myXGCV.line_width = 0;
691: XtDestroyGC (current->clock.EraseGC);
692: new->clock.EraseGC = XtGetGC(gcurrent, valuemask, &myXGCV);
693: redisplay = TRUE;
694: }
695:
696: if ((new->core.x != current->core.x)
697: || (new->core.y != current->core.y)
698: || (new->core.width != current->core.width)
699: || (new->core.height != current->core.height)
700: || (new->core.border_width != current->core.border_width))
701: /* need to make geometry request */;
702:
703: return (redisplay);
704:
705: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.