wmitime/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
  20 #include <sys/wait.h>
  21 #include <sys/stat.h>
  22 #include <sys/param.h>
  23 #include <sys/types.h>
  24 #include <sys/ioctl.h>
  25 #include <sys/socket.h>
  26
  27 #include <X11/Xlib.h>
  28 #include <X11/xpm.h>
  29 #include <X11/extensions/shape.h>
  30
  31 #include "../wmgeneral/wmgeneral.h"
  32 #include "../wmgeneral/misc.h"
  33
  34 #ifdef fr_FR
  35 #define fr
  36 #endif
  37
  38 #ifdef fr
  39 #include "french.h"
  40 #else
  41 #include "language.h"
  42 #endif
  43
  44 #include "wmitime-master.xpm"
  45 char wmitime_mask_bits[64*64];
  46 int  wmitime_mask_width = 64;
  47 int  wmitime_mask_height = 64;
  48
  49 #define WMITIME_VERSION "0.1"
  50
  51 #define CHAR_WIDTH 5
  52 #define CHAR_HEIGHT 7
  53
  54 #define BCHAR_WIDTH 6
  55 #define BCHAR_HEIGHT 9
  56
  57 #define MY_PI (3.14159)
  58
  59 extern  char **environ;
  60
  61 char    *ProgName;
  62
  63 char uconfig_file[256];
  64
  65 time_t          curtime;
  66 time_t          prevtime;
  67
  68 int prevhourx=19;
  69 int prevhoury=33;
  70 int prevminx=19;
  71 int prevminy=33;
  72
  73 static struct tm *clk;
  74
  75 int TwelveHour=0;
  76
  77 void usage(void);
  78 void printversion(void);
  79 void BlitString(char *name, int x, int y);
  80 void BlitNum(int num, int x, int y);
  81 void wmitime_routine(int, char **);
  82 int PortWatch( short port );
  83 int ReadConfigInt(FILE *fp, char *setting, int *value);
  84 int ReadConfigString(FILE *fp, char *setting, char *value);
  85 int Read_Config_File( char *filename );
  86 void DrawInetTime(void);
  87 void DrawStdTime(void);
  88 void DrawDate(void);
  89 void DrawInetWheel(void);
  90 void DrawStdWheel(void);
  91 void DrawLine(int x1, int y1, int x2, int y2, int sourcex, int sourcey);
  92
  93 int main(int argc, char *argv[]) {
  94
  95         int             i;
  96
  97     uconfig_file[0] = 0;
  98
  99         /* Parse Command Line */
 100
 101         ProgName = argv[0];
 102         if (strlen(ProgName) >= 5)
 103                 ProgName += (strlen(ProgName) - 5);
 104
 105         for (i=1; i<argc; i++) {
 106                 char *arg = argv[i];
 107
 108                 if (*arg=='-') {
 109                         switch (arg[1]) {
 110                         case 'd' :
 111                                 if (strcmp(arg+1, "display")) {
 112                                         usage();
 113                                         exit(1);
 114                                 }
 115                                 break;
 116                         case 'g' :
 117                                 if (strcmp(arg+1, "geometry")) {
 118                                         usage();
 119                                         exit(1);
 120                                 }
 121                                 break;
 122                         case 'v' :
 123                                 printversion();
 124                                 exit(0);
 125                                 break;
 126             case 'c' :
 127                 if (argc > (i+1))
 128                 {
 129                     strcpy(uconfig_file, argv[i+1]);
 130                     i++;
 131                 }
 132                 break;
 133             case '1' :
 134                 if (arg[2] == '2')
 135                 {
 136                     // Twelve-hour mode
 137                     TwelveHour = 1;
 138                 }
 139                 break;
 140             default:
 141                                 usage();
 142                                 exit(0);
 143                                 break;
 144                         }
 145                 }
 146         }
 147
 148         wmitime_routine(argc, argv);
 149
 150         return 0;
 151 }
 152
 153 /*******************************************************************************\
 154 |* wmitime_routine                                                                                                                 *|
 155 \*******************************************************************************/
 156
 157 void wmitime_routine(int argc, char **argv)
 158 {
 159     int                 i;
 160         XEvent          Event;
 161         int                     but_stat = -1;
 162
 163
 164 //    char config_file[512];
 165
 166     createXBMfromXPM(wmitime_mask_bits, wmitime_master_xpm, wmitime_mask_width, wmitime_mask_height);
 167
 168         openXwindow(argc, argv, wmitime_master_xpm, wmitime_mask_bits, wmitime_mask_width, wmitime_mask_height);
 169
 170         AddMouseRegion(0, 5, 6, 58, 16);
 171
 172     // We don't need a config file (yet)...
 173
 174 #if 0
 175     // Read config file
 176
 177     if (uconfig_file[0] != 0)
 178     {
 179         // user-specified config file
 180         fprintf(stderr, "Using user-specified config file '%s'.\n", uconfig_file);
 181         Read_Config_File(uconfig_file);
 182     }
 183     else
 184     {
 185         sprintf(config_file, "%s/.wmitimerc", getenv("HOME"));
 186
 187         if (!Read_Config_File(config_file))
 188         {
 189             // Fall back to /etc/wminetrc
 190             sprintf(config_file, "/etc/wmitimerc");
 191
 192             Read_Config_File(config_file);
 193         }
 194     }
 195 #endif
 196
 197     RedrawWindow();
 198
 199     prevtime = time(0) - 1;
 200
 201     while (1)
 202     {
 203                 curtime = time(0);
 204
 205         if ( curtime > prevtime)
 206         {
 207             prevtime = curtime;
 208
 209             clk = localtime(&curtime);
 210
 211             // Update display
 212
 213             DrawInetTime();
 214
 215             DrawStdTime();
 216
 217             DrawInetWheel();
 218
 219             DrawDate();
 220
 221             DrawStdWheel();
 222
 223             RedrawWindow();
 224
 225         }
 226
 227         // X Events
 228         while (XPending(display))
 229         {
 230                         XNextEvent(display, &Event);
 231             switch (Event.type)
 232             {
 233                         case Expose:
 234                                 RedrawWindow();
 235                                 break;
 236                         case DestroyNotify:
 237                                 XCloseDisplay(display);
 238                                 exit(0);
 239                 break;
 240                         case ButtonPress:
 241                                 i = CheckMouseRegion(Event.xbutton.x, Event.xbutton.y);
 242
 243                                 but_stat = i;
 244                                 break;
 245                         case ButtonRelease:
 246                                 i = CheckMouseRegion(Event.xbutton.x, Event.xbutton.y);
 247
 248                 if (but_stat == i && but_stat >= 0)
 249                 {
 250                     switch (but_stat)
 251                     {
 252                     case 0 :
 253                         TwelveHour = (!TwelveHour);
 254                         prevtime--;
 255                         break;
 256                     case 1 :
 257                         break;
 258                     case 2:
 259                         break;
 260                     case 3:
 261                         break;
 262                     case 4:
 263                         break;
 264
 265                                         }
 266                                 }
 267                                 but_stat = -1;
 268 //                              RedrawWindow();
 269                                 break;
 270                         }
 271                 }
 272
 273                 usleep(100000);
 274         }
 275 }
 276
 277
 278 void DrawInetTime(void)
 279 {
 280     int iTime;
 281
 282     // Compute Inet Time
 283     iTime=(clk->tm_hour*3600+clk->tm_min*60+clk->tm_sec);
 284     iTime=iTime+((timezone-1)+3600);
 285     if (clk->tm_isdst)
 286         iTime-=3600;
 287     iTime=(iTime*1000)/86400;
 288
 289     if (iTime >= 1000)
 290         iTime-=1000;
 291     else
 292         if (iTime < 0)
 293             iTime+=1000;
 294
 295     // Blit it
 296
 297     BlitNum(iTime, 38, 18);
 298
 299 }
 300
 301 void DrawStdTime(void)
 302 {
 303     int xoff=0, yoff=0;
 304     int srcx=0, srcy=0;
 305     int i,j;
 306     char blitstr[32];
 307     int len;
 308
 309     i = clk->tm_hour;
 310
 311     if (TwelveHour)
 312     {
 313         if (i > 12)
 314             i-=12;
 315
 316         if (i==0)
 317             i=12;
 318
 319         sprintf(blitstr, "%2i:%02i:%02i", i, clk->tm_min, clk->tm_sec);
 320     }
 321     else
 322     {
 323         sprintf(blitstr, "%02i:%02i:%02i", i, clk->tm_min, clk->tm_sec);
 324     }
 325
 326
 327
 328     len = strlen(blitstr);
 329
 330     // Set starting co-ordinates...
 331     xoff = 6;
 332     yoff = 6;
 333
 334     // Blit it.
 335     for( i=0;  i<len; i++)
 336     {
 337         if (blitstr[i] == ':')
 338         {
 339             copyXPMArea(138, 23, 4, BCHAR_HEIGHT, xoff, yoff);
 340             xoff+=4;
 341         }
 342         else if (isdigit(blitstr[i]))
 343         {
 344             j = blitstr[i] - '0';
 345             srcx = 68;
 346             srcy = 23;
 347
 348             while (j)
 349             {
 350                 j--;
 351                 srcx += (BCHAR_WIDTH + 1);
 352             }
 353
 354             copyXPMArea(srcx, srcy, BCHAR_WIDTH+1, BCHAR_HEIGHT, xoff, yoff);
 355             xoff+=(BCHAR_WIDTH + 1);
 356         }
 357         else
 358         {
 359             copyXPMArea(66, 10, BCHAR_WIDTH+1, BCHAR_HEIGHT, xoff, yoff);
 360             xoff+=(BCHAR_WIDTH + 1);
 361         }
 362     }
 363
 364 }
 365
 366 void DrawDate(void)
 367 {
 368     char BlitStr[20];
 369
 370     sprintf(BlitStr, "%s", daynames[clk->tm_wday]);
 371     BlitString( BlitStr, 6, 50);
 372
 373 #ifdef fr
 374
 375     // French date model
 376     sprintf(BlitStr, "%s", monthnames[clk->tm_mon]);
 377     BlitString( BlitStr, 40, 50);
 378
 379     sprintf(BlitStr, "%02i", clk->tm_mday);
 380     BlitString( BlitStr, 25, 50);
 381 #else
 382
 383     sprintf(BlitStr, "%s", monthnames[clk->tm_mon]);
 384     BlitString( BlitStr, 25, 50);
 385
 386     sprintf(BlitStr, "%02i", clk->tm_mday);
 387     BlitString( BlitStr, 45, 50);
 388
 389 #endif
 390 }
 391
 392 void DrawInetWheel(void)
 393 {
 394     int WheelPos=0;
 395     int i;
 396     int xoff=0, yoff=0;
 397     int iTime;
 398
 399     // Calculate Wheel Position...
 400     iTime=(clk->tm_hour*3600+clk->tm_min*60+clk->tm_sec);
 401     iTime=iTime+((timezone-1)+3600);
 402     if (clk->tm_isdst)
 403         iTime-=3600;
 404     iTime=(iTime*1000)/8640;
 405
 406     if (iTime >= 10000)
 407         iTime-=10000;
 408     else
 409         if (iTime < 0)
 410             iTime+=10000;
 411
 412     iTime %= 10;
 413
 414     WheelPos = floor( (iTime *8) / 10);
 415
 416     // Draw the Wheel...
 417     i=WheelPos;
 418     yoff=35;
 419     xoff=67;
 420
 421     xoff+=19;
 422
 423     while(i)
 424     {
 425         xoff +=19;
 426         i--;
 427     }
 428
 429     copyXPMArea(xoff, yoff, 19, 19, 39, 29);
 430
 431 }
 432
 433
 434 void DrawStdWheel(void)
 435 {
 436     //19x33 = center
 437     //radius of 14
 438
 439     int sx, sy;
 440     int cx, cy;
 441     int dx, dy;
 442     int hr;
 443     double psi;
 444
 445     cx=19;
 446     cy=33;
 447
 448     sx = 2;
 449     sy = 97;
 450
 451     // Hour Hand...
 452
 453     DrawLine(cx, cy, prevhourx, prevhoury, 66, 9); // erase old line
 454
 455     hr = (clk->tm_hour % 12);
 456
 457     psi = hr * (M_PI / 6.0);
 458         psi += clk->tm_min * (M_PI / 360);
 459
 460     dx = floor(sin(psi) * 22 * 0.5 + 0.5);
 461     dy = floor(-cos(psi) * 16 * 0.5 + 0.5);
 462
 463     dx += cx;
 464     dy += cy;
 465
 466     prevhourx=dx;
 467     prevhoury=dy;
 468
 469     DrawLine(cx, cy, dx, dy, sx, sy);
 470
 471     // Minute Hand...
 472
 473     DrawLine(cx, cy, prevminx, prevminy, 66, 9); // erase old line
 474
 475     cx=19;
 476     cy=33;
 477     sx = 2;
 478     sy = 96;
 479
 480     psi = clk->tm_min * (M_PI / 30.0);
 481         psi += clk->tm_sec * (M_PI / 1800);
 482
 483     dx = floor(sin(psi) * 22 * 0.7 + 0.5);
 484         dy = floor(-cos(psi) * 16 * 0.7 + 0.5);
 485
 486     dx += cx;
 487     dy += cy;
 488
 489     prevminx = dx;
 490     prevminy = dy;
 491
 492
 493     DrawLine(cx, cy, dx, dy, sx, sy);
 494 }
 495
 496 void DrawLine(int x1, int y1, int x2, int y2, int sourcex, int sourcey)
 497 {
 498     int x, y;
 499     int deltax, deltay;
 500     int xs, ys;
 501
 502     float xd=0, yd=0;
 503     float xi, yi;
 504
 505     x = x1;
 506     y = y1;
 507
 508
 509     if ( (x2-x1) < 0)
 510         xs = -1;
 511     else
 512         xs = 1;
 513
 514     if ( (y2-y1) < 0)
 515         ys = -1;
 516     else
 517         ys = 1;
 518
 519     deltax = abs( x2 - x1 );
 520     deltay = abs( y2 - y1 );
 521
 522     if (deltay !=0)
 523         xi = (float) ((float)deltax / (float) deltay);
 524     else
 525         xi=0;
 526
 527     if (deltax !=0)
 528         yi = (float) ((float)deltay / (float) deltax);
 529     else
 530         yi=0;
 531
 532     if ( deltax > deltay )
 533     {
 534         for (x=x1; x!= x2; x+= xs)
 535         {
 536             yd += yi;
 537             y += (int) (yd * ys);
 538
 539             copyXPMArea(sourcex, sourcey, 1, 1, x, y);
 540
 541             yd -= (int) yd;
 542         }
 543     }
 544     else
 545     {
 546         for (y=y1; y!= y2; y+= ys)
 547         {
 548             xd += xi;
 549             x += (int) (xd * xs);
 550
 551             copyXPMArea(sourcex, sourcey, 1, 1, x, y);
 552
 553             xd -= (int) xd;
 554         }
 555     }
 556 }
 557
 558
 559
 560 // Blits a string at given co-ordinates
 561 void BlitString(char *name, int x, int y)
 562 {
 563     int         i;
 564         int             c;
 565     int         k;
 566
 567         k = x;
 568     for (i=0; name[i]; i++)
 569     {
 570
 571         c = toupper(name[i]);
 572         if (c >= 'A' && c <= 'Z')
 573         {   // its a letter
 574                         c -= 'A';
 575                         copyXPMArea(c * 6, 74, 6, 8, k, y);
 576                         k += 6;
 577         }
 578         else
 579         {   // its a number or symbol
 580                         c -= '0';
 581                         copyXPMArea(c * 6, 64, 6, 8, k, y);
 582                         k += 6;
 583                 }
 584         }
 585
 586 }
 587
 588 void BlitNum(int num, int x, int y)
 589 {
 590     char buf[1024];
 591     int newx=x;
 592
 593     sprintf(buf, "%03i", num);
 594
 595     BlitString(buf, newx, y);
 596 }
 597
 598
 599 // ReadConfigSetting
 600 int ReadConfigString(FILE *fp, char *setting, char *value)
 601 {
 602     char str[1024];
 603     char buf[1024];
 604     int i;
 605     int len;
 606     int slen;
 607     char *p=NULL;
 608
 609
 610     if (!fp)
 611     {
 612         return 0;
 613     }
 614
 615     sprintf(str, "%s=", setting);
 616     slen = strlen(str);
 617
 618     fseek(fp, 0, SEEK_SET);
 619
 620     while ( !feof(fp) )
 621     {
 622
 623         if (!fgets(buf, 512, fp))
 624             break;
 625
 626         len = strlen(buf);
 627
 628         // strip linefeed
 629         for (i=0; i!=len; i++)
 630         {
 631             if (buf[i] == '\n')
 632             {
 633                 buf[i] = 0;
 634             }
 635         }
 636
 637         //printf("Scanning '%s'...\n", buf);
 638         if ( strncmp(buf, str, strlen(str)) == 0)
 639         {
 640             // found our setting
 641
 642             for(i=0; i!=slen; i++)
 643             {
 644                 if ( buf[i] == '=' )
 645                 {
 646                     p=buf+i+1;
 647                     strcpy(value, p);
 648                     return 1;
 649                 }
 650             }
 651
 652         }
 653     }
 654
 655         return 0;
 656 }
 657
 658 int ReadConfigInt(FILE *fp, char *setting, int *value)
 659 {
 660     char buf[1024];
 661
 662     if (ReadConfigString(fp, setting, (char *) &buf))
 663     {
 664         *value = atoi(buf);
 665         return 1;
 666     }
 667
 668     return 0;
 669 }
 670
 671 int Read_Config_File( char *filename )
 672 {
 673     FILE *fp;
 674
 675     fp = fopen(filename, "r");
 676     if (fp)
 677     {
 678
 679         fclose(fp);
 680         return 1;
 681     }
 682     else
 683     {
 684         perror("Read_Config_File");
 685         fprintf(stderr, "Unable to open %s, no settings read.\n", filename);
 686         return 0;
 687     }
 688
 689 }
 690
 691
 692
 693
 694
 695
 696
 697 /*******************************************************************************\
 698 |* usage                                                                                                                                           *|
 699 \*******************************************************************************/
 700
 701 void usage(void)
 702 {
 703     fprintf(stderr, "\nWMiTIME - illusion <clarkd@skynet.ca>  http://www.neotokyo.org/illusion\n\n");
 704         fprintf(stderr, "usage:\n");
 705     fprintf(stderr, "    -12                       12-hour mode\n");
 706         fprintf(stderr, "    -display <display name>\n");
 707         fprintf(stderr, "    -geometry +XPOS+YPOS      initial window position\n");
 708 //    fprintf(stderr, "    -c <filename>             use specified config file\n");
 709     fprintf(stderr, "    -h                        this help screen\n");
 710         fprintf(stderr, "    -v                        print the version number\n");
 711     fprintf(stderr, "\n");
 712 }
 713
 714 /*******************************************************************************\
 715 |* printversion                                                                                                                            *|
 716 \*******************************************************************************/
 717
 718 void printversion(void)
 719 {
 720         fprintf(stderr, "wmitime v%s\n", WMITIME_VERSION);
 721 }