wmclock/wmclock.c

   1 /* wmclock.c: a dockable clock applet for Window Maker
   2  * created 1999-Apr-09 jmk
   3  *
   4  * by Jim Knoble <jmknoble@pobox.com>
   5  * Copyright (C) 1999 Jim Knoble
   6  *
   7  * Significant portions of this software are derived from asclock by
   8  * Beat Christen <spiff@longstreet.ch>.  Such portions are copyright
   9  * by Beat Christen and the other authors of asclock.
  10  *
  11  * Disclaimer:
  12  *
  13  * The software is provided "as is", without warranty of any kind,
  14  * express or implied, including but not limited to the warranties of
  15  * merchantability, fitness for a particular purpose and
  16  * noninfringement. In no event shall the author(s) be liable for any
  17  * claim, damages or other liability, whether in an action of
  18  * contract, tort or otherwise, arising from, out of or in connection
  19  * with the software or the use or other dealings in the software.
  20  */
  21
  22 #include <sys/select.h>
  23 #include <sys/types.h>
  24 #include <sys/wait.h>
  25 #include <sys/time.h>
  26 #include <stdio.h>
  27 #include <stdlib.h>
  28 #include <string.h>
  29 #include <time.h>
  30 #include <unistd.h>
  31 #include <X11/Xatom.h>
  32 #include <X11/Xlib.h>
  33 #include <X11/xpm.h>
  34 #include <X11/extensions/shape.h>
  35
  36 #include "dynlist.h"
  37
  38 /**********************************************************************/
  39 #define ONLY_SHAPED_WINDOW      1
  40
  41 #define NUM_TIME_POSITIONS      5
  42 #define NUM_X_POSITIONS         11
  43 #define NUM_Y_POSITIONS         4
  44
  45 #define DIGIT_1_X_POS           0
  46 #define DIGIT_2_X_POS           1
  47 #define DIGIT_3_X_POS           3
  48 #define DIGIT_4_X_POS           4
  49 #define DIGIT_Y_POS             0
  50 #define LED_NUM_Y_OFFSET        0
  51 #define LED_THIN_1_X_OFFSET     13
  52 #define LED_NUM_WIDTH           9
  53 #define LED_NUM_HEIGHT          11
  54 #define LED_THIN_1_WIDTH        5
  55
  56 #define COLON_X_POS             2
  57 #define COLON_Y_POS             DIGIT_Y_POS
  58 #define COLON_X_OFFSET          90
  59 #define COLON_Y_OFFSET          0
  60 #define BLANK_X_OFFSET          119
  61 #define BLANK_Y_OFFSET          COLON_Y_OFFSET
  62 #define COLON_WIDTH             3
  63 #define COLON_HEIGHT            11
  64
  65 #define AMPM_X_POS              5
  66 #define AM_X_OFFSET             94
  67 #define AM_Y_OFFSET             5
  68 #define PM_X_OFFSET             107
  69 #define PM_Y_OFFSET             5
  70 #define AM_WIDTH                12
  71 #define AM_HEIGHT               6
  72 #define PM_WIDTH                11
  73 #define PM_HEIGHT               6
  74
  75 #define MONTH_X_POS             10
  76 #define MONTH_Y_POS             3
  77 #define MONTH_X_OFFSET          0
  78 #define MONTH_WIDTH             22
  79 #define MONTH_HEIGHT            6
  80
  81 #define DATE_LEFT_X_POS         7
  82 #define DATE_CENTER_X_POS       8
  83 #define DATE_RIGHT_X_POS        9
  84 #define DATE_Y_POS              2
  85 #define DATE_Y_OFFSET           0
  86 #define DATE_NUM_WIDTH          9
  87 #define DATE_NUM_HEIGHT         13
  88
  89 #define WEEKDAY_X_POS           6
  90 #define WEEKDAY_Y_POS           1
  91 #define WEEKDAY_X_OFFSET        0
  92 #define WEEKDAY_WIDTH           21
  93 #define WEEKDAY_HEIGHT          6
  94
  95 #define OUR_WINDOW_EVENTS       (ExposureMask | ButtonPressMask | StructureNotifyMask)
  96
  97 #define LED_XPM_BRIGHT_LINE_INDEX       3
  98 #define LED_XPM_BRIGHT_CHAR             '+'
  99 #define LED_XPM_DIM_LINE_INDEX          4
 100 #define LED_XPM_DIM_CHAR                '@'
 101
 102 #define DEFAULT_XPM_CLOSENESS   40000
 103
 104 #define DIM_NUMERATOR   5
 105 #define DIM_DENOMINATOR 10
 106 #define makeDimColor(c) (((c) * DIM_NUMERATOR) / DIM_DENOMINATOR)
 107
 108 /**********************************************************************/
 109 #ifndef ONLY_SHAPED_WINDOW
 110 # include "clk.xpm"
 111 #endif /* !ONLY_SHAPED_WINDOW */
 112 #include "month.xpm"
 113 #include "weekday.xpm"
 114 #include "xpm/date.xpm"
 115 #include "xpm/led.xpm"
 116 #include "xpm/mask.xbm"
 117 #include "xpm/mask.xpm"
 118
 119 typedef struct _XpmIcon {
 120     Pixmap        pixmap;
 121     Pixmap        mask;
 122     XpmAttributes attributes;
 123 } XpmIcon;
 124
 125 void showUsage(void);
 126 void showVersion(void);
 127 int buildCommand(char *, char **, int *, int *);
 128 void executeCommand(char *);
 129 void showError(const char *, const char*);
 130 void showFatalError(const char *, const char*);
 131 void GetXpms(void);
 132 int flushExposeEvents(Window);
 133 void redrawWindow(XpmIcon *);
 134 Pixel GetColor(const char *);
 135 int mytime(void);
 136 void showYear(void);
 137 void showTime12(void);
 138 void showTime24(void);
 139 void showTime(void);
 140 char* extractProgName(char *);
 141 int processArgs(int, char **);
 142
 143 /**********************************************************************/
 144 int enable12HourClock = 0;      /* default value is 24h format */
 145 int enableShapedWindow = 1;     /* default value is noshape */
 146 int enableBlinking = 1;         /* default is blinking */
 147 int startIconified = 0;         /* default is not iconified */
 148 int enableYearDisplay = 0;      /* default is to show time, not year */
 149
 150 int timePos12[NUM_TIME_POSITIONS]  = { 5, 14, 24, 28, 37 };
 151 int timePos24[NUM_TIME_POSITIONS]  = { 4,  8, 17, 22, 31 };
 152 /* with shape */
 153 int xPosShaped[NUM_X_POSITIONS] = { 0, 0, 0, 0, 0, 40, 17, 17, 22, 27, 15 };
 154 int yPosShaped[NUM_Y_POSITIONS] = { 3, 21, 30, 45 };
 155
 156 #ifndef ONLY_SHAPED_WINDOW
 157 /* no shape */
 158 int xPosUnshaped[NUM_X_POSITIONS] = { 5, 5, 5, 5, 5, 45, 21, 21, 26, 31, 19 };
 159 int yPosUnshaped[NUM_Y_POSITIONS] = { 7, 25, 34, 49 };
 160 #endif /* !ONLY_SHAPED_WINDOW */
 161
 162 int xPos[NUM_X_POSITIONS];
 163 int yPos[NUM_Y_POSITIONS];
 164
 165 Display    *dpy;
 166 Window     rootWindow;
 167 int        screen;
 168 int        xFd;
 169 fd_set     xFdSet;
 170 int        displayDepth;
 171 XSizeHints sizeHints;
 172 XWMHints   wmHints;
 173 Pixel      bgPixel, fgPixel;
 174 GC         normalGC;
 175 Window     iconWin, win;
 176
 177 char *progName;
 178 char *className = "WMClock";
 179 char *geometry = "";
 180 char *ledColor = "LightSeaGreen";
 181
 182 char *commandToExec = NULL;
 183 char *commandBuf = NULL;
 184 int   commandLength = 0;
 185 int   commandIndex = 0;
 186
 187 char *errColorCells = "not enough free color cells or xpm not found\n";
 188
 189 char *userClockXpm;
 190 char *userMonthXpm;
 191 char *userWeekdayXpm;
 192 int   useUserClockXpm = 0;
 193 int   useUserMonthXpm = 0;
 194 int   useUserWeekdayXpm = 0;
 195
 196 XpmIcon clockBg, led, months, dateNums, weekdays;
 197 XpmIcon visible;
 198
 199 time_t actualTime;
 200 long   actualMinutes;
 201
 202 static struct tm *localTime;
 203
 204 char *usageText[] = {
 205 "Options:",
 206 "    -12                     show 12-hour time (am/pm)",
 207 "    -24                     show 24-hour time",
 208 "    -year                   show year instead of time",
 209 "    -noblink                don't blink",
 210 "    -exe <command>          start <command> on mouse click",
 211 "    -led <color>            use <color> as color of led",
 212 #ifndef ONLY_SHAPED_WINDOW
 213 "    -clockxpm <filename>    get clock background from pixmap in <filename>",
 214 #endif /* !ONLY_SHAPED_WINDOW */
 215 "    -monthxpm <filename>    get month names from pixmap in <filename>",
 216 "    -weekdayxpm <filename>  get weekday names from pixmap in <filename>",
 217 "    -version                display the version",
 218 NULL
 219 };
 220
 221 char *version = VERSION;
 222
 223 /**********************************************************************/
 224 /* Display usage information */
 225 void showUsage(void)
 226 {
 227    char **cpp;
 228
 229    fprintf(stderr, "Usage:  %s [option [option ...]]\n\n", progName);
 230    for (cpp = usageText; *cpp; cpp++)
 231     {
 232        fprintf(stderr, "%s\n", *cpp);
 233     }
 234    fprintf(stderr,"\n");
 235    exit(1);
 236 }
 237
 238 /* Display the program version */
 239 void showVersion()
 240 {
 241    fprintf(stderr, "%s version %s\n", progName, version);
 242    exit(1);
 243 }
 244
 245 /* Build the shell command to execute */
 246 int buildCommand(char *command, char **buf, int *buf_len, int *i)
 247 {
 248    int status;
 249
 250    status = append_string_to_buf(buf, buf_len, i, command);
 251    if (APPEND_FAILURE == status)
 252     {
 253        return (0);
 254     }
 255    status = append_string_to_buf(buf, buf_len, i, " &");
 256    return ((APPEND_FAILURE == status) ? 0 : 1);
 257 }
 258
 259 /* Execute the given shell command */
 260 void executeCommand(char *command)
 261 {
 262    int status;
 263
 264    if (NULL == command)
 265     {
 266        return;
 267     }
 268    status = system(command);
 269
 270    if (-1 == status)
 271     {
 272        perror("system");
 273     }
 274 }
 275
 276 /* Display an error message */
 277 void showError(const char *message, const char *data)
 278 {
 279    fprintf(stderr,"%s: can't %s %s\n", progName, message, data);
 280 }
 281
 282 /* Display an error message and exit */
 283 void showFatalError(const char *message, const char *data)
 284 {
 285    showError(message, data);
 286    exit(1);
 287 }
 288
 289 /* Konvertiere XPMIcons nach Pixmaps */
 290 void GetXpms(void)
 291 {
 292    static char     **clock_xpm;
 293    XColor            color;
 294    XWindowAttributes attributes;
 295    char              ledBright[64];
 296    char              ledDim[64];
 297    int               status;
 298
 299 #ifdef ONLY_SHAPED_WINDOW
 300    clock_xpm = mask_xpm;
 301 #else /* !ONLY_SHAPED_WINDOW */
 302    clock_xpm = enableShapedWindow ? mask_xpm : clk_xpm;
 303 #endif /* ONLY_SHAPED_WINDOW */
 304
 305    /* for the colormap */
 306    XGetWindowAttributes(dpy, rootWindow, &attributes);
 307
 308    /* get user-defined color */
 309    if (!XParseColor(dpy, attributes.colormap, ledColor, &color))
 310     {
 311        showError("parse color", ledColor);
 312     }
 313
 314    sprintf(ledBright, "%c      c #%04X%04X%04X", LED_XPM_BRIGHT_CHAR,
 315            color.red, color.green, color.blue);
 316    led_xpm[LED_XPM_BRIGHT_LINE_INDEX] = &ledBright[0];
 317
 318    color.red   = makeDimColor(color.red);
 319    color.green = makeDimColor(color.green);
 320    color.blue  = makeDimColor(color.blue);
 321    sprintf(&ledDim[0], "%c      c #%04X%04X%04X", LED_XPM_DIM_CHAR,
 322            color.red, color.green, color.blue);
 323    led_xpm[LED_XPM_DIM_LINE_INDEX] = &ledDim[0];
 324
 325    clockBg.attributes.closeness = DEFAULT_XPM_CLOSENESS;
 326    clockBg.attributes.valuemask |=
 327       (XpmReturnPixels | XpmReturnExtensions | XpmCloseness);
 328
 329    if (useUserClockXpm)
 330     {
 331        status = XpmReadFileToPixmap(dpy, rootWindow, userClockXpm,
 332                                     &clockBg.pixmap, &clockBg.mask,
 333                                     &clockBg.attributes);
 334     }
 335    else
 336     {
 337        status = XpmCreatePixmapFromData(dpy, rootWindow, clock_xpm,
 338                                         &clockBg.pixmap, &clockBg.mask,
 339                                         &clockBg.attributes);
 340     }
 341    if (XpmSuccess != status)
 342     {
 343        showFatalError("create clock pixmap:", errColorCells);
 344     }
 345
 346 #ifdef ONLY_SHAPED_WINDOW
 347    visible.attributes.depth  = displayDepth;
 348    visible.attributes.width  = clockBg.attributes.width;
 349    visible.attributes.height = clockBg.attributes.height;
 350    visible.pixmap = XCreatePixmap(dpy, rootWindow, visible.attributes.width,
 351                                   visible.attributes.height,
 352                                   visible.attributes.depth);
 353 #else /* !ONLY_SHAPED_WINDOW */
 354    visible.attributes.closeness = DEFAULT_XPM_CLOSENESS;
 355    visible.attributes.valuemask |=
 356       (XpmReturnPixels | XpmReturnExtensions | XpmCloseness);
 357    status = XpmCreatePixmapFromData(dpy, rootWindow, clk_xpm,
 358                                     &visible.pixmap, &visible.mask,
 359                                     &visible.attributes);
 360 #endif /* ONLY_SHAPED_WINDOW */
 361
 362    led.attributes.closeness = DEFAULT_XPM_CLOSENESS;
 363    led.attributes.valuemask |=
 364       (XpmReturnPixels | XpmReturnExtensions | XpmCloseness);
 365    status = XpmCreatePixmapFromData(dpy, rootWindow, led_xpm,
 366                                     &led.pixmap, &led.mask,
 367                                     &led.attributes);
 368    if (XpmSuccess != status)
 369     {
 370        showFatalError("create led pixmap:", errColorCells);
 371     }
 372
 373    months.attributes.closeness = DEFAULT_XPM_CLOSENESS;
 374    months.attributes.valuemask |=
 375       (XpmReturnPixels | XpmReturnExtensions | XpmCloseness);
 376    if (useUserMonthXpm)
 377     {
 378        status = XpmReadFileToPixmap(dpy, rootWindow, userMonthXpm,
 379                                     &months.pixmap, &months.mask,
 380                                     &months.attributes);
 381     }
 382    else
 383     {
 384        status = XpmCreatePixmapFromData(dpy, rootWindow, month_xpm,
 385                                         &months.pixmap, &months.mask,
 386                                         &months.attributes);
 387     }
 388    if (XpmSuccess != status)
 389     {
 390        showFatalError("create month pixmap:", errColorCells);
 391     }
 392
 393    dateNums.attributes.closeness = DEFAULT_XPM_CLOSENESS;
 394    dateNums.attributes.valuemask |=
 395       (XpmReturnPixels | XpmReturnExtensions | XpmCloseness);
 396    status = XpmCreatePixmapFromData(dpy, rootWindow, date_xpm,
 397                                     &dateNums.pixmap, &dateNums.mask,
 398                                     &dateNums.attributes);
 399    if (XpmSuccess != status)
 400     {
 401        showFatalError("create date pixmap:", errColorCells);
 402     }
 403
 404    weekdays.attributes.closeness = DEFAULT_XPM_CLOSENESS;
 405    weekdays.attributes.valuemask |=
 406       (XpmReturnPixels | XpmReturnExtensions | XpmCloseness);
 407    if (useUserWeekdayXpm)
 408     {
 409        status = XpmReadFileToPixmap(dpy, rootWindow, userWeekdayXpm,
 410                                     &weekdays.pixmap, &weekdays.mask,
 411                                     &weekdays.attributes);
 412     }
 413    else
 414     {
 415        status = XpmCreatePixmapFromData(dpy, rootWindow, weekday_xpm,
 416                                         &weekdays.pixmap, &weekdays.mask,
 417                                         &weekdays.attributes);
 418     }
 419    if (XpmSuccess != status)
 420     {
 421        showFatalError("create weekday pixmap:", errColorCells);
 422     }
 423 }
 424
 425 /* Remove expose events for a specific window from the queue */
 426 int flushExposeEvents(Window w)
 427 {
 428    XEvent dummy;
 429    int    i = 0;
 430
 431    while (XCheckTypedWindowEvent(dpy, w, Expose, &dummy))
 432     {
 433        i++;
 434     }
 435    return(i);
 436 }
 437
 438 /* (Re-)Draw the main window and the icon window */
 439 void redrawWindow(XpmIcon *v)
 440 {
 441    flushExposeEvents(iconWin);
 442    XCopyArea(dpy, v->pixmap, iconWin, normalGC,
 443              0, 0, v->attributes.width, v->attributes.height, 0, 0);
 444    flushExposeEvents(win);
 445    XCopyArea(dpy, v->pixmap, win, normalGC,
 446              0, 0, v->attributes.width, v->attributes.height, 0, 0);
 447 }
 448
 449 /* Get a Pixel for the given color name */
 450 Pixel GetColor(const char *colorName)
 451 {
 452    XColor            color;
 453    XWindowAttributes attributes;
 454
 455    XGetWindowAttributes(dpy, rootWindow, &attributes);
 456    color.pixel = 0;
 457    if (!XParseColor(dpy, attributes.colormap, colorName, &color))
 458     {
 459        showError("parse color", colorName);
 460     }
 461    else if (!XAllocColor(dpy, attributes.colormap, &color))
 462     {
 463        showError("allocate color", colorName);
 464     }
 465    return(color.pixel);
 466 }
 467
 468 /* Fetch the system time and time zone */
 469 int mytime(void)
 470 {
 471    struct timeval  tv;
 472    struct timezone tz;
 473
 474    gettimeofday(&tv, &tz);
 475
 476    return(tv.tv_sec);
 477 }
 478
 479 /* Display the current year in the LED display */
 480 void showYear(void)
 481 {
 482    int year;
 483    int digitXOffset;
 484    int digitYOffset;
 485
 486    year = localTime->tm_year + 1900;
 487
 488    digitYOffset = LED_NUM_Y_OFFSET;
 489    digitXOffset = LED_NUM_WIDTH * (year / 1000);
 490    XCopyArea(dpy, led.pixmap, visible.pixmap, normalGC,
 491              digitXOffset , digitYOffset, LED_NUM_WIDTH, LED_NUM_HEIGHT,
 492              xPos[DIGIT_1_X_POS], yPos[DIGIT_Y_POS]);
 493    digitXOffset = LED_NUM_WIDTH * ((year / 100) % 10);
 494    XCopyArea(dpy, led.pixmap, visible.pixmap, normalGC,
 495              digitXOffset , digitYOffset, LED_NUM_WIDTH, LED_NUM_HEIGHT,
 496              xPos[DIGIT_2_X_POS], yPos[DIGIT_Y_POS]);
 497    digitXOffset = LED_NUM_WIDTH * ((year / 10) % 10);
 498    XCopyArea(dpy, led.pixmap, visible.pixmap, normalGC,
 499              digitXOffset , digitYOffset, LED_NUM_WIDTH, LED_NUM_HEIGHT,
 500              xPos[DIGIT_3_X_POS], yPos[DIGIT_Y_POS]);
 501    digitXOffset = LED_NUM_WIDTH * (year % 10);
 502    XCopyArea(dpy, led.pixmap, visible.pixmap, normalGC,
 503              digitXOffset , digitYOffset, LED_NUM_WIDTH, LED_NUM_HEIGHT,
 504              xPos[DIGIT_4_X_POS], yPos[DIGIT_Y_POS]);
 505 }
 506
 507 /* Display time in twelve-hour mode, with am/pm indicator */
 508 void showTime12(void)
 509 {
 510    int digitXOffset;
 511    int digitYOffset;
 512    int localHour = localTime->tm_hour % 12;
 513
 514    if (0 == localHour)
 515     {
 516        localHour = 12;
 517     }
 518    if (localTime->tm_hour < 12)
 519     {
 520        /* AM */
 521        XCopyArea(dpy, led.pixmap, visible.pixmap, normalGC,
 522                  AM_X_OFFSET, AM_Y_OFFSET, AM_WIDTH, AM_HEIGHT,
 523                  xPos[AMPM_X_POS], yPos[DIGIT_Y_POS] + AM_Y_OFFSET);
 524     }
 525    else
 526     {
 527        /* PM */
 528        XCopyArea(dpy, led.pixmap, visible.pixmap, normalGC,
 529                  PM_X_OFFSET, PM_Y_OFFSET, PM_WIDTH, PM_HEIGHT,
 530                  xPos[AMPM_X_POS], yPos[DIGIT_Y_POS] + PM_Y_OFFSET);
 531     }
 532
 533    digitYOffset = LED_NUM_Y_OFFSET;
 534    if (localHour > 9)
 535     {
 536        digitXOffset = LED_THIN_1_X_OFFSET;
 537        XCopyArea(dpy, led.pixmap, visible.pixmap, normalGC,
 538                  digitXOffset, digitYOffset, LED_THIN_1_WIDTH, LED_NUM_HEIGHT,
 539                  xPos[DIGIT_1_X_POS], yPos[DIGIT_Y_POS]);
 540     }
 541    digitXOffset = LED_NUM_WIDTH * (localHour % 10);
 542    XCopyArea(dpy, led.pixmap, visible.pixmap, normalGC,
 543              digitXOffset, digitYOffset, LED_NUM_WIDTH, LED_NUM_HEIGHT,
 544              xPos[DIGIT_2_X_POS], yPos[DIGIT_Y_POS]);
 545    digitXOffset = LED_NUM_WIDTH * (localTime->tm_min / 10);
 546    XCopyArea(dpy, led.pixmap, visible.pixmap, normalGC,
 547              digitXOffset, digitYOffset, LED_NUM_WIDTH, LED_NUM_HEIGHT,
 548              xPos[DIGIT_3_X_POS], yPos[DIGIT_Y_POS]);
 549    digitXOffset = LED_NUM_WIDTH * (localTime->tm_min % 10);
 550    XCopyArea(dpy, led.pixmap, visible.pixmap, normalGC,
 551              digitXOffset, digitYOffset, LED_NUM_WIDTH, LED_NUM_HEIGHT,
 552              xPos[DIGIT_4_X_POS], yPos[DIGIT_Y_POS]);
 553 }
 554
 555 /* Display time in 24-hour mode, without am/pm indicator */
 556 void showTime24(void)
 557 {
 558    int digitXOffset;
 559    int digitYOffset;
 560
 561    digitYOffset = LED_NUM_Y_OFFSET;
 562    digitXOffset = LED_NUM_WIDTH * (localTime->tm_hour / 10);
 563    XCopyArea(dpy, led.pixmap, visible.pixmap, normalGC,
 564              digitXOffset, digitYOffset, LED_NUM_WIDTH, LED_NUM_HEIGHT,
 565              xPos[DIGIT_1_X_POS], yPos[DIGIT_Y_POS]);
 566    digitXOffset = LED_NUM_WIDTH * (localTime->tm_hour % 10);
 567    XCopyArea(dpy, led.pixmap, visible.pixmap, normalGC,
 568              digitXOffset, digitYOffset, LED_NUM_WIDTH, LED_NUM_HEIGHT,
 569              xPos[DIGIT_2_X_POS], yPos[DIGIT_Y_POS]);
 570    digitXOffset = LED_NUM_WIDTH * (localTime->tm_min / 10);
 571    XCopyArea(dpy, led.pixmap, visible.pixmap, normalGC,
 572              digitXOffset, digitYOffset, LED_NUM_WIDTH, LED_NUM_HEIGHT,
 573              xPos[DIGIT_3_X_POS], yPos[DIGIT_Y_POS]);
 574    digitXOffset = LED_NUM_WIDTH * (localTime->tm_min % 10);
 575    XCopyArea(dpy, led.pixmap, visible.pixmap, normalGC,
 576              digitXOffset, digitYOffset, LED_NUM_WIDTH, LED_NUM_HEIGHT,
 577              xPos[DIGIT_4_X_POS], yPos[DIGIT_Y_POS]);
 578 }
 579
 580 void showTime(void)
 581 {
 582    int xOffset;
 583    int yOffset;
 584
 585    /* Zeit auslesen */
 586    actualTime = mytime();
 587    actualMinutes = actualTime / 60;
 588
 589    localTime = localtime(&actualTime);
 590
 591    /* leere clock holen */
 592    XCopyArea(dpy, clockBg.pixmap, visible.pixmap, normalGC,
 593              0, 0, sizeHints.width, sizeHints.height, 0, 0);
 594
 595    if (enableYearDisplay)
 596     {
 597        showYear();
 598     }
 599    else if (enable12HourClock)
 600     {
 601        showTime12();
 602     }
 603    else
 604     {
 605        showTime24();
 606     }
 607
 608    /* Monat */
 609    xOffset = MONTH_X_OFFSET;
 610    yOffset = MONTH_HEIGHT * (localTime->tm_mon);
 611    XCopyArea(dpy, months.pixmap, visible.pixmap, normalGC,
 612              xOffset, yOffset, MONTH_WIDTH, MONTH_HEIGHT,
 613              xPos[MONTH_X_POS], yPos[MONTH_Y_POS]);
 614
 615    /* Datum */
 616    yOffset = DATE_Y_OFFSET;
 617    if (localTime->tm_mday > 9)
 618     {
 619        xOffset = DATE_NUM_WIDTH * (((localTime->tm_mday / 10) + 9) % 10);
 620        XCopyArea(dpy, dateNums.pixmap, visible.pixmap, normalGC,
 621                  xOffset, yOffset, DATE_NUM_WIDTH, DATE_NUM_HEIGHT,
 622                  xPos[DATE_LEFT_X_POS], yPos[DATE_Y_POS]);
 623        xOffset = DATE_NUM_WIDTH * (((localTime->tm_mday % 10) + 9) % 10);
 624        XCopyArea(dpy, dateNums.pixmap, visible.pixmap, normalGC,
 625                  xOffset, yOffset, DATE_NUM_WIDTH, DATE_NUM_HEIGHT,
 626                  xPos[DATE_RIGHT_X_POS], yPos[DATE_Y_POS]);
 627     }
 628    else
 629     {
 630        xOffset = DATE_NUM_WIDTH * (localTime->tm_mday - 1);
 631        XCopyArea(dpy, dateNums.pixmap, visible.pixmap, normalGC,
 632                  xOffset, yOffset, DATE_NUM_WIDTH, DATE_NUM_HEIGHT,
 633                  xPos[DATE_CENTER_X_POS], yPos[DATE_Y_POS]);
 634     }
 635
 636    /* Wochentag */
 637    xOffset = WEEKDAY_X_OFFSET;
 638    yOffset = WEEKDAY_HEIGHT * ((localTime->tm_wday + 6) % 7);
 639    XCopyArea(dpy, weekdays.pixmap, visible.pixmap, normalGC,
 640              xOffset, yOffset, WEEKDAY_WIDTH, WEEKDAY_HEIGHT,
 641              xPos[WEEKDAY_X_POS], yPos[WEEKDAY_Y_POS]);
 642
 643    if ((!enableBlinking) && (!enableYearDisplay))
 644     {
 645        /* Sekunden Doppelpunkt ein */
 646        xOffset = COLON_X_OFFSET;
 647        yOffset = COLON_Y_OFFSET;
 648        XCopyArea(dpy, led.pixmap, visible.pixmap, normalGC,
 649                  xOffset, yOffset, COLON_WIDTH, COLON_HEIGHT,
 650                  xPos[COLON_X_POS], yPos[COLON_Y_POS]);
 651     }
 652 }
 653
 654 /* Extract program name from the zeroth program argument */
 655 char *extractProgName(char *argv0)
 656 {
 657    char *prog_name = NULL;
 658
 659    if (NULL != argv0)
 660     {
 661        prog_name = strrchr(argv0, '/');
 662        if (NULL == prog_name)
 663         {
 664            prog_name = argv0;
 665         }
 666        else
 667         {
 668            prog_name++;
 669         }
 670     }
 671    return (prog_name);
 672 }
 673
 674 /* Process program arguments and set corresponding options */
 675 int processArgs(int argc, char **argv)
 676 {
 677    int i;
 678
 679    for (i = 1; i < argc; i++)
 680     {
 681        if (0 == strcmp(argv[i], "--"))
 682         {
 683            break;
 684         }
 685        else if ((0 == strcmp(argv[i], "-12")) ||
 686                 (0 == strcmp(argv[i], "-1")) ||
 687                 (0 == strcmp(argv[i], "--12")))
 688         {
 689            enable12HourClock = 1;
 690         }
 691        else if ((0 == strcmp(argv[i], "-24")) ||
 692                 (0 == strcmp(argv[i], "-2")) ||
 693                 (0 == strcmp(argv[i], "--24")))
 694         {
 695            enable12HourClock = 0;
 696         }
 697        else if ((0 == strcmp(argv[i], "-exe")) ||
 698                 (0 == strcmp(argv[i], "-e")) ||
 699                 (0 == strcmp(argv[i], "--exe")))
 700         {
 701            if (++i >= argc)
 702             {
 703                showUsage();
 704             }
 705            commandToExec = argv[i];
 706         }
 707        else if ((0 == strcmp(argv[i], "-led")) ||
 708                 (0 == strcmp(argv[i], "-l")) ||
 709                 (0 == strcmp(argv[i], "--led")))
 710         {
 711            if (++i >= argc)
 712             {
 713                showUsage();
 714             }
 715            ledColor = argv[i];
 716         }
 717        else if ((0 == strcmp(argv[i], "-clockxpm")) ||
 718                 (0 == strcmp(argv[i], "-c")) ||
 719                 (0 == strcmp(argv[i], "--clockxpm")))
 720         {
 721 #ifndef ONLY_SHAPED_WINDOW
 722            if (++i >= argc)
 723             {
 724                showUsage();
 725             }
 726            userClockXpm = argv[i];
 727            useUserClockXpm = 1;
 728 #endif /* !ONLY_SHAPED_WINDOW */
 729         }
 730        else if ((0 == strcmp(argv[i], "-monthxpm")) ||
 731                 (0 == strcmp(argv[i], "-m")) ||
 732                 (0 == strcmp(argv[i], "--monthxpm")))
 733         {
 734            if (++i >= argc)
 735             {
 736                showUsage();
 737             }
 738            userMonthXpm = argv[i];
 739            useUserMonthXpm = 1;
 740         }
 741        else if ((0 == strcmp(argv[i], "-weekdayxpm")) ||
 742                 (0 == strcmp(argv[i], "-w")) ||
 743                 (0 == strcmp(argv[i], "--weekdayxpm")))
 744         {
 745            if (++i >= argc)
 746             {
 747                showUsage();
 748             }
 749            userWeekdayXpm = argv[i];
 750            useUserWeekdayXpm = 1;
 751         }
 752        else if ((0 == strcmp(argv[i], "-noblink")) ||
 753                 (0 == strcmp(argv[i], "-n")) ||
 754                 (0 == strcmp(argv[i], "--noblink")))
 755         {
 756            enableBlinking = 0;
 757         }
 758        else if ((0 == strcmp(argv[i], "-year")) ||
 759                 (0 == strcmp(argv[i], "-y")) ||
 760                 (0 == strcmp(argv[i], "--year")))
 761         {
 762            enableYearDisplay = 1;
 763         }
 764        else if ((0 == strcmp(argv[i], "-position")) ||
 765                 (0 == strcmp(argv[i], "-p")) ||
 766                 (0 == strcmp(argv[i], "--position")))
 767         {
 768 #ifndef ONLY_SHAPED_WINDOW
 769            if (++i >= argc)
 770             {
 771                showUsage();
 772             }
 773            geometry = argv[i];
 774 #endif /* !ONLY_SHAPED_WINDOW */
 775         }
 776        else if ((0 == strcmp(argv[i], "-shape")) ||
 777                 (0 == strcmp(argv[i], "-s")) ||
 778                 (0 == strcmp(argv[i], "--shape")))
 779         {
 780            enableShapedWindow = 1;
 781         }
 782        else if ((0 == strcmp(argv[i], "-iconic")) ||
 783                 (0 == strcmp(argv[i], "-i")) ||
 784                 (0 == strcmp(argv[i], "--iconic")))
 785         {
 786 #ifndef ONLY_SHAPED_WINDOW
 787            startIconified = 1;
 788 #endif /* !ONLY_SHAPED_WINDOW */
 789         }
 790        else if ((0 == strcmp(argv[i], "-version")) ||
 791                 (0 == strcmp(argv[i], "-V")) ||
 792                 (0 == strcmp(argv[i], "--version")))
 793         {
 794            showVersion();
 795         }
 796        else if ((0 == strcmp(argv[i], "-help")) ||
 797                 (0 == strcmp(argv[i], "-h")) ||
 798                 (0 == strcmp(argv[i], "--help")))
 799         {
 800            showUsage();
 801         }
 802        else
 803         {
 804            fprintf(stderr, "%s: unrecognized option `%s'\n",
 805                    progName, argv[i]);
 806            showUsage();
 807         }
 808     }
 809    return (i);
 810 }
 811
 812 /**********************************************************************/
 813 int main(int argc, char **argv)
 814 {
 815    int           i;
 816    unsigned int  borderWidth = 0;
 817    char          *displayName = NULL;
 818    XGCValues     gcValues;
 819    unsigned long gcMask;
 820    XEvent        event;
 821    XTextProperty wmName;
 822    XClassHint    classHint;
 823    Pixmap        shapeMask;
 824    struct timeval nextEvent;
 825
 826    /* Parse command line options */
 827    progName = extractProgName(argv[0]);
 828    processArgs(argc, argv);
 829
 830    /* init led position */
 831 #ifndef ONLY_SHAPED_WINDOW
 832    for (i = 0; i < NUM_Y_POSITIONS; i++)
 833     {
 834        yPos[i] = enableShapedWindow ? yPosShaped[i] : yPosUnshaped[i];
 835     }
 836    for (i = 0; i < NUM_X_POSITIONS; i++)
 837     {
 838        xPos[i] = enableShapedWindow ? xPosShaped[i] : xPosUnshaped[i];
 839     }
 840 #else /* ONLY_SHAPED_WINDOW */
 841    for (i = 0; i < NUM_Y_POSITIONS; i++)
 842     {
 843        yPos[i] = yPosShaped[i];
 844     }
 845    for (i = 0; i < NUM_X_POSITIONS; i++)
 846     {
 847        xPos[i] = xPosShaped[i];
 848     }
 849 #endif /* !ONLY_SHAPED_WINDOW */
 850    for (i = 0; i < NUM_TIME_POSITIONS; i++)
 851     {
 852       if (enable12HourClock && (!enableYearDisplay))
 853        {
 854          xPos[i] += timePos24[i];
 855        }
 856       else
 857        {
 858          xPos[i] += timePos12[i];
 859        }
 860     }
 861
 862    /* Open the display */
 863    dpy = XOpenDisplay(displayName);
 864    if (NULL == dpy)
 865     {
 866        fprintf(stderr, "%s: can't open display %s\n", progName,
 867                XDisplayName(displayName));
 868        exit(1);
 869     }
 870    screen       = DefaultScreen(dpy);
 871    rootWindow   = RootWindow(dpy, screen);
 872    displayDepth = DefaultDepth(dpy, screen);
 873    xFd          = XConnectionNumber(dpy);
 874
 875    /* Icon Daten nach XImage konvertieren */
 876    GetXpms();
 877
 878    /* Create a window to hold the banner */
 879    sizeHints.x = 0;
 880    sizeHints.y = 0;
 881    sizeHints.min_width  = clockBg.attributes.width;
 882    sizeHints.min_height = clockBg.attributes.height;
 883    sizeHints.max_width  = clockBg.attributes.width;
 884    sizeHints.max_height = clockBg.attributes.height;
 885    sizeHints.base_width  = clockBg.attributes.width;
 886    sizeHints.base_height = clockBg.attributes.height;
 887    sizeHints.flags = USSize | USPosition | PMinSize | PMaxSize | PBaseSize;
 888
 889    bgPixel = GetColor("white");
 890    fgPixel = GetColor("black");
 891
 892    XWMGeometry(dpy, screen, geometry, NULL, borderWidth, &sizeHints,
 893                &sizeHints.x, &sizeHints.y, &sizeHints.width, &sizeHints.height,
 894                &sizeHints.win_gravity);
 895    sizeHints.width  = clockBg.attributes.width;
 896    sizeHints.height = clockBg.attributes.height;
 897
 898    win = XCreateSimpleWindow(dpy, rootWindow, sizeHints.x, sizeHints.y,
 899                              sizeHints.width, sizeHints.height,
 900                              borderWidth, fgPixel, bgPixel);
 901    iconWin = XCreateSimpleWindow(dpy, win, sizeHints.x, sizeHints.y,
 902                                  sizeHints.width, sizeHints.height,
 903                                  borderWidth, fgPixel, bgPixel);
 904
 905    /* Hints aktivieren */
 906    XSetWMNormalHints(dpy, win, &sizeHints);
 907    classHint.res_name = progName;
 908    classHint.res_class = className;
 909    XSetClassHint(dpy, win, &classHint);
 910
 911    XSelectInput(dpy, win, OUR_WINDOW_EVENTS);
 912    XSelectInput(dpy, iconWin, OUR_WINDOW_EVENTS);
 913
 914    if (0 == XStringListToTextProperty(&progName, 1, &wmName))
 915     {
 916        fprintf(stderr, "%s: can't allocate window name text property\n",
 917                progName);
 918        exit(-1);
 919     }
 920    XSetWMName(dpy, win, &wmName);
 921
 922    /* Create a GC for drawing */
 923    gcMask = GCForeground | GCBackground | GCGraphicsExposures;
 924    gcValues.foreground = fgPixel;
 925    gcValues.background = bgPixel;
 926    gcValues.graphics_exposures = False;
 927    normalGC = XCreateGC(dpy, rootWindow, gcMask, &gcValues);
 928
 929    if (enableShapedWindow)
 930     {
 931        shapeMask = XCreateBitmapFromData(dpy, win, (char *)mask_bits,
 932                                          mask_width, mask_height);
 933        XShapeCombineMask(dpy, win, ShapeBounding, 0, 0, shapeMask, ShapeSet);
 934        XShapeCombineMask(dpy, iconWin, ShapeBounding, 0, 0, shapeMask,
 935                          ShapeSet);
 936     }
 937
 938    wmHints.initial_state = WithdrawnState;
 939    wmHints.icon_window = iconWin;
 940    wmHints.icon_x = sizeHints.x;
 941    wmHints.icon_y = sizeHints.y;
 942    wmHints.window_group = win;
 943    wmHints.flags = StateHint | IconWindowHint | IconPositionHint |
 944       WindowGroupHint;
 945    XSetWMHints(dpy, win, &wmHints);
 946
 947    XSetCommand(dpy, win, argv, argc);
 948    XMapWindow(dpy,win);
 949
 950    showTime();
 951    redrawWindow(&visible);
 952    while (1)
 953     {
 954        if (actualTime != mytime())
 955         {
 956            actualTime = mytime();
 957            if (actualMinutes != (actualTime / 60))
 958             {
 959                showTime();
 960                if (!enableBlinking)
 961                 {
 962                   redrawWindow(&visible);
 963                 }
 964             }
 965           if (enableBlinking && (!enableYearDisplay))
 966             {
 967                if (actualTime % 2)
 968                 {
 969                    /* Sekunden Doppelpunkt ein */
 970                    XCopyArea(dpy, led.pixmap, visible.pixmap, normalGC,
 971                              COLON_X_OFFSET, COLON_Y_OFFSET,
 972                              COLON_WIDTH, COLON_HEIGHT,
 973                              xPos[COLON_X_POS], yPos[COLON_Y_POS]);
 974                 }
 975                else
 976                 {
 977                    /* Sekunden Doppelpunkt aus */
 978                    XCopyArea(dpy, led.pixmap, visible.pixmap, normalGC,
 979                              BLANK_X_OFFSET, BLANK_Y_OFFSET,
 980                              COLON_WIDTH, COLON_HEIGHT,
 981                              xPos[COLON_X_POS], yPos[COLON_Y_POS]);
 982                 }
 983                redrawWindow(&visible);
 984             }
 985            if (0 == (actualTime % 2))
 986             {
 987                /* Clean up zombie processes */
 988 #ifdef DEBUG
 989                fprintf(stderr, "%s: cleaning up zombies (time %ld)\n",
 990                        progName, actualTime);
 991 #endif /* DEBUG */
 992                if (NULL != commandToExec)
 993                 {
 994                    waitpid(0, NULL, WNOHANG);
 995                 }
 996             }
 997         }
 998
 999        /* read a packet */
1000        while (XPending(dpy))
1001         {
1002            XNextEvent(dpy, &event);
1003            switch(event.type)
1004             {
1005              case Expose:
1006                if (0 == event.xexpose.count)
1007                 {
1008                    redrawWindow(&visible);
1009                 }
1010                break;
1011             case ButtonPress:
1012                if (NULL != commandToExec)
1013                 {
1014                    pid_t fork_pid;
1015
1016                    if ((NULL == commandBuf) &&
1017                        (!buildCommand(commandToExec, &commandBuf,
1018                                       &commandLength, &commandIndex)))
1019                     {
1020                        break;
1021                     }
1022                    fork_pid = fork();
1023                    switch (fork_pid)
1024                     {
1025                      case 0:
1026                        /* We're the child process;
1027                         * run the command and exit.
1028                         */
1029                        executeCommand(commandBuf);
1030                        /* When the system() call finishes, we're done. */
1031                        exit(0);
1032                        break;
1033                      case -1:
1034                        /* We're the parent process, but
1035                         * fork() gave an error.
1036                         */
1037                        perror("fork");
1038                        break;
1039                      default:
1040                        /* We're the parent process;
1041                         * keep on doing what we normally do.
1042                         */
1043                        break;
1044                     }
1045                 }
1046                break;
1047             case DestroyNotify:
1048 #if 0
1049                XFreeGC(dpy, normalGC);
1050                XDestroyWindow(dpy, win);
1051                XDestroyWindow(dpy, iconWin);
1052 #endif /* 0 */
1053 #ifdef ONLY_SHAPED_WINDOW
1054                XFreePixmap(dpy, visible.pixmap);
1055 #endif /* ONLY_SHAPED_WINDOW */
1056                XCloseDisplay(dpy);
1057                exit(0);
1058              default:
1059                break;
1060             }
1061         }
1062        XFlush(dpy);
1063 #ifdef SYSV
1064        if (enableYearDisplay)
1065         {
1066            poll((struct poll *) 0, (size_t) 0, 200);    /* 1/5 sec */
1067         }
1068        else
1069         {
1070            poll((struct poll *) 0, (size_t) 0, 50);     /* 5/100 sec */
1071         }
1072 #else
1073        /* We compute the date of next event, in order to avoid polling */
1074        if (enableBlinking)
1075          {
1076            gettimeofday(&nextEvent,NULL);
1077            nextEvent.tv_sec = 0;
1078            nextEvent.tv_usec = 1000000-nextEvent.tv_usec;
1079          }
1080        else
1081          {
1082            if (enableYearDisplay)
1083              {
1084                nextEvent.tv_sec = 86400-actualTime%86400;
1085                nextEvent.tv_usec = 0;
1086              }
1087            else
1088              {
1089                nextEvent.tv_sec = 60-actualTime%60;
1090                nextEvent.tv_usec = 0;
1091              }
1092          }
1093        FD_ZERO(&xFdSet);
1094        FD_SET(xFd,&xFdSet);
1095        select(FD_SETSIZE,&xFdSet,NULL,NULL,&nextEvent);
1096 #endif
1097     }
1098    return (0);
1099 }
1100