util/getstyle.c

   1 /* getstyle.c - outputs style related options from WindowMaker to stdout
   2  *
   3  *  WindowMaker window manager
   4  *
   5  *  Copyright (c) 1997, 1998 Alfredo K. Kojima
   6  *
   7  *  This program is free software; you can redistribute it and/or modify
   8  *  it under the terms of the GNU General Public License as published by
   9  *  the Free Software Foundation; either version 2 of the License, or
  10  *  (at your option) any later version.
  11  *
  12  *  This program is distributed in the hope that it will be useful,
  13  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *  GNU General Public License for more details.
  16  *
  17  *  You should have received a copy of the GNU General Public License
  18  *  along with this program; if not, write to the Free Software
  19  *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
  20  *  USA.
  21  */
  22
  23
  24 #define PROG_VERSION "getstyle (Window Maker) 0.4"
  25
  26
  27
  28 #include <stdlib.h>
  29 #include <stdio.h>
  30 #include <proplist.h>
  31 #include <string.h>
  32 #include <unistd.h>
  33 #include <string.h>
  34 #include <pwd.h>
  35 #include <limits.h>
  36 #include <assert.h>
  37
  38 #ifndef PATH_MAX
  39 #define PATH_MAX  1024
  40 #endif
  41
  42 #include "../src/wconfig.h"
  43
  44 /* table of style related options */
  45 static char *options[] = {
  46     "TitleJustify",
  47     "ClipTitleFont",
  48     "WindowTitleFont",
  49     "MenuTitleFont",
  50     "MenuTextFont",
  51     "IconTitleFont",
  52     "DisplayFont",
  53     "LargeDisplayFont",
  54     "HighlightColor",
  55     "HighlightTextColor",
  56     "ClipTitleColor",
  57     "CClipTitleColor",
  58     "FTitleColor",
  59     "PTitleColor",
  60     "UTitleColor",
  61     "FTitleBack",
  62     "PTitleBack",
  63     "UTitleBack",
  64     "ResizebarBack",
  65     "MenuTitleColor",
  66     "MenuTextColor",
  67     "MenuDisabledColor",
  68     "MenuTitleBack",
  69     "MenuTextBack",
  70     "IconBack",
  71     "IconTitleColor",
  72     "IconTitleBack",
  73     "MenuStyle",
  74     NULL
  75 };
  76
  77
  78 /* table of theme related options */
  79 static char *theme_options[] = {
  80     "WorkspaceBack",
  81     NULL
  82 };
  83
  84
  85
  86
  87 char *ProgName;
  88
  89 proplist_t PixmapPath = NULL;
  90
  91 char *ThemePath = NULL;
  92
  93
  94 void
  95 print_help()
  96 {
  97     printf("Usage: %s [OPTIONS] [FILE]\n", ProgName);
  98     puts("Retrieves style/theme configuration and output to FILE or to stdout");
  99     puts("");
 100     puts("  -t, --theme-options output theme related options when producing a style file");
 101     puts("  -p, --pack          produce output as a theme pack");
 102     puts("  --help              display this help and exit");
 103     puts("  --version           output version information and exit");
 104 }
 105
 106
 107 char*
 108 globalDefaultsPathForDomain(char *domain)
 109 {
 110     char path[1024];
 111     char *tmp;
 112
 113     sprintf(path, "%s/%s", SYSCONFDIR, domain);
 114
 115     tmp = malloc(strlen(path)+2);
 116     assert(tmp!=NULL);
 117     strcpy(tmp, path);
 118
 119     return tmp;
 120 }
 121
 122
 123 char*
 124 defaultsPathForDomain(char *domain)
 125 {
 126     char path[1024];
 127     char *gspath, *tmp;
 128
 129     gspath = getenv("GNUSTEP_USER_ROOT");
 130     if (gspath) {
 131         strcpy(path, gspath);
 132         strcat(path, "/");
 133     } else {
 134         char *home;
 135
 136         home = getenv("HOME");
 137         if (!home) {
 138             printf("%s:could not get HOME environment variable!\n", ProgName);
 139             exit(0);
 140         }
 141         strcpy(path, home);
 142         strcat(path, "/GNUstep/");
 143     }
 144     strcat(path, DEFAULTS_DIR);
 145     strcat(path, "/");
 146     strcat(path, domain);
 147
 148     tmp = malloc(strlen(path)+2);
 149     strcpy(tmp, path);
 150
 151     return tmp;
 152 }
 153
 154
 155 BOOL
 156 StringCompareHook(proplist_t pl1, proplist_t pl2)
 157 {
 158     char *str1, *str2;
 159
 160     str1 = PLGetString(pl1);
 161     str2 = PLGetString(pl2);
 162
 163     if (strcasecmp(str1, str2)==0)
 164       return YES;
 165     else
 166       return NO;
 167 }
 168
 169
 170 void
 171 abortar(char *reason)
 172 {
 173     char buffer[4000];
 174
 175     printf("%s: %s\n", ProgName, reason);
 176
 177     if (ThemePath) {
 178         printf("Removing unfinished theme pack\n");
 179         sprintf(buffer, "/bin/rm -fr \"%s\"", ThemePath);
 180
 181         if (system(buffer)!=0) {
 182             printf("%s: could not execute command %s\n", ProgName, buffer);
 183         }
 184     }
 185     exit(1);
 186 }
 187
 188
 189
 190
 191 char*
 192 wgethomedir()
 193 {
 194     char *home = getenv("HOME");
 195     struct passwd *user;
 196
 197     if (home)
 198       return home;
 199
 200     user = getpwuid(getuid());
 201     if (!user) {
 202         char buffer[80];
 203
 204         sprintf(buffer, "could not get password entry for UID %i", getuid());
 205         perror(buffer);
 206         return "/";
 207     }
 208     if (!user->pw_dir) {
 209         return "/";
 210     } else {
 211         return user->pw_dir;
 212     }
 213 }
 214
 215
 216 void*
 217 wmalloc(int size)
 218 {
 219     void *tmp;
 220
 221     tmp = malloc(size);
 222     if (!tmp) {
 223         abortar("out of memory");
 224     }
 225
 226     return tmp;
 227 }
 228
 229
 230 char*
 231 wstrdup(char *str)
 232 {
 233     char *tmp;
 234
 235     tmp = wmalloc(strlen(str)+1);
 236
 237     strcpy(tmp, str);
 238
 239     return tmp;
 240 }
 241
 242
 243 static char*
 244 getuserhomedir(char *username)
 245 {
 246     struct passwd *user;
 247
 248     user = getpwnam(username);
 249     if (!user) {
 250         char buffer[100];
 251
 252         sprintf(buffer,"could not get password entry for user %s", username);
 253         perror(buffer);
 254         return NULL;
 255     }
 256     if (!user->pw_dir) {
 257         return "/";
 258     } else {
 259         return user->pw_dir;
 260     }
 261 }
 262
 263
 264
 265
 266 char*
 267 wexpandpath(char *path)
 268 {
 269     char buffer2[PATH_MAX+2];
 270     char buffer[PATH_MAX+2];
 271     int i;
 272
 273     memset(buffer, 0, PATH_MAX+2);
 274
 275     if (*path=='~') {
 276         char *home;
 277
 278         path++;
 279         if (*path=='/' || *path==0) {
 280             home = wgethomedir();
 281             strcat(buffer, home);
 282         } else {
 283             int j;
 284             j = 0;
 285             while (*path!=0 && *path!='/') {
 286                 buffer2[j++] = *path;
 287                 buffer2[j] = 0;
 288                 path++;
 289             }
 290             home = getuserhomedir(buffer2);
 291             if (!home)
 292                 return NULL;
 293             strcat(buffer, home);
 294         }
 295     }
 296
 297     i = strlen(buffer);
 298
 299     while (*path!=0) {
 300         char *tmp;
 301
 302         if (*path=='$') {
 303             int j = 0;
 304             path++;
 305             /* expand $(HOME) or $HOME style environment variables */
 306             if (*path=='(') {
 307                 path++;
 308                 while (*path!=0 && *path!=')') {
 309                     buffer2[j++] = *(path++);
 310                     buffer2[j] = 0;
 311                 }
 312                 if (*path==')')
 313                     path++;
 314                 tmp = getenv(buffer2);
 315                 if (!tmp) {
 316                     buffer[i] = 0;
 317                     strcat(buffer, "$(");
 318                     strcat(buffer, buffer2);
 319                     strcat(buffer, ")");
 320                     i += strlen(buffer2)+3;
 321                 } else {
 322                     strcat(buffer, tmp);
 323                     i += strlen(tmp);
 324                 }
 325             } else {
 326                 while (*path!=0 && *path!='/') {
 327                     buffer2[j++] = *(path++);
 328                     buffer2[j] = 0;
 329                 }
 330                 tmp = getenv(buffer2);
 331                 if (!tmp) {
 332                     strcat(buffer, "$");
 333                     strcat(buffer, buffer2);
 334                     i += strlen(buffer2)+1;
 335                 } else {
 336                     strcat(buffer, tmp);
 337                     i += strlen(tmp);
 338                 }
 339             }
 340         } else {
 341             buffer[i++] = *path;
 342             path++;
 343         }
 344     }
 345
 346     return wstrdup(buffer);
 347 }
 348
 349
 350
 351 char*
 352 wfindfileinarray(proplist_t paths, char *file)
 353 {
 354     int i;
 355     char *path;
 356     int len, flen;
 357     char *fullpath;
 358
 359     if (!file)
 360         return NULL;
 361
 362     if (*file=='/' || *file=='~' || !paths || !PLIsArray(paths)
 363         || PLGetNumberOfElements(paths)==0) {
 364         if (access(file, R_OK)<0) {
 365             fullpath = wexpandpath(file);
 366             if (!fullpath)
 367                 return NULL;
 368
 369             if (access(fullpath, R_OK)<0) {
 370                 free(fullpath);
 371                 return NULL;
 372             } else {
 373                 return fullpath;
 374             }
 375         } else {
 376             return wstrdup(file);
 377         }
 378     }
 379
 380     flen = strlen(file);
 381     for (i=0; i < PLGetNumberOfElements(paths); i++) {
 382         proplist_t tmp;
 383         char *dir;
 384
 385         tmp = PLGetArrayElement(paths, i);
 386         if (!PLIsString(tmp) || !(dir = PLGetString(tmp)))
 387             continue;
 388
 389         len = strlen(dir);
 390         path = wmalloc(len+flen+2);
 391         path = memcpy(path, dir, len);
 392         path[len]=0;
 393         strcat(path, "/");
 394         strcat(path, file);
 395         /* expand tilde */
 396         fullpath = wexpandpath(path);
 397         free(path);
 398         if (fullpath) {
 399             /* check if file is readable */
 400             if (access(fullpath, R_OK)==0) {
 401                 return fullpath;
 402             }
 403             free(fullpath);
 404         }
 405     }
 406     return NULL;
 407 }
 408
 409
 410
 411
 412 void
 413 copyFile(char *dir, char *file)
 414 {
 415     char buffer[4000];
 416
 417     sprintf(buffer, "/bin/cp \"%s\" \"%s\"", file, dir);
 418     if (system(buffer)!=0) {
 419         printf("%s: could not copy file %s\n", ProgName, file);
 420     }
 421 }
 422
 423
 424 void
 425 findCopyFile(char *dir, char *file)
 426 {
 427     char *fullPath;
 428
 429     fullPath = wfindfileinarray(PixmapPath, file);
 430     if (!fullPath) {
 431         char buffer[4000];
 432
 433         sprintf(buffer, "coould not find file %s", file);
 434         abortar(buffer);
 435     }
 436     copyFile(dir, fullPath);
 437     free(fullPath);
 438 }
 439
 440
 441 char*
 442 makeThemePack(proplist_t style, char *themeName)
 443 {
 444     proplist_t keys;
 445     proplist_t key;
 446     proplist_t value;
 447     int i;
 448     char *themeDir;
 449
 450     themeDir = wmalloc(strlen(themeName)+50);
 451     sprintf(themeDir, "%s.themed", themeName);
 452     ThemePath = themeDir;
 453     {
 454         char *tmp;
 455
 456         tmp = wmalloc(strlen(themeDir)+20);
 457         sprintf(tmp, "/bin/mkdir \"%s\"", themeDir);
 458         if (system(tmp)!=0) {
 459             printf("%s: could not create directory %s. Probably there's already a theme with that name in this directory.\n", ProgName, themeDir);
 460             exit(1);
 461         }
 462         free(tmp);
 463     }
 464     keys = PLGetAllDictionaryKeys(style);
 465
 466     for (i = 0; i < PLGetNumberOfElements(keys); i++) {
 467         key = PLGetArrayElement(keys, i);
 468
 469         value = PLGetDictionaryEntry(style, key);
 470         if (value && PLIsArray(value) && PLGetNumberOfElements(value) > 2) {
 471             proplist_t type;
 472             char *t;
 473
 474             type = PLGetArrayElement(value, 0);
 475             t = PLGetString(type);
 476             if (t && (strcasecmp(t, "tpixmap")==0
 477                       || strcasecmp(t, "spixmap")==0
 478                       || strcasecmp(t, "cpixmap")==0
 479                       || strcasecmp(t, "mpixmap")==0
 480                       || strcasecmp(t, "tdgradient")==0
 481                       || strcasecmp(t, "tvgradient")==0
 482                       || strcasecmp(t, "thgradient")==0)) {
 483                 proplist_t file;
 484                 char *p;
 485                 char *newPath;
 486
 487                 file = PLGetArrayElement(value, 1);
 488
 489                 p = strrchr(PLGetString(file), '/');
 490                 if (p) {
 491                     copyFile(themeDir, PLGetString(file));
 492
 493                     newPath = wstrdup(p+1);
 494                     PLRemoveArrayElement(value, 1);
 495                     PLInsertArrayElement(value, PLMakeString(newPath), 1);
 496                     free(newPath);
 497                 } else {
 498                     findCopyFile(themeDir, PLGetString(file));
 499                 }
 500             }
 501         }
 502     }
 503
 504     return themeDir;
 505 }
 506
 507
 508 int
 509 main(int argc, char **argv)
 510 {
 511     proplist_t prop, style, key, val;
 512     char *path;
 513     int i, theme_too=0;
 514     int make_pack = 0;
 515     char *style_file = NULL;
 516
 517
 518     ProgName = argv[0];
 519
 520     if (argc>1) {
 521         for (i=1; i<argc; i++) {
 522             if (strcmp(argv[i], "-p")==0
 523                 || strcmp(argv[i], "--pack")==0) {
 524                 make_pack = 1;
 525                 theme_too = 1;
 526             } else if (strcmp(argv[i], "-t")==0
 527                        || strcmp(argv[i], "--theme-options")==0) {
 528                 theme_too++;
 529             } else if (strcmp(argv[i], "--help")==0) {
 530                 print_help();
 531                 exit(0);
 532             } else if (strcmp(argv[i], "--version")==0) {
 533                 puts(PROG_VERSION);
 534                 exit(0);
 535             } else {
 536                 if (style_file!=NULL) {
 537                     printf("%s: invalid argument '%s'\n", argv[0],
 538                            style_file[0]=='-' ? style_file : argv[i]);
 539                     printf("Try '%s --help' for more information\n", argv[0]);
 540                     exit(1);
 541                 }
 542                 style_file = argv[i];
 543             }
 544         }
 545     }
 546
 547     if (make_pack && !style_file) {
 548         printf("%s: you must supply a name for the theme pack\n", ProgName);
 549         exit(1);
 550     }
 551
 552     PLSetStringCmpHook(StringCompareHook);
 553
 554     path = defaultsPathForDomain("WindowMaker");
 555
 556     prop = PLGetProplistWithPath(path);
 557     if (!prop) {
 558         printf("%s:could not load WindowMaker configuration file \"%s\".\n",
 559                ProgName, path);
 560         exit(1);
 561     }
 562     free(path);
 563
 564     /* get global value */
 565     path = globalDefaultsPathForDomain("WindowMaker");
 566     val = PLGetProplistWithPath(path);
 567     if (val) {
 568         PLMergeDictionaries(val, prop);
 569         PLRelease(prop);
 570         prop = val;
 571     }
 572
 573     style = PLMakeDictionaryFromEntries(NULL, NULL, NULL);
 574
 575
 576     for (i=0; options[i]!=NULL; i++) {
 577         key = PLMakeString(options[i]);
 578
 579         val = PLGetDictionaryEntry(prop, key);
 580         if (val)
 581             PLInsertDictionaryEntry(style, key, val);
 582     }
 583
 584     val = PLGetDictionaryEntry(prop, PLMakeString("PixmapPath"));
 585     if (val)
 586         PixmapPath = val;
 587
 588     if (theme_too) {
 589         for (i=0; theme_options[i]!=NULL; i++) {
 590             key = PLMakeString(theme_options[i]);
 591
 592             val = PLGetDictionaryEntry(prop, key);
 593             if (val)
 594                 PLInsertDictionaryEntry(style, key, val);
 595         }
 596     }
 597
 598     if (make_pack) {
 599         char *path;
 600
 601         makeThemePack(style, style_file);
 602
 603         path = wmalloc(strlen(ThemePath)+32);
 604         strcpy(path, ThemePath);
 605         strcat(path, "/style");
 606         PLSetFilename(style, PLMakeString(path));
 607         PLSave(style, NO);
 608     } else {
 609         if (style_file) {
 610             val = PLMakeString(style_file);
 611             PLSetFilename(style, val);
 612             PLSave(style, NO);
 613         } else {
 614             puts(PLGetDescriptionIndent(style, 0));
 615         }
 616     }
 617     exit(0);
 618 }
 619
 620