Skip to content
GitLab
Commit c4bc1693 authored by Kaleb Keithley Keithley's avatar Kaleb Keithley Keithley
Browse files

R6.6 is the Xorg base-line

parents
Hide whitespace changes
Inline Side-by-side
Clock-color.ad 0 → 100644
View file @ c4bc1693
! $Xorg: Clock-col.ad,v 1.3 2000/08/17 19:53:59 cpqbld Exp $
Clock*Background: grey
Clock*BorderColor: light blue
Clock*hour: yellow
Clock*jewel: yellow
Clock*minute: yellow
Clock.c 0 → 100644
View file @ c4bc1693
/*
* $Xorg: Clock.c,v 1.4 2001/02/09 02:05:33 xorgcvs Exp $
*
Copyright 1989, 1998 The Open Group
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.
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
Except as contained in this notice, the name of The Open Group shall not be
used in advertising or otherwise to promote the sale, use or other dealings
in this Software without prior written authorization from The Open Group.
*/
/*
* Clock.c
*
* a NeWS clone clock
*/
#include <X11/IntrinsicP.h>
#include <X11/StringDefs.h>
#include <X11/Xmu/Converters.h>
#include "ClockP.h"
#include <X11/Xos.h>
#include <stdio.h>
#include <math.h>
#include <X11/extensions/shape.h>
#ifdef X_NOT_STDC_ENV
extern struct tm *localtime();
#define Time_t long
extern Time_t time();
#else
#include <time.h>
#define Time_t time_t
#endif
#define offset(field) XtOffsetOf(ClockRec, clock.field)
#define goffset(field) XtOffsetOf(WidgetRec, core.field)
static XtResource resources[] = {
{XtNwidth, XtCWidth, XtRDimension, sizeof(Dimension),
goffset(width), XtRImmediate, (XtPointer) 120},
{XtNheight, XtCHeight, XtRDimension, sizeof(Dimension),
goffset(height), XtRImmediate, (XtPointer) 120},
{XtNminute, XtCForeground, XtRPixel, sizeof (Pixel),
offset(minute), XtRString, XtDefaultForeground},
{XtNhour, XtCForeground, XtRPixel, sizeof (Pixel),
offset(hour), XtRString, XtDefaultForeground},
{XtNjewel, XtCForeground, XtRPixel, sizeof (Pixel),
offset(jewel), XtRString, XtDefaultForeground},
{XtNbackingStore, XtCBackingStore, XtRBackingStore, sizeof (int),
offset (backing_store), XtRString, "default"},
{XtNborderSize, XtCBorderSize, XtRFloat, sizeof (float),
offset (border_size), XtRString, "0.1"},
{XtNjewelSize, XtCBorderSize, XtRFloat, sizeof (float),
offset (jewel_size), XtRString, "0.075"},
{XtNshapeWindow, XtCShapeWindow, XtRBoolean, sizeof (Boolean),
offset (shape_window), XtRImmediate, (XtPointer) True},
{XtNtransparent, XtCTransparent, XtRBoolean, sizeof (Boolean),
offset (transparent), XtRImmediate, (XtPointer) False},
};
#undef offset
#undef goffset
static void new_time();
static void Initialize(), Realize(), Destroy(), Redisplay(), Resize();
# define BORDER_SIZE(w) ((w)->clock.border_size)
# define WINDOW_WIDTH(w) (2.0 - BORDER_SIZE(w)*2)
# define WINDOW_HEIGHT(w) (2.0 - BORDER_SIZE(w)*2)
# define MINUTE_WIDTH(w) (0.05)
# define HOUR_WIDTH(w) (0.05)
# define JEWEL_SIZE(w) ((w)->clock.jewel_size)
# define MINUTE_LENGTH(w) (JEWEL_Y(w) - JEWEL_SIZE(w) / 2.0)
# define HOUR_LENGTH(w) (MINUTE_LENGTH(w) * 0.6)
# define JEWEL_X(w) (0.0)
# define JEWEL_Y(w) (1.0 - (BORDER_SIZE(w) + JEWEL_SIZE(w)))
static void ClassInitialize();
ClockClassRec clockClassRec = {
{ /* core fields */
/* superclass */ &widgetClassRec,
/* class_name */ "Clock",
/* 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,
/* num_resources */ XtNumber(resources),
/* xrm_class */ NULLQUARK,
/* compress_motion */ TRUE,
/* compress_exposure */ TRUE,
/* compress_enterleave */ TRUE,
/* visible_interest */ FALSE,
/* destroy */ Destroy,
/* resize */ Resize,
/* expose */ Redisplay,
/* set_values */ NULL,
/* set_values_hook */ NULL,
/* set_values_almost */ NULL,
/* get_values_hook */ NULL,
/* accept_focus */ NULL,
/* version */ XtVersion,
/* callback_private */ NULL,
/* tm_table */ NULL,
/* query_geometry */ XtInheritQueryGeometry,
}
};
static void ClassInitialize()
{
XtAddConverter( XtRString, XtRBackingStore, XmuCvtStringToBackingStore,
NULL, 0 );
}
WidgetClass clockWidgetClass = (WidgetClass) &clockClassRec;
/* ARGSUSED */
static void Initialize (greq, gnew, args, num_args)
Widget greq, gnew;
ArgList args;
Cardinal *num_args;
{
ClockWidget w = (ClockWidget)gnew;
XtGCMask valuemask;
XGCValues myXGCV;
int shape_event_base, shape_error_base;
valuemask = GCForeground;
if (w->clock.transparent)
{
;
}
else
{
myXGCV.foreground = w->clock.minute;
w->clock.minuteGC = XtGetGC(gnew, valuemask, &myXGCV);
myXGCV.foreground = w->clock.hour;
w->clock.hourGC = XtGetGC(gnew, valuemask, &myXGCV);
myXGCV.foreground = w->clock.jewel;
w->clock.jewelGC = XtGetGC(gnew, valuemask, &myXGCV);
myXGCV.foreground = w->core.background_pixel;
w->clock.eraseGC = XtGetGC(gnew, valuemask, &myXGCV);
}
/* wait for Realize to add the timeout */
w->clock.interval_id = 0;
if (w->clock.shape_window && !XShapeQueryExtension (XtDisplay (w),
&shape_event_base,
&shape_error_base))
w->clock.shape_window = False;
w->clock.shape_mask = 0;
w->clock.shapeGC = 0;
w->clock.shape_width = 0;
w->clock.shape_height = 0;
w->clock.polys_valid = 0;
}
static void Resize (widget)
Widget widget;
{
ClockWidget w = (ClockWidget) widget;
XGCValues xgcv;
Widget parent;
XWindowChanges xwc;
int face_width, face_height;
int x, y;
Pixmap shape_mask;
if (!XtIsRealized((Widget) w))
return;
/*
* compute desired border size
*/
SetTransform (&w->clock.maskt,
0, w->core.width,
w->core.height, 0,
-1.0, 1.0,
-1.0, 1.0);
face_width = abs (Xwidth (BORDER_SIZE(w), BORDER_SIZE(w), &w->clock.maskt));
face_height = abs (Xheight (BORDER_SIZE(w), BORDER_SIZE(w), &w->clock.maskt));
/*
* shape the windows and borders
*/
if (w->clock.shape_window) {
SetTransform (&w->clock.t,
face_width, w->core.width - face_width,
w->core.height - face_height, face_height,
-WINDOW_WIDTH(w)/2, WINDOW_WIDTH(w)/2,
-WINDOW_HEIGHT(w)/2, WINDOW_HEIGHT(w)/2);
/*
* allocate a pixmap to draw shapes in
*/
if (w->clock.shape_mask &&
(w->clock.shape_width != w->core.width ||
w->clock.shape_height != w->core.height))
{
XFreePixmap (XtDisplay (w), w->clock.shape_mask);
w->clock.shape_mask = None;
}
if (!w->clock.shape_mask)
{
w->clock.shape_mask = XCreatePixmap (XtDisplay (w), XtWindow (w),
w->core.width, w->core.height, 1);
}
shape_mask = w->clock.shape_mask;
if (!w->clock.shapeGC)
w->clock.shapeGC = XCreateGC (XtDisplay (w), shape_mask, 0, &xgcv);
/* erase the pixmap */
XSetForeground (XtDisplay (w), w->clock.shapeGC, 0);
XFillRectangle (XtDisplay (w), shape_mask, w->clock.shapeGC,
0, 0, w->core.width, w->core.height);
XSetForeground (XtDisplay (w), w->clock.shapeGC, 1);
/*
* draw the bounding shape. Doing this first
* eliminates extra exposure events.
*/
if (w->clock.border_size > 0.0 || !w->clock.transparent)
{
TFillArc (XtDisplay (w), shape_mask,
w->clock.shapeGC, &w->clock.maskt,
-1.0, -1.0,
2.0, 2.0,
0, 360 * 64);
}
if (w->clock.transparent)
{
if (w->clock.border_size > 0.0)
{
XSetForeground (XtDisplay (w), w->clock.shapeGC, 0);
TFillArc (XtDisplay (w), shape_mask,
w->clock.shapeGC, &w->clock.t,
-WINDOW_WIDTH(w)/2, -WINDOW_HEIGHT(w)/2,
WINDOW_WIDTH(w), WINDOW_HEIGHT(w),
0, 360 * 64);
XSetForeground (XtDisplay (w), w->clock.shapeGC, 1);
}
paint_jewel (w, shape_mask, w->clock.shapeGC);
paint_hands (w, shape_mask, w->clock.shapeGC, w->clock.shapeGC);
}
/*
* Find the highest enclosing widget and shape it
*/
x = 0;
y = 0;
for (parent = (Widget) w; XtParent (parent); parent = XtParent (parent)) {
x = x + parent->core.x + parent->core.border_width;
y = y + parent->core.y + parent->core.border_width;
}
XShapeCombineMask (XtDisplay (parent), XtWindow (parent), ShapeBounding,
x, y, shape_mask, ShapeSet);
/* erase the pixmap */
XSetForeground (XtDisplay (w), w->clock.shapeGC, 0);
XFillRectangle (XtDisplay (w), shape_mask, w->clock.shapeGC,
0, 0, w->core.width, w->core.height);
XSetForeground (XtDisplay (w), w->clock.shapeGC, 1);
/*
* draw the clip shape
*/
if (w->clock.transparent)
{
paint_jewel (w, shape_mask, w->clock.shapeGC);
paint_hands (w, shape_mask, w->clock.shapeGC, w->clock.shapeGC);
}
else
{
TFillArc (XtDisplay (w), shape_mask,
w->clock.shapeGC, &w->clock.t,
-WINDOW_WIDTH(w)/2, -WINDOW_HEIGHT(w)/2,
WINDOW_WIDTH(w), WINDOW_HEIGHT(w),
0, 360 * 64);
}
XShapeCombineMask (XtDisplay (w), XtWindow (w), ShapeClip,
0, 0, shape_mask, ShapeSet);
} else
{
/*
* reconfigure the widget to split the availible
* space between the window and the border
*/
if (face_width > face_height)
xwc.border_width = face_height;
else
xwc.border_width = face_width;
xwc.width = w->core.width - xwc.border_width * 2;
xwc.height = w->core.height - xwc.border_width * 2;
XConfigureWindow (XtDisplay (w), XtWindow (w),
CWWidth|CWHeight|CWBorderWidth,
&xwc);
SetTransform (&w->clock.t,
0, xwc.width,
xwc.height, 0,
-WINDOW_WIDTH(w)/2, WINDOW_WIDTH(w)/2,
-WINDOW_HEIGHT(w)/2, WINDOW_HEIGHT(w)/2);
}
}
static void Realize (gw, valueMask, attrs)
Widget gw;
XtValueMask *valueMask;
XSetWindowAttributes *attrs;
{
ClockWidget w = (ClockWidget)gw;
if (w->clock.backing_store != Always + WhenMapped + NotUseful) {
attrs->backing_store = w->clock.backing_store;
*valueMask |= CWBackingStore;
}
if (w->clock.transparent)
{
attrs->background_pixel = w->clock.minute;
*valueMask |= CWBackPixel;
*valueMask &= ~CWBackPixmap;
}
XtCreateWindow( gw, (unsigned)InputOutput, (Visual *)CopyFromParent,
*valueMask, attrs );
if (!w->clock.transparent)
Resize (w);
new_time ((XtPointer) gw, 0);
}
static void Destroy (gw)
Widget gw;
{
ClockWidget w = (ClockWidget)gw;
if (w->clock.interval_id) XtRemoveTimeOut (w->clock.interval_id);
if (! w->clock.transparent) {
XtReleaseGC(gw, w->clock.minuteGC);
XtReleaseGC(gw, w->clock.hourGC);
XtReleaseGC(gw, w->clock.jewelGC);
XtReleaseGC(gw, w->clock.eraseGC);
}
if (w->clock.shapeGC)
XFreeGC(XtDisplay(gw), w->clock.shapeGC);
if (w->clock.shape_mask)
XFreePixmap (XtDisplay (w), w->clock.shape_mask);
}
/* ARGSUSED */
static void Redisplay(gw, event, region)
Widget gw;
XEvent *event;
Region region;
{
ClockWidget w;
w = (ClockWidget) gw;
if (!w->clock.transparent)
{
paint_jewel (w, XtWindow (w), w->clock.jewelGC);
paint_hands (w, XtWindow (w), w->clock.minuteGC, w->clock.hourGC);
}
}
/*
* routines to draw the hands and jewel
*/
#ifndef PI /* may be found in <math.h> */
# define PI (3.14159265358979323846)
#endif
/*
* converts a number from 0..1 representing a clockwise radial distance
* from the 12 oclock position to a radian measure of the counter-clockwise
* distance from the 3 oclock position
*/
static double
clock_to_angle (clock)
double clock;
{
if (clock >= .75)
clock -= 1.0;
return -2.0 * PI * clock + PI / 2.0;
}
/* ARGSUSED */
static void new_time (client_data, id)
XtPointer client_data;
XtIntervalId *id; /* unused */
{
ClockWidget w = (ClockWidget)client_data;
Time_t now;
struct tm *tm;
if (!w->clock.transparent)
if (w->clock.polys_valid) {
paint_hands (w, XtWindow (w), w->clock.eraseGC, w->clock.eraseGC);
check_jewel (w, XtWindow (w), w->clock.jewelGC);
}
(void) time (&now);
tm = localtime (&now);
if (tm->tm_hour >= 12)
tm->tm_hour -= 12;
w->clock.hour_angle = clock_to_angle ((((double) tm->tm_hour) +
((double) tm->tm_min) / 60.0) / 12.0);
w->clock.minute_angle =
clock_to_angle (((double) tm->tm_min) / 60.0);
/*
* add the timeout before painting the hands, that may
* take a while and we'd like the clock to keep up
* with time changes.
*/
w->clock.interval_id =
XtAppAddTimeOut (XtWidgetToApplicationContext((Widget) w),
(60 - tm->tm_sec) * 1000, new_time, client_data);
compute_hands (w);
if (w->clock.transparent)
Resize (w);
else
paint_hands (w, XtWindow (w), w->clock.minuteGC, w->clock.hourGC);
} /* new_time */
paint_jewel (w, d, gc)
ClockWidget w;
Drawable d;
GC gc;
{
if (JEWEL_SIZE(w) > 0.0)
{
TFillArc (XtDisplay (w), d, gc, &w->clock.t,
JEWEL_X(w) - JEWEL_SIZE(w) / 2.0,
JEWEL_Y(w) - JEWEL_SIZE(w) / 2.0,
JEWEL_SIZE(w), JEWEL_SIZE(w), 0, 360 * 64);
}
}
#define sqr(x) ((x)*(x))
/*
* check to see if the polygon intersects the circular jewel
*/
check_jewel_poly (w, poly)
ClockWidget w;
TPoint poly[POLY_SIZE];
{
double a2, b2, c2, d2;
double x, y, size;
int i;
if (JEWEL_SIZE(w) > 0.0)
{
x = JEWEL_X(w);
y = JEWEL_Y(w);
size = JEWEL_SIZE(w);
/*
* check each side of the polygon to see if the
* distance from the line to the center of the
* circular jewel is less than the radius.
*/
for (i = 0; i < POLY_SIZE-1; i++) {
a2 = sqr (poly[i].x - x) + sqr (poly[i].y - y);
b2 = sqr (poly[i+1].x - x) + sqr (poly[i+1].y - y);
c2 = sqr (poly[i].x - poly[i+1].x) + sqr (poly[i].y - poly[i+1].y);
d2 = a2 + b2 - c2;
if (d2 <= sqr (size) &&
a2 <= 2 * c2 && b2 <= 2 * c2 ||
a2 <= sqr (size) ||
b2 <= sqr (size))
return 1;
}
}
return 0;
}
check_jewel (w, d, gc)
ClockWidget w;
Drawable d;
GC gc;
{
if (!w->clock.polys_valid || JEWEL_SIZE(w) <= 0.0)
return;
if ((MINUTE_LENGTH(w) >= (JEWEL_Y(w) - JEWEL_SIZE(w)/2.0) &&
check_jewel_poly (w, w->clock.minute_poly)) ||
(HOUR_LENGTH(w) >= (JEWEL_Y(w) - JEWEL_SIZE(w)/2.0) &&
check_jewel_poly (w, w->clock.minute_poly)))
{
paint_jewel (w, d, gc);
}
}
/*
* A hand is a rectangle with a triangular cap at the far end.
* This is represented with a five sided polygon.
*/
compute_hand (w, a, l, width, poly)
ClockWidget w;
double a, l, width;
TPoint poly[POLY_SIZE];
{
double c, s;
c = cos(a);
s = sin(a);
poly[0].x = c * l;
poly[0].y = s * l;
poly[1].x = (l - width) * c - s * width;
poly[1].y = (l - width) * s + c * width;
poly[2].x = (-width) * c - s * width;
poly[2].y = (-width) * s + c * width;
poly[3].x = (-width) * c + s * width;
poly[3].y = (-width) * s - c * width;
poly[4].x = (l - width) * c + s * width;
poly[4].y = (l - width) * s - c * width;
poly[5].x = poly[0].x;
poly[5].y = poly[0].y;
}
compute_hands (w)
ClockWidget w;
{
compute_hand (w, w->clock.minute_angle,
MINUTE_LENGTH(w), MINUTE_WIDTH(w), w->clock.minute_poly);
compute_hand (w, w->clock.hour_angle,
HOUR_LENGTH(w), HOUR_WIDTH(w), w->clock.hour_poly);
w->clock.polys_valid = 1;
}
paint_hand (w, d, gc, poly)
ClockWidget w;
Drawable d;
GC gc;
TPoint poly[POLY_SIZE];
{
TFillPolygon (XtDisplay (w), d, gc, &w->clock.t, poly, POLY_SIZE,
Convex, CoordModeOrigin);
}
paint_hands (w, d, minute_gc, hour_gc)
ClockWidget w;
Drawable d;
GC minute_gc, hour_gc;
{
if (w->clock.polys_valid) {
paint_hand (w, d, hour_gc, w->clock.hour_poly);
paint_hand (w, d, minute_gc, w->clock.minute_poly);
}
}
Clock.h 0 → 100644
View file @ c4bc1693
/* $Xorg: Clock.h,v 1.4 2001/02/09 02:05:33 xorgcvs Exp $ */
/*
Copyright 1993, 1998 The Open Group
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.
The above copyright notice and this permission notice shall be included
in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR
OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
OTHER DEALINGS IN THE SOFTWARE.
Except as contained in this notice, the name of The Open Group shall
not be used in advertising or otherwise to promote the sale, use or
other dealings in this Software without prior written authorization