xarclock-1.0.orig/ 40755 765 144 0 6153110706 12374 5ustar joeyusersxarclock-1.0.orig/clmask.bit100644 765 144 3544 6000132577 14452 0ustar joeyusers#define clock_mask_width 48 #define clock_mask_height 48 static char clock_mask_bits[] = { 0x00, 0x00, 0xfe, 0x3f, 0x00, 0x00, 0x00, 0x00, 0xfe, 0x3f, 0x00, 0x00, 0x00, 0x00, 0xfe, 0x3f, 0x00, 0x00, 0x00, 0x80, 0xff, 0xff, 0x00, 0x00, 0x00, 0xe0, 0xff, 0xff, 0x03, 0x00, 0x00, 0xf0, 0xff, 0xff, 0x07, 0x00, 0x00, 0xf8, 0xff, 0xff, 0x0f, 0x00, 0x00, 0xfc, 0xff, 0xff, 0x1f, 0x00, 0x00, 0xfe, 0xff, 0xff, 0x3f, 0x00, 0x00, 0xff, 0xff, 0xff, 0x7f, 0x00, 0x80, 0xff, 0xff, 0xff, 0xff, 0x00, 0xc0, 0xff, 0xff, 0xff, 0xff, 0x01, 0xe0, 0xff, 0xff, 0xff, 0xff, 0x03, 0xe0, 0xff, 0xff, 0xff, 0xff, 0x03, 0xf0, 0xff, 0xff, 0xff, 0xff, 0x07, 0xf0, 0xff, 0xff, 0xff, 0xff, 0x07, 0xf8, 0xff, 0xff, 0xff, 0xff, 0x0f, 0xf8, 0xff, 0xff, 0xff, 0xff, 0x0f, 0xf8, 0xff, 0xff, 0xff, 0xff, 0x0f, 0xfc, 0xff, 0xff, 0xff, 0xff, 0x1f, 0xfc, 0xff, 0xff, 0xff, 0xff, 0x1f, 0xfc, 0xff, 0xff, 0xff, 0xff, 0x1f, 0xfc, 0xff, 0xff, 0xff, 0xff, 0x7f, 0xfc, 0xff, 0xff, 0xff, 0xff, 0x7f, 0xfc, 0xff, 0xff, 0xff, 0xff, 0x7f, 0xfc, 0xff, 0xff, 0xff, 0xff, 0x7f, 0xfc, 0xff, 0xff, 0xff, 0xff, 0x1f, 0xfc, 0xff, 0xff, 0xff, 0xff, 0x1f, 0xfc, 0xff, 0xff, 0xff, 0xff, 0x0f, 0xf8, 0xff, 0xff, 0xff, 0xff, 0x0f, 0xf8, 0xff, 0xff, 0xff, 0xff, 0x0f, 0xf0, 0xff, 0xff, 0xff, 0xff, 0x07, 0xf0, 0xff, 0xff, 0xff, 0xff, 0x07, 0xe0, 0xff, 0xff, 0xff, 0xff, 0x03, 0xe0, 0xff, 0xff, 0xff, 0xff, 0x01, 0xc0, 0xff, 0xff, 0xff, 0xff, 0x01, 0x80, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0x7f, 0x00, 0x00, 0xfe, 0xff, 0xff, 0x3f, 0x00, 0x00, 0xfc, 0xff, 0xff, 0x1f, 0x00, 0x00, 0xf8, 0xff, 0xff, 0x0f, 0x00, 0x00, 0xf0, 0xff, 0xff, 0x07, 0x00, 0x00, 0xe0, 0xff, 0xff, 0x03, 0x00, 0x00, 0x80, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xfe, 0x3f, 0x00, 0x00, 0x00, 0x00, 0xfe, 0x3f, 0x00, 0x00, 0x00, 0x00, 0xfe, 0x3f, 0x00, 0x00, 0x00, 0x00, 0xfe, 0x3f, 0x00, 0x00}; xarclock-1.0.orig/clock.bit100644 765 144 3603 6000132577 14267 0ustar joeyusers#define clock_width 48 #define clock_height 48 #define clock_x_hot -1 #define clock_y_hot -1 static char clock_bits[] = { 0x00, 0x00, 0xfe, 0x3f, 0x00, 0x00, 0x00, 0x00, 0xfe, 0x3f, 0x00, 0x00, 0x00, 0x00, 0xfe, 0x3f, 0x00, 0x00, 0x00, 0x80, 0xff, 0xff, 0x00, 0x00, 0x00, 0xe0, 0xff, 0xff, 0x03, 0x00, 0x00, 0xf0, 0xff, 0xff, 0x07, 0x00, 0x00, 0xf8, 0x87, 0xf1, 0x0f, 0x00, 0x00, 0xfc, 0x80, 0x81, 0x1f, 0x00, 0x00, 0x3e, 0x80, 0x01, 0x3e, 0x00, 0x00, 0x9f, 0x01, 0xc0, 0x7c, 0x00, 0x80, 0x8f, 0x01, 0xc0, 0xf8, 0x00, 0xc0, 0x07, 0x00, 0x00, 0xf0, 0x01, 0xe0, 0x03, 0x00, 0x00, 0xe0, 0x03, 0xe0, 0x01, 0x00, 0x00, 0xc0, 0x03, 0xf0, 0x00, 0x00, 0x40, 0x80, 0x07, 0xf0, 0x06, 0x00, 0xe0, 0xb0, 0x07, 0x78, 0x06, 0x00, 0xf0, 0x30, 0x0f, 0x78, 0x00, 0x00, 0x78, 0x00, 0x0f, 0x78, 0x00, 0x00, 0x3c, 0x00, 0x0f, 0x3c, 0x00, 0x00, 0x1e, 0x00, 0x1e, 0x3c, 0x00, 0x00, 0x0f, 0x00, 0x1e, 0x3c, 0x00, 0x80, 0x07, 0x00, 0x1e, 0x3c, 0x00, 0xc0, 0x03, 0x00, 0x7e, 0xfc, 0x01, 0xc0, 0x03, 0xc0, 0x7f, 0xfc, 0x01, 0x80, 0x07, 0xc0, 0x7f, 0x3c, 0x00, 0x00, 0x0f, 0x00, 0x7e, 0x3c, 0x00, 0x00, 0x1e, 0x00, 0x1e, 0x3c, 0x00, 0x00, 0x1c, 0x00, 0x1e, 0x7c, 0x00, 0x00, 0x08, 0x00, 0x0f, 0x78, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x78, 0x06, 0x00, 0x00, 0x30, 0x0f, 0xf0, 0x06, 0x00, 0x00, 0xb0, 0x07, 0xf0, 0x00, 0x00, 0x00, 0x80, 0x07, 0xe0, 0x01, 0x00, 0x00, 0xc0, 0x03, 0xe0, 0x03, 0x00, 0x00, 0xe0, 0x01, 0xc0, 0x07, 0x00, 0x00, 0xf0, 0x01, 0x80, 0x8f, 0x01, 0xc0, 0xf8, 0x00, 0x00, 0x9f, 0x01, 0xc0, 0x7c, 0x00, 0x00, 0x3e, 0x80, 0x01, 0x3e, 0x00, 0x00, 0xfc, 0x80, 0x81, 0x1f, 0x00, 0x00, 0xf8, 0x87, 0xf1, 0x0f, 0x00, 0x00, 0xf0, 0xff, 0xff, 0x07, 0x00, 0x00, 0xe0, 0xff, 0xff, 0x03, 0x00, 0x00, 0x80, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xfe, 0x3f, 0x00, 0x00, 0x00, 0x00, 0xfe, 0x3f, 0x00, 0x00, 0x00, 0x00, 0xfe, 0x3f, 0x00, 0x00, 0x00, 0x00, 0xfe, 0x3f, 0x00, 0x00}; xarclock-1.0.orig/README100644 765 144 1745 6006503464 13364 0ustar joeyusersPackage name: XARClock/ Version number: 1.0 Report bugs to: jaime@inforamp.net Purpose: If clocks had been invented in Argentina (southern hemisphere), they would run anti-clockwise. Down there a sundial runs the other way around! The program is an extension of the standard X clock widget. New features are: Configurable direction of rotation and font support in analog mode. Original code copyrighted by Digital Equipment Corporation and the Massachusetts Institute of Technology. Usage: xarclock [-roman] [-arabic] [-south] [-north] [-analog] [-digital] [-bw ] [-fg ] [-bg ] [-hd ] [-hl ] [-bd ] [-fn ] [-help] [-padding ] [-rv] [-update ] [-display displayname] [-geometry geom] Date archived: April 1994 Special notes: Why not ? To install: run the following commands xmkmf make xarclock-1.0.orig/Clock.h100644 765 144 10652 6000132577 13722 0ustar joeyusers/* * ***************************************************************** * * * * * Copyright (c) Digital Equipment Corporation, 1991, 1994 * * * * * * All Rights Reserved. Unpublished rights reserved under * * * the copyright laws of the United States. * * * * * * The software contained on this media is proprietary to * * * and embodies the confidential technology of Digital * * * Equipment Corporation. Possession, use, duplication or * * * dissemination of the software and media is authorized only * * * pursuant to a valid written license from Digital Equipment * * * Corporation. * * * * * * RESTRICTED RIGHTS LEGEND Use, duplication, or disclosure * * * by the U.S. Government is subject to restrictions as set * * * forth in Subparagraph (c)(1)(ii) of DFARS 252.227-7013, * * * or in FAR 52.227-19, as applicable. * * * * * ***************************************************************** */ /* * HISTORY */ /* * $XConsortium: Clock.h,v 1.29 90/10/22 14:43:12 converse Exp $ */ /*********************************************************** Copyright 1987, 1988 by Digital Equipment Corporation, Maynard, Massachusetts, and the Massachusetts Institute of Technology, Cambridge, Massachusetts. All Rights Reserved Permission to use, copy, modify, and distribute this software and its documentation for any purpose and without fee is hereby granted, provided that the above copyright notice appear in all copies and that both that copyright notice and this permission notice appear in supporting documentation, and that the names of Digital or MIT not be used in advertising or publicity pertaining to distribution of the software without specific, written prior permission. DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. ******************************************************************/ #ifndef _XawClock_h #define _XawClock_h /*********************************************************************** * * Clock Widget * ***********************************************************************/ #include /* Parameters: Name Class RepType Default Value ---- ----- ------- ------------- analog Boolean Boolean True roman Boolean Boolean True north Boolean Boolean False background Background Pixel white backingStore BackingStore BackingStore default border BorderColor Pixel Black borderWidth BorderWidth Dimension 1 chime Boolean Boolean False destroyCallback Callback Pointer NULL font Font XFontStruct* fixed foreground Foreground Pixel black hand Foreground Pixel black height Height Dimension 164 highlight Foreground Pixel black mappedWhenManaged MappedWhenManaged Boolean True padding Margin int 8 update Interval int 60 (seconds) width Width Dimension 164 x Position Position 0 y Position Position 0 */ /* Resource names used to the clock widget */ /* color of hands */ #define XtNhand "hands" /* Boolean: digital if FALSE */ #define XtNanalog "analog" /* Boolean: arabic if FALSE */ #define XtNroman "roman" /* Boolean: clockwise if FALSE */ #define XtNnorth "north" /* Boolean: */ #define XtNchime "chime" /* Int: amount of space around outside of clock */ #define XtNpadding "padding" typedef struct _ClockRec *ClockWidget; /* completely defined in ClockPrivate.h */ typedef struct _ClockClassRec *ClockWidgetClass; /* completely defined in ClockPrivate.h */ extern WidgetClass clockWidgetClass; #endif /* _XawClock_h */ /* DON'T ADD STUFF AFTER THIS #endif */ xarclock-1.0.orig/xarclock.c100644 765 144 12027 6006503221 14460 0ustar joeyusers#ifndef lint static char rcsid[] = "$XConsortium: xclock.c,v 1.28 89/12/11 15:51:32 kit Exp $"; #endif /* lint */ /* * Copyright 1989 Massachusetts Institute of Technology * * Permission to use, copy, modify, distribute, and sell this software and its * documentation for any purpose is hereby granted without fee, provided that * the above copyright notice appear in all copies and that both that * copyright notice and this permission notice appear in supporting * documentation, and that the name of M.I.T. not be used in advertising or * publicity pertaining to distribution of the software without specific, * written prior permission. M.I.T. makes no representations about the * suitability of this software for any purpose. It is provided "as is" * without express or implied warranty. * * M.I.T. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL M.I.T. * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ /* * xclock -- Hacked from Tony Della Fera. */ /* * xarclock -- By Jaime Garcia Ghirelli. */ #include #include #include #include #include #include #include "clock.bit" #include "clmask.bit" extern void exit(); static void quit(); /* Command line options table. Only resources are entered here...there is a pass over the remaining options after XtParseCommand is let loose. */ static XrmOptionDescRec options[] = { {"-chime", "*clock.chime", XrmoptionNoArg, "TRUE"}, {"-hd", "*clock.hands", XrmoptionSepArg, NULL}, {"-hands", "*clock.hands", XrmoptionSepArg, NULL}, {"-hl", "*clock.highlight", XrmoptionSepArg, NULL}, {"-highlight", "*clock.highlight", XrmoptionSepArg, NULL}, {"-update", "*clock.update", XrmoptionSepArg, NULL}, {"-padding", "*clock.padding", XrmoptionSepArg, NULL}, {"-d", "*clock.analog", XrmoptionNoArg, "FALSE"}, {"-digital", "*clock.analog", XrmoptionNoArg, "FALSE"}, {"-analog", "*clock.analog", XrmoptionNoArg, "TRUE"}, {"-arabic", "*clock.roman", XrmoptionNoArg, "FALSE"}, {"-roman", "*clock.roman", XrmoptionNoArg, "TRUE"}, {"-south", "*clock.north", XrmoptionNoArg, "FALSE"}, {"-north", "*clock.north", XrmoptionNoArg, "TRUE"}, }; static XtActionsRec xclock_actions[] = { { "quit", quit }, }; static Atom wm_delete_window; /* * Report the syntax for calling xarclock. */ Syntax(call) char *call; { (void) printf ("Usage: %s \n", call); (void) printf ("[-roman] [-arabic] [-south] [-north] \n"); (void) printf ("[-analog] [-digital] [-bw ] \n"); (void) printf ("[-fg ] [-bg ] [-hd ] \n"); (void) printf ("[-hl ] [-bd ] \n"); (void) printf ("[-fn ] [-help] [-padding ] \n"); (void) printf ("[-rv] [-update ] [-display displayname] \n"); (void) printf ("[-geometry geom] \n\n"); exit(1); } void main(argc, argv) int argc; char **argv; { Widget toplevel; Arg arg; Pixmap icon_pixmap = None; XtAppContext app_con; toplevel = XtAppInitialize (&app_con, "XClock", options, XtNumber(options), &argc, argv, NULL, NULL, ZERO); if (argc != 1) Syntax(argv[0]); XtAppAddActions (app_con, xclock_actions, XtNumber(xclock_actions)); /* * This is a hack so that f.delete will do something useful in this * single-window application. */ XtOverrideTranslations(toplevel, XtParseTranslationTable ("WM_PROTOCOLS: quit()")); XtSetArg(arg, XtNiconPixmap, &icon_pixmap); XtGetValues(toplevel, &arg, ONE); if (icon_pixmap == None) { arg.value = (XtArgVal)XCreateBitmapFromData(XtDisplay(toplevel), XtScreen(toplevel)->root, clock_bits, clock_width, clock_height); XtSetValues (toplevel, &arg, ONE); } XtSetArg(arg, XtNiconMask, &icon_pixmap); XtGetValues(toplevel, &arg, ONE); if (icon_pixmap == None) { arg.value = (XtArgVal)XCreateBitmapFromData(XtDisplay(toplevel), XtScreen(toplevel)->root, clock_mask_bits, clock_mask_width, clock_mask_height); XtSetValues (toplevel, &arg, ONE); } XtCreateManagedWidget ("clock", clockWidgetClass, toplevel, NULL, ZERO); XtRealizeWidget (toplevel); wm_delete_window = XInternAtom (XtDisplay(toplevel), "WM_DELETE_WINDOW", False); (void) XSetWMProtocols (XtDisplay(toplevel), XtWindow(toplevel), &wm_delete_window, 1); XtAppMainLoop (app_con); } static void quit (w, event, params, num_params) Widget w; XEvent *event; String *params; Cardinal *num_params; { if (event->type == ClientMessage && event->xclient.data.l[0] != wm_delete_window) { XBell (XtDisplay(w), 0); return; } XCloseDisplay (XtDisplay(w)); exit (0); } xarclock-1.0.orig/ARClock.c100644 765 144 61211 6006511204 14127 0ustar joeyusers#ifndef lint static char Xrcsid[] = "$XConsortium: Clock.c,v 1.50 89/12/06 15:23:24 kit Exp $"; #endif /* lint */ /*********************************************************** Copyright 1987, 1988 by Digital Equipment Corporation, Maynard, Massachusetts, and the Massachusetts Institute of Technology, Cambridge, Massachusetts. All Rights Reserved Permission to use, copy, modify, and distribute this software and its documentation for any purpose and without fee is hereby granted, provided that the above copyright notice appear in all copies and that both that copyright notice and this permission notice appear in supporting documentation, and that the names of Digital or MIT not be used in advertising or publicity pertaining to distribution of the software without specific, written prior permission. DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. ******************************************************************/ #include #include #include #include #include /* extern long time(); BUG */ static void clock_tic(), DrawHand(), DrawSecond(), SetSeg(), DrawClockFace(); static erase_hands(), round(); /* Private Definitions */ #define VERTICES_IN_HANDS 6 /* to draw triangle */ #define PI 3.14159265358979 #define TWOPI (2. * PI) #define SECOND_HAND_FRACT 90 #define MINUTE_HAND_FRACT 70 #define HOUR_HAND_FRACT 40 #define HAND_WIDTH_FRACT 7 #define SECOND_WIDTH_FRACT 5 #define SECOND_HAND_TIME 30 #define TEXT_RADIUS_FRACT 65 #define ANALOG_SIZE_DEFAULT 164 #define max(a, b) ((a) > (b) ? (a) : (b)) #define min(a, b) ((a) < (b) ? (a) : (b)) #define abs(a) ((a) < 0 ? -(a) : (a)) /* Initialization of defaults */ #define offset(field) XtOffset(ClockWidget,clock.field) #define goffset(field) XtOffset(Widget,core.field) static XtResource resources[] = { {XtNwidth, XtCWidth, XtRDimension, sizeof(Dimension), goffset(width), XtRImmediate, (caddr_t) 0}, {XtNheight, XtCHeight, XtRDimension, sizeof(Dimension), goffset(height), XtRImmediate, (caddr_t) 0}, {XtNbackground, XtCBackground, XtRPixel, sizeof(Pixel), goffset(background_pixel), XtRString, "XtdefaultBackground"}, {XtNupdate, XtCInterval, XtRInt, sizeof(int), offset(update), XtRImmediate, (caddr_t) 60 }, {XtNforeground, XtCForeground, XtRPixel, sizeof(Pixel), offset(fgpixel), XtRString, "XtdefaultForeground"}, {XtNhand, XtCForeground, XtRPixel, sizeof(Pixel), offset(Hdpixel), XtRString, "XtdefaultForeground"}, {XtNhighlight, XtCForeground, XtRPixel, sizeof(Pixel), offset(Hipixel), XtRString, "XtdefaultForeground"}, {XtNanalog, XtCBoolean, XtRBoolean, sizeof(Boolean), offset(analog), XtRImmediate, (caddr_t) TRUE}, {XtNroman, XtCBoolean, XtRBoolean, sizeof(Boolean), offset(roman), XtRImmediate, (caddr_t) TRUE}, {XtNnorth, XtCBoolean, XtRBoolean, sizeof(Boolean), offset(north), XtRImmediate, (caddr_t) FALSE}, {XtNchime, XtCBoolean, XtRBoolean, sizeof(Boolean), offset(chime), XtRImmediate, (caddr_t) FALSE }, {XtNpadding, XtCMargin, XtRInt, sizeof(int), offset(padding), XtRImmediate, (caddr_t) 8}, {XtNfont, XtCFont, XtRFontStruct, sizeof(XFontStruct *), offset(font), XtRString, "fixed"}, {XtNbackingStore, XtCBackingStore, XtRBackingStore, sizeof (int), offset (backing_store), XtRString, "default"}, }; #undef offset #undef goffset static void ClassInitialize(); static void Initialize(), Realize(), Destroy(), Resize(), Redisplay(); static Boolean SetValues(); ClockClassRec clockClassRec = { { /* core fields */ /* superclass */ &widgetClassRec, /* class_name */ "Clock", /* widget_size */ sizeof(ClockRec), /* class_initialize */ ClassInitialize, /* class_part_initialize */ NULL, /* class_inited */ FALSE, /* initialize */ Initialize, /* initialize_hook */ NULL, /* realize */ Realize, /* actions */ NULL, /* num_actions */ 0, /* resources */ resources, /* resource_count */ XtNumber(resources), /* xrm_class */ 0, /* compress_motion */ TRUE, /* compress_exposure */ TRUE, /* compress_enterleave */ TRUE, /* visible_interest */ FALSE, /* destroy */ Destroy, /* resize */ Resize, /* expose */ Redisplay, /* set_values */ SetValues, /* set_values_hook */ NULL, /* set_values_almost */ XtInheritSetValuesAlmost, /* get_values_hook */ NULL, /* accept_focus */ NULL, /* version */ XtVersion, /* callback_private */ NULL, /* tm_table */ NULL, /* query_geometry */ XtInheritQueryGeometry, /* display_accelerator */ XtInheritDisplayAccelerator, /* extension */ NULL } }; WidgetClass clockWidgetClass = (WidgetClass) &clockClassRec; /**************************************************************** * * Private Procedures * ****************************************************************/ static void ClassInitialize() { XawInitializeWidgetSet(); XtAddConverter( XtRString, XtRBackingStore, XmuCvtStringToBackingStore, NULL, 0 ); } /* ARGSUSED */ static void Initialize (request, new) Widget request, new; { ClockWidget w = (ClockWidget)new; XtGCMask valuemask; XGCValues myXGCV; int min_height, min_width; valuemask = GCForeground | GCBackground | GCFont | GCLineWidth; if (w->clock.font != NULL) myXGCV.font = w->clock.font->fid; else valuemask &= ~GCFont; /* use server default font */ min_width = min_height = ANALOG_SIZE_DEFAULT; if(!w->clock.analog) { char *str; struct tm tm, *localtime(); long time_value; (void) time(&time_value); tm = *localtime(&time_value); str = asctime(&tm); if (w->clock.font == NULL) w->clock.font = XQueryFont( XtDisplay(w), XGContextFromGC( DefaultGCOfScreen(XtScreen(w))) ); min_width = XTextWidth(w->clock.font, str, strlen(str)) + 2 * w->clock.padding; min_height = w->clock.font->ascent + w->clock.font->descent + 2 * w->clock.padding; } if (w->core.width == 0) w->core.width = min_width; if (w->core.height == 0) w->core.height = min_height; myXGCV.foreground = w->clock.fgpixel; myXGCV.background = w->core.background_pixel; if (w->clock.font != NULL) myXGCV.font = w->clock.font->fid; else valuemask &= ~GCFont; /* use server default font */ myXGCV.line_width = 0; w->clock.myGC = XtGetGC((Widget)w, valuemask, &myXGCV); valuemask = GCForeground | GCLineWidth ; myXGCV.foreground = w->core.background_pixel; w->clock.EraseGC = XtGetGC((Widget)w, valuemask, &myXGCV); myXGCV.foreground = w->clock.Hipixel; w->clock.HighGC = XtGetGC((Widget)w, valuemask, &myXGCV); valuemask = GCForeground; myXGCV.foreground = w->clock.Hdpixel; w->clock.HandGC = XtGetGC((Widget)w, valuemask, &myXGCV); if (w->clock.update <= 0) w->clock.update = 60; /* make invalid update's use a default */ w->clock.show_second_hand = (w->clock.update <= SECOND_HAND_TIME); w->clock.numseg = 0; w->clock.interval_id = 0; } static void Realize (gw, valueMask, attrs) Widget gw; XtValueMask *valueMask; XSetWindowAttributes *attrs; { ClockWidget w = (ClockWidget) gw; #ifdef notdef *valueMask |= CWBitGravity; attrs->bit_gravity = ForgetGravity; #endif switch (w->clock.backing_store) { case Always: case NotUseful: case WhenMapped: *valueMask |=CWBackingStore; attrs->backing_store = w->clock.backing_store; break; } XtCreateWindow( gw, InputOutput, (Visual *)CopyFromParent, *valueMask, attrs); Resize(gw); } static void Destroy (gw) Widget gw; { ClockWidget w = (ClockWidget) gw; if (w->clock.interval_id) XtRemoveTimeOut (w->clock.interval_id); XtDestroyGC (w->clock.myGC); XtDestroyGC (w->clock.HighGC); XtDestroyGC (w->clock.HandGC); XtDestroyGC (w->clock.EraseGC); } static void Resize (gw) Widget gw; { ClockWidget w = (ClockWidget) gw; /* don't do this computation if window hasn't been realized yet. */ if (XtIsRealized(gw) && w->clock.analog) { /* need signed value since Dimension is unsigned */ int radius = ((int) min(w->core.width, w->core.height) - (int) (2 * w->clock.padding)) / 2; w->clock.radius = (Dimension) max (radius, 1); w->clock.second_hand_length = ((SECOND_HAND_FRACT * w->clock.radius)/ 100); w->clock.minute_hand_length = ((MINUTE_HAND_FRACT * w->clock.radius)/ 100); w->clock.hour_hand_length = ((HOUR_HAND_FRACT * w->clock.radius)/ 100); w->clock.hand_width = ((HAND_WIDTH_FRACT * w->clock.radius)/ 100); w->clock.second_hand_width = ((SECOND_WIDTH_FRACT * w->clock.radius)/ 100); w->clock.text_position_radius =((TEXT_RADIUS_FRACT * w->clock.radius)/100); w->clock.centerX = w->core.width / 2; w->clock.centerY = w->core.height / 2; } } /* ARGSUSED */ static void Redisplay (gw, event, region) Widget gw; XEvent *event; /* unused */ Region region; /* unused */ { ClockWidget w = (ClockWidget) gw; if (w->clock.analog) { if (w->clock.numseg != 0) erase_hands (w, (struct tm *) 0); DrawClockFace(w); } else { w->clock.prev_time_string[0] = '\0'; } clock_tic((caddr_t)w, (XtIntervalId)0); } /* ARGSUSED */ static void clock_tic(client_data, id) caddr_t client_data; XtIntervalId *id; { ClockWidget w = (ClockWidget)client_data; struct tm *localtime(); struct tm tm; long time_value; char *time_ptr; register Display *dpy = XtDisplay(w); register Window win = XtWindow(w); register i, j; double angle, x, y; double cos(); double sin(); static String arabic_roman_numbers[]= { "9", "10", "11", "12", "1", "2", "3", "4", "5", "6", "7", "8", "3", "2", "1", "12", "11", "10", "9", "8", "7", "6", "5", "4", "IX", "X", "XI", "XII", "I", "II", "III", "IIII", "V", "VI","VII", "VIII", "III", "II", "I", "XII", "XI", "X", "IX", "VIII", "VII", "VI","V", "IIII", }; if (id || !w->clock.interval_id) w->clock.interval_id = XtAppAddTimeOut( XtWidgetToApplicationContext( (Widget) w), w->clock.update*1000, clock_tic, (caddr_t)w ); (void) time(&time_value); tm = *localtime(&time_value); /* * Beep on the half hour; double-beep on the hour. */ if (w->clock.chime == TRUE) { if (w->clock.beeped && (tm.tm_min != 30) && (tm.tm_min != 0)) w->clock.beeped = FALSE; if (((tm.tm_min == 30) || (tm.tm_min == 0)) && (!w->clock.beeped)) { w->clock.beeped = TRUE; XBell(dpy, 50); if (tm.tm_min == 0) XBell(dpy, 50); } } if( w->clock.analog == FALSE ) { int clear_from; int i, len, prev_len; time_ptr = asctime(&tm); len = strlen (time_ptr); if (time_ptr[len - 1] == '\n') time_ptr[--len] = '\0'; prev_len = strlen (w->clock.prev_time_string); for (i = 0; ((i < len) && (i < prev_len) && (w->clock.prev_time_string[i] == time_ptr[i])); i++); strcpy (w->clock.prev_time_string+i, time_ptr+i); XDrawImageString (dpy, win, w->clock.myGC, (2+w->clock.padding + XTextWidth (w->clock.font, time_ptr, i)), 2+w->clock.font->ascent+w->clock.padding, time_ptr + i, len - i); /* * Clear any left over bits */ clear_from = XTextWidth (w->clock.font, time_ptr, len) + 2 + w->clock.padding; if (clear_from < w->core.width) XFillRectangle (dpy, win, w->clock.EraseGC, clear_from, 0, w->core.width - clear_from, w->core.height); } else { /* * The second (or minute) hand is sec (or min) * sixtieths around the clock face. The hour hand is * (hour + min/60) twelfths of the way around the * clock-face. The derivation is left as an excercise * for the reader. */ /* * 12 hour clock. */ if(tm.tm_hour > 12) tm.tm_hour -= 12; erase_hands (w, &tm); if (w->clock.numseg == 0 || tm.tm_min != w->clock.otm.tm_min || tm.tm_hour != w->clock.otm.tm_hour) { w->clock.segbuffptr = w->clock.segbuff; w->clock.numseg = 0; /* * Draw the numbers */ for (i = 0; i < 12; i++) { if (w->clock.north == FALSE) j = i; else j = i + 12; angle = i * PI / 6; x = w->clock.text_position_radius * cos(angle); y = w->clock.text_position_radius * sin(angle); /* Translate for X co-ordinate system */ x = (int) w->clock.centerX + x; y = (int) w->clock.centerY - y; if (w->clock.roman == FALSE) j = j; else j = j + 24; /* Center string */ x = x - XTextWidth(w->clock.font, arabic_roman_numbers[j], strlen(arabic_roman_numbers[j]))/2; y = y + (w->clock.font->ascent + w->clock.font->descent)/2; XDrawImageString(XtDisplay(w), XtWindow(w), w->clock.myGC, x, y, arabic_roman_numbers[j], strlen(arabic_roman_numbers[j])); } /* * Calculate the hour hand, fill it in with its * color and then outline it. Next, do the same * with the minute hand. This is a cheap hidden * line algorithm. */ DrawHand(w, w->clock.minute_hand_length, w->clock.hand_width, ((double) tm.tm_min)/60.0 ); if(w->clock.Hdpixel != w->core.background_pixel) XFillPolygon( dpy, win, w->clock.HandGC, w->clock.segbuff, VERTICES_IN_HANDS, Convex, CoordModeOrigin ); XDrawLines( dpy, win, w->clock.HighGC, w->clock.segbuff, VERTICES_IN_HANDS, CoordModeOrigin); w->clock.hour = w->clock.segbuffptr; DrawHand(w, w->clock.hour_hand_length, w->clock.hand_width, ((((double)tm.tm_hour) + (((double)tm.tm_min)/60.0)) / 12.0) ); if(w->clock.Hdpixel != w->core.background_pixel) { XFillPolygon(dpy, win, w->clock.HandGC, w->clock.hour, VERTICES_IN_HANDS, Convex, CoordModeOrigin ); } XDrawLines( dpy, win, w->clock.HighGC, w->clock.hour, VERTICES_IN_HANDS, CoordModeOrigin ); w->clock.sec = w->clock.segbuffptr; } if (w->clock.show_second_hand == TRUE) { w->clock.segbuffptr = w->clock.sec; DrawSecond(w, w->clock.second_hand_length - 2, w->clock.second_hand_width, w->clock.minute_hand_length + 2, ((double) tm.tm_sec)/60.0 ); if(w->clock.Hdpixel != w->core.background_pixel) XFillPolygon( dpy, win, w->clock.HandGC, w->clock.sec, VERTICES_IN_HANDS -2, Convex, CoordModeOrigin ); XDrawLines( dpy, win, w->clock.HighGC, w->clock.sec, VERTICES_IN_HANDS-1, CoordModeOrigin ); } w->clock.otm = tm; } } static erase_hands (w, tm) ClockWidget w; struct tm *tm; { /* * Erase old hands. */ if(w->clock.numseg > 0) { Display *dpy; Window win; dpy = XtDisplay (w); win = XtWindow (w); if (w->clock.show_second_hand == TRUE) { XDrawLines(dpy, win, w->clock.EraseGC, w->clock.sec, VERTICES_IN_HANDS-1, CoordModeOrigin); if(w->clock.Hdpixel != w->core.background_pixel) { XFillPolygon(dpy, win, w->clock.EraseGC, w->clock.sec, VERTICES_IN_HANDS-2, Convex, CoordModeOrigin ); } } if(!tm || tm->tm_min != w->clock.otm.tm_min || tm->tm_hour != w->clock.otm.tm_hour) { XDrawLines( dpy, win, w->clock.EraseGC, w->clock.segbuff, VERTICES_IN_HANDS, CoordModeOrigin); XDrawLines( dpy, win, w->clock.EraseGC, w->clock.hour, VERTICES_IN_HANDS, CoordModeOrigin); if(w->clock.Hdpixel != w->core.background_pixel) { XFillPolygon( dpy, win, w->clock.EraseGC, w->clock.segbuff, VERTICES_IN_HANDS, Convex, CoordModeOrigin); XFillPolygon( dpy, win, w->clock.EraseGC, w->clock.hour, VERTICES_IN_HANDS, Convex, CoordModeOrigin); } } } } /* * DrawLine - Draws a line. * * blank_length is the distance from the center which the line begins. * length is the maximum length of the hand. * Fraction_of_a_circle is a fraction between 0 and 1 (inclusive) indicating * how far around the circle (clockwise) from high noon. * * The blank_length feature is because I wanted to draw tick-marks around the * circle (for seconds). The obvious means of drawing lines from the center * to the perimeter, then erasing all but the outside most pixels doesn't * work because of round-off error (sigh). */ static void DrawLine(w, blank_length, length, fraction_of_a_circle) ClockWidget w; Dimension blank_length; Dimension length; double fraction_of_a_circle; { double dblank_length = (double)blank_length, dlength = (double)length; double angle, cosangle, sinangle; double cos(); double sin(); int cx = w->clock.centerX, cy = w->clock.centerY, x1, y1, x2, y2; /* * Argentinean check */ if (w->clock.north == FALSE) fraction_of_a_circle = 1 - fraction_of_a_circle; /* * A full circle is 2 PI radians. * Angles are measured from 12 o'clock, clockwise increasing. * Since in X, +x is to the right and +y is downward: * * x = x0 + r * sin(theta) * y = y0 - r * cos(theta) * */ angle = TWOPI * fraction_of_a_circle; cosangle = cos(angle); sinangle = sin(angle); /* break this out so that stupid compilers can cope */ x1 = cx + (int)(dblank_length * sinangle); y1 = cy - (int)(dblank_length * cosangle); x2 = cx + (int)(dlength * sinangle); y2 = cy - (int)(dlength * cosangle); SetSeg(w, x1, y1, x2, y2); } /* * DrawHand - Draws a hand. * * length is the maximum length of the hand. * width is the half-width of the hand. * Fraction_of_a_circle is a fraction between 0 and 1 (inclusive) indicating * how far around the circle (clockwise) from high noon. * */ static void DrawHand(w, length, width, fraction_of_a_circle) ClockWidget w; Dimension length, width; double fraction_of_a_circle; { register double angle, cosangle, sinangle; register double ws, wc; Position x, y, x1, y1, x2, y2; double cos(); double sin(); /* * Argentinean check */ if (w->clock.north == FALSE) fraction_of_a_circle = 1 - fraction_of_a_circle; /* * A full circle is 2 PI radians. * Angles are measured from 12 o'clock, clockwise increasing. * Since in X, +x is to the right and +y is downward: * * x = x0 + r * sin(theta) * y = y0 - r * cos(theta) * */ angle = TWOPI * fraction_of_a_circle; cosangle = cos(angle); sinangle = sin(angle); /* * Order of points when drawing the hand. * * 1,4 * / \ * / \ * / \ * 2 ------- 3 */ wc = width * cosangle; ws = width * sinangle; SetSeg(w, x = w->clock.centerX + round(length * sinangle), y = w->clock.centerY - round(length * cosangle), x1 = w->clock.centerX - round(ws + wc), y1 = w->clock.centerY + round(wc - ws)); /* 1 ---- 2 */ /* 2 */ SetSeg(w, x1, y1, x2 = w->clock.centerX - round(ws - wc), y2 = w->clock.centerY + round(wc + ws)); /* 2 ----- 3 */ SetSeg(w, x2, y2, x, y); /* 3 ----- 1(4) */ } /* * DrawSecond - Draws the second hand (diamond). * * length is the maximum length of the hand. * width is the half-width of the hand. * offset is direct distance from center to tail end. * Fraction_of_a_circle is a fraction between 0 and 1 (inclusive) indicating * how far around the circle (clockwise) from high noon. * */ static void DrawSecond(w, length, width, offset, fraction_of_a_circle) ClockWidget w; Dimension length, width, offset; double fraction_of_a_circle; { register double angle, cosangle, sinangle; register double ms, mc, ws, wc; register int mid; Position x, y; double cos(); double sin(); /* * Argentinean check */ if (w->clock.north == FALSE) fraction_of_a_circle = 1 - fraction_of_a_circle; /* * A full circle is 2 PI radians. * Angles are measured from 12 o'clock, clockwise increasing. * Since in X, +x is to the right and +y is downward: * * x = x0 + r * sin(theta) * y = y0 - r * cos(theta) * */ angle = TWOPI * fraction_of_a_circle; cosangle = cos(angle); sinangle = sin(angle); /* * Order of points when drawing the hand. * * 1,5 * / \ * / \ * / \ * 2< >4 * \ / * \ / * \ / * - 3 * | * | * offset * | * | * - + center */ mid = (length + offset) / 2; mc = mid * cosangle; ms = mid * sinangle; wc = width * cosangle; ws = width * sinangle; /*1 ---- 2 */ SetSeg(w, x = w->clock.centerX + round(length * sinangle), y = w->clock.centerY - round(length * cosangle), w->clock.centerX + round(ms - wc), w->clock.centerY - round(mc + ws) ); SetSeg(w, w->clock.centerX + round(offset *sinangle), w->clock.centerY - round(offset * cosangle), /* 2-----3 */ w->clock.centerX + round(ms + wc), w->clock.centerY - round(mc - ws)); w->clock.segbuffptr->x = x; w->clock.segbuffptr++->y = y; w->clock.numseg ++; } static void SetSeg(w, x1, y1, x2, y2) ClockWidget w; int x1, y1, x2, y2; { w->clock.segbuffptr->x = x1; w->clock.segbuffptr++->y = y1; w->clock.segbuffptr->x = x2; w->clock.segbuffptr++->y = y2; w->clock.numseg += 2; } /* * Draw the clock face (every fifth tick-mark is longer * than the others). */ static void DrawClockFace(w) ClockWidget w; { register int i; register int delta = (w->clock.radius - w->clock.second_hand_length) / 3; w->clock.segbuffptr = w->clock.segbuff; w->clock.numseg = 0; for (i = 0; i < 60; i++) DrawLine(w, ( (i % 5) == 0 ? w->clock.second_hand_length : (w->clock.radius - delta) ), w->clock.radius, ((double) i)/60.); /* * Go ahead and draw it. */ XDrawSegments(XtDisplay(w), XtWindow(w), w->clock.myGC, (XSegment *) &(w->clock.segbuff[0]), w->clock.numseg/2); w->clock.segbuffptr = w->clock.segbuff; w->clock.numseg = 0; } static int round(x) double x; { return(x >= 0.0 ? (int)(x + .5) : (int)(x - .5)); } /* ARGSUSED */ static Boolean SetValues (gcurrent, grequest, gnew) Widget gcurrent, grequest, gnew; { ClockWidget current = (ClockWidget) gcurrent; ClockWidget new = (ClockWidget) gnew; Boolean redisplay = FALSE; XtGCMask valuemask; XGCValues myXGCV; /* first check for changes to clock-specific resources. We'll accept all the changes, but may need to do some computations first. */ if (new->clock.update != current->clock.update) { if (current->clock.interval_id) XtRemoveTimeOut (current->clock.interval_id); if (XtIsRealized(new)) new->clock.interval_id = XtAppAddTimeOut( XtWidgetToApplicationContext(gnew), new->clock.update*1000, clock_tic, (caddr_t)gnew); new->clock.show_second_hand =(new->clock.update <= SECOND_HAND_TIME); } if (new->clock.padding != current->clock.padding) redisplay = TRUE; if (new->clock.analog != current->clock.analog) redisplay = TRUE; if (new->clock.font != current->clock.font) redisplay = TRUE; if ((new->clock.fgpixel != current->clock.fgpixel) || (new->core.background_pixel != current->core.background_pixel)) { valuemask = GCForeground | GCBackground | GCFont | GCLineWidth; myXGCV.foreground = new->clock.fgpixel; myXGCV.background = new->core.background_pixel; myXGCV.font = new->clock.font->fid; myXGCV.line_width = 0; XtDestroyGC (current->clock.myGC); new->clock.myGC = XtGetGC(gcurrent, valuemask, &myXGCV); redisplay = TRUE; } if (new->clock.Hipixel != current->clock.Hipixel) { valuemask = GCForeground | GCLineWidth; myXGCV.foreground = new->clock.fgpixel; myXGCV.font = new->clock.font->fid; myXGCV.line_width = 0; XtDestroyGC (current->clock.HighGC); new->clock.HighGC = XtGetGC((Widget)gcurrent, valuemask, &myXGCV); redisplay = TRUE; } if (new->clock.Hdpixel != current->clock.Hdpixel) { valuemask = GCForeground; myXGCV.foreground = new->clock.fgpixel; XtDestroyGC (current->clock.HandGC); new->clock.HandGC = XtGetGC((Widget)gcurrent, valuemask, &myXGCV); redisplay = TRUE; } if (new->core.background_pixel != current->core.background_pixel) { valuemask = GCForeground | GCLineWidth; myXGCV.foreground = new->core.background_pixel; myXGCV.line_width = 0; XtDestroyGC (current->clock.EraseGC); new->clock.EraseGC = XtGetGC((Widget)gcurrent, valuemask, &myXGCV); redisplay = TRUE; } return (redisplay); } xarclock-1.0.orig/ClockP.h100644 765 144 10675 6006503637 14054 0ustar joeyusers/* * ***************************************************************** * * * * * Copyright (c) Digital Equipment Corporation, 1991, 1994 * * * * * * All Rights Reserved. Unpublished rights reserved under * * * the copyright laws of the United States. * * * * * * The software contained on this media is proprietary to * * * and embodies the confidential technology of Digital * * * Equipment Corporation. Possession, use, duplication or * * * dissemination of the software and media is authorized only * * * pursuant to a valid written license from Digital Equipment * * * Corporation. * * * * * * RESTRICTED RIGHTS LEGEND Use, duplication, or disclosure * * * by the U.S. Government is subject to restrictions as set * * * forth in Subparagraph (c)(1)(ii) of DFARS 252.227-7013, * * * or in FAR 52.227-19, as applicable. * * * * * ***************************************************************** */ /* * HISTORY */ /* * $XConsortium: ClockP.h,v 1.21 90/10/22 14:43:22 converse Exp $ */ /*********************************************************** Copyright 1987, 1988 by Digital Equipment Corporation, Maynard, Massachusetts, and the Massachusetts Institute of Technology, Cambridge, Massachusetts. All Rights Reserved Permission to use, copy, modify, and distribute this software and its documentation for any purpose and without fee is hereby granted, provided that the above copyright notice appear in all copies and that both that copyright notice and this permission notice appear in supporting documentation, and that the names of Digital or MIT not be used in advertising or publicity pertaining to distribution of the software without specific, written prior permission. DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. ******************************************************************/ #ifndef _XawClockP_h #define _XawClockP_h #include /* Needed for struct tm. */ #include #include #define SEG_BUFF_SIZE 128 #define ASCII_TIME_BUFLEN 32 /* big enough for 26 plus slop */ /* New fields for the clock widget instance record */ typedef struct { Pixel fgpixel; /* color index for text */ Pixel Hipixel; /* color index for Highlighting */ Pixel Hdpixel; /* color index for hands */ XFontStruct *font; /* font for text */ GC myGC; /* pointer to GraphicsContext */ GC EraseGC; /* eraser GC */ GC HandGC; /* Hand GC */ GC HighGC; /* Highlighting GC */ /* start of graph stuff */ int update; /* update frequence */ Dimension radius; /* radius factor */ int backing_store; /* backing store type */ Boolean chime; Boolean beeped; Boolean analog; Boolean roman; Boolean north; Boolean show_second_hand; Dimension second_hand_length; Dimension minute_hand_length; Dimension hour_hand_length; Dimension hand_width; Dimension second_hand_width; Dimension text_position_radius; Position centerX; Position centerY; int numseg; int padding; XPoint segbuff[SEG_BUFF_SIZE]; XPoint *segbuffptr; XPoint *hour, *sec; struct tm otm ; XtIntervalId interval_id; char prev_time_string[ASCII_TIME_BUFLEN]; } ClockPart; /* Full instance record declaration */ typedef struct _ClockRec { CorePart core; SimplePart simple; ClockPart clock; } ClockRec; /* New fields for the Clock widget class record */ typedef struct {int dummy;} ClockClassPart; /* Full class record declaration. */ typedef struct _ClockClassRec { CoreClassPart core_class; SimpleClassPart simple_class; ClockClassPart clock_class; } ClockClassRec; /* Class pointer. */ extern ClockClassRec clockClassRec; #endif /* _XawClockP_h */ xarclock-1.0.orig/Imakefile100644 765 144 320 6000132577 14256 0ustar joeyusersDEFINES = -I. -I/usr/include CCOPTIONS = SYS_LIBRARIES = -lXmu -lXt -lm -lXaw LOCAL_LIBRARIES = $(XLIB) DEPLIB = SRCS = ARClock.c xarclock.c OBJS = ARClock.o xarclock.o ComplexProgramTarget(xarclock)