Logo Search packages:      
Sourcecode: xclock version File versions  Download package

Clock.c

/* $Xorg: Clock.c,v 1.4 2001/02/09 02:05:39 xorgcvs Exp $ */
/* $XdotOrg: xc/programs/xclock/Clock.c,v 1.3 2004/10/30 20:33:44 alanc Exp $ */

/***********************************************************

Copyright 1987, 1988, 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.


Copyright 1987, 1988 by Digital Equipment Corporation, Maynard, 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 name of Digital 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.

******************************************************************/
/*
 * Copyright 2004 Sun Microsystems, Inc.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * 3. Neither the name of Sun Microsystems, Inc. nor the names of its
 *    contributors may be used to endorse or promote products derived from
 *    this software without specific prior written permission.
 *
 * This software is provided "AS IS," without a warranty of any kind.
 *
 * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
 * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
 * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED.
 * SUN AND ITS LICENSORS SHALL NOT BE LIABLE FOR ANY DAMAGES OR
 * LIABILITIES  SUFFERED BY LICENSEE AS A RESULT OF  OR RELATING TO USE,
 * MODIFICATION OR DISTRIBUTION OF THE SOFTWARE OR ITS DERIVATIVES.
 * IN NO EVENT WILL SUN OR ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE,
 * PROFIT OR DATA, OR FOR DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL,
 * INCIDENTAL OR PUNITIVE DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE
 * THEORY OF LIABILITY, ARISING OUT OF THE USE OF OR INABILITY TO USE
 * SOFTWARE, EVEN IF SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
 *
 * Authors:  I18N - Steve Swales - March 2000
 *         bgpixmap - Alan Coopersmith (as part of STSF project) - Sept. 2001
 */
/* $XFree86: xc/programs/xclock/Clock.c,v 3.25 2003/07/04 16:24:30 eich Exp $ */

#ifdef HAVE_CONFIG_H
# include "config.h"
#endif

#include <X11/Xlib.h>
#include <X11/StringDefs.h>
#include <X11/IntrinsicP.h>
#include "ClockP.h"
#include <X11/Xosdefs.h>
#include <stdio.h>
#include <X11/Xos.h>
#include <X11/Xaw/XawInit.h>

#if defined(XawVersion) && (XawVersion >= 7000002L)
#define USE_XAW_PIXMAP_CVT
#else
#include <X11/xpm.h>
#endif

#include <time.h>
#define Time_t time_t

#ifdef XKB
#include <X11/extensions/XKBbells.h>
#endif

#ifndef NO_I18N
#include <stdlib.h> /* for getenv() */
#include <locale.h>
extern Boolean no_locale; /* if True, use old (unlocalized) behaviour */
#endif

      
/* Private Definitions */

#define VERTICES_IN_HANDS     6     /* to draw triangle */
#define PI              3.14159265358979
#define TWOPI                 (2. * PI)

#define MINOR_TICK_FRACT      95
#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 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) XtOffsetOf(ClockRec, clock.field)
#define goffset(field) XtOffsetOf(WidgetRec, core.field)

static XtResource resources[] = {
    {XtNwidth, XtCWidth, XtRDimension, sizeof(Dimension),
      goffset(width), XtRImmediate, (XtPointer) 0},
    {XtNheight, XtCHeight, XtRDimension, sizeof(Dimension),
      goffset(height), XtRImmediate, (XtPointer) 0},
    {XtNupdate, XtCInterval, XtRInt, sizeof(int), 
        offset(update), XtRImmediate, (XtPointer) 60 },
#ifndef XRENDER
    {XtNforeground, XtCForeground, XtRPixel, sizeof(Pixel),
        offset(fgpixel), XtRString, XtDefaultForeground},
#endif
    {XtNhand, XtCForeground, XtRPixel, sizeof(Pixel),
        offset(Hdpixel), XtRString, XtDefaultForeground},
    {XtNhighlight, XtCForeground, XtRPixel, sizeof(Pixel),
        offset(Hipixel), XtRString, XtDefaultForeground},
    {XtNutime, XtCBoolean, XtRBoolean, sizeof(Boolean),
      offset(utime), XtRImmediate, (XtPointer) FALSE},
    {XtNanalog, XtCBoolean, XtRBoolean, sizeof(Boolean),
        offset(analog), XtRImmediate, (XtPointer) TRUE},
    {XtNtwentyfour, XtCBoolean, XtRBoolean, sizeof(Boolean),
        offset(twentyfour), XtRImmediate, (XtPointer) TRUE},
    {XtNbrief, XtCBoolean, XtRBoolean, sizeof(Boolean),
        offset(brief), XtRImmediate, (XtPointer) FALSE},
    {XtNstrftime, XtCString, XtRString, sizeof(String),
        offset(strftime), XtRString, ""},
    {XtNchime, XtCBoolean, XtRBoolean, sizeof(Boolean),
      offset(chime), XtRImmediate, (XtPointer) FALSE },
    {XtNpadding, XtCMargin, XtRInt, sizeof(int),
        offset(padding), XtRImmediate, (XtPointer) 8},
    {XtNfont, XtCFont, XtRFontStruct, sizeof(XFontStruct *),
        offset(font), XtRString, XtDefaultFont},
#ifndef NO_I18N
     {XtNfontSet, XtCFontSet, XtRFontSet, sizeof(XFontSet),
        offset(fontSet), XtRString, XtDefaultFontSet,},   
#endif
    {XtNbackingStore, XtCBackingStore, XtRBackingStore, sizeof (int),
      offset (backing_store), XtRString, "default"},
#ifdef XRENDER
    {XtNrender, XtCBoolean, XtRBoolean, sizeof(Boolean),
      offset(render), XtRImmediate, (XtPointer) TRUE },
    {XtNbuffer, XtCBoolean, XtRBoolean, sizeof(Boolean),
      offset(buffer), XtRImmediate, (XtPointer) TRUE },
    {XtNsharp, XtCBoolean, XtRBoolean, sizeof(Boolean),
      offset(sharp), XtRImmediate, (XtPointer) FALSE },
    {XtNforeground, XtCForeground, XtRXftColor, sizeof(XftColor),
        offset(fg_color), XtRString, XtDefaultForeground},
    {XtNhourColor, XtCForeground, XtRXftColor, sizeof(XftColor),
      offset(hour_color), XtRString, XtDefaultForeground},
    {XtNminuteColor, XtCForeground, XtRXftColor, sizeof(XftColor),
      offset(min_color), XtRString, XtDefaultForeground},
    {XtNsecondColor, XtCForeground, XtRXftColor, sizeof(XftColor),
      offset(sec_color), XtRString, XtDefaultForeground},
    {XtNmajorColor, XtCForeground, XtRXftColor, sizeof(XftColor),
      offset(major_color), XtRString, XtDefaultForeground},
    {XtNminorColor, XtCForeground, XtRXftColor, sizeof(XftColor),
      offset(minor_color), XtRString, XtDefaultForeground},
    {XtNface, XtCFace, XtRXftFont, sizeof (XftFont *),
      offset (face), XtRString, ""},
#endif
};

#undef offset
#undef goffset

static void ClassInitialize ( void );
static void Initialize ( Widget request, Widget new, ArgList args, 
                   Cardinal *num_args );
static void Realize ( Widget gw, XtValueMask *valueMask, 
                  XSetWindowAttributes *attrs );
static void Destroy ( Widget gw );
static void Resize ( Widget gw );
static void Redisplay ( Widget gw, XEvent *event, Region region );
static void clock_tic ( XtPointer client_data, XtIntervalId *id );
static void erase_hands ( ClockWidget w, struct tm *tm );
static void ClockAngle ( int tick_units, double *sinp, double *cosp );
static void DrawLine ( ClockWidget w, Dimension blank_length, 
                   Dimension length, int tick_units );
static void DrawHand ( ClockWidget w, Dimension length, Dimension width, 
                   int tick_units );
static void DrawSecond ( ClockWidget w, Dimension length, Dimension width, 
                   Dimension offset, int tick_units );
static void SetSeg ( ClockWidget w, int x1, int y1, int x2, int y2 );
static void DrawClockFace ( ClockWidget w );
static int clock_round ( double x );
static Boolean SetValues ( Widget gcurrent, Widget grequest, Widget gnew, 
                     ArgList args, Cardinal *num_args );

