util/setstyle.c

   1 /* setstyle.c - loads style related options to wmaker
   2  *
   3  *  WindowMaker window manager
   4  *
   5  *  Copyright (c) 1997-2003 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 "setstyle (Window Maker) 0.6"
  25
  26 #include <stdlib.h>
  27 #include <stdio.h>
  28 #include <sys/stat.h>
  29 #include <unistd.h>
  30 #include <string.h>
  31 #include <X11/Xlib.h>
  32 #include <WINGs/WUtil.h>
  33
  34
  35
  36 #include "../src/wconfig.h"
  37
  38 #define MAX_OPTIONS 128
  39
  40 char *FontOptions[] = {
  41     "IconTitleFont",
  42     "ClipTitleFont",
  43     "DisplayFont",
  44     "LargeDisplayFont",
  45     "MenuTextFont",
  46     "MenuTitleFont",
  47     "WindowTitleFont",
  48     NULL
  49 };
  50
  51 char *CursorOptions[] = {
  52     "NormalCursor",
  53     "ArrowCursor",
  54     "MoveCursor",
  55     "ResizeCursor",
  56     "TopLeftResizeCursor",
  57     "TopRightResizeCursor",
  58     "BottomLeftResizeCursor",
  59     "BottomRightResizeCursor",
  60     "VerticalResizeCursor",
  61     "HorizontalResizeCursor",
  62     "WaitCursor",
  63     "QuestionCursor",
  64     "TextCursor",
  65     "SelectCursor",
  66     NULL
  67 };
  68
  69
  70
  71 char *ProgName;
  72 int ignoreFonts = 0;
  73 int ignoreCursors = 0;
  74
  75 Display *dpy;
  76
  77 extern char* convertFont(char *font, Bool keepXLFD);
  78
  79 WMPropList *readBlackBoxStyle(char *path);
  80
  81
  82 static Bool
  83 isCursorOption(char *option)
  84 {
  85     int i;
  86
  87     for (i=0; CursorOptions[i]!=NULL; i++) {
  88         if (strcasecmp(option, CursorOptions[i])==0) {
  89             return True;
  90         }
  91     }
  92
  93     return False;
  94 }
  95
  96
  97 static Bool
  98 isFontOption(char *option)
  99 {
 100     int i;
 101
 102     for (i=0; FontOptions[i]!=NULL; i++) {
 103         if (strcasecmp(option, FontOptions[i])==0) {
 104             return True;
 105         }
 106     }
 107
 108     return False;
 109 }
 110
 111
 112 char*
 113 defaultsPathForDomain(char *domain)
 114 {
 115     static char path[1024];
 116     char *gspath;
 117
 118     gspath = getenv("GNUSTEP_USER_ROOT");
 119     if (gspath) {
 120         strcpy(path, gspath);
 121         strcat(path, "/");
 122     } else {
 123         char *home;
 124
 125         home = getenv("HOME");
 126         if (!home) {
 127             printf("%s:could not get HOME environment variable!\n", ProgName);
 128             exit(0);
 129         }
 130
 131         strcpy(path, home);
 132         strcat(path, "/GNUstep/");
 133     }
 134     strcat(path, DEFAULTS_DIR);
 135     strcat(path, "/");
 136     strcat(path, domain);
 137
 138     return path;
 139 }
 140
 141
 142
 143 void
 144 hackPathInTexture(WMPropList *texture, char *prefix)
 145 {
 146     WMPropList *type;
 147     char *t;
 148
 149     /* get texture type */
 150     type = WMGetFromPLArray(texture, 0);
 151     t = WMGetFromPLString(type);
 152     if (t == NULL)
 153         return;
 154     if (strcasecmp(t, "tpixmap")==0
 155         || strcasecmp(t, "spixmap")==0
 156         || strcasecmp(t, "mpixmap")==0
 157         || strcasecmp(t, "cpixmap")==0
 158         || strcasecmp(t, "tvgradient")==0
 159         || strcasecmp(t, "thgradient")==0
 160         || strcasecmp(t, "tdgradient")==0) {
 161         WMPropList *file;
 162         char buffer[4018];
 163
 164         /* get pixmap file path */
 165         file = WMGetFromPLArray(texture, 1);
 166         sprintf(buffer, "%s/%s", prefix, WMGetFromPLString(file));
 167         /* replace path with full path */
 168         WMDeleteFromPLArray(texture, 1);
 169         WMInsertInPLArray(texture, 1, WMCreatePLString(buffer));
 170     } else if (strcasecmp(t, "bitmap") == 0) {
 171         WMPropList *file;
 172         char buffer[4018];
 173
 174         /* get bitmap file path */
 175         file = WMGetFromPLArray(texture, 1);
 176         sprintf(buffer, "%s/%s", prefix, WMGetFromPLString(file));
 177         /* replace path with full path */
 178         WMDeleteFromPLArray(texture, 1);
 179         WMInsertInPLArray(texture, 1, WMCreatePLString(buffer));
 180
 181         /* get mask file path */
 182         file = WMGetFromPLArray(texture, 2);
 183         sprintf(buffer, "%s/%s", prefix, WMGetFromPLString(file));
 184         /* replace path with full path */
 185         WMDeleteFromPLArray(texture, 2);
 186         WMInsertInPLArray(texture, 2, WMCreatePLString(buffer));
 187     }
 188 }
 189
 190
 191 void
 192 hackPaths(WMPropList *style, char *prefix)
 193 {
 194     WMPropList *keys;
 195     WMPropList *key;
 196     WMPropList *value;
 197     int i;
 198
 199
 200     keys = WMGetPLDictionaryKeys(style);
 201
 202     for (i = 0; i < WMGetPropListItemCount(keys); i++) {
 203         key = WMGetFromPLArray(keys, i);
 204
 205         value = WMGetFromPLDictionary(style, key);
 206         if (!value)
 207             continue;
 208
 209         if (strcasecmp(WMGetFromPLString(key), "WorkspaceSpecificBack")==0) {
 210             if (WMIsPLArray(value)) {
 211                 int j;
 212                 WMPropList *texture;
 213
 214                 for (j = 0; j < WMGetPropListItemCount(value); j++) {
 215                     texture = WMGetFromPLArray(value, j);
 216
 217                     if (texture && WMIsPLArray(texture)
 218                         && WMGetPropListItemCount(texture) > 2) {
 219
 220                         hackPathInTexture(texture, prefix);
 221                     }
 222                 }
 223             }
 224         } else {
 225
 226             if (WMIsPLArray(value) && WMGetPropListItemCount(value) > 2) {
 227
 228                 hackPathInTexture(value, prefix);
 229             }
 230         }
 231     }
 232
 233 }
 234
 235
 236 static WMPropList*
 237 getColor(WMPropList *texture)
 238 {
 239     WMPropList *value, *type;
 240     char *str;
 241
 242     type = WMGetFromPLArray(texture, 0);
 243     if (!type)
 244         return NULL;
 245
 246     value = NULL;
 247
 248     str = WMGetFromPLString(type);
 249     if (strcasecmp(str, "solid")==0) {
 250         value = WMGetFromPLArray(texture, 1);
 251     } else if (strcasecmp(str, "dgradient")==0
 252                || strcasecmp(str, "hgradient")==0
 253                || strcasecmp(str, "vgradient")==0) {
 254         WMPropList *c1, *c2;
 255         int r1, g1, b1, r2, g2, b2;
 256         char buffer[32];
 257
 258         c1 = WMGetFromPLArray(texture, 1);
 259         c2 = WMGetFromPLArray(texture, 2);
 260         if (!dpy) {
 261             if (sscanf(WMGetFromPLString(c1), "#%2x%2x%2x", &r1, &g1, &b1)==3
 262                 && sscanf(WMGetFromPLString(c2), "#%2x%2x%2x", &r2, &g2, &b2)==3) {
 263                 sprintf(buffer, "#%02x%02x%02x", (r1+r2)/2, (g1+g2)/2,
 264                         (b1+b2)/2);
 265                 value = WMCreatePLString(buffer);
 266             } else {
 267                 value = c1;
 268             }
 269         } else {
 270             XColor color1;
 271             XColor color2;
 272
 273             XParseColor(dpy, DefaultColormap(dpy, DefaultScreen(dpy)),
 274                         WMGetFromPLString(c1), &color1);
 275             XParseColor(dpy, DefaultColormap(dpy, DefaultScreen(dpy)),
 276                         WMGetFromPLString(c2), &color2);
 277
 278             sprintf(buffer, "#%02x%02x%02x",
 279                     (color1.red+color2.red)>>9,
 280                     (color1.green+color2.green)>>9,
 281                     (color1.blue+color2.blue)>>9);
 282             value = WMCreatePLString(buffer);
 283         }
 284     } else if (strcasecmp(str, "mdgradient")==0
 285                || strcasecmp(str, "mhgradient")==0
 286                || strcasecmp(str, "mvgradient")==0) {
 287
 288         value = WMGetFromPLArray(texture, 1);
 289
 290     } else if (strcasecmp(str, "tpixmap")==0
 291                || strcasecmp(str, "cpixmap")==0
 292                || strcasecmp(str, "spixmap")==0) {
 293
 294         value = WMGetFromPLArray(texture, 2);
 295     }
 296
 297     return value;
 298 }
 299
 300
 301 /*
 302  * since some of the options introduce incompatibilities, we will need
 303  * to do a kluge here or the themes ppl will get real annoying.
 304  * So, treat for the absence of the following options:
 305  * IconTitleColor
 306  * IconTitleBack
 307  */
 308 void
 309 hackStyle(WMPropList *style)
 310 {
 311     WMPropList *keys, *tmp;
 312     int foundIconTitle = 0, foundResizebarBack = 0;
 313     int i;
 314
 315     keys = WMGetPLDictionaryKeys(style);
 316
 317     for (i = 0; i < WMGetPropListItemCount(keys); i++) {
 318         char *str;
 319
 320         tmp = WMGetFromPLArray(keys, i);
 321         str = WMGetFromPLString(tmp);
 322         if (str) {
 323             if (ignoreFonts && isFontOption(str)) {
 324                 WMRemoveFromPLDictionary(style, tmp);
 325                 continue;
 326             }
 327             if (ignoreCursors && isCursorOption(str)) {
 328                 WMRemoveFromPLDictionary(style, tmp);
 329                 continue;
 330             }
 331             if (isFontOption(str)) {
 332                 WMPropList *value;
 333                 char *newfont, *oldfont;
 334
 335                 value = WMGetFromPLDictionary(style, tmp);
 336                 if (value) {
 337                     oldfont = WMGetFromPLString(value);
 338                     newfont = convertFont(oldfont, False);
 339                     if (newfont != oldfont) {
 340                         value = WMCreatePLString(newfont);
 341                         WMPutInPLDictionary(style, tmp, value);
 342                         WMReleasePropList(value);
 343                         wfree(newfont);
 344                     }
 345                 }
 346             }
 347             if (strcasecmp(str, "IconTitleColor")==0
 348                 || strcasecmp(str, "IconTitleBack")==0) {
 349                 foundIconTitle = 1;
 350             } else if (strcasecmp(str, "ResizebarBack")==0) {
 351                 foundResizebarBack = 1;
 352             }
 353         }
 354     }
 355
 356     if (!foundIconTitle) {
 357         /* set the default values */
 358         tmp = WMGetFromPLDictionary(style, WMCreatePLString("FTitleColor"));
 359         if (tmp) {
 360             WMPutInPLDictionary(style, WMCreatePLString("IconTitleColor"),
 361                                 tmp);
 362         }
 363
 364         tmp = WMGetFromPLDictionary(style, WMCreatePLString("FTitleBack"));
 365         if (tmp) {
 366             WMPropList *value;
 367
 368             value = getColor(tmp);
 369
 370             if (value) {
 371                 WMPutInPLDictionary(style, WMCreatePLString("IconTitleBack"),
 372                                     value);
 373             }
 374         }
 375     }
 376
 377     if (!foundResizebarBack) {
 378         /* set the default values */
 379         tmp = WMGetFromPLDictionary(style, WMCreatePLString("UTitleBack"));
 380         if (tmp) {
 381             WMPropList *value;
 382
 383             value = getColor(tmp);
 384
 385             if (value) {
 386                 WMPropList *t;
 387
 388                 t = WMCreatePLArray(WMCreatePLString("solid"), value,
 389                                     NULL);
 390                 WMPutInPLDictionary(style, WMCreatePLString("ResizebarBack"),
 391                                     t);
 392             }
 393         }
 394     }
 395
 396
 397     if (!WMGetFromPLDictionary(style, WMCreatePLString("MenuStyle"))) {
 398         WMPutInPLDictionary(style, WMCreatePLString("MenuStyle"),
 399                             WMCreatePLString("normal"));
 400     }
 401 }
 402
 403
 404 void
 405 print_help()
 406 {
 407     printf("Usage: %s [OPTIONS] FILE\n", ProgName);
 408     puts("Reads style/theme configuration from FILE and updates Window Maker.");
 409     puts("");
 410     puts("  --no-fonts          ignore font related options");
 411     puts("  --no-cursors        ignore cursor related options");
 412     puts("  --ignore <option>   ignore changes in the specified option");
 413     puts("  --help              display this help and exit");
 414     /*
 415      puts("  --format <format>   specifies the format of the theme to be converted");
 416      */
 417     puts("  --version           output version information and exit");
 418     /*puts("");
 419      puts("Supported formats: blackbox");*/
 420 }
 421
 422
 423 #define F_BLACKBOX      1
 424
 425 int
 426 main(int argc, char **argv)
 427 {
 428     WMPropList *prop, *style;
 429     char *path;
 430     char *file = NULL;
 431     struct stat statbuf;
 432     int i;
 433     int ignoreCount = 0;
 434     char *ignoreList[MAX_OPTIONS];
 435
 436     dpy = XOpenDisplay("");
 437
 438     ProgName = argv[0];
 439
 440     if (argc<2) {
 441         printf("%s: missing argument\n", ProgName);
 442         printf("Try '%s --help' for more information\n", ProgName);
 443         exit(1);
 444     }
 445
 446     for (i = 1; i < argc; i++) {
 447         if (strcmp("--ignore", argv[i])==0) {
 448             i++;
 449             if (i == argc) {
 450                 printf("%s: missing argument for option --ignore\n", ProgName);
 451                 exit(1);
 452             }
 453             ignoreList[ignoreCount++] = argv[i];
 454
 455         } else if (strcmp("--no-fonts", argv[i])==0) {
 456             ignoreFonts = 1;
 457         } else if (strcmp("--no-cursors", argv[i])==0) {
 458             ignoreCursors = 1;
 459         } else if (strcmp("--version", argv[i])==0) {
 460             puts(PROG_VERSION);
 461             exit(0);
 462         } else if (strcmp("--help", argv[i])==0) {
 463             print_help();
 464             exit(0);
 465 #if 0
 466         } else if (strcmp("--format", argv[i])==0) {
 467             i++;
 468             if (i == argc) {
 469                 printf("%s: missing argument for option --format\n", ProgName);
 470                 exit(1);
 471             }
 472             if (strcasecmp(argv[i], "blackbox")==0) {
 473                 format = F_BLACKBOX;
 474             } else {
 475                 printf("%s: unknown theme format '%s'\n", ProgName, argv[i]);
 476                 exit(1);
 477             }
 478 #endif
 479         } else {
 480             if (file) {
 481                 printf("%s: invalid argument '%s'\n", ProgName, argv[i]);
 482                 printf("Try '%s --help' for more information\n", ProgName);
 483                 exit(1);
 484             }
 485             file = argv[i];
 486         }
 487     }
 488
 489     WMPLSetCaseSensitive(False);
 490
 491     path = defaultsPathForDomain("WindowMaker");
 492
 493     prop = WMReadPropListFromFile(path);
 494     if (!prop) {
 495         perror(path);
 496         printf("%s:could not load WindowMaker configuration file.\n",
 497                ProgName);
 498         exit(1);
 499     }
 500
 501     if (stat(file, &statbuf) < 0) {
 502         perror(file);
 503         exit(1);
 504     }
 505 #if 0
 506     if (format == F_BLACKBOX) {
 507         style = readBlackBoxStyle(file);
 508         if (!style) {
 509             printf("%s: could not open style file\n", ProgName);
 510             exit(1);
 511         }
 512     } else
 513 #endif
 514     {
 515         if (S_ISDIR(statbuf.st_mode)) {
 516             char buffer[4018];
 517             char *prefix;
 518             /* theme pack */
 519
 520             if (*argv[argc-1] != '/') {
 521                 if (!getcwd(buffer, 4000)) {
 522                     printf("%s: complete path for %s is too long\n", ProgName,
 523                            file);
 524                     exit(1);
 525                 }
 526                 if (strlen(buffer) + strlen(file) > 4000) {
 527                     printf("%s: complete path for %s is too long\n", ProgName,
 528                            file);
 529                     exit(1);
 530                 }
 531                 strcat(buffer, "/");
 532             } else {
 533                 buffer[0] = 0;
 534             }
 535             strcat(buffer, file);
 536
 537             prefix = malloc(strlen(buffer)+10);
 538             if (!prefix) {
 539                 printf("%s: out of memory\n", ProgName);
 540                 exit(1);
 541             }
 542             strcpy(prefix, buffer);
 543
 544             strcat(buffer, "/style");
 545
 546             style = WMReadPropListFromFile(buffer);
 547             if (!style) {
 548                 perror(buffer);
 549                 printf("%s:could not load style file.\n", ProgName);
 550                 exit(1);
 551             }
 552
 553             hackPaths(style, prefix);
 554             free(prefix);
 555         } else {
 556             /* normal style file */
 557
 558             style = WMReadPropListFromFile(file);
 559             if (!style) {
 560                 perror(file);
 561                 printf("%s:could not load style file.\n", ProgName);
 562                 exit(1);
 563             }
 564         }
 565     }
 566
 567     if (!WMIsPLDictionary(style)) {
 568         printf("%s: '%s' is not a style file/theme\n", ProgName, file);
 569         exit(1);
 570     }
 571
 572     hackStyle(style);
 573
 574     if (ignoreCount > 0) {
 575         for (i = 0; i < ignoreCount; i++) {
 576             WMRemoveFromPLDictionary(style, WMCreatePLString(ignoreList[i]));
 577         }
 578     }
 579
 580     WMMergePLDictionaries(prop, style, True);
 581
 582     WMWritePropListToFile(prop, path, True);
 583     {
 584         XEvent ev;
 585
 586         if (dpy) {
 587             int i;
 588             char *msg = "Reconfigure";
 589
 590             memset(&ev, 0, sizeof(XEvent));
 591
 592             ev.xclient.type = ClientMessage;
 593             ev.xclient.message_type = XInternAtom(dpy, "_WINDOWMAKER_COMMAND",
 594                                                   False);
 595             ev.xclient.window = DefaultRootWindow(dpy);
 596             ev.xclient.format = 8;
 597
 598             for (i = 0; i <= strlen(msg); i++) {
 599                 ev.xclient.data.b[i] = msg[i];
 600             }
 601             XSendEvent(dpy, DefaultRootWindow(dpy), False,
 602                        SubstructureRedirectMask, &ev);
 603             XFlush(dpy);
 604         }
 605     }
 606
 607     exit(0);
 608 }
 609
 610
 611 #if 0
 612 char*
 613 getToken(char *str, int i, char *buf)
 614 {
 615
 616 }
 617
 618
 619 static WMPropList*
 620 readBlackBoxStyle(char *path)
 621 {
 622     FILE *f;
 623     char buffer[128], char token[128];
 624     WMPropList *style, *p;
 625
 626     f = fopen(path, "rb");
 627     if (!f) {
 628         perror(path);
 629         return NULL;
 630     }
 631
 632     while (1) {
 633         if (!fgets(buffer, 127, f))
 634             break;
 635
 636         if (strncasecmp(buffer, "menu.title:", 11)==0) {
 637
 638         }
 639     }
 640 }
 641 #endif
 642