wmitime/wmitime.c

   1 /*
   2
   3  wmitime.c -- internet time clock
   4
   5  by Dave Clark (clarkd@skynet.ca) (http://www.neotokyo.org/illusion)
   6
   7  This software is licensed through the GNU General Public Lisence.
   8
   9 */
  10
  11 #include <stdlib.h>
  12 #include <stdio.h>
  13 #include <time.h>
  14 #include <string.h>
  15 #include <fcntl.h>
  16 #include <unistd.h>
  17 #include <ctype.h>
  18 #include <math.h>
  19 #include <locale.h>
  20 #include <langinfo.h>
  21 #include <iconv.h>
  22
  23 #include <sys/wait.h>
  24 #include <sys/stat.h>
  25 #include <sys/param.h>
  26 #include <sys/types.h>
  27 #include <sys/ioctl.h>
  28 #include <sys/socket.h>
  29
  30 #include <X11/Xlib.h>
  31 #include <X11/xpm.h>
  32 #include <X11/extensions/shape.h>
  33
  34 #include "wmgeneral/wmgeneral.h"
  35 #include "wmgeneral/misc.h"
  36
  37 #include "wmitime-master.xpm"
  38 char wmitime_mask_bits[64*64];
  39 int  wmitime_mask_width = 64;
  40 int  wmitime_mask_height = 64;
  41
  42 #define WMITIME_VERSION "0.1"
  43
  44 #define CHAR_WIDTH 5
  45 #define CHAR_HEIGHT 7
  46
  47 #define BCHAR_WIDTH 6
  48 #define BCHAR_HEIGHT 9
  49
  50 #define MY_PI (3.14159)
  51
  52 extern  char **environ;
  53
  54 char    *ProgName;
  55
  56 char locale[256];
  57
  58 time_t          curtime;
  59 time_t          prevtime;
  60
  61 int prevhourx=19;
  62 int prevhoury=33;
  63 int prevminx=19;
  64 int prevminy=33;
  65
  66 static struct tm *clk;
  67
  68 int TwelveHour=0;
  69
  70 void usage(void);
  71 void printversion(void);
  72 void BlitString(char *name, int x, int y);
  73 void BlitNum(int num, int x, int y);
  74 void wmitime_routine(int, char **);
  75 int PortWatch( short port );
  76 void DrawInetTime(void);
  77 void DrawStdTime(void);
  78 void DrawDate(void);
  79 void DrawInetWheel(void);
  80 void DrawStdWheel(void);
  81 void DrawLine(int x1, int y1, int x2, int y2, int sourcex, int sourcey);
  82
  83 int main(int argc, char *argv[]) {
  84
  85         int             i;
  86
  87     locale[0] = 0;
  88
  89         /* Parse Command Line */
  90
  91         ProgName = argv[0];
  92         if (strlen(ProgName) >= 5)
  93                 ProgName += (strlen(ProgName) - 5);
  94
  95         for (i=1; i<argc; i++) {
  96                 char *arg = argv[i];
  97
  98                 if (*arg=='-') {
  99                         switch (arg[1]) {
 100                         case 'd' :
 101                                 if (strcmp(arg+1, "display")) {
 102                                         usage();
 103                                         exit(1);
 104                                 }
 105                                 break;
 106                         case 'g' :
 107                                 if (strcmp(arg+1, "geometry")) {
 108                                         usage();
 109                                         exit(1);
 110                                 }
 111                                 break;
 112                         case 'v' :
 113                                 printversion();
 114                                 exit(0);
 115                                 break;
 116             case '1' :
 117                 if (arg[2] == '2')
 118                 {
 119                     /* Twelve-hour mode */
 120                     TwelveHour = 1;
 121                 }
 122                 break;
 123             case 'l' :
 124                 if (argc > (i+1))
 125                 {
 126                     strcpy(locale, argv[i+1]);
 127                     i++;
 128                 }
 129                 break;
 130             default:
 131                                 usage();
 132                                 exit(0);
 133                                 break;
 134                         }
 135                 }
 136         }
 137
 138         if (setlocale(LC_ALL, locale) == NULL)
 139             fprintf(stderr,
 140                     "warning: locale '%s' not recognized; defaulting to '%s'.",
 141                     locale, setlocale(LC_ALL, NULL));
 142
 143         wmitime_routine(argc, argv);
 144
 145         return 0;
 146 }
 147
 148 /*******************************************************************************\
 149 |* wmitime_routine                                                                                                                 *|
 150 \*******************************************************************************/
 151
 152 void wmitime_routine(int argc, char **argv)
 153 {
 154     int                 i;
 155         XEvent          Event;
 156         int                     but_stat = -1;
 157
 158
 159     createXBMfromXPM(wmitime_mask_bits, wmitime_master_xpm, wmitime_mask_width, wmitime_mask_height);
 160
 161         openXwindow(argc, argv, wmitime_master_xpm, wmitime_mask_bits, wmitime_mask_width, wmitime_mask_height);
 162
 163         AddMouseRegion(0, 5, 6, 58, 16);
 164
 165     RedrawWindow();
 166
 167     prevtime = time(0) - 1;
 168
 169     while (1)
 170     {
 171                 curtime = time(0);
 172
 173         if ( curtime > prevtime)
 174         {
 175             prevtime = curtime;
 176
 177             clk = localtime(&curtime);
 178
 179             /* Update display */
 180
 181             DrawInetTime();
 182
 183             DrawStdTime();
 184
 185             DrawInetWheel();
 186
 187             DrawDate();
 188
 189             DrawStdWheel();
 190
 191             RedrawWindow();
 192
 193         }
 194
 195         /* X Events */
 196         while (XPending(display))
 197         {
 198                         XNextEvent(display, &Event);
 199             switch (Event.type)
 200             {
 201                         case Expose:
 202                                 RedrawWindow();
 203                                 break;
 204                         case DestroyNotify:
 205                                 XCloseDisplay(display);
 206                                 exit(0);
 207                 break;
 208                         case ButtonPress:
 209                                 i = CheckMouseRegion(Event.xbutton.x, Event.xbutton.y);
 210
 211                                 but_stat = i;
 212                                 break;
 213                         case ButtonRelease:
 214                                 i = CheckMouseRegion(Event.xbutton.x, Event.xbutton.y);
 215
 216                 if (but_stat == i && but_stat >= 0)
 217                 {
 218                     switch (but_stat)
 219                     {
 220                     case 0 :
 221                         TwelveHour = (!TwelveHour);
 222                         prevtime--;
 223                         break;
 224                     case 1 :
 225                         break;
 226                     case 2:
 227                         break;
 228                     case 3:
 229                         break;
 230                     case 4:
 231                         break;
 232
 233                                         }
 234                                 }
 235                                 but_stat = -1;
 236                                 /* RedrawWindow(); */
 237                                 break;
 238                         }
 239                 }
 240
 241                 usleep(100000);
 242         }
 243 }
 244
 245
 246 void DrawInetTime(void)
 247 {
 248     int iTime;
 249
 250     /* Compute Inet Time */
 251     iTime=(clk->tm_hour*3600+clk->tm_min*60+clk->tm_sec);
 252     iTime=iTime+((timezone-1)+3600);
 253     if (clk->tm_isdst)
 254         iTime-=3600;
 255     iTime=(iTime*1000)/86400;
 256
 257     if (iTime >= 1000)
 258         iTime-=1000;
 259     else
 260         if (iTime < 0)
 261             iTime+=1000;
 262
 263     /* Blit it */
 264
 265     BlitNum(iTime, 38, 18);
 266
 267 }
 268
 269 void DrawStdTime(void)
 270 {
 271     int xoff=0, yoff=0;
 272     int srcx=0, srcy=0;
 273     int i,j;
 274     char blitstr[32];
 275     int len;
 276
 277     i = clk->tm_hour;
 278
 279     if (TwelveHour)
 280     {
 281         if (i > 12)
 282             i-=12;
 283
 284         if (i==0)
 285             i=12;
 286
 287         sprintf(blitstr, "%2i:%02i:%02i", i, clk->tm_min, clk->tm_sec);
 288     }
 289     else
 290     {
 291         sprintf(blitstr, "%02i:%02i:%02i", i, clk->tm_min, clk->tm_sec);
 292     }
 293
 294
 295
 296     len = strlen(blitstr);
 297
 298     /* Set starting co-ordinates... */
 299     xoff = 6;
 300     yoff = 6;
 301
 302     /* Blit it. */
 303     for( i=0;  i<len; i++)
 304     {
 305         if (blitstr[i] == ':')
 306         {
 307             copyXPMArea(138, 23, 4, BCHAR_HEIGHT, xoff, yoff);
 308             xoff+=4;
 309         }
 310         else if (isdigit(blitstr[i]))
 311         {
 312             j = blitstr[i] - '0';
 313             srcx = 68;
 314             srcy = 23;
 315
 316             while (j)
 317             {
 318                 j--;
 319                 srcx += (BCHAR_WIDTH + 1);
 320             }
 321
 322             copyXPMArea(srcx, srcy, BCHAR_WIDTH+1, BCHAR_HEIGHT, xoff, yoff);
 323             xoff+=(BCHAR_WIDTH + 1);
 324         }
 325         else
 326         {
 327             copyXPMArea(66, 10, BCHAR_WIDTH+1, BCHAR_HEIGHT, xoff, yoff);
 328             xoff+=(BCHAR_WIDTH + 1);
 329         }
 330     }
 331
 332 }
 333
 334 void DrawDate(void)
 335 {
 336     char OrigBlitStr[20], BlitStr[20];
 337     char *inbuf, *outbuf;
 338     size_t inbytesleft, outbytesleft;
 339     iconv_t cd;
 340
 341     cd = iconv_open("ASCII//TRANSLIT", nl_langinfo(CODESET));
 342
 343     inbuf = OrigBlitStr;
 344     outbuf = BlitStr;
 345     inbytesleft = sizeof OrigBlitStr;
 346     outbytesleft = sizeof BlitStr;
 347
 348     sprintf(OrigBlitStr, "%s", nl_langinfo(ABDAY_1 + clk->tm_wday));
 349     iconv(cd, &inbuf, &inbytesleft, &outbuf, &outbytesleft);
 350     BlitStr[2] = 0;
 351     BlitString( BlitStr, 6, 50);
 352
 353     inbuf = OrigBlitStr;
 354     outbuf = BlitStr;
 355     inbytesleft = sizeof OrigBlitStr;
 356     outbytesleft = sizeof BlitStr;
 357
 358     sprintf(OrigBlitStr, "%s", nl_langinfo(ABMON_1 + clk->tm_mon));
 359     iconv(cd, &inbuf, &inbytesleft, &outbuf, &outbytesleft);
 360     BlitStr[3] = 0;
 361     BlitString( BlitStr, 40, 50);
 362
 363     iconv_close(cd);
 364
 365     sprintf(BlitStr, "%02i", clk->tm_mday);
 366     BlitString( BlitStr, 25, 50);
 367 }
 368
 369 void DrawInetWheel(void)
 370 {
 371     int WheelPos=0;
 372     int i;
 373     int xoff=0, yoff=0;
 374     int iTime;
 375
 376     /* Calculate Wheel Position... */
 377     iTime=(clk->tm_hour*3600+clk->tm_min*60+clk->tm_sec);
 378     iTime=iTime+((timezone-1)+3600);
 379     if (clk->tm_isdst)
 380         iTime-=3600;
 381     iTime=(iTime*1000)/8640;
 382
 383     if (iTime >= 10000)
 384         iTime-=10000;
 385     else
 386         if (iTime < 0)
 387             iTime+=10000;
 388
 389     iTime %= 10;
 390
 391     WheelPos = floor( (iTime *8) / 10);
 392
 393     /* Draw the Wheel... */
 394     i=WheelPos;
 395     yoff=35;
 396     xoff=67;
 397
 398     xoff+=19;
 399
 400     while(i)
 401     {
 402         xoff +=19;
 403         i--;
 404     }
 405
 406     copyXPMArea(xoff, yoff, 19, 19, 39, 29);
 407
 408 }
 409
 410
 411 void DrawStdWheel(void)
 412 {
 413     /* 19x33 = center
 414      * radius of 14 */
 415
 416     int sx, sy;
 417     int cx, cy;
 418     int dx, dy;
 419     int hr;
 420     double psi;
 421
 422     cx=19;
 423     cy=33;
 424
 425     sx = 2;
 426     sy = 97;
 427
 428     /* Hour Hand... */
 429
 430     DrawLine(cx, cy, prevhourx, prevhoury, 66, 9); /* erase old line */
 431
 432     hr = (clk->tm_hour % 12);
 433
 434     psi = hr * (M_PI / 6.0);
 435         psi += clk->tm_min * (M_PI / 360);
 436
 437     dx = floor(sin(psi) * 22 * 0.5 + 0.5);
 438     dy = floor(-cos(psi) * 16 * 0.5 + 0.5);
 439
 440     dx += cx;
 441     dy += cy;
 442
 443     prevhourx=dx;
 444     prevhoury=dy;
 445
 446     DrawLine(cx, cy, dx, dy, sx, sy);
 447
 448     /* Minute Hand... */
 449
 450     DrawLine(cx, cy, prevminx, prevminy, 66, 9); /* erase old line */
 451
 452     cx=19;
 453     cy=33;
 454     sx = 2;
 455     sy = 96;
 456
 457     psi = clk->tm_min * (M_PI / 30.0);
 458         psi += clk->tm_sec * (M_PI / 1800);
 459
 460     dx = floor(sin(psi) * 22 * 0.7 + 0.5);
 461         dy = floor(-cos(psi) * 16 * 0.7 + 0.5);
 462
 463     dx += cx;
 464     dy += cy;
 465
 466     prevminx = dx;
 467     prevminy = dy;
 468
 469
 470     DrawLine(cx, cy, dx, dy, sx, sy);
 471 }
 472
 473 void DrawLine(int x1, int y1, int x2, int y2, int sourcex, int sourcey)
 474 {
 475     int x, y;
 476     int deltax, deltay;
 477     int xs, ys;
 478
 479     float xd=0, yd=0;
 480     float xi, yi;
 481
 482     x = x1;
 483     y = y1;
 484
 485
 486     if ( (x2-x1) < 0)
 487         xs = -1;
 488     else
 489         xs = 1;
 490
 491     if ( (y2-y1) < 0)
 492         ys = -1;
 493     else
 494         ys = 1;
 495
 496     deltax = abs( x2 - x1 );
 497     deltay = abs( y2 - y1 );
 498
 499     if (deltay !=0)
 500         xi = (float) ((float)deltax / (float) deltay);
 501     else
 502         xi=0;
 503
 504     if (deltax !=0)
 505         yi = (float) ((float)deltay / (float) deltax);
 506     else
 507         yi=0;
 508
 509     if ( deltax > deltay )
 510     {
 511         for (x=x1; x!= x2; x+= xs)
 512         {
 513             yd += yi;
 514             y += (int) (yd * ys);
 515
 516             copyXPMArea(sourcex, sourcey, 1, 1, x, y);
 517
 518             yd -= (int) yd;
 519         }
 520     }
 521     else
 522     {
 523         for (y=y1; y!= y2; y+= ys)
 524         {
 525             xd += xi;
 526             x += (int) (xd * xs);
 527
 528             copyXPMArea(sourcex, sourcey, 1, 1, x, y);
 529
 530             xd -= (int) xd;
 531         }
 532     }
 533 }
 534
 535
 536
 537 /* Blits a string at given co-ordinates */
 538 void BlitString(char *name, int x, int y)
 539 {
 540     int         i;
 541         int             c;
 542     int         k;
 543
 544         k = x;
 545     for (i=0; name[i]; i++)
 546     {
 547
 548         c = toupper(name[i]);
 549         if (c >= 'A' && c <= 'Z')
 550         {  /* its a letter */
 551                         c -= 'A';
 552                         copyXPMArea(c * 6, 74, 6, 8, k, y);
 553                         k += 6;
 554         }
 555         else
 556         {   /* its a number or symbol */
 557                         c -= '0';
 558                         copyXPMArea(c * 6, 64, 6, 8, k, y);
 559                         k += 6;
 560                 }
 561         }
 562
 563 }
 564
 565 void BlitNum(int num, int x, int y)
 566 {
 567     char buf[1024];
 568     int newx=x;
 569
 570     sprintf(buf, "%03i", num);
 571
 572     BlitString(buf, newx, y);
 573 }
 574
 575 /*******************************************************************************\
 576 |* usage                                                                                                                                           *|
 577 \*******************************************************************************/
 578
 579 void usage(void)
 580 {
 581     fprintf(stderr, "\nWMiTIME - Window Maker Developers Team <wmaker-dev@lists.windowmaker.org>\n");
 582     fprintf(stderr, "          original author: Dave Clark <clarkd@skynet.ca>\n\n");
 583         fprintf(stderr, "usage:\n");
 584     fprintf(stderr, "    -12                       12-hour mode\n");
 585         fprintf(stderr, "    -display <display name>\n");
 586         fprintf(stderr, "    -geometry +XPOS+YPOS      initial window position\n");
 587         fprintf(stderr, "    -l <locale>               specify locale\n");
 588     fprintf(stderr, "    -h                        this help screen\n");
 589         fprintf(stderr, "    -v                        print the version number\n");
 590     fprintf(stderr, "\n");
 591 }
 592
 593 /*******************************************************************************\
 594 |* printversion                                                                                                                            *|
 595 \*******************************************************************************/
 596
 597 void printversion(void)
 598 {
 599         fprintf(stderr, "wmitime v%s\n", WMITIME_VERSION);
 600 }