ClockClassRec clockClassRec = {
    { /* core fields */
    /* superclass       */    (WidgetClass) &simpleClassRec,
    /* 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        */    NULLQUARK,
    /* compress_motion        */    TRUE,
    /* compress_exposure      */    XtExposeCompressMaximal,
    /* 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
    },
    { /* simple fields */
    /* change_sensitive         */      XtInheritChangeSensitive
    },
    { /* clock fields */
    /* ignore                   */      0
    }
};

WidgetClass clockWidgetClass = (WidgetClass) &clockClassRec;

/****************************************************************
 *
 * Private Procedures
 *
 ****************************************************************/
#ifndef USE_XAW_PIXMAP_CVT
static void CvtStringToPixmap(
    XrmValue*           args,
    Cardinal*           num_args,
    XrmValuePtr         fromVal,
    XrmValuePtr         toVal
    )
{
    static Pixmap pmap;
    Pixmap shapemask;
    char *name = (char *)fromVal->addr;
    Screen *screen;
    Display *dpy;

    if (*num_args != 1)
     XtErrorMsg("wrongParameters","cvtStringToPixmap","XtToolkitError",
             "String to pixmap conversion needs screen argument",
              (String *)NULL, (Cardinal *)NULL);

    if (strcmp(name, "None") == 0) {
        pmap = None;
    } else { 
      screen = *((Screen **) args[0].addr);
      dpy = DisplayOfScreen(screen);

      XpmReadFileToPixmap(dpy, RootWindowOfScreen(screen), name, &pmap,
        &shapemask, NULL);
    }

    (*toVal).size = sizeof(Pixmap); 
    (*toVal).addr = (XPointer) &pmap ;
}
#endif

#ifdef XRENDER
XtConvertArgRec xftColorConvertArgs[] = {
    {XtWidgetBaseOffset, (XtPointer)XtOffsetOf(WidgetRec, core.screen),
     sizeof(Screen *)},
    {XtWidgetBaseOffset, (XtPointer)XtOffsetOf(WidgetRec, core.colormap),
     sizeof(Colormap)}
};

#define     donestr(type, value, tstr) \
      {                                         \
          if (toVal->addr != NULL) {                        \
            if (toVal->size < sizeof(type)) {         \
                toVal->size = sizeof(type);                 \
                XtDisplayStringConversionWarning(dpy,       \
                  (char*) fromVal->addr, tstr);       \
                return False;                   \
            }                                   \
            *(type*)(toVal->addr) = (value);          \
          }                                     \
          else {                                \
            static type static_val;                   \
            static_val = (value);                     \
            toVal->addr = (XPointer)&static_val;            \
          }                                     \
          toVal->size = sizeof(type);                       \
          return True;                          \
      }

static void
XmuFreeXftColor (XtAppContext app, XrmValuePtr toVal, XtPointer closure,
             XrmValuePtr args, Cardinal *num_args)
{
    Screen  *screen;
    Colormap      colormap;
    XftColor      *color;
    
    if (*num_args != 2)
    {
      XtAppErrorMsg (app,
                   "freeXftColor", "wrongParameters",
                   "XtToolkitError",
                   "Freeing an XftColor requires screen and colormap arguments",
                   (String *) NULL, (Cardinal *)NULL);
      return;
    }

    screen = *((Screen **) args[0].addr);
    colormap = *((Colormap *) args[1].addr);
    color = (XftColor *) toVal->addr;
    XftColorFree (DisplayOfScreen (screen),
              DefaultVisual (DisplayOfScreen (screen),
                         XScreenNumberOfScreen (screen)),
              colormap, color);
}
    
static Boolean
XmuCvtStringToXftColor(Display *dpy,
                   XrmValue *args, Cardinal *num_args,
                   XrmValue *fromVal, XrmValue *toVal,
                   XtPointer *converter_data)
{
    char        *spec;
    XRenderColor    renderColor;
    XftColor          xftColor;
    Screen      *screen;
    Colormap          colormap;
    
    if (*num_args != 2)
    {
      XtAppErrorMsg (XtDisplayToApplicationContext (dpy),
                   "cvtStringToXftColor", "wrongParameters",
                   "XtToolkitError",
                   "String to render color conversion needs screen and colormap arguments",
                   (String *) NULL, (Cardinal *)NULL);
      return False;
    }

    screen = *((Screen **) args[0].addr);
    colormap = *((Colormap *) args[1].addr);

    spec = (char *) fromVal->addr;
    if (strcasecmp (spec, XtDefaultForeground) == 0)
    {
      renderColor.red = 0;
      renderColor.green = 0;
      renderColor.blue = 0;
      renderColor.alpha = 0xffff;
    }
    else if (strcasecmp (spec, XtDefaultBackground) == 0)
    {
      renderColor.red = 0xffff;
      renderColor.green = 0xffff;
      renderColor.blue = 0xffff;
      renderColor.alpha = 0xffff;
    }
    else if (!XRenderParseColor (dpy, spec, &renderColor))
      return False;
    if (!XftColorAllocValue (dpy, 
                       DefaultVisual (dpy,
                                  XScreenNumberOfScreen (screen)),
                       colormap,
                       &renderColor,
                       &xftColor))
      return False;
    
    donestr (XftColor, xftColor, XtRXftColor);
}

static void
XmuFreeXftFont (XtAppContext app, XrmValuePtr toVal, XtPointer closure,
            XrmValuePtr args, Cardinal *num_args)
{
    Screen  *screen;
    XftFont *font;
    
    if (*num_args != 1)
    {
      XtAppErrorMsg (app,
                   "freeXftFont", "wrongParameters",
                   "XtToolkitError",
                   "Freeing an XftFont requires screen argument",
                   (String *) NULL, (Cardinal *)NULL);
      return;
    }

    screen = *((Screen **) args[0].addr);
    font = *((XftFont **) toVal->addr);
    if (font)
      XftFontClose (DisplayOfScreen (screen), font);
}

static Boolean
XmuCvtStringToXftFont(Display *dpy,
                  XrmValue *args, Cardinal *num_args,
                  XrmValue *fromVal, XrmValue *toVal,
                  XtPointer *converter_data)
{
    char    *name;
    XftFont *font;
    Screen  *screen;
    
    if (*num_args != 1)
    {
      XtAppErrorMsg (XtDisplayToApplicationContext (dpy),
                   "cvtStringToXftFont", "wrongParameters",
                   "XtToolkitError",
                   "String to XftFont conversion needs screen argument",
                   (String *) NULL, (Cardinal *)NULL);
      return False;
    }

    screen = *((Screen **) args[0].addr);
    name = (char *) fromVal->addr;
    
    font = XftFontOpenName (dpy,
                      XScreenNumberOfScreen (screen),
                      name);
    if (font)
    {
      donestr (XftFont *, font, XtRXftFont);
    }
    XtDisplayStringConversionWarning(dpy, (char *) fromVal->addr, XtRXftFont);
    return False;
}

XtConvertArgRec xftFontConvertArgs[] = {
    {XtWidgetBaseOffset, (XtPointer)XtOffsetOf(WidgetRec, core.screen),
     sizeof(Screen *)},
};

#endif

static void 
ClassInitialize(void)
{
#ifdef USE_XAW_PIXMAP_CVT
    XawInitializeWidgetSet();
#else 
    static XtConvertArgRec scrnConvertArg[] = {
      {XtBaseOffset, (XtPointer) XtOffset(Widget, core.screen), 
       sizeof(Screen *)}
    };
    XtAddConverter( XtRString, XtRPixmap, CvtStringToPixmap, 
                      scrnConvertArg, XtNumber(scrnConvertArg));
#endif
    XtAddConverter( XtRString, XtRBackingStore, XmuCvtStringToBackingStore,
                NULL, 0 );
#ifdef XRENDER
    XtSetTypeConverter (XtRString, XtRXftColor, 
                  XmuCvtStringToXftColor, 
                  xftColorConvertArgs, XtNumber(xftColorConvertArgs),
                  XtCacheByDisplay, XmuFreeXftColor);
    XtSetTypeConverter (XtRString, XtRXftFont,
                  XmuCvtStringToXftFont,
                  xftFontConvertArgs, XtNumber(xftFontConvertArgs),
                  XtCacheByDisplay, XmuFreeXftFont);
#endif
}

