wmthemech/src/wmThemeCh.c

   1 #include <config.h>
   2
   3 #include <stdio.h>
   4 #include <stdlib.h>
   5 #include <string.h>
   6
   7 #include <unistd.h>
   8 #include <dirent.h>
   9 #include <sys/stat.h>
  10 #include <fcntl.h>
  11
  12 #include <X11/X.h>
  13 #include <X11/xpm.h>
  14
  15 #include <time.h>
  16 #include "wmgeneral.h"
  17 #include "stringlist.h"
  18
  19 #include "xpm/back.xpm"
  20 #include "xpm/star.xpm"
  21 #include "xpm/no_icon.xpm"
  22
  23
  24
  25 /*
  26  *  Delay between refreshes (in microseconds)
  27  */
  28 #define DELAY 10000L
  29
  30 #define ICONSIZE 64
  31
  32
  33 /* Database structures */
  34
  35 enum th_type {THEME, WALL};
  36
  37 struct theme {
  38         enum th_type type;
  39         char       * path;
  40 /*      int          theme;
  41         char       * options;*/
  42 };
  43
  44 struct category {
  45         char * name;
  46         LIST * themes;
  47 };
  48
  49
  50 LIST * thm_db;
  51 LIST * cat_db;
  52
  53 /* Themes directories, last one will be replaced */
  54 char * themes_dir[] = {
  55         "/usr/share/WindowMaker/Themes",
  56         "/usr/X11R6/share/WindowMaker/Themes",
  57         "/usr/local/share/WindowMaker/Themes",
  58         "$GNUSTEP_USER_ROOT/Library/WindowMaker/Themes"
  59 };
  60
  61
  62 /* Wallpapers directories, last one will be replaced */
  63 char * wallpapers_dir[] = {
  64         "/usr/share/WindowMaker/Backgrounds",
  65         "/usr/X11R6/share/WindowMaker/Backgrounds",
  66         "/usr/local/share/WindowMaker/Backgrounds",
  67         "$GNUSTEP_USER_ROOT/Library/WindowMaker/Backgrounds"
  68 };
  69
  70
  71 char hid_cat_db[] = ".wmThemeCh.cat.db";
  72 char     cat_db_file[] =  "wmThemeCh.cat.db";
  73 char reg_cat   [] = "categories";
  74
  75 int current_category = 0;
  76 unsigned long int auto_switch_delay = 0;
  77 unsigned long int auto_switch_next = 0;
  78
  79 char * mask_bits;
  80
  81 XpmAttributes   Attributes;
  82 Colormap        cmap;
  83
  84
  85 int
  86 BuildBitmask ()
  87 {
  88         int i, j, off = 0;
  89         int size = (ICONSIZE * ICONSIZE - 1) / 8 + 1;
  90
  91         mask_bits = malloc (size);
  92
  93         /* must have iconsize % 8 = 0 */
  94
  95         for (i = 0; i < 4 * ICONSIZE / 8; i++) {
  96                 mask_bits[off++] = 0;
  97         }
  98         for (i = 0; i < ICONSIZE - 8; i++) {
  99                 mask_bits[off++] = 0xf0;
 100                 for (j = 0; j < (ICONSIZE / 8 - 2); j++) {
 101                         mask_bits[off++] = 0xff;
 102                 }
 103                 mask_bits[off++] = 0x0f;
 104         }
 105         for (i = 0; i < 4 * ICONSIZE / 8; i++) {
 106                 mask_bits[off++] = 0;
 107         }
 108
 109         return 0;
 110 }
 111
 112
 113 #define ADD_CATEGORY(string) \
 114         do {                                                         \
 115                 struct category * newcat;                            \
 116                                                                      \
 117                 newcat         = malloc (sizeof (struct category) ); \
 118                 newcat->name   = strdup (string);                    \
 119                 newcat->themes = create_list ();                     \
 120                 add_item (cat_db, (unsigned int) newcat);            \
 121         } while (0);
 122
 123 #define PROCESS_CATEGORY_FILE \
 124         if ( (catfile = fopen (catname,"r") ) )                     \
 125         {                                                           \
 126                 while (fscanf (catfile, "%255s", ImageName) == 1) { \
 127                         ADD_CATEGORY(ImageName);                    \
 128                 }                                                   \
 129                 fclose (catfile);                                   \
 130         }                                                           \
 131         free (catname);
 132
 133 /* Register categories recognized by system + user */
 134 int
 135 get_categories ()
 136 {
 137         char * catname;
 138         char * home = getenv ("HOME");
 139         char   ImageName[256];
 140         FILE * catfile;
 141
 142         ADD_CATEGORY("*");
 143
 144         catname = malloc (strlen (home) + strlen (PACKAGE_NAME)
 145                 + strlen (reg_cat) + 4);
 146
 147         sprintf (catname, "%s/.%s/%s", home, PACKAGE_NAME, reg_cat);
 148
 149         PROCESS_CATEGORY_FILE
 150
 151         catname = malloc (strlen (PACKAGE) + strlen (reg_cat) + 13);
 152
 153         sprintf (catname, "/usr/share/%s/%s", PACKAGE, reg_cat);
 154
 155         PROCESS_CATEGORY_FILE
 156
 157         catname = malloc (strlen (PACKAGE) + strlen (reg_cat) + 19);
 158
 159         sprintf (catname, "/usr/local/share/%s/%s", PACKAGE, reg_cat);
 160
 161         PROCESS_CATEGORY_FILE
 162
 163         return 0;
 164 }
 165
 166
 167 enum de_type { ERROR = -1, IGNORED, STYLE, DE_THEME, SUBDIR, IMAGE };
 168
 169 /* Return values :
 170  * -1 : stat error
 171  *  0 : Ignored entries : ., .., category
 172  *  1 : regular file (.style)
 173  *  2 : theme directory (.themed)
 174  *  3 : sub-directory
 175  *  4 : image
 176  */
 177 enum de_type
 178 entry_type (char * dir, char * entry)
 179 {
 180         char * name = malloc (strlen (dir) + strlen (entry) + 2);
 181         struct stat buf;
 182
 183         sprintf (name, "%s/%s", dir, entry);
 184
 185         if (stat (name, &buf) ) {
 186                 perror ("stat ");
 187                 free (name);
 188                 return ERROR;
 189         }
 190
 191         free (name);
 192
 193         if (! S_ISDIR (buf.st_mode) ) {
 194                 if (! strcmp (entry,cat_db_file ) ) return IGNORED;
 195                 if (! strcmp (entry,hid_cat_db) ) return IGNORED;
 196                 /* TODO : Use file (1) */
 197                 if (strstr (entry, ".xpm" ) ) return IMAGE;
 198                 if (strstr (entry, ".png" ) ) return IMAGE;
 199                 if (strstr (entry, ".jpg" ) ) return IMAGE;
 200                 if (strstr (entry, ".jpeg") ) return IMAGE;
 201                 if (strstr (entry, ".tif" ) ) return IMAGE;
 202                 if (strstr (entry, ".ppm" ) ) return IMAGE;
 203
 204                 return STYLE;
 205         }
 206
 207         if (strstr (entry, ".themed")                  ) return DE_THEME;
 208         if (strcmp (entry,"." ) && strcmp (entry,"..") ) return SUBDIR;
 209
 210         return IGNORED;
 211 }
 212
 213
 214 struct theme *
 215 insert_into_thm (char * path, enum th_type type)
 216 {
 217         struct theme * new_theme = malloc (sizeof (struct theme) );
 218
 219         new_theme->type = type;
 220         new_theme->path = strdup (path);
 221         add_item (thm_db, (int) new_theme);
 222
 223         return new_theme;
 224 }
 225
 226 int
 227 insert_into_cat (struct theme * theme, LIST * cat_list)
 228 {
 229         int i, j, lcat;
 230         char * lcat_nam;
 231
 232         add_item ( ( (struct category *) get_item (cat_db, 0) ) -> themes,
 233                 (int) theme);
 234
 235         /* for each category theme is in */
 236         for (j = 0; (lcat = get_item (cat_list, j) ) != -1; j++) {
 237                 int ucat;
 238                 lcat_nam = (char *) lcat;
 239                 /* for each user category */
 240                 for (i=1; (ucat = get_item (cat_db, i) ) != -1; i++) {
 241                         struct category * cat = (struct category *) ucat;
 242                         /* check if they match */
 243                         if (! strcmp (lcat_nam, cat->name) ) {
 244                                 add_item (cat->themes, (int) theme);
 245                                 break;
 246                         }
 247                 }
 248         }
 249
 250         return 0;
 251 }
 252
 253 LIST *
 254 theme_specific_cat (char * path, LIST * cat_list)
 255 {
 256         FILE * th_cat;
 257         char * th_cat_nam = malloc (strlen (path) + strlen (hid_cat_db) + 2);
 258         int i, ret, version, subversion;
 259         char cat_nam[512];
 260         LIST * new_list;
 261
 262         sprintf (th_cat_nam, "%s/%s", path, cat_db_file);
 263         th_cat = fopen (th_cat_nam, "r");
 264
 265         if (! th_cat) {
 266                 sprintf (th_cat_nam, "%s/%s", path, hid_cat_db);
 267                 th_cat = fopen (th_cat_nam, "r");
 268
 269                 if (! th_cat) {
 270                         free (th_cat_nam);
 271                         return cat_list;
 272                 }
 273         }
 274
 275         ret = fscanf (th_cat, "# wmThemeCh categories database file version %i.%i",
 276                 &version, &subversion);
 277
 278         if (ret != 2) {
 279                 printf("%s : invalid signature\n", th_cat_nam);
 280                 fclose (th_cat);
 281                 free (th_cat_nam);
 282                 return cat_list;
 283         }
 284
 285         if (version > 1) {
 286                 printf("%s : incompatible version\n", th_cat_nam);
 287                 fclose (th_cat);
 288                 free (th_cat_nam);
 289                 return cat_list;
 290         }
 291
 292         new_list = create_list ();
 293         add_list (new_list, cat_list);
 294
 295         while ( (ret = fscanf (th_cat, "%s", cat_nam) ) == 1) {
 296                 for (i=0; get_item (cat_db,i) != -1; i++) {
 297                         struct category * cat =
 298                                 (struct category *) get_item (cat_db,i);
 299                         if (! strcmp (cat_nam, cat->name) ) {
 300 /*                              printf("%s : '%s'\n", th_cat_nam, cat_nam); */
 301                                 add_item (new_list, (int) strdup (cat->name) );
 302                                 break;
 303                         }
 304                 }
 305         }
 306
 307         fclose (th_cat);
 308         free (th_cat_nam);
 309
 310         return new_list;
 311 }
 312
 313 /* Read "categories" file in path.
 314  * Themes in path and its subdirs are belonging to categories listed
 315  * in that file if these categories are defined by user profile.
 316  * Updates cat_list accordingly.
 317  */
 318 int
 319 add_dir_cat (const char * path, LIST * cat_list)
 320 {
 321         FILE * th_cat;
 322         char * th_cat_nam = malloc (strlen (path) + strlen (hid_cat_db) + 2);
 323         int ret, version, subversion;
 324         char cat_nam[512];
 325
 326         sprintf (th_cat_nam, "%s/%s", path, hid_cat_db);
 327         th_cat = fopen (th_cat_nam, "r");
 328
 329         if (! th_cat) {
 330                 free (th_cat_nam);
 331                 return 0;
 332         }
 333
 334         ret = fscanf (th_cat, "# wmThemeCh categories database file version %i.%i",
 335                 &version, &subversion);
 336
 337         if (ret != 2) {
 338                 printf("%s : invalid signature\n", th_cat_nam);
 339                 fclose (th_cat);
 340                 free (th_cat_nam);
 341                 return 0;
 342         }
 343
 344
 345         while ( (ret = fscanf (th_cat, "%s", cat_nam) ) == 1) {
 346                 int i;
 347
 348                 for (i=0; get_item (cat_db, i) != -1; i++) {
 349                         struct category * cat =
 350                                 (struct category *) get_item (cat_db, i);
 351                         if (! strcmp (cat_nam, cat->name) ) {
 352 /*                              printf("%s : '%s'\n", th_cat_nam, cat_nam); */
 353                                 add_item (cat_list, (int) strdup (cat->name) );
 354                                 break;
 355                         }
 356                 }
 357         }
 358
 359         fclose (th_cat);
 360         free (th_cat_nam);
 361
 362         return 0;
 363 }
 364
 365
 366 int
 367 get_themes (char * path, LIST * par_cat_list)
 368 {
 369         struct dirent ** namelist;
 370         LIST * cat_list = create_list();
 371         int    themes_count = 0;
 372
 373         int count = scandir (path, &namelist, NULL, alphasort);
 374
 375         if (count < 0) {
 376                 free (cat_list);
 377                 return -1;
 378         }
 379
 380         if (par_cat_list) add_list (cat_list, par_cat_list);
 381
 382         add_dir_cat (path, cat_list);
 383
 384         while (count--) {
 385                 char fullname[512];
 386                 struct theme * new_theme;
 387                 LIST * th_spec_cat;
 388
 389                 sprintf (fullname, "%s/%s", path, namelist[count]->d_name);
 390
 391                 switch (entry_type (path, namelist[count]->d_name) ) {
 392                 case ERROR   :
 393                 case IGNORED : break;
 394                 case STYLE   :
 395                         new_theme = insert_into_thm (fullname, THEME);
 396                         insert_into_cat (new_theme, cat_list);
 397                         break;
 398                 case DE_THEME  :
 399                         new_theme = insert_into_thm (fullname, THEME);
 400                         th_spec_cat = theme_specific_cat (fullname, cat_list);
 401                         insert_into_cat (new_theme, th_spec_cat);
 402                         if (th_spec_cat != cat_list) {
 403                                 delete_list (th_spec_cat);
 404                         }
 405                         break;
 406                 case SUBDIR :
 407                         get_themes (fullname, cat_list);
 408                 case IMAGE  : break;
 409                 }
 410         }
 411
 412         free (cat_list);
 413
 414         return 0;
 415 }
 416
 417 int
 418 get_wallpapers (char * path, LIST * par_cat_list)
 419 {
 420         struct dirent ** namelist;
 421         LIST * cat_list = create_list();
 422         int    themes_count = 0;
 423
 424         int count = scandir (path, &namelist, NULL, NULL);
 425
 426         if (count < 0) {
 427                 free (cat_list);
 428                 return -1;
 429         }
 430
 431         if (par_cat_list) add_list (cat_list, par_cat_list);
 432
 433         add_dir_cat (path, cat_list);
 434
 435         while (count--) {
 436                 char fullname[512];
 437                 struct theme * new_theme;
 438
 439                 sprintf (fullname, "%s/%s", path, namelist[count]->d_name);
 440
 441                 switch (entry_type (path, namelist[count]->d_name) ) {
 442                 case ERROR   :
 443                 case IGNORED :
 444                 case STYLE   :
 445                 case DE_THEME: break;
 446                 case SUBDIR  :
 447                         get_wallpapers (fullname, cat_list);
 448                         break;
 449                 case IMAGE   :
 450                         new_theme = insert_into_thm (fullname, WALL);
 451                         insert_into_cat (new_theme, cat_list);
 452                 }
 453         }
 454
 455         free (cat_list);
 456
 457         return 0;
 458 }
 459
 460 int
 461 BuildDatabase ()
 462 {
 463         char * user_theme_dir     = "/Library/WindowMaker/Themes";
 464         char * user_wallpaper_dir = "/Library/WindowMaker/Backgrounds";
 465         char * gnustep_user_root  = getenv("GNUSTEP_USER_ROOT");
 466
 467         int dir_idx;
 468
 469         thm_db = create_list();
 470         cat_db = create_list();
 471
 472         if (!gnustep_user_root) {
 473                 char * home = getenv ("HOME");
 474                 gnustep_user_root = malloc (strlen (home) + 9);
 475                 sprintf (gnustep_user_root, "%s/GNUstep", home);
 476         }
 477
 478         themes_dir[3] = malloc (strlen (gnustep_user_root)
 479                 + strlen (user_theme_dir) + 1);
 480         sprintf (themes_dir[3], "%s%s", gnustep_user_root, user_theme_dir);
 481
 482         wallpapers_dir[3] = malloc (strlen (gnustep_user_root)
 483                 + strlen (user_wallpaper_dir) + 1);
 484         sprintf (wallpapers_dir[3], "%s%s", gnustep_user_root, user_wallpaper_dir);
 485
 486         get_categories ();
 487
 488         for (dir_idx=0; dir_idx < 4; dir_idx++) {
 489                 get_themes     (    themes_dir[dir_idx], NULL);
 490                 get_wallpapers (wallpapers_dir[dir_idx], NULL);
 491         }
 492
 493         return 0;
 494 }
 495
 496
 497 \f
 498
 499
 500 char *
 501 get_pixmap_path (const char * icon_name)
 502 {
 503         char * path;
 504         char * home = getenv ("HOME");
 505         struct stat stat_buf;
 506
 507         path = malloc ( strlen (home) + strlen (PACKAGE_NAME)
 508                       + strlen (icon_name) + 8);
 509
 510         sprintf (path, "%s/.%s/%s.xpm", home, PACKAGE_NAME, icon_name);
 511
 512         if (! stat (path, &stat_buf) ) {
 513                 return path;
 514         }
 515
 516         free (path);
 517         path = malloc (strlen (PACKAGE) + strlen (icon_name) + 23);
 518
 519         sprintf (path, "/usr/local/share/%s/%s.xpm", PACKAGE, icon_name);
 520
 521         if (! stat (path, &stat_buf) ) {
 522                 return path;
 523         }
 524
 525         free (path);
 526         path = malloc (strlen (PACKAGE) + strlen (icon_name) + 17);
 527
 528         sprintf (path, "/usr/share/%s/%s.xpm", PACKAGE, icon_name);
 529
 530         if (! stat (path, &stat_buf) ) {
 531                 return path;
 532         }
 533
 534         free (path);
 535         return NULL;
 536 }
 537
 538
 539 int
 540 DrawPixmap (char * XpmFileName)
 541 {
 542         static Pixmap NewPixmap, NewShapeMask = 0;
 543         static int ret, havePixmap= 0;
 544
 545 /*      copyXPMArea(5, 69, 54, 54, 5, 5); * Clear window */
 546         copyXPMArea(4, 4, 56, 56, 4, 4); /* Clear window */
 547
 548         if (havePixmap) {
 549                 /*
 550                 * free up the colors, if we alloc'd some before
 551                 */
 552                 if (Attributes.nalloc_pixels > 0)
 553                         XFreeColors(display, cmap,  Attributes.alloc_pixels,
 554                                 Attributes.nalloc_pixels, 0);
 555                 /*
 556                  *  Free last pixmap -- we dont need it anymore...
 557                  *  A ShapeMask is returned if the Pixmap
 558                  *  had the color None used.
 559                  *  We could probably change Transparent to None
 560                  *  to make use of this, but for now,
 561                  *  lets just ignore it...
 562                  */
 563                 if (NewShapeMask != 0) XFreePixmap (display, NewShapeMask);
 564
 565                 XFreePixmap(display, NewPixmap);
 566
 567                 XpmFreeAttributes (&Attributes);
 568
 569                 havePixmap= 0;
 570         } /* havePixmap */
 571
 572         /*
 573          *   Grab new pixmap. Accept a reasonable color match.
 574          */
 575         Attributes.valuemask   = XpmExactColors | XpmCloseness
 576                                        | XpmReturnAllocPixels;
 577         Attributes.exactColors = 0;
 578         Attributes.closeness   = 40000;
 579
 580         /* TODO : We might cache icons */
 581
 582         if (XpmFileName) {
 583                 if (strcmp (XpmFileName,"*") ) {
 584                         ret = XpmReadFileToPixmap (display, Root, XpmFileName,
 585                                 &NewPixmap, &NewShapeMask, &Attributes);
 586                 } else {
 587                         ret = XpmCreatePixmapFromData (display, Root, star_xpm,
 588                                 &NewPixmap, &NewShapeMask, &Attributes);
 589                 }
 590         } else {
 591                 ret = XpmCreatePixmapFromData (display, Root, no_icon_xpm,
 592                         &NewPixmap, &NewShapeMask, &Attributes);
 593         }
 594
 595         if (ret >= 0)
 596         {
 597                 int Height = Attributes.height;
 598                 XCopyArea (display, NewPixmap, wmgen.pixmap, NormalGC,
 599                         0, 0, Attributes.width, Height, 4, 4);
 600                 havePixmap= 1;
 601         }
 602
 603         /*
 604          * Make changes visible
 605          */
 606         RedrawWindow();
 607
 608         return 0;
 609 }
 610
 611
 612 \f
 613
 614
 615 int
 616 ChangeCategory ()
 617 {
 618         char * XpmFileName = NULL;
 619
 620         current_category++;
 621         if (get_item (cat_db, current_category) == -1) current_category = 0;
 622         if (current_category) {
 623                 XpmFileName = get_pixmap_path (
 624                         ( (struct category *) get_item
 625                                 (cat_db, current_category) ) -> name);
 626         } else {
 627                 XpmFileName = strdup("*");
 628         }
 629
 630         DrawPixmap (XpmFileName);
 631
 632         if (XpmFileName) free (XpmFileName);
 633
 634         return 0;
 635 }
 636
 637
 638 int
 639 ChangeTheme ()
 640 {
 641         int fd;
 642         char Command[512];
 643
 644         static unsigned int oldidx = -1;
 645         unsigned int val, i;
 646         struct category * cur_cat = (struct category *)
 647                 get_item (cat_db, current_category);
 648
 649         for (i = 0; get_item (cur_cat->themes, i) != -1; i++);
 650
 651         switch (i) {
 652         case  0 : return 1;
 653         case  1 : val = 0; break;
 654         default :
 655                 fd = open ("/dev/random", O_RDONLY);
 656
 657                 /* We're disallowing "changing" to the same */
 658                 read (fd, &val, sizeof (int) );
 659                 val = val % (i - 1);
 660                 if (val >= oldidx) val++;
 661
 662                 close (fd);
 663                 oldidx = val;
 664         }
 665
 666         switch ( ( (struct theme *) get_item (cur_cat->themes, val) ) -> type) {
 667         case THEME :
 668                 sprintf (Command, "setstyle \"%s\"", ( (struct theme *)
 669                         get_item (cur_cat->themes, val) ) -> path);
 670                 break;
 671         case WALL :
 672                 sprintf (Command, "wmsetbg -u \"%s\"", ( (struct theme *)
 673                         get_item (cur_cat->themes, val) ) -> path);
 674         }
 675
 676         system(Command);
 677
 678         auto_switch_next = time(NULL) + (auto_switch_delay * 60);
 679         return 0;
 680 }
 681
 682
 683 void
 684 pressEvent (XButtonEvent *xev)
 685 {
 686         /* Mouse's left button clicked */
 687         if (xev->button == Button1) ChangeTheme ();
 688
 689         /* Mouse's right button clicked */
 690         if (xev->button == Button3) ChangeCategory ();
 691 }
 692
 693
 694 int
 695 ProcessXEvents ()
 696 {
 697         while (XPending (display) )
 698         {
 699                 XEvent event;
 700
 701                 XNextEvent (display, &event);
 702
 703                 switch (event.type) {
 704                 case Expose        : RedrawWindow ();             break;
 705                 case ButtonPress   : pressEvent (&event.xbutton); break;
 706                 case ButtonRelease : break;
 707                 }
 708         }
 709
 710         return 0;
 711 }
 712
 713
 714 \f
 715
 716
 717 void
 718 print_usage ()
 719 {
 720         printf ("%s\n", PACKAGE_STRING);
 721         printf ("Report problems to <%s>\n", PACKAGE_BUGREPORT);
 722         printf ("\nusage: %s [options]...\n\n", PACKAGE_NAME);
 723         printf ("\t-display <Display>\tUse alternate X display.\n");
 724         printf ("\t-h\t\t\tDisplay help screen.\n\n");
 725 }
 726
 727
 728 void
 729 ParseCMDLine (int argc, char *argv[])
 730 {
 731         int  i, x;
 732
 733         for (i = 1; i < argc; i++) {
 734                 if (strcmp(argv[i], "-a") == 0) {
 735                         if (argc > i+1) {
 736                                 x = sscanf(argv[i+1], "%u", &auto_switch_delay);
 737                                 if (x != 1) {
 738                                         auto_switch_delay = 0;
 739                                         printf("Found auto-option but could not parse parameter\n");
 740                                         exit(-1);
 741                                 } else {
 742                                         ++i;
 743                                 }
 744                         } else {
 745                                 printf("Found auto-option but number is missing!\n");
 746                                 exit(-1);
 747                         }
 748                 } else {
 749
 750                         if (!strcmp (argv[i], "-display") ) {
 751                                 ++i;
 752                         } else {
 753                                 print_usage();
 754                                 exit (1);
 755                         }
 756                 }
 757         }
 758 }
 759
 760
 761 int
 762 Init (int argc, char * argv[])
 763 {
 764         char * basename = current_category
 765                 ? ( (struct category *)
 766                         get_item (cat_db, current_category)
 767                   ) -> name
 768                 : NULL;
 769
 770         char * path = NULL;
 771
 772         ParseCMDLine  (argc, argv);
 773         BuildDatabase ();
 774
 775         if (current_category) {
 776                 path = get_pixmap_path (basename);
 777         } else {
 778                 path = strdup ("*");
 779         }
 780
 781         BuildBitmask();
 782         openXwindow (argc, argv, back_xpm, mask_bits,
 783                 ICONSIZE, ICONSIZE);
 784
 785         cmap = DefaultColormap(display, DefaultScreen(display));
 786
 787         Attributes.nalloc_pixels = 0;
 788
 789         DrawPixmap (path);
 790
 791         if (path) free (path);
 792
 793         return 0;
 794 }
 795
 796
 797 int
 798 main (int argc, char *argv[])
 799 {
 800         unsigned int delay_timer = 0;
 801         Init (argc, argv);
 802
 803         if (auto_switch_delay > 0) {
 804                 auto_switch_next = time(NULL) + (auto_switch_delay * 60);
 805         }
 806
 807         /* TODO : use sigsuspend */
 808
 809         while (1) {
 810                 ProcessXEvents ();
 811                 delay_timer += DELAY;
 812                 if ( delay_timer > 10000000L ) { /* check every 10 seconds */
 813                         delay_timer = 0;
 814                         if (auto_switch_delay > 0) {
 815                                 if (auto_switch_next < time(NULL)) {
 816                                         ChangeTheme();
 817                                 }
 818                         }
 819                 }
 820                 usleep (DELAY);
 821         }
 822 }