![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to xclock.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / new / X / xclock|
Return to xclock.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / new / X / xclock |
1.1 root 1: #ifndef lint
2: static char sccsid[] = "@(#)xclock.c 1.2 10/16/86";
3: #endif
4:
5: #include <X/mit-copyright.h>
6:
7: /* Copyright 1985 Massachusetts Institute of Technology */
8:
9: /*
10: * xclock.c MIT Project Athena, X Window system clock.
11: *
12: * This program provides the user with a small
13: * window contining a digital clock with day and date.
14: * Parameters are variable from the command line.
15: *
16: * Author: Tony Della Fera, DEC
17: * September, 1984
18: * Hacked up by a cast of thousands....
19: */
20:
21: #include <stdio.h>
22: #include <math.h>
23: #include <sys/time.h>
24: #include <X/Xlib.h>
25:
26: #define PI 3.141592
27:
28: #define SEG_BUFF_SIZE 128
29:
30: #define SECOND_HAND_FRACT 90
31: #define MINUTE_HAND_FRACT 70
32: #define HOUR_HAND_FRACT 40
33: #define SECOND_HAND_TIME 30
34:
35: #define DEF_UPDATE 60
36:
37: #define DEF_BORDER 2
38: #define DEF_VECTOR_HEIGHT 1
39: #define DEF_VECTOR_WIDTH 1
40:
41: #define DEF_DIGITAL_PADDING 10
42: #define DEF_DIGITAL_FONT "6x10"
43: #define DEF_ANALOG_PADDING 8
44: #define DEF_ANALOG_WIDTH 164
45: #define DEF_ANALOG_HEIGHT 164
46:
47: #define DEF_BORDER_COLOR BlackPixel
48: #define DEF_HIGH_COLOR BlackPixel
49: #define DEF_FRGRND_COLOR BlackPixel
50: #define DEF_BKGRND_COLOR WhitePixel
51:
52: #define UNINIT -1
53: #define FAILURE 0
54:
55: #define max(a, b) ((a) > (b) ? (a) : (b))
56: #define min(a, b) ((a) < (b) ? (a) : (b))
57: #define abs(a) ((a) < 0 ? -(a) : (a))
58:
59: typedef enum _bool {FALSE, TRUE} Bool;
60:
61: Bool XClockDebug = FALSE;
62: Bool AnalogClock = FALSE;
63: Bool ShowSecondHand = FALSE;
64: Bool Reverse = FALSE;
65:
66: int CenterX = 0;
67: int CenterY = 0;
68: int NumSegs = 0;
69:
70: int FrgrndColor;
71: int BkgrndColor;
72: int BorderColor;
73: int HighColor;
74:
75: Vertex SegBuff[SEG_BUFF_SIZE];
76: Vertex *SegBuffPtr;
77:
78: Window ClockWindow;
79:
80: main(argc, argv)
81: int argc;
82: char **argv;
83: {
84: char time_string[26];
85: register char *time_ptr = time_string;
86: #ifdef DEBUG
87: register Bool debug = XClockDebug;
88: #endif
89: register int i;
90: register int radius;
91: register int padding = UNINIT; /* UNINIT = parameter uninitialized. */
92: int border = UNINIT; /* UNINIT = parameter uninitialized. */
93: int update = UNINIT; /* UNINIT = parameter uninitialized. */
94: int win_width = UNINIT; /* UNINIT = parameter uninitialized. */
95: int win_height = UNINIT; /* UNINIT = parameter uninitialized. */
96: int second_hand_length;
97: int minute_hand_length;
98: int hour_hand_length;
99: int readfds = 0;
100: int maxfds = 0;
101: int string_width;
102: int status;
103: Bool even_update = FALSE;
104:
105: long time_value;
106:
107: char *index();
108: char *ctime(), asctim();
109: char *strind;
110: char *fn = DEF_DIGITAL_FONT;
111: char *fore_color = NULL;
112: char *back_color = NULL;
113: char *high_color = NULL;
114: char *brdr_color = NULL;
115: char *geom = NULL;
116: char *display = NULL;
117: int rvflag = 0;
118:
119: Color cdef;
120:
121: struct tm *localtime();
122: struct timeval timeout;
123: struct tm tm;
124: struct tm otm;
125:
126: Font font;
127: FontInfo font_info;
128: XEvent event;
129: char *def_val;
130:
131: def_val = XGetDefault(argv[0], "BorderWidth");
132: if (def_val != NULL) border = atoi(def_val);
133:
134: def_val = XGetDefault(argv[0], "BodyFont");
135: if (def_val != NULL) fn = def_val;
136:
137: fore_color = XGetDefault(argv[0], "Foreground");
138: back_color = XGetDefault(argv[0], "Background");
139: high_color = XGetDefault(argv[0], "Highlight");
140: brdr_color = XGetDefault(argv[0], "Border");
141:
142: def_val = XGetDefault(argv[0], "ReverseVideo");
143: if(def_val != NULL && strcmp(def_val, "on") == 0) rvflag++;
144:
145: def_val = XGetDefault(argv[0], "InternalBorder");
146: if (def_val != NULL) padding = atoi(def_val);
147:
148: if ((def_val = XGetDefault(argv[0], "Mode")) != NULL) {
149: if (strcmp(def_val, "analog") == 0) AnalogClock = TRUE;
150: if (strcmp(def_val, "digital") == 0) AnalogClock = FALSE;
151: if (strcmp(def_val, "Analog") == 0) AnalogClock = TRUE;
152: if (strcmp(def_val, "Digital") == 0) AnalogClock = FALSE;
153: }
154:
155: def_val = XGetDefault(argv[0],"Update");
156: if (def_val != NULL) update = atoi(def_val);
157:
158: geom = XGetDefault(argv[0], "Geometry");
159:
160: for (i = 1; i < argc; i++) {
161: if (argv [i] [0] == '=') {
162: geom = argv[i];
163: continue;
164: }
165: strind = index(argv[i], ':');
166: if(strind != NULL) {
167: display = argv[i];
168: continue;
169: }
170: strind = index(argv [i], '-');
171: if (strind == NULL) Syntax(argv[0]);
172: if (strcmp(argv [i], "-a") == 0 ||
173: strcmp(argv [i], "-analog") == 0) {
174: AnalogClock = TRUE;
175: continue;
176: }
177: if (strcmp(argv [i], "-d") == 0 ||
178: strcmp(argv [i], "-digital") == 0) {
179: AnalogClock = FALSE;
180: continue;
181: }
182: if (strcmp(argv [i], "-bw") == 0 ||
183: strcmp(argv [i], "-border") == 0) {
184: if (++i >= argc) Syntax(argv[0]);
185: border = atoi(argv [i]);
186: continue;
187: }
188: #ifdef DEBUG
189: if (strcmp(argv [i], "-debug") == 0) {
190: XClockDebug = TRUE;
191: debug = TRUE;
192: continue;
193: }
194: #endif
195: if (strcmp(argv [i], "-fn") == 0 ||
196: strcmp(argv [i], "-font") == 0) {
197: if (++i >= argc) Syntax(argv[0]);
198: fn = argv [i];
199: continue;
200: }
201: if (strcmp(argv [i], "-fg") == 0 ||
202: strcmp(argv [i], "-foreground") == 0) {
203: if (++i >= argc) Syntax(argv[0]);
204: fore_color = argv [i];
205: continue;
206: }
207: if (strcmp(argv [i], "-bg") == 0 ||
208: strcmp(argv [i], "-background") == 0) {
209: if (++i >= argc) Syntax(argv[0]);
210: back_color = argv [i];
211: continue;
212: }
213: if (strcmp(argv [i], "-hl") == 0 ||
214: strcmp(argv [i], "-highlight") == 0) {
215: if (++i >= argc) Syntax(argv[0]);
216: high_color = argv [i];
217: continue;
218: }
219: if (strcmp(argv [i], "-bd") == 0 ||
220: strcmp(argv [i], "-bordercolor") == 0) {
221: if (++i >= argc) Syntax(argv[0]);
222: brdr_color = argv [i];
223: continue;
224: }
225: if (strcmp(argv [i], "-help") == 0) {
226: Syntax(argv[0]);
227: }
228: if (strcmp(argv [i], "-p") == 0 ||
229: strcmp(argv [i], "-padding") == 0) {
230: if (++i >= argc) Syntax(argv[0]);
231: padding = atoi(argv [i]);
232: continue;
233: }
234: if (strcmp(argv [i], "-rv") == 0 ||
235: strcmp(argv [i], "-reverse") == 0) {
236: rvflag++;
237: continue;
238: }
239: if (strcmp(argv [i], "-u") == 0 ||
240: strcmp(argv [i], "-update") == 0) {
241: if (++i >= argc) Syntax(argv[0]);
242: update = atoi(argv [i]);
243: continue;
244: }
245: Syntax(argv[0]);
246: }
247:
248: /*
249: * Open up the display.
250: */
251: if (XOpenDisplay(display) == NULL) {
252: XClockError("Error while trying to open display");
253: }
254: if (rvflag) Reverse = TRUE;
255:
256: /*
257: * Set up colors and pixmaps.
258: */
259: if (brdr_color != NULL) {
260: if (DisplayCells() > 2) {
261: if (
262: XParseColor(brdr_color, &cdef) &&
263: XGetHardwareColor(&cdef)
264: ) BorderColor = cdef.pixel;
265: else BorderColor = DEF_BORDER_COLOR;
266: }
267: else if (strcmp(brdr_color, "black") == 0)
268: BorderColor = BlackPixel;
269: else if (strcmp(brdr_color, "white") == 0)
270: BorderColor = WhitePixel;
271: else BorderColor = DEF_BORDER_COLOR;
272: }
273: else BorderColor = DEF_BORDER_COLOR;
274:
275: if (fore_color != NULL) {
276: if (DisplayCells() > 2) {
277: if (
278: XParseColor(fore_color, &cdef) &&
279: XGetHardwareColor(&cdef)
280: ) FrgrndColor = cdef.pixel;
281: else FrgrndColor = DEF_FRGRND_COLOR;
282: }
283: else if (strcmp(fore_color, "black") == 0)
284: FrgrndColor = BlackPixel;
285: else if (strcmp(fore_color, "white") == 0)
286: FrgrndColor = WhitePixel;
287: else FrgrndColor = DEF_FRGRND_COLOR;
288: }
289: else FrgrndColor = DEF_FRGRND_COLOR;
290:
291: if (back_color != NULL) {
292: if (DisplayCells() > 2) {
293: if (
294: XParseColor(back_color, &cdef) &&
295: XGetHardwareColor(&cdef)
296: ) BkgrndColor = cdef.pixel;
297: else BkgrndColor = DEF_BKGRND_COLOR;
298: }
299: else if (strcmp(back_color, "black") == 0)
300: BkgrndColor = BlackPixel;
301: else if (strcmp(back_color, "white") == 0)
302: BkgrndColor = WhitePixel;
303: else BkgrndColor = DEF_BKGRND_COLOR;
304: }
305: else BkgrndColor = DEF_BKGRND_COLOR;
306:
307: if ((high_color != NULL) && AnalogClock) {
308: if (DisplayCells() > 2) {
309: if (
310: XParseColor(high_color, &cdef) &&
311: XGetHardwareColor(&cdef)
312: ) HighColor = cdef.pixel;
313: else HighColor = DEF_HIGH_COLOR;
314: }
315: else if (strcmp(high_color, "black") == 0)
316: HighColor = BlackPixel;
317: else if (strcmp(high_color, "white") == 0)
318: HighColor = WhitePixel;
319: else HighColor = DEF_HIGH_COLOR;
320: }
321: else HighColor = DEF_HIGH_COLOR;
322:
323: if (Reverse) {
324: HighColor = BorderColor = BkgrndColor;
325: BkgrndColor = FrgrndColor;
326: FrgrndColor = HighColor;
327: }
328:
329: /*
330: * Set up analog and digital specific defaults.
331: */
332: if (AnalogClock == TRUE) {
333: /*
334: * Set analog defaults.
335: */
336: if (padding == UNINIT) padding = DEF_ANALOG_PADDING;
337: if (update == UNINIT) update = DEF_UPDATE;
338: if (update <= SECOND_HAND_TIME) ShowSecondHand = TRUE;
339: /*
340: * Initialize the segment buffer and segment buffer pointer.
341: */
342: SegBuffPtr = SegBuff;
343:
344: /*
345: * Initialize the number of "segments" in the buffer; each
346: * segment is one Vertex or 3 shorts, an x value, a y value
347: * and the flags as passed to XDraw.
348: */
349: NumSegs = 0;
350: }
351: else {
352: /*
353: * Set digital defaults.
354: */
355:
356: if (padding == UNINIT) padding = DEF_DIGITAL_PADDING;
357: if (update == UNINIT) update = DEF_UPDATE;
358:
359: /*
360: * Get font dependent information and determine window
361: * size from a test string.
362: */
363: time(&time_value);
364: time_ptr = ctime(&time_value);
365: time_ptr[strlen(time_ptr) - 1] = 0;
366:
367: font = XGetFont(fn);
368: if (font == FAILURE) XClockError("Can't get font");
369:
370: status = XQueryFont(font, &font_info);
371: if (status == FAILURE) XClockError("Can't query font");
372:
373: string_width = XQueryWidth (time_ptr, font);
374:
375: }
376:
377:
378: /*
379: * Now set analog and digital independent defaults.
380: */
381: if (border == UNINIT) border = DEF_BORDER;
382: if (update > 1 && ((60 / update) * update == 60)) even_update = TRUE;
383:
384: /*
385: * Open the main window.
386: */
387: {
388: int min_width, min_height;
389: char default_geom[20];
390: OpaqueFrame frame;
391: if (AnalogClock) {
392: min_width = DEF_ANALOG_WIDTH/3;
393: min_height = DEF_ANALOG_HEIGHT/3;
394: sprintf (default_geom,
395: "%dx%d-0-0", DEF_ANALOG_WIDTH, DEF_ANALOG_HEIGHT);
396: }
397: else {
398: min_width = string_width + (2 * padding);
399: min_height = font_info.height + (2 * padding);
400: sprintf (default_geom, "%dx%d-0-0", min_width, min_height);
401: }
402: frame.bdrwidth = border;
403: frame.border = XMakeTile (BorderColor);
404: frame.background = XMakeTile (BkgrndColor);
405: ClockWindow = XCreate (
406: AnalogClock ? "Analog XClock" : "Digital XClock",
407: argv[0],
408: geom,
409: default_geom,
410: &frame,
411: min_width,
412: min_height);
413: if (ClockWindow == FAILURE)
414: XClockError("Can't open clock window");
415: }
416:
417: /*
418: * Select window exposure events to see if the contents of
419: * the window have been erased or altered. Select unmap events so
420: * we can stop output when iconified.
421: */
422: XSelectInput(ClockWindow, ExposeWindow|UnmapWindow);
423:
424: /*
425: * Map clock window to screen.
426: */
427: XMapWindow(ClockWindow);
428:
429: /*
430: * Initialize the select system call's maximum file
431: * descriptor number to be one more than the file descriptor
432: * number of the X connection.
433: */
434: maxfds = dpyno() + 1;
435:
436: /*
437: * Initialize the select timeout structure.
438: */
439: timeout.tv_sec = update;
440: timeout.tv_usec = 0;
441:
442: /*
443: * Initialize the old-time structure.
444: */
445: otm = *localtime(&time_value);
446:
447: /*
448: * Synchronize X before proceeding.
449: */
450: XSync(FALSE);
451:
452: /*
453: * Main clock loop.
454: */
455: while (TRUE) {
456: time(&time_value);
457: tm = *localtime(&time_value);
458: if (even_update) {
459: /* Truncate to update interval, get new timeout */
460: timeout.tv_sec = update - tm.tm_sec;
461: tm.tm_sec = (tm.tm_sec / update) * update;
462: timeout.tv_sec += tm.tm_sec;
463: }
464: if (AnalogClock == FALSE) {
465: /*
466: * See if there are any events pending that
467: * arn't supposed to be there.
468: */
469: if (XPending() != 0) {
470: /*
471: * There is an event pending so we must
472: * check to see if it is an ExposeWindow
473: * event, if it is anything else somthing
474: * went wrong!
475: */
476: XNextEvent(&event);
477: if (event.type == UnmapWindow) {
478: XPeekEvent(&event);
479: continue;
480: }
481: if (event.type != ExposeWindow) {
482: XClockError("Unexpected X_Event (digital mode)");
483: }
484: }
485: time_ptr = asctime(&tm);
486: time_ptr[strlen(time_ptr) - 1] = 0;
487: XTextPad (
488: ClockWindow,
489: padding, padding,
490: time_ptr, strlen(time_ptr),
491: font, 0, 0,
492: FrgrndColor, BkgrndColor,
493: GXcopy, AllPlanes
494: );
495: }
496: else {
497: /*
498: * Look for an X_Event associated with xclock.
499: */
500: if (XPending() != 0) {
501: /*
502: * There is an event pending so we must
503: * check to see if it is an ExposeWindow
504: * event, if it is anything else, somthing
505: * went wrong!
506: */
507: XNextEvent(&event);
508: if (event.type == UnmapWindow) {
509: XPeekEvent(&event);
510: continue;
511: }
512: if (event.type == ExposeWindow) {
513: /*
514: * Ok, we have a window exposure event,
515: * refresh the clock face. Check to
516: * see if the window has changed size.
517: */
518: XExposeWindowEvent *exp_event = (XExposeWindowEvent *)&event;
519: if ((exp_event->width != win_width) ||
520: (exp_event->height != win_height)) {
521: win_width = exp_event->width;
522: win_height = exp_event->height;
523: radius = (min(win_width, win_height) -(2 * padding)) / 2;
524: second_hand_length =
525: ((SECOND_HAND_FRACT *
526: radius)
527: / 100);
528: minute_hand_length =
529: ((MINUTE_HAND_FRACT *
530: radius) / 100);
531: hour_hand_length =
532: ((HOUR_HAND_FRACT *
533: radius) / 100);
534: CenterX = win_width / 2;
535: CenterY = win_height / 2;
536: }
537: DrawClockFace(second_hand_length,
538: radius);
539: }
540: else {
541: /*
542: * We should never get here!
543: */
544: XClockError("Unexpected X_Event (analog mode)");
545: }
546: }
547: /*
548: * The second (or minute) hand is sec (or min)
549: * sixtieths around the clock face. The hour hand is
550: * (hour + min/60) twelfths of the way around the
551: * clock-face. The derivation is left as an excercise
552: * for the reader.
553: */
554:
555: /*
556: * Erase old hands.
557: */
558: if (ShowSecondHand == TRUE) {
559: DrawHand(1, second_hand_length,
560: ((double) otm.tm_sec)/60.0);
561: }
562: DrawHand(1, minute_hand_length,
563: ((double) otm.tm_min)/60.0);
564: DrawHand(1, hour_hand_length,
565: (((double)otm.tm_hour) +
566: (((double)otm.tm_min)/60.0))/12.0);
567: Sync(BkgrndColor);
568:
569: /*
570: * 12 hour clock.
571: */
572: if(tm.tm_hour > 12)
573: tm.tm_hour -= 12;
574:
575: /*
576: * Draw new hands.
577: */
578: if (ShowSecondHand == TRUE) {
579: DrawHand(1, second_hand_length,
580: ((double) tm.tm_sec)/60.0);
581: }
582: DrawHand(1, minute_hand_length,
583: ((double) tm.tm_min)/60.0);
584: DrawHand(1, hour_hand_length,
585: (((double) tm.tm_hour) +
586: (((double) tm.tm_min)/60.0))/12.0);
587: Sync(HighColor);
588:
589: /*
590: * Make the new time now be the old time.
591: */
592: otm = tm;
593: }
594: XFlush ();
595:
596: /*
597: * Use the select system call on the file descriptor in
598: * the display structure to determine if there is work
599: * to be done. If not block untill timeout. Remember to
600: * reset the file descriptor before each select.
601: */
602: readfds = 1 << dpyno();
603: if (select(maxfds, &readfds, NULL, NULL, &timeout) == -1)
604: XClockError("Error in select on display file descriptor");
605: }
606: }
607:
608:
609: /*
610: * DrawHand - Draws (or erases) a hand. Fraction_of_a_circle is a
611: * fraction between 0 and 1 (inclusive) indicating how far around the
612: * circle (clockwise) high noon.
613: *
614: * Blank_length is the distance from the center which the hand begins
615: * (logically 0, but I have the feature, I might as well use it).
616: * length is the maximum length of the hand.
617: *
618: * The blank_length feature is because I wanted to draw tick-marks around the
619: * circle (for seconds). The obvious means of drawing lines from the center
620: * to the perimeter, then erasing all but the outside most pixels doesn't
621: * work because of round-off error (sigh).
622: */
623: DrawHand(blank_length, length, fraction_of_a_circle)
624: int blank_length;
625: int length;
626: double fraction_of_a_circle;
627: {
628:
629: double cos();
630: double sin();
631: double angle;
632:
633: /*
634: * A full circle is 2 PI radians.
635: * Angles are measured from 6 o'clock, not noon (or so it seems).
636: * Thus, when fraction_of_a_circle is 0, we want angle to be PI,
637: * and when fraction_of_a_circle is 1, we want angle to be 3 PI.
638: *
639: * Also, angles increase counter-clockwise, not clockwise, so we
640: * throw in a factor of -1 so our clock doesn't run backwards.
641: */
642: angle = (-2 * PI * fraction_of_a_circle) + PI;
643:
644: /*
645: * Add the move instruction to the segment buffer and increment
646: * the "next" pointer.
647: */
648: SegBuffPtr->x = CenterX + (int)((float)blank_length * sin(angle));
649: SegBuffPtr->y = CenterY + (int)((float)blank_length * cos(angle));
650: SegBuffPtr->flags = VertexDontDraw;
651: SegBuffPtr++;
652: NumSegs++;
653:
654: /*
655: * Add the new point to the buffer and increment the "next" pointer.
656: */
657: SegBuffPtr->x = CenterX + (int)((float)length * sin(angle));
658: SegBuffPtr->y = CenterY + (int)((float)length * cos(angle));
659: SegBuffPtr->flags = VertexDrawLastPoint;
660: SegBuffPtr++;
661: NumSegs++;
662: }
663:
664:
665: /*
666: * Draw the clock face (every fifth tick-mark is longer
667: * than the others).
668: */
669: DrawClockFace(second_hand, radius)
670: int second_hand;
671: int radius;
672: {
673: register Bool debug = XClockDebug;
674: register int i;
675: register int delta = (radius - second_hand) / 3;
676:
677: XClear(ClockWindow);
678: for (i = 0; i < 60; i++) {
679: if ((i % 5) == 0) {
680: DrawHand(second_hand, radius, ((double) i)/60.);
681: }
682: else {
683: DrawHand((radius - delta), radius, ((double) i)/60.);
684: }
685: }
686: /*
687: * Flush the buffer to the VS100.
688: */
689: Sync(FrgrndColor);
690: }
691:
692:
693: /*
694: * This routine synchronizes the segment buffer contents with the
695: * VS100 screen. In effect, it flushes the buffer contents to the
696: * screen.
697: */
698: Sync(color)
699: int color; /* X drawing color. */
700: {
701: register Bool debug = XClockDebug;
702:
703: /*
704: * Call the X draw curve routine.
705: */
706: XDraw(
707: ClockWindow,
708: SegBuff, NumSegs,
709: DEF_VECTOR_WIDTH, DEF_VECTOR_HEIGHT,
710: color, GXcopy, AllPlanes
711: );
712:
713: /*
714: * Reset the segment buffer pointer and the segment counter.
715: */
716: SegBuffPtr = SegBuff;
717: NumSegs = 0;
718: }
719:
720:
721:
722: /*
723: * Report the syntax for calling xclock.
724: */
725: Syntax(call)
726: char *call;
727: {
728: printf ("Usage: %s [-analog] [-bw <pixels>] [-digital]\n", call);
729: printf (" [-fg <color>] [-bg <color>] [-hl <color>] [-bd <color>]\n");
730: printf (" [-fn <font_name>] [-help] [-padding <pixels>]\n");
731: printf (" [-rv] [-update <seconds>] [[<host>]:[<vs>]]\n");
732: printf (" [=[<width>][x<height>][<+-><xoff>[<+-><yoff>]]]\n\n");
733: printf ("Default: %s -digital -bw %d -font %s -padding %d -update %d =-0-0\n\n",
734: call, DEF_BORDER, DEF_DIGITAL_FONT, DEF_DIGITAL_PADDING, DEF_UPDATE);
735: printf ("Default: %s -analog -bw %d -padding %d -update %d =%dx%d-0-0\n\n",
736: call, DEF_BORDER, DEF_DIGITAL_PADDING, DEF_UPDATE,
737: DEF_ANALOG_WIDTH, DEF_ANALOG_HEIGHT);
738: printf ("Notes: The order in which switches are specified is not significant.\n");
739: printf (" In analog mode the second hand only appears for update times\n");
740: printf (" less than or equal to %d seconds.\n", SECOND_HAND_TIME);
741: exit(0);
742: }
743:
744:
745: /*
746: * XClockError - Fatal xclock error.
747: */
748: XClockError (identifier)
749: char *identifier;
750: {
751: register Bool debug = XClockDebug;
752:
753: if (debug) printf("XClockError: Fatal xclock error encountered.\n");
754: perror("xclock");
755: fprintf(stderr, "xclock: %s\n", identifier);
756:
757: exit(1);
758: }
759:
760: /*
761: * End of xclock.c
762: */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.