static char *
TimeString (ClockWidget w, struct tm *tm)
{
   if (w->clock.brief)
   {
      if (w->clock.twentyfour)
      {
        static char brief[6];
        sprintf (brief, "%02d:%02d", tm->tm_hour, tm->tm_min);
        return brief;
      }
      else
      {
       static char brief[9];
       int hour = tm->tm_hour % 12;
       if (!hour) hour = 12;
       sprintf (brief, "%02d:%02d %cM", hour, tm->tm_min,
          tm->tm_hour >= 12 ? 'P' : 'A');
       return brief;
      }
   }
   else if (w->clock.utime)
   {
      static char utime[35];
      Time_t tsec;
      tsec = time(NULL);
      sprintf (utime, "%10lu seconds since Epoch", (unsigned long)tsec);
      return utime;
   } else if (*w->clock.strftime) {
     /*Note: this code is probably excessively paranoid 
       about buffer overflow.  The extra size 10 padding
       is also meant as a further guard against programmer 
       error, although it is a little controversial*/
     static char ctime[STRFTIME_BUFF_SIZE+10];
     ctime[0] = ctime[STRFTIME_BUFF_SIZE] = '\0';
     if (0 < strftime (ctime, STRFTIME_BUFF_SIZE-1,w->clock.strftime, tm)) {
       ctime[STRFTIME_BUFF_SIZE-1] = '\0';
       return ctime;
     } else {
       return asctime (tm);
     }
   }
   else if (w->clock.twentyfour)
      return asctime (tm);
   else
   {
      static char long12[28];
      strftime(long12, sizeof long12, "%a %b %d %I:%M:%S %p %Y", tm);
      return long12;
   }
}

/* ARGSUSED */
static void 
Initialize (Widget request, Widget new, ArgList args, Cardinal *num_args)
{
    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;
       Time_t time_value;
       int len;

#ifndef NO_I18N 
       w->clock.utf8 = False;

       if (!no_locale) {
         char *time_locale = setlocale(LC_TIME, NULL);

         if (strstr(time_locale, "UTF-8") || strstr(time_locale, "utf8")) {
             w->clock.utf8 = True;
         }

         /*
          * initialize time format from CFTIME if set, otherwise
          * default to "%c".  This emulates ascftime, but we use
          * strftime so we can limit the string buffer size to
          * avoid possible buffer overflow.
          */
         if ((w->clock.strftime == NULL) || (w->clock.strftime[0] == 0)) {
             w->clock.strftime = getenv("CFTIME");
             if (w->clock.strftime == NULL) {
               w->clock.strftime = "%c";
             }
         }
       }
#endif /* NO_I18N */

       (void) time(&time_value);
       tm = *localtime(&time_value);
       str = TimeString (w, &tm);
       len = strlen(str);
       if (str[len - 1] == '\n') 
         str[--len] = '\0';

#ifdef XRENDER
       if (w->clock.render)
       {
      XGlyphInfo  extents;
#ifndef NO_I18N
      if (w->clock.utf8) 
          XftTextExtentsUtf8 (XtDisplay (w), w->clock.face,
                        (FcChar8 *) str, len, &extents);
      else
#endif
          XftTextExtents8 (XtDisplay (w), w->clock.face,
                       (FcChar8 *) str, len, &extents);
      min_width = extents.xOff + 2 * w->clock.padding;
      min_height = w->clock.face->ascent + w->clock.face->descent +
                 2 * w->clock.padding;
       }
       else
#endif
#ifndef NO_I18N 
       if (!no_locale) {
         XFontSetExtents *fse;

         if(w->clock.fontSet == NULL) {
             char **missing, *default_str;
             int n_missing;
             w->clock.fontSet = XCreateFontSet( XtDisplay(w),
             XtDefaultFontSet,
             &missing,
             &n_missing,
             &default_str);
         }
         if (w->clock.fontSet != NULL)
         {
             /* don't free this... it's freed with the XFontSet. */
             fse = XExtentsOfFontSet(w->clock.fontSet);
             
             min_width = XmbTextEscapement(w->clock.fontSet,str,
             len)
             + 2 * w->clock.padding;
             min_height = fse->max_logical_extent.height +
             3 * w->clock.padding;
         }
       }
       else
#endif /* NO_I18N */
       {
         if (w->clock.font == NULL)
             w->clock.font = XQueryFont( XtDisplay(w),
                                 XGContextFromGC(
                                  DefaultGCOfScreen(XtScreen(w))) );
         min_width = XTextWidth(w->clock.font, str, len) +
             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 = ClockFgPixel (w);
    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 | GCGraphicsExposures;
    myXGCV.foreground = w->core.background_pixel;
    if (w->core.background_pixmap != XtUnspecifiedPixmap) {
      myXGCV.tile = w->core.background_pixmap;
      myXGCV.fill_style = FillTiled;
      valuemask |= (GCTile | GCFillStyle);
    }
    myXGCV.graphics_exposures = False;
    w->clock.EraseGC = XtGetGC((Widget)w, valuemask, &myXGCV);
    valuemask &= ~(GCTile | GCFillStyle);

    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;
    memset (&w->clock.otm, '\0', sizeof (w->clock.otm));
#ifdef XRENDER
    {
      int major, minor;
      
      if (XRenderQueryVersion (XtDisplay (w), &major, &minor) &&
          (major > 0 ||
           (major == 0 && minor >= 4)))
      {
          w->clock.can_polygon = True;
      }
      else
          w->clock.can_polygon = False;
    }
    w->clock.pixmap = 0;
    w->clock.draw = 0;
    w->clock.damage.x = 0;
    w->clock.damage.y = 0;
    w->clock.damage.height = 0;
    w->clock.damage.width = 0;
#endif
}

#ifdef XRENDER
static void
RenderPrepare (ClockWidget  w, XftColor *color)
{
    if (!w->clock.draw)
    {
      Drawable    d = XtWindow (w);
      if (w->clock.buffer)
      {
          if (!w->clock.pixmap)
          {
            Arg arg[1];
            w->clock.pixmap = XCreatePixmap (XtDisplay (w), d,
                                     w->core.width,
                                     w->core.height,
                                     w->core.depth);
            arg[0].name = XtNbackgroundPixmap;
            arg[0].value = 0;
            XtSetValues ((Widget) w, arg, 1);
          }
          d = w->clock.pixmap;
      }
          
      w->clock.draw = XftDrawCreate (XtDisplay (w), d,
                               DefaultVisual (XtDisplay (w),
                                          DefaultScreen(XtDisplay (w))),
                               w->core.colormap);
      w->clock.picture = XftDrawPicture (w->clock.draw);
    }
    if (color)
      w->clock.fill_picture = XftDrawSrcPicture (w->clock.draw, color);
}

static void
RenderClip (ClockWidget w)
{
    Region  r;
    Drawable      d;
    
    RenderPrepare (w, 0);
    if (w->clock.buffer)
      d = w->clock.pixmap;
    else
      d = XtWindow (w);
    XFillRectangle (XtDisplay (w), d, w->clock.EraseGC,
                w->clock.damage.x,
                w->clock.damage.y,
                w->clock.damage.width,
                w->clock.damage.height);
    r = XCreateRegion ();
    XUnionRectWithRegion (&w->clock.damage,
                    r, r);
    XftDrawSetClip (w->clock.draw, r);
    XDestroyRegion (r);
}

static void
RenderTextBounds (ClockWidget w, char *str, int off, int len, 
              XRectangle *bounds, int *xp, int *yp)
{
    XGlyphInfo  head, tail;
    int         x, y;

#ifndef NO_I18N
    if (w->clock.utf8)
    {
      XftTextExtentsUtf8 (XtDisplay (w), w->clock.face, 
                      (FcChar8 *) str, off, &head);
      XftTextExtentsUtf8 (XtDisplay (w), w->clock.face, 
                      (FcChar8 *) str + off, len - off, &tail);
    }
    else
#endif
    {
      XftTextExtents8 (XtDisplay (w), w->clock.face, (FcChar8 *) str, 
                   off, &head);
      XftTextExtents8 (XtDisplay (w), w->clock.face, (FcChar8 *) str + off, 
                   len - off, &tail);
    }

    /*
     * Compute position of tail
     */
    x = w->clock.padding + head.xOff;
    y = w->clock.face->ascent + w->clock.padding + head.yOff;
    /*
     * Compute bounds of tail, pad a bit as the bounds aren't exact
     */
    bounds->x = x - tail.x - 1;
    bounds->y = y - tail.y - 1;
    bounds->width = tail.width + 2;
    bounds->height = tail.height + 2;
    if (xp) *xp = x;
    if (yp) *yp = y;
}

static void
RenderUpdateRectBounds (XRectangle *damage, XRectangle *bounds)
{
    int         x1 = bounds->x;
    int         y1 = bounds->y;
    int         x2 = bounds->x + bounds->width; 
    int         y2 = bounds->y + bounds->height; 
    int         d_x1 = damage->x;
    int         d_y1 = damage->y;
    int         d_x2 = damage->x + damage->width; 
    int         d_y2 = damage->y + damage->height; 

    if (x1 == x2) 
    { 
      x1 = d_x1; 
      x2 = d_x2; 
    }
    else
    {
      if (d_x1 < x1) x1 = d_x1;
      if (d_x2 > x2) x2 = d_x2;
    }
    if (y1 == y2)
    {
      y1 = d_y1;
      y2 = d_y2;
    }
    else
    {
      if (d_y1 < y1) y1 = d_y1;
      if (d_y2 > y2) y2 = d_y2;
    }

    bounds->x = x1;
    bounds->y = y1;
    bounds->width = x2 - x1;
    bounds->height = y2 - y1;
}

static Boolean
RenderRectIn (XRectangle *rect, XRectangle *bounds)
{
    int         x1 = bounds->x;
    int         y1 = bounds->y;
    int         x2 = bounds->x + bounds->width; 
    int         y2 = bounds->y + bounds->height; 
    int         r_x1 = rect->x;
    int         r_y1 = rect->y;
    int         r_x2 = rect->x + rect->width; 
    int         r_y2 = rect->y + rect->height; 
    
    return r_x1 < x2 && x1 < r_x2 && r_y1 < y2 && y1 < r_y2;
}

#define LINE_WIDTH  0.01
#include <math.h>

#define XCoord(x,w) ((x) * (w)->clock.x_scale + (w)->clock.x_off)
#define YCoord(y,w) ((y) * (w)->clock.y_scale + (w)->clock.y_off)

static void
RenderUpdateBounds (XPointDouble *points, int npoints, XRectangle *bounds)
{
    int         x1 = bounds->x;
    int         y1 = bounds->y;
    int         x2 = bounds->x + bounds->width; 
    int         y2 = bounds->y + bounds->height; 
    
    while (npoints--)
    {
      int       r_x1 = points[0].x;
      int       r_y1 = points[0].y;
      int       r_x2 = points[0].x + 1;
      int       r_y2 = points[0].y + 1;

      if (x1 == x2)
          x2 = x1 = r_x1;
      if (y1 == y2)
          y2 = y1 = r_y1;
      if (r_x1 < x1) x1 = r_x1;
      if (r_y1 < y1) y1 = r_y1;
      if (r_x2 > x2) x2 = r_x2;
      if (r_y2 > y2) y2 = r_y2;
      points++;
    }
    bounds->x = x1;
    bounds->y = y1;
    bounds->width = x2 - x1;
    bounds->height = y2 - y1;
}

static Boolean
RenderCheckBounds (XPointDouble *points, int npoints, XRectangle *bounds)
{
    int         x1 = bounds->x;
    int         y1 = bounds->y;
    int         x2 = bounds->x + bounds->width; 
    int         y2 = bounds->y + bounds->height; 
    
    while (npoints--)
    {
      if (x1 <= points->x && points->x <= x2 &&
          y1 <= points->y && points->y <= y2)
          return True;
      points++;
    }
    return False;
}

static void
RenderUpdate (ClockWidget w)
{
    if (w->clock.buffer && w->clock.pixmap)
    {
      XCopyArea (XtDisplay (w), w->clock.pixmap,
               XtWindow (w), w->clock.EraseGC,
               w->clock.damage.x, w->clock.damage.y,
               w->clock.damage.width, w->clock.damage.height,
               w->clock.damage.x, w->clock.damage.y);
    }
}

static void
RenderResetBounds (XRectangle *bounds)
{
    bounds->x = 0;
    bounds->y = 0;
    bounds->width = 0;
    bounds->height = 0;
}

static void
RenderLine (ClockWidget w, XDouble x1, XDouble y1, XDouble x2, XDouble y2,
          XftColor *color,
          Boolean draw)
{
    XPointDouble    poly[4];
    XDouble     dx = (x2 - x1);
    XDouble     dy = (y2 - y1);
    XDouble     len = sqrt (dx*dx + dy*dy);
    XDouble     ldx = (LINE_WIDTH/2.0) * dy / len;
    XDouble     ldy = (LINE_WIDTH/2.0) * dx / len;

    poly[0].x = XCoord (x1 + ldx, w);
    poly[0].y = YCoord (y1 - ldy, w);
    
    poly[1].x = XCoord (x2 + ldx, w);
    poly[1].y = YCoord (y2 - ldy, w);
    
    poly[2].x = XCoord (x2 - ldx, w);
    poly[2].y = YCoord (y2 + ldy, w);
    
    poly[3].x = XCoord (x1 - ldx, w);
    poly[3].y = YCoord (y1 + ldy, w);

    RenderUpdateBounds (poly, 4, &w->clock.damage);
    if (draw)
    {
      if (RenderCheckBounds (poly, 4, &w->clock.damage))
      {
          RenderPrepare (w, color);
          XRenderCompositeDoublePoly (XtDisplay (w),
                              PictOpOver,
                              w->clock.fill_picture,
                              w->clock.picture,
                              w->clock.mask_format,
                              0, 0, 0, 0, poly, 4, EvenOddRule);
      }
    }
    else
      RenderUpdateBounds (poly, 4, &w->clock.damage);
}

static void
RenderRotate (ClockWidget w, XPointDouble *out, double x, double y, double s, double c)
{
    out->x = XCoord (x * c - y * s, w);
    out->y = YCoord (y * c + x * s, w);
}

static void
RenderHand (ClockWidget w, int tick_units, int size, XftColor *color,
          Boolean draw)
{
    double      c, s;
    XPointDouble    poly[3];
    double      outer_x;
    double      inner_y;

    ClockAngle (tick_units, &c, &s);
    s = -s;

    /* compute raw positions */
    outer_x = size / 100.0;
    inner_y = HAND_WIDTH_FRACT / 100.0;

    /* rotate them into position */
    RenderRotate (w, &poly[0], outer_x, 0.0, s, c);
    RenderRotate (w, &poly[1], -inner_y, inner_y, s, c);
    RenderRotate (w, &poly[2], -inner_y, -inner_y, s, c);
    
    if (draw)
    {
      if (RenderCheckBounds (poly, 3, &w->clock.damage))
      {
          RenderPrepare (w, color);
          XRenderCompositeDoublePoly (XtDisplay (w),
                              PictOpOver,
                              w->clock.fill_picture,
                              w->clock.picture,
                              w->clock.mask_format,
                              0, 0, 0, 0, poly, 3, EvenOddRule);
      }
    }
    RenderUpdateBounds (poly, 3, &w->clock.damage);
}

static void
RenderHands (ClockWidget w, struct tm *tm, Boolean draw)
{
    RenderHand (w, tm->tm_hour * 300 + tm->tm_min*5, HOUR_HAND_FRACT, &w->clock.hour_color, draw);
    RenderHand (w, tm->tm_min * 60 + tm->tm_sec, MINUTE_HAND_FRACT, &w->clock.min_color, draw);
}

static void
RenderSec (ClockWidget w, struct tm *tm, Boolean draw)
{
    double      c, s;
    XPointDouble    poly[10];
    double      inner_x, middle_x, outer_x, far_x;
    double      middle_y;
    double      line_y;

    ClockAngle (tm->tm_sec * 60, &c, &s);
    
    s = -s;
    
    /*
     * Compute raw positions
     */
    line_y = LINE_WIDTH;
    inner_x = (MINUTE_HAND_FRACT / 100.0);
    middle_x = ((SECOND_HAND_FRACT + MINUTE_HAND_FRACT) / 200.0);
    outer_x = (SECOND_HAND_FRACT / 100.0);
    far_x = (MINOR_TICK_FRACT / 100.0);
    middle_y = (SECOND_WIDTH_FRACT / 100.0);
    
    /*
     * Rotate them into position
     */
    RenderRotate (w, &poly[0], -line_y, line_y, s, c);
    RenderRotate (w, &poly[1], inner_x, line_y, s, c);
    RenderRotate (w, &poly[2], middle_x, middle_y, s, c);
    RenderRotate (w, &poly[3], outer_x, line_y, s, c);
    RenderRotate (w, &poly[4], far_x, line_y, s, c);
    RenderRotate (w, &poly[5], far_x, -line_y, s, c);
    RenderRotate (w, &poly[6], outer_x, -line_y, s, c);
    RenderRotate (w, &poly[7], middle_x, -middle_y, s, c);
    RenderRotate (w, &poly[8], inner_x, -line_y, s, c);
    RenderRotate (w, &poly[9], -line_y, -line_y, s, c);

    if (draw)
    {
      if (RenderCheckBounds (poly, 10, &w->clock.damage))
      {
          RenderPrepare (w, &w->clock.sec_color);
          XRenderCompositeDoublePoly (XtDisplay (w),
                              PictOpOver,
                              w->clock.fill_picture,
                              w->clock.picture,
                              w->clock.mask_format,
                              0, 0, 0, 0, poly, 10, EvenOddRule);
      }
    }
    else
    {
      RenderUpdateBounds (poly, 10, &w->clock.damage);
    }
}

#endif

static void 
Realize(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;
     }
     (*clockWidgetClass->core_class.superclass->core_class.realize)
       (gw, valueMask, attrs);
     Resize(gw);
}

static void 
Destroy(Widget gw)
{
     ClockWidget w = (ClockWidget) gw;
     if (w->clock.interval_id) XtRemoveTimeOut (w->clock.interval_id);
#ifdef RENDER
    if (w->clock.picture)
      XRenderFreePicture (dpy, w->clock.picture);
    if (w->clock.fill_picture)
      XRenderFreePicture (dpy, w->clock.fill_picture);
#endif
     XtReleaseGC (gw, w->clock.myGC);
     XtReleaseGC (gw, w->clock.HighGC);
     XtReleaseGC (gw, w->clock.HandGC);
     XtReleaseGC (gw, w->clock.EraseGC);
}

static void 
Resize(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 = (int)(SECOND_HAND_FRACT * w->clock.radius) / 100;
        w->clock.minute_hand_length = (int)(MINUTE_HAND_FRACT * w->clock.radius) / 100;
        w->clock.hour_hand_length = (int)(HOUR_HAND_FRACT * w->clock.radius) / 100;
        w->clock.hand_width = (int)(HAND_WIDTH_FRACT * w->clock.radius) / 100;
        w->clock.second_hand_width = (int)(SECOND_WIDTH_FRACT * w->clock.radius) / 100;

        w->clock.centerX = w->core.width / 2;
        w->clock.centerY = w->core.height / 2;
    }
#ifdef XRENDER
    w->clock.x_scale = 0.45 * w->core.width;
    w->clock.y_scale = 0.45 * w->core.height;
    w->clock.x_off = 0.5 * w->core.width;
    w->clock.y_off = 0.5 * w->core.height;
    if (w->clock.pixmap)
    {
      XFreePixmap (XtDisplay (w), w->clock.pixmap);
      w->clock.pixmap = 0;
      if (w->clock.draw)
      {
          XftDrawDestroy (w->clock.draw);
          w->clock.draw = 0;
      }
      w->clock.picture = 0;
    }
#endif
}

/* ARGSUSED */
static void 
Redisplay(Widget gw, XEvent *event, Region region)
{
    ClockWidget w = (ClockWidget) gw;
    if (w->clock.analog) {
#ifdef XRENDER
      if (w->clock.render && w->clock.can_polygon)
          XClipBox (region, &w->clock.damage);
      else
#endif
      {
          if (w->clock.numseg != 0)
            erase_hands (w, (struct tm *) 0);
          DrawClockFace(w);
      }
    } else {
#ifdef XRENDER
      if (w->clock.render)
          XClipBox (region, &w->clock.damage);
#endif
      w->clock.prev_time_string[0] = '\0';
    }
    clock_tic((XtPointer)w, (XtIntervalId)0);
}

/* ARGSUSED */
static void 
clock_tic(XtPointer client_data, XtIntervalId *id)
{
        ClockWidget w = (ClockWidget)client_data;    
      struct tm tm; 
      Time_t      time_value;
      struct timeval    tv;
      char  *time_ptr;
        register Display *dpy = XtDisplay(w);
        register Window win = XtWindow(w);

      X_GETTIMEOFDAY (&tv);
      if (id || !w->clock.interval_id)
          w->clock.interval_id =
            XtAppAddTimeOut( XtWidgetToApplicationContext( (Widget) w),
                        (w->clock.update - 1) * 1000 + (1000000 - tv.tv_usec)/1000, clock_tic, (XtPointer)w );
      time_value = tv.tv_sec;
      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;
#ifdef XKB
            if (tm.tm_min==0) {
                XkbStdBell(dpy,win,50,XkbBI_ClockChimeHour);
                XkbStdBell(dpy,win,50,XkbBI_RepeatingLastBell);
            }
            else {
                XkbStdBell(dpy,win,50,XkbBI_ClockChimeHalf);
            }
#else
            XBell(dpy, 50);   
            if (tm.tm_min == 0)
              XBell(dpy, 50);
#endif
          }
      }
      if( w->clock.analog == FALSE ) {
          int     clear_from = w->core.width;
          int i, len, prev_len;

          time_ptr = TimeString (w, &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++);

#ifdef XRENDER
          if (w->clock.render)
          {
            XRectangle  old_tail, new_tail, head;
            int       x, y;

            RenderTextBounds (w, w->clock.prev_time_string, i, prev_len,
                          &old_tail, 0, 0);
            RenderUpdateRectBounds (&old_tail, &w->clock.damage);
            RenderTextBounds (w, time_ptr, i, len,
                          &new_tail, 0, 0);
            RenderUpdateRectBounds (&new_tail, &w->clock.damage);
            
            while (i)
            {
                RenderTextBounds (w, time_ptr, 0, i, &head, 0, 0);
                if (!RenderRectIn (&head, &w->clock.damage))
                  break;
                i--;
            }
            RenderTextBounds (w, time_ptr, i, len, &new_tail, &x, &y);
            RenderClip (w);
            RenderPrepare (w, 0);
#ifndef NO_I18N
            if (w->clock.utf8) {
                XftDrawStringUtf8 (w->clock.draw,
                            &w->clock.fg_color,
                            w->clock.face,
                            x, y,
                            (FcChar8 *) time_ptr + i, len - i);

            } 
            else
#endif 
            {
                XftDrawString8 (w->clock.draw,
                            &w->clock.fg_color,
                            w->clock.face,
                            x, y,
                            (FcChar8 *) time_ptr + i, len - i);
            }
            RenderUpdate (w);
            RenderResetBounds (&w->clock.damage);
          }
          else
#endif
#ifndef NO_I18N
          if(!no_locale) {
            if(0 < len) {
                XFontSetExtents *fse
                  = XExtentsOfFontSet(w->clock.fontSet);
                
                XmbDrawImageString(dpy,win,w->clock.fontSet,w->clock.myGC,
                               (2+w->clock.padding +
                              (i?XmbTextEscapement(w->clock.fontSet,
                                               time_ptr,i):0)),
                               2+w->clock.padding+fse->max_logical_extent.height,
                               time_ptr+i,len-i
                  );
                /*            
                 * Clear any left over bits
                 */
                clear_from = XmbTextEscapement (w->clock.fontSet,time_ptr,
                                        len) + 2+w->clock.padding;
            }
          } else
#endif /* NO_I18N */
          {
            XDrawImageString (dpy, win, w->clock.myGC,
                          (1+w->clock.padding +
                           XTextWidth (w->clock.font, time_ptr, i)),
                          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 < (int)w->core.width)
            XClearArea (dpy, win,
                clear_from, 0, w->core.width - clear_from, w->core.height,
                False);
#if defined(HAS_STRLCAT) || defined(HAVE_STRLCPY)
          strlcpy (w->clock.prev_time_string+i, time_ptr+i,
                 sizeof(w->clock.prev_time_string)-i);
#else
          strncpy (w->clock.prev_time_string+i, time_ptr+i,
                 sizeof(w->clock.prev_time_string)-i);
          w->clock.prev_time_string[sizeof(w->clock.prev_time_string)-1] = 0;
#endif
      } 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;

#ifdef XRENDER
                  if (w->clock.render && w->clock.can_polygon)
                  {
                      w->clock.mask_format = XRenderFindStandardFormat (XtDisplay (w),
                                                            w->clock.sharp ?
                                                            PictStandardA1 :
                                                            PictStandardA8);
                      /*
                       * Compute repaint area
                       */
                      if (tm.tm_min != w->clock.otm.tm_min ||
                        tm.tm_hour != w->clock.otm.tm_hour ||
                        tm.tm_sec != w->clock.otm.tm_sec)
                      {
                        RenderHands (w, &w->clock.otm, False);
                        RenderHands (w, &tm, False);
                      }
                      if (w->clock.show_second_hand &&
                        tm.tm_sec != w->clock.otm.tm_sec)
                      {
                        RenderSec (w, &w->clock.otm, False);
                        RenderSec (w, &tm, False);
                      }
                      if (w->clock.damage.width && 
                        w->clock.damage.height)
                      {
                        RenderClip (w);
                        DrawClockFace (w);
                        RenderHands (w, &tm, True);
                        if (w->clock.show_second_hand == TRUE)
                            RenderSec (w, &tm, True);
                      }
                      w->clock.otm = tm;
                      RenderUpdate (w);
                      RenderResetBounds (&w->clock.damage);
                      return;
                  }
#endif

                  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;
                      /*
                       * 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,
                        tm.tm_min * 60
                      );
                      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,
                        tm.tm_hour * 300 + tm.tm_min * 5
                      );
                      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,
                        tm.tm_sec * 60
                      );
                      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 void
erase_hands(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);
          }
      }
    }
}

static float const Sines[] = {
0.000000, 0.001745, 0.003490, 0.005235, 0.006981, 0.008726, 0.010471, 0.012217,
0.013962, 0.015707, 0.017452, 0.019197, 0.020942, 0.022687, 0.024432, 0.026176,
0.027921, 0.029666, 0.031410, 0.033155, 0.034899, 0.036643, 0.038387, 0.040131,
0.041875, 0.043619, 0.045362, 0.047106, 0.048849, 0.050592, 0.052335, 0.054078,
0.055821, 0.057564, 0.059306, 0.061048, 0.062790, 0.064532, 0.066273, 0.068015,
0.069756, 0.071497, 0.073238, 0.074978, 0.076719, 0.078459, 0.080198, 0.081938,
0.083677, 0.085416, 0.087155, 0.088894, 0.090632, 0.092370, 0.094108, 0.095845,
0.097582, 0.099319, 0.101056, 0.102792, 0.104528, 0.106264, 0.107999, 0.109734,
0.111468, 0.113203, 0.114937, 0.116670, 0.118403, 0.120136, 0.121869, 0.123601,
0.125333, 0.127064, 0.128795, 0.130526, 0.132256, 0.133986, 0.135715, 0.137444,
0.139173, 0.140901, 0.142628, 0.144356, 0.146083, 0.147809, 0.149535, 0.151260,
0.152985, 0.154710, 0.156434, 0.158158, 0.159881, 0.161603, 0.163325, 0.165047,
0.166768, 0.168489, 0.170209, 0.171929, 0.173648, 0.175366, 0.177084, 0.178802,
0.180519, 0.182235, 0.183951, 0.185666, 0.187381, 0.189095, 0.190808, 0.192521,
0.194234, 0.195946, 0.197657, 0.199367, 0.201077, 0.202787, 0.204496, 0.206204,
0.207911, 0.209618, 0.211324, 0.213030, 0.214735, 0.216439, 0.218143, 0.219846,
0.221548, 0.223250, 0.224951, 0.226651, 0.228350, 0.230049, 0.231747, 0.233445,
0.235142, 0.236838, 0.238533, 0.240228, 0.241921, 0.243615, 0.245307, 0.246999,
0.248689, 0.250380, 0.252069, 0.253757, 0.255445, 0.257132, 0.258819, 0.260504,
0.262189, 0.263873, 0.265556, 0.267238, 0.268919, 0.270600, 0.272280, 0.273959,
0.275637, 0.277314, 0.278991, 0.280666, 0.282341, 0.284015, 0.285688, 0.287360,
0.289031, 0.290702, 0.292371, 0.294040, 0.295708, 0.297374, 0.299040, 0.300705,
0.302369, 0.304033, 0.305695, 0.307356, 0.309016, 0.310676, 0.312334, 0.313992,
0.315649, 0.317304, 0.318959, 0.320612, 0.322265, 0.323917, 0.325568, 0.327217,
0.328866, 0.330514, 0.332161, 0.333806, 0.335451, 0.337095, 0.338737, 0.340379,
0.342020, 0.343659, 0.345298, 0.346935, 0.348572, 0.350207, 0.351841, 0.353474,
0.355106, 0.356737, 0.358367, 0.359996, 0.361624, 0.363251, 0.364876, 0.366501,
0.368124, 0.369746, 0.371367, 0.372987, 0.374606, 0.376224, 0.377840, 0.379456,
0.381070, 0.382683, 0.384295, 0.385906, 0.387515, 0.389123, 0.390731, 0.392337,
0.393941, 0.395545, 0.397147, 0.398749, 0.400349, 0.401947, 0.403545, 0.405141,
0.406736, 0.408330, 0.409923, 0.411514, 0.413104, 0.414693, 0.416280, 0.417867,
0.419452, 0.421035, 0.422618, 0.424199, 0.425779, 0.427357, 0.428935, 0.430511,
0.432085, 0.433659, 0.435231, 0.436801, 0.438371, 0.439939, 0.441505, 0.443071,
0.444635, 0.446197, 0.447759, 0.449318, 0.450877, 0.452434, 0.453990, 0.455544,
0.457097, 0.458649, 0.460199, 0.461748, 0.463296, 0.464842, 0.466386, 0.467929,
0.469471, 0.471011, 0.472550, 0.474088, 0.475624, 0.477158, 0.478691, 0.480223,
0.481753, 0.483282, 0.484809, 0.486335, 0.487859, 0.489382, 0.490903, 0.492423,
0.493941, 0.495458, 0.496973, 0.498487, 0.499999, 0.501510, 0.503019, 0.504527,
0.506033, 0.507538, 0.509041, 0.510542, 0.512042, 0.513541, 0.515038, 0.516533,
0.518027, 0.519519, 0.521009, 0.522498, 0.523985, 0.525471, 0.526955, 0.528438,
0.529919, 0.531398, 0.532876, 0.534352, 0.535826, 0.537299, 0.538770, 0.540240,
0.541708, 0.543174, 0.544639, 0.546101, 0.547563, 0.549022, 0.550480, 0.551936,
0.553391, 0.554844, 0.556295, 0.557745, 0.559192, 0.560638, 0.562083, 0.563526,
0.564967, 0.566406, 0.567843, 0.569279, 0.570713, 0.572145, 0.573576, 0.575005,
0.576432, 0.577857, 0.579281, 0.580702, 0.582122, 0.583541, 0.584957, 0.586372,
0.587785, 0.589196, 0.590605, 0.592013, 0.593418, 0.594822, 0.596224, 0.597625,
0.599023, 0.600420, 0.601815, 0.603207, 0.604599, 0.605988, 0.607375, 0.608761,
0.610145, 0.611527, 0.612907, 0.614285, 0.615661, 0.617035, 0.618408, 0.619779,
0.621147, 0.622514, 0.623879, 0.625242, 0.626603, 0.627963, 0.629320, 0.630675,
0.632029, 0.633380, 0.634730, 0.636078, 0.637423, 0.638767, 0.640109, 0.641449,
0.642787, 0.644123, 0.645457, 0.646789, 0.648119, 0.649448, 0.650774, 0.652098,
0.653420, 0.654740, 0.656059, 0.657375, 0.658689, 0.660001, 0.661311, 0.662620,
0.663926, 0.665230, 0.666532, 0.667832, 0.669130, 0.670426, 0.671720, 0.673012,
0.674302, 0.675590, 0.676875, 0.678159, 0.679441, 0.680720, 0.681998, 0.683273,
0.684547, 0.685818, 0.687087, 0.688354, 0.689619, 0.690882, 0.692143, 0.693401,
0.694658, 0.695912, 0.697165, 0.698415, 0.699663, 0.700909, 0.702153, 0.703394,
0.704634, 0.705871, 0.707106, 
};
static float const Cosines[] = {
1.000000, 0.999998, 0.999993, 0.999986, 0.999975, 0.999961, 0.999945, 0.999925,
0.999902, 0.999876, 0.999847, 0.999815, 0.999780, 0.999742, 0.999701, 0.999657,
0.999610, 0.999559, 0.999506, 0.999450, 0.999390, 0.999328, 0.999262, 0.999194,
0.999122, 0.999048, 0.998970, 0.998889, 0.998806, 0.998719, 0.998629, 0.998536,
0.998440, 0.998341, 0.998239, 0.998134, 0.998026, 0.997915, 0.997801, 0.997684,
0.997564, 0.997440, 0.997314, 0.997185, 0.997052, 0.996917, 0.996778, 0.996637,
0.996492, 0.996345, 0.996194, 0.996041, 0.995884, 0.995724, 0.995561, 0.995396,
0.995227, 0.995055, 0.994880, 0.994702, 0.994521, 0.994337, 0.994150, 0.993960,
0.993767, 0.993571, 0.993372, 0.993170, 0.992965, 0.992757, 0.992546, 0.992331,
0.992114, 0.991894, 0.991671, 0.991444, 0.991215, 0.990983, 0.990747, 0.990509,
0.990268, 0.990023, 0.989776, 0.989525, 0.989272, 0.989015, 0.988756, 0.988493,
0.988228, 0.987959, 0.987688, 0.987413, 0.987136, 0.986855, 0.986572, 0.986285,
0.985996, 0.985703, 0.985407, 0.985109, 0.984807, 0.984503, 0.984195, 0.983885,
0.983571, 0.983254, 0.982935, 0.982612, 0.982287, 0.981958, 0.981627, 0.981292,
0.980955, 0.980614, 0.980271, 0.979924, 0.979575, 0.979222, 0.978867, 0.978508,
0.978147, 0.977783, 0.977415, 0.977045, 0.976672, 0.976296, 0.975916, 0.975534,
0.975149, 0.974761, 0.974370, 0.973975, 0.973578, 0.973178, 0.972775, 0.972369,
0.971961, 0.971549, 0.971134, 0.970716, 0.970295, 0.969872, 0.969445, 0.969015,
0.968583, 0.968147, 0.967709, 0.967267, 0.966823, 0.966376, 0.965925, 0.965472,
0.965016, 0.964557, 0.964095, 0.963630, 0.963162, 0.962691, 0.962217, 0.961741,
0.961261, 0.960779, 0.960293, 0.959805, 0.959313, 0.958819, 0.958322, 0.957822,
0.957319, 0.956813, 0.956304, 0.955793, 0.955278, 0.954760, 0.954240, 0.953716,
0.953190, 0.952661, 0.952129, 0.951594, 0.951056, 0.950515, 0.949972, 0.949425,
0.948876, 0.948323, 0.947768, 0.947210, 0.946649, 0.946085, 0.945518, 0.944948,
0.944376, 0.943800, 0.943222, 0.942641, 0.942057, 0.941470, 0.940880, 0.940288,
0.939692, 0.939094, 0.938493, 0.937888, 0.937281, 0.936672, 0.936059, 0.935444,
0.934825, 0.934204, 0.933580, 0.932953, 0.932323, 0.931691, 0.931055, 0.930417,
0.929776, 0.929132, 0.928485, 0.927836, 0.927183, 0.926528, 0.925870, 0.925209,
0.924546, 0.923879, 0.923210, 0.922538, 0.921863, 0.921185, 0.920504, 0.919821,
0.919135, 0.918446, 0.917754, 0.917060, 0.916362, 0.915662, 0.914959, 0.914253,
0.913545, 0.912834, 0.912120, 0.911403, 0.910683, 0.909961, 0.909236, 0.908508,
0.907777, 0.907044, 0.906307, 0.905568, 0.904827, 0.904082, 0.903335, 0.902585,
0.901832, 0.901077, 0.900318, 0.899557, 0.898794, 0.898027, 0.897258, 0.896486,
0.895711, 0.894934, 0.894154, 0.893371, 0.892585, 0.891797, 0.891006, 0.890212,
0.889416, 0.888617, 0.887815, 0.887010, 0.886203, 0.885393, 0.884580, 0.883765,
0.882947, 0.882126, 0.881303, 0.880477, 0.879648, 0.878817, 0.877982, 0.877146,
0.876306, 0.875464, 0.874619, 0.873772, 0.872922, 0.872069, 0.871213, 0.870355,
0.869494, 0.868631, 0.867765, 0.866896, 0.866025, 0.865151, 0.864274, 0.863395,
0.862513, 0.861629, 0.860742, 0.859852, 0.858959, 0.858064, 0.857167, 0.856267,
0.855364, 0.854458, 0.853550, 0.852640, 0.851726, 0.850811, 0.849892, 0.848971,
0.848048, 0.847121, 0.846193, 0.845261, 0.844327, 0.843391, 0.842452, 0.841510,
0.840566, 0.839619, 0.838670, 0.837718, 0.836764, 0.835807, 0.834847, 0.833885,
0.832921, 0.831954, 0.830984, 0.830012, 0.829037, 0.828060, 0.827080, 0.826098,
0.825113, 0.824126, 0.823136, 0.822144, 0.821149, 0.820151, 0.819152, 0.818149,
0.817144, 0.816137, 0.815127, 0.814115, 0.813100, 0.812083, 0.811063, 0.810041,
0.809016, 0.807989, 0.806960, 0.805928, 0.804893, 0.803856, 0.802817, 0.801775,
0.800731, 0.799684, 0.798635, 0.797583, 0.796529, 0.795473, 0.794414, 0.793353,
0.792289, 0.791223, 0.790155, 0.789084, 0.788010, 0.786935, 0.785856, 0.784776,
0.783693, 0.782608, 0.781520, 0.780430, 0.779337, 0.778243, 0.777145, 0.776046,
0.774944, 0.773840, 0.772733, 0.771624, 0.770513, 0.769399, 0.768283, 0.767165,
0.766044, 0.764921, 0.763796, 0.762668, 0.761538, 0.760405, 0.759271, 0.758134,
0.756995, 0.755853, 0.754709, 0.753563, 0.752414, 0.751264, 0.750111, 0.748955,
0.747798, 0.746638, 0.745475, 0.744311, 0.743144, 0.741975, 0.740804, 0.739631,
0.738455, 0.737277, 0.736097, 0.734914, 0.733729, 0.732542, 0.731353, 0.730162,
0.728968, 0.727772, 0.726574, 0.725374, 0.724171, 0.722967, 0.721760, 0.720551,
0.719339, 0.718126, 0.716910, 0.715692, 0.714472, 0.713250, 0.712026, 0.710799,
0.709570, 0.708339, 0.707106, 
};

static void 
ClockAngle(int tick_units, double *sinp, double *cosp)
{
    int reduced, upper;

    reduced = tick_units % 450;
    upper = tick_units / 450;
    if (upper & 1)
      reduced = 450 - reduced;
    if ((upper + 1) & 2) {
      *sinp = Cosines[reduced];
      *cosp = Sines[reduced];
    } else {
      *sinp = Sines[reduced];
      *cosp = Cosines[reduced];
    }
    if (upper >= 2 && upper < 6)
      *cosp = -*cosp;
    if (upper >= 4)
      *sinp = -*sinp;
}

/*
 * DrawLine - Draws a line.
 *
 * blank_length is the distance from the center which the line begins.
 * length is the maximum length of the hand.
 * Tick_units is a number between zero and 12*60 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(ClockWidget w, Dimension blank_length, Dimension length, 
       int tick_units)
{
      double dblank_length = (double)blank_length, dlength = (double)length;
      double cosangle, sinangle;
      int cx = w->clock.centerX, cy = w->clock.centerY, x1, y1, x2, y2;

      /*
       *  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)
       *
       */
      ClockAngle(tick_units, &sinangle, &cosangle);

      /* 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.
 * Tick_units is a number between zero and 12*60 indicating
 * how far around the circle (clockwise) from high noon.
 *
 */
static void 
DrawHand(ClockWidget w, Dimension length, Dimension width, int tick_units)
{

      double cosangle, sinangle;
      register double ws, wc;
      Position x, y, x1, y1, x2, y2;

      /*
       *  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)
       *
       */
      ClockAngle(tick_units, &sinangle, &cosangle);
      /*
       * Order of points when drawing the hand.
       *
       *          1,4
       *          / \
       *           /   \
       *          /     \
       *        2 ------- 3
       */
      wc = width * cosangle;
      ws = width * sinangle;
      SetSeg(w,
             x = w->clock.centerX + clock_round(length * sinangle),
             y = w->clock.centerY - clock_round(length * cosangle),
             x1 = w->clock.centerX - clock_round(ws + wc), 
             y1 = w->clock.centerY + clock_round(wc - ws));  /* 1 ---- 2 */
      /* 2 */
      SetSeg(w, x1, y1, 
             x2 = w->clock.centerX - clock_round(ws - wc), 
             y2 = w->clock.centerY + clock_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.
 * Tick_units is a number between zero and 12*60 indicating
 * how far around the circle (clockwise) from high noon.
 *
 */
static void 
DrawSecond(ClockWidget w, Dimension length, Dimension width, 
         Dimension offset, int tick_units)
{

      double cosangle, sinangle;
      register double ms, mc, ws, wc;
      register int mid;
      Position x, y;

      /*
       *  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)
       *
       */
      ClockAngle(tick_units, &sinangle, &cosangle);
      /*
       * Order of points when drawing the hand.
       *
       *          1,5
       *          / \
       *           /   \
       *          /     \
       *        2<       >4
       *          \     /
       *           \   /
       *          \ /
       *    -      3
       *    |
       *    |
       *   offset
       *    |
       *    |
       *    -      + center
       */

      mid = (int) (length + offset) / 2;
      mc = mid * cosangle;
      ms = mid * sinangle;
      wc = width * cosangle;
      ws = width * sinangle;
      /*1 ---- 2 */
      SetSeg(w,
             x = w->clock.centerX + clock_round(length * sinangle),
             y = w->clock.centerY - clock_round(length * cosangle),
             w->clock.centerX + clock_round(ms - wc),
             w->clock.centerY - clock_round(mc + ws) );
      SetSeg(w, w->clock.centerX + clock_round(offset *sinangle),
             w->clock.centerY - clock_round(offset * cosangle), /* 2-----3 */
             w->clock.centerX + clock_round(ms + wc), 
             w->clock.centerY - clock_round(mc - ws));
      w->clock.segbuffptr->x = x;
      w->clock.segbuffptr++->y = y;
      w->clock.numseg ++;
}

static void 
SetSeg(ClockWidget w, int x1, int y1, int x2, int 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(ClockWidget w)
{
      register int i;
      register int delta = (int)(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++)
      {
#ifdef XRENDER
          if (w->clock.render && w->clock.can_polygon)
          {
            double      s, c;
            XDouble     x1, y1, x2, y2;
            XftColor    *color;
            ClockAngle (i * 60, &s, &c);
            x1 = c;
            y1 = s;
            if (i % 5)
            {
                x2 = c * (MINOR_TICK_FRACT / 100.0);
                y2 = s * (MINOR_TICK_FRACT / 100.0);
                color = &w->clock.minor_color;
            }
            else
            {
                x2 = c * (SECOND_HAND_FRACT / 100.0);
                y2 = s * (SECOND_HAND_FRACT / 100.0);
                color = &w->clock.major_color;
            }
            RenderLine (w, x1, y1, x2, y2, color, True);
          }
          else
#endif
          {
            DrawLine(w, ( (i % 5) == 0 ? 
                       w->clock.second_hand_length :
                       (w->clock.radius - delta) ),
                   w->clock.radius, i * 60);
          }
      }
#ifdef XRENDER
      if (w->clock.render && w->clock.can_polygon)
          return;
#endif
      /*
       * 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 
clock_round(double x)
{
      return(x >= 0.0 ? (int)(x + .5) : (int)(x - .5));
}

#ifdef XRENDER
static Boolean
sameColor (XftColor *old, XftColor *new)
{
    if (old->color.red != new->color.red) return False;
    if (old->color.green != new->color.green) return False;
    if (old->color.blue != new->color.blue) return False;
    if (old->color.alpha != new->color.alpha) return False;
    return True;
}
#endif

/* ARGSUSED */
static Boolean 
SetValues(Widget gcurrent, Widget grequest, Widget gnew, 
        ArgList args, Cardinal *num_args)
{
      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( (Widget) new))
            new->clock.interval_id = XtAppAddTimeOut( 
                                         XtWidgetToApplicationContext(gnew),
                               new->clock.update*1000,
                                 clock_tic, (XtPointer)gnew);

        new->clock.show_second_hand =(new->clock.update <= SECOND_HAND_TIME);
        if (new->clock.show_second_hand != current->clock.show_second_hand)
          redisplay = TRUE;
      }

      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;

#ifndef NO_I18N
       if (new->clock.fontSet != current->clock.fontSet)
         redisplay = TRUE;
#endif

      if ((ClockFgPixel(new) != ClockFgPixel (current))
          || (new->core.background_pixel != current->core.background_pixel)) {
          valuemask = GCForeground | GCBackground | GCFont | GCLineWidth;
        myXGCV.foreground = ClockFgPixel (new);
        myXGCV.background = new->core.background_pixel;
          myXGCV.font = new->clock.font->fid;
        myXGCV.line_width = 0;
        XtReleaseGC (gcurrent, 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.Hipixel;
          myXGCV.font = new->clock.font->fid;
        myXGCV.line_width = 0;
        XtReleaseGC (gcurrent, 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.Hdpixel;
        XtReleaseGC (gcurrent, 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 | GCGraphicsExposures;
        myXGCV.foreground = new->core.background_pixel;
        myXGCV.line_width = 0;
        myXGCV.graphics_exposures = False;
        XtReleaseGC (gcurrent, current->clock.EraseGC);
        new->clock.EraseGC = XtGetGC((Widget)gcurrent, valuemask, &myXGCV);
        redisplay = TRUE;
        }
#ifdef XRENDER
     if (new->clock.face != current->clock.face)
      redisplay = TRUE;
     if (!sameColor (&new->clock.hour_color, &current->clock.fg_color) ||
       !sameColor (&new->clock.hour_color, &current->clock.hour_color) ||
       !sameColor (&new->clock.min_color, &current->clock.min_color) ||
       !sameColor (&new->clock.sec_color, &current->clock.sec_color) ||
       !sameColor (&new->clock.major_color, &current->clock.major_color) ||
       !sameColor (&new->clock.minor_color, &current->clock.minor_color))
      redisplay = True;
    if (new->clock.sharp != current->clock.sharp)
      redisplay = True;
    if (new->clock.render != current->clock.render)
      redisplay = True;
    if (new->clock.buffer != current->clock.buffer)
    {
      if (new->clock.pixmap)
      {
          XFreePixmap (XtDisplay (new), new->clock.pixmap);
          new->clock.pixmap = 0;
      }
      if (new->clock.draw)
      {
          XftDrawDestroy (new->clock.draw);
          new->clock.draw = 0;
      }
      new->clock.picture = 0;
    }
#endif
     return (redisplay);

}

Generated by  Doxygen 1.6.0   Back to index