mirror of
https://github.com/gryf/wmaker.git
synced 2025-12-19 04:20:27 +01:00
f54b0de7b4
now converts all *Font keys in the style files before merging them with G/D/WindowMaker and (vice-versa) getstyle converts the keys from G/D/WindowMaker before it does anything else whether its stdout printing or themepacks. enabling quick theme conversions to new font system.
773 lines
16 KiB
C
773 lines
16 KiB
C
/* getstyle.c - outputs style related options from WindowMaker to stdout
|
|
*
|
|
* WindowMaker window manager
|
|
*
|
|
* Copyright (c) 1997-2003 Alfredo K. Kojima
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
|
* USA.
|
|
*/
|
|
|
|
|
|
#define PROG_VERSION "getstyle (Window Maker) 0.6"
|
|
|
|
|
|
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <unistd.h>
|
|
#include <string.h>
|
|
#include <pwd.h>
|
|
#include <limits.h>
|
|
#include <assert.h>
|
|
#include <WINGs/WUtil.h>
|
|
|
|
#ifndef PATH_MAX
|
|
#define PATH_MAX 1024
|
|
#endif
|
|
|
|
#include "../src/wconfig.h"
|
|
|
|
/* table of style related options */
|
|
static char *options[] = {
|
|
"TitleJustify",
|
|
"ClipTitleFont",
|
|
"WindowTitleFont",
|
|
"MenuTitleFont",
|
|
"MenuTextFont",
|
|
"IconTitleFont",
|
|
"DisplayFont",
|
|
"LargeDisplayFont",
|
|
"WindowTitleExtendSpace",
|
|
"MenuTitleExtendSpace",
|
|
"MenuTextExtendSpace",
|
|
"HighlightColor",
|
|
"HighlightTextColor",
|
|
"ClipTitleColor",
|
|
"CClipTitleColor",
|
|
"FTitleColor",
|
|
"PTitleColor",
|
|
"UTitleColor",
|
|
"FTitleBack",
|
|
"PTitleBack",
|
|
"UTitleBack",
|
|
"ResizebarBack",
|
|
"MenuTitleColor",
|
|
"MenuTextColor",
|
|
"MenuDisabledColor",
|
|
"MenuTitleBack",
|
|
"MenuTextBack",
|
|
"IconBack",
|
|
"IconTitleColor",
|
|
"IconTitleBack",
|
|
"MenuStyle",
|
|
"WindowTitleExtendSpace",
|
|
"MenuTitleExtendSpace",
|
|
"MenuTextExtendSpace",
|
|
NULL
|
|
};
|
|
|
|
|
|
/* table of theme related options */
|
|
static char *theme_options[] = {
|
|
"WorkspaceBack",
|
|
"NormalCursor",
|
|
"ArrowCursor",
|
|
"MoveCursor",
|
|
"ResizeCursor",
|
|
"TopLeftResizeCursor",
|
|
"TopRightResizeCursor",
|
|
"BottomLeftResizeCursor",
|
|
"BottomRightResizeCursor",
|
|
"VerticalResizeCursor",
|
|
"HorizontalResizeCursor",
|
|
"WaitCursor",
|
|
"QuestionCursor",
|
|
"TextCursor",
|
|
"SelectCursor",
|
|
NULL
|
|
};
|
|
|
|
|
|
/* table of style related fonts */
|
|
|
|
static char *font_styles[] = {
|
|
"ClipTitleFont",
|
|
"WindowTitleFont",
|
|
"MenuTitleFont",
|
|
"MenuTextFont",
|
|
"IconTitleFont",
|
|
"DisplayFont",
|
|
"LargeDisplayFont",
|
|
NULL
|
|
};
|
|
|
|
char *default_font = "sans:pixelsize=12";
|
|
|
|
char *ProgName;
|
|
|
|
WMPropList *PixmapPath = NULL;
|
|
|
|
char *ThemePath = NULL;
|
|
|
|
|
|
void
|
|
print_help()
|
|
{
|
|
printf("Usage: %s [OPTIONS] [FILE]\n", ProgName);
|
|
puts("Retrieves style/theme configuration and output to FILE or to stdout");
|
|
puts("");
|
|
puts(" -t, --theme-options output theme related options when producing a style file");
|
|
puts(" -p, --pack produce output as a theme pack");
|
|
puts(" --help display this help and exit");
|
|
puts(" --version output version information and exit");
|
|
}
|
|
|
|
|
|
char*
|
|
globalDefaultsPathForDomain(char *domain)
|
|
{
|
|
static char path[1024];
|
|
|
|
sprintf(path, "%s/WindowMaker/%s", SYSCONFDIR, domain);
|
|
|
|
return path;
|
|
}
|
|
|
|
|
|
char*
|
|
defaultsPathForDomain(char *domain)
|
|
{
|
|
static char path[1024];
|
|
char *gspath;
|
|
|
|
gspath = getenv("GNUSTEP_USER_ROOT");
|
|
if (gspath) {
|
|
strcpy(path, gspath);
|
|
strcat(path, "/");
|
|
} else {
|
|
char *home;
|
|
|
|
home = getenv("HOME");
|
|
if (!home) {
|
|
printf("%s:could not get HOME environment variable!\n", ProgName);
|
|
exit(0);
|
|
}
|
|
strcpy(path, home);
|
|
strcat(path, "/GNUstep/");
|
|
}
|
|
strcat(path, DEFAULTS_DIR);
|
|
strcat(path, "/");
|
|
strcat(path, domain);
|
|
|
|
return path;
|
|
}
|
|
|
|
|
|
void
|
|
abortar(char *reason)
|
|
{
|
|
char buffer[4000];
|
|
|
|
printf("%s: %s\n", ProgName, reason);
|
|
|
|
if (ThemePath) {
|
|
printf("Removing unfinished theme pack\n");
|
|
sprintf(buffer, "/bin/rm -fr \"%s\"", ThemePath);
|
|
|
|
if (system(buffer)!=0) {
|
|
printf("%s: could not execute command %s\n", ProgName, buffer);
|
|
}
|
|
}
|
|
exit(1);
|
|
}
|
|
|
|
|
|
|
|
|
|
char*
|
|
wgethomedir()
|
|
{
|
|
char *home = getenv("HOME");
|
|
struct passwd *user;
|
|
|
|
if (home)
|
|
return home;
|
|
|
|
user = getpwuid(getuid());
|
|
if (!user) {
|
|
char buffer[80];
|
|
|
|
sprintf(buffer, "could not get password entry for UID %i", getuid());
|
|
perror(buffer);
|
|
return "/";
|
|
}
|
|
if (!user->pw_dir) {
|
|
return "/";
|
|
} else {
|
|
return user->pw_dir;
|
|
}
|
|
}
|
|
|
|
|
|
void*
|
|
mymalloc(int size)
|
|
{
|
|
void *tmp;
|
|
|
|
tmp = malloc(size);
|
|
if (!tmp) {
|
|
abortar("out of memory");
|
|
}
|
|
|
|
return tmp;
|
|
}
|
|
|
|
|
|
char*
|
|
mystrdup(char *str)
|
|
{
|
|
char *tmp;
|
|
|
|
tmp = mymalloc(strlen(str)+1);
|
|
|
|
strcpy(tmp, str);
|
|
|
|
return tmp;
|
|
}
|
|
|
|
|
|
static char*
|
|
getuserhomedir(char *username)
|
|
{
|
|
struct passwd *user;
|
|
|
|
user = getpwnam(username);
|
|
if (!user) {
|
|
char buffer[100];
|
|
|
|
sprintf(buffer,"could not get password entry for user %s", username);
|
|
perror(buffer);
|
|
return NULL;
|
|
}
|
|
if (!user->pw_dir) {
|
|
return "/";
|
|
} else {
|
|
return user->pw_dir;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
char*
|
|
wexpandpath(char *path)
|
|
{
|
|
char buffer2[PATH_MAX+2];
|
|
char buffer[PATH_MAX+2];
|
|
int i;
|
|
|
|
memset(buffer, 0, PATH_MAX+2);
|
|
|
|
if (*path=='~') {
|
|
char *home;
|
|
|
|
path++;
|
|
if (*path=='/' || *path==0) {
|
|
home = wgethomedir();
|
|
strcat(buffer, home);
|
|
} else {
|
|
int j;
|
|
j = 0;
|
|
while (*path!=0 && *path!='/') {
|
|
buffer2[j++] = *path;
|
|
buffer2[j] = 0;
|
|
path++;
|
|
}
|
|
home = getuserhomedir(buffer2);
|
|
if (!home)
|
|
return NULL;
|
|
strcat(buffer, home);
|
|
}
|
|
}
|
|
|
|
i = strlen(buffer);
|
|
|
|
while (*path!=0) {
|
|
char *tmp;
|
|
|
|
if (*path=='$') {
|
|
int j = 0;
|
|
path++;
|
|
/* expand $(HOME) or $HOME style environment variables */
|
|
if (*path=='(') {
|
|
path++;
|
|
while (*path!=0 && *path!=')') {
|
|
buffer2[j++] = *(path++);
|
|
buffer2[j] = 0;
|
|
}
|
|
if (*path==')')
|
|
path++;
|
|
tmp = getenv(buffer2);
|
|
if (!tmp) {
|
|
buffer[i] = 0;
|
|
strcat(buffer, "$(");
|
|
strcat(buffer, buffer2);
|
|
strcat(buffer, ")");
|
|
i += strlen(buffer2)+3;
|
|
} else {
|
|
strcat(buffer, tmp);
|
|
i += strlen(tmp);
|
|
}
|
|
} else {
|
|
while (*path!=0 && *path!='/') {
|
|
buffer2[j++] = *(path++);
|
|
buffer2[j] = 0;
|
|
}
|
|
tmp = getenv(buffer2);
|
|
if (!tmp) {
|
|
strcat(buffer, "$");
|
|
strcat(buffer, buffer2);
|
|
i += strlen(buffer2)+1;
|
|
} else {
|
|
strcat(buffer, tmp);
|
|
i += strlen(tmp);
|
|
}
|
|
}
|
|
} else {
|
|
buffer[i++] = *path;
|
|
path++;
|
|
}
|
|
}
|
|
|
|
return mystrdup(buffer);
|
|
}
|
|
|
|
|
|
|
|
char*
|
|
wfindfileinarray(WMPropList *paths, char *file)
|
|
{
|
|
int i;
|
|
char *path;
|
|
int len, flen;
|
|
char *fullpath;
|
|
|
|
if (!file)
|
|
return NULL;
|
|
|
|
if (*file=='/' || *file=='~' || !paths || !WMIsPLArray(paths)
|
|
|| WMGetPropListItemCount(paths)==0) {
|
|
if (access(file, R_OK)<0) {
|
|
fullpath = wexpandpath(file);
|
|
if (!fullpath)
|
|
return NULL;
|
|
|
|
if (access(fullpath, R_OK)<0) {
|
|
free(fullpath);
|
|
return NULL;
|
|
} else {
|
|
return fullpath;
|
|
}
|
|
} else {
|
|
return mystrdup(file);
|
|
}
|
|
}
|
|
|
|
flen = strlen(file);
|
|
for (i=0; i < WMGetPropListItemCount(paths); i++) {
|
|
WMPropList *tmp;
|
|
char *dir;
|
|
|
|
tmp = WMGetFromPLArray(paths, i);
|
|
if (!WMIsPLString(tmp) || !(dir = WMGetFromPLString(tmp)))
|
|
continue;
|
|
|
|
len = strlen(dir);
|
|
path = mymalloc(len+flen+2);
|
|
path = memcpy(path, dir, len);
|
|
path[len]=0;
|
|
strcat(path, "/");
|
|
strcat(path, file);
|
|
/* expand tilde */
|
|
fullpath = wexpandpath(path);
|
|
free(path);
|
|
if (fullpath) {
|
|
/* check if file is readable */
|
|
if (access(fullpath, R_OK)==0) {
|
|
return fullpath;
|
|
}
|
|
free(fullpath);
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
char*
|
|
capitalize(char *element)
|
|
{
|
|
unsigned int first = 1;
|
|
char *p;
|
|
char *b;
|
|
b = element;
|
|
for (p = b; *p != 0; p++)
|
|
{
|
|
if (isalpha(*p) && first) {
|
|
first = 0;
|
|
*p = toupper(*p);
|
|
}
|
|
else if (*p == '-' || *p == ' ') {
|
|
first = 1;
|
|
}
|
|
}
|
|
return b;
|
|
}
|
|
|
|
char*
|
|
getElementFromXLFD(const char *xlfd, int index)
|
|
{
|
|
const char *p = xlfd;
|
|
while (*p != 0) {
|
|
if (*p == '-' && --index == 0) {
|
|
const char *end = strchr(p + 1, '-');
|
|
char *buf;
|
|
size_t len;
|
|
if (end == 0) end = p + strlen(p);
|
|
len = end - (p + 1);
|
|
buf = wmalloc(len);
|
|
memcpy(buf, p + 1, len);
|
|
buf[len] = 0;
|
|
return buf;
|
|
}
|
|
p++;
|
|
}
|
|
return "*";
|
|
}
|
|
|
|
char*
|
|
xlfdToFc(char *xlfd)
|
|
{
|
|
char *Fcname = NULL;
|
|
|
|
char *family = getElementFromXLFD(xlfd, 2);
|
|
char *size = getElementFromXLFD(xlfd, 7);
|
|
char *weight = getElementFromXLFD(xlfd, 3);
|
|
char *slant = getElementFromXLFD(xlfd, 4);
|
|
|
|
if (strcmp(family, "*") != 0) {
|
|
Fcname = wstrconcat(Fcname, capitalize(family));
|
|
}
|
|
if (strcmp(size, "*") != 0) {
|
|
Fcname = wstrconcat(Fcname, ":pixelsize=");
|
|
Fcname = wstrconcat(Fcname, size);
|
|
}
|
|
if (strcmp(weight, "*") != 0) {
|
|
Fcname = wstrconcat(Fcname, ":style=");
|
|
Fcname = wstrconcat(Fcname, capitalize(weight));
|
|
}
|
|
if (strcmp(slant, "*") != 0) {
|
|
if (strcmp(slant, "i") == 0) {
|
|
Fcname = wstrconcat(Fcname, ":slant=");
|
|
Fcname = wstrconcat(Fcname, "Italic");
|
|
} else if (strcmp(slant, "o") == 0) {
|
|
Fcname = wstrconcat(Fcname, ":slant=");
|
|
Fcname = wstrconcat(Fcname, "Oblique");
|
|
} else if (strcmp(slant, "ri") == 0) {
|
|
Fcname = wstrconcat(Fcname, ":slant=");
|
|
Fcname = wstrconcat(Fcname, "Rev Italic");
|
|
} else if (strcmp(slant, "ro") == 0) {
|
|
Fcname = wstrconcat(Fcname, ":slant=");
|
|
Fcname = wstrconcat(Fcname, "Rev Oblique");
|
|
}
|
|
}
|
|
if (!Fcname)
|
|
Fcname = wstrdup(default_font);
|
|
|
|
wfree(family);
|
|
wfree(size);
|
|
wfree(weight);
|
|
wfree(slant);
|
|
|
|
return Fcname;
|
|
}
|
|
|
|
void
|
|
copyFile(char *dir, char *file)
|
|
{
|
|
char buffer[4000];
|
|
|
|
sprintf(buffer, "/bin/cp \"%s\" \"%s\"", file, dir);
|
|
if (system(buffer)!=0) {
|
|
printf("%s: could not copy file %s\n", ProgName, file);
|
|
}
|
|
}
|
|
|
|
|
|
void
|
|
findCopyFile(char *dir, char *file)
|
|
{
|
|
char *fullPath;
|
|
|
|
fullPath = wfindfileinarray(PixmapPath, file);
|
|
if (!fullPath) {
|
|
char buffer[4000];
|
|
|
|
sprintf(buffer, "coould not find file %s", file);
|
|
abortar(buffer);
|
|
}
|
|
copyFile(dir, fullPath);
|
|
free(fullPath);
|
|
}
|
|
|
|
|
|
char*
|
|
makeThemePack(WMPropList *style, char *themeName)
|
|
{
|
|
WMPropList *keys;
|
|
WMPropList *key;
|
|
WMPropList *value;
|
|
int i;
|
|
char *themeDir;
|
|
|
|
themeDir = mymalloc(strlen(themeName)+50);
|
|
sprintf(themeDir, "%s.themed", themeName);
|
|
ThemePath = themeDir;
|
|
{
|
|
char *tmp;
|
|
|
|
tmp = mymalloc(strlen(themeDir)+20);
|
|
sprintf(tmp, "/bin/mkdir \"%s\"", themeDir);
|
|
if (system(tmp)!=0) {
|
|
printf("%s: could not create directory %s. Probably there's already a theme with that name in this directory.\n", ProgName, themeDir);
|
|
exit(1);
|
|
}
|
|
free(tmp);
|
|
}
|
|
keys = WMGetPLDictionaryKeys(style);
|
|
|
|
for (i = 0; i < WMGetPropListItemCount(keys); i++) {
|
|
key = WMGetFromPLArray(keys, i);
|
|
|
|
value = WMGetFromPLDictionary(style, key);
|
|
if (value && WMIsPLArray(value) && WMGetPropListItemCount(value) > 2) {
|
|
WMPropList *type;
|
|
char *t;
|
|
|
|
type = WMGetFromPLArray(value, 0);
|
|
t = WMGetFromPLString(type);
|
|
if (t == NULL)
|
|
continue;
|
|
|
|
if (strcasecmp(t, "tpixmap")==0
|
|
|| strcasecmp(t, "spixmap")==0
|
|
|| strcasecmp(t, "cpixmap")==0
|
|
|| strcasecmp(t, "mpixmap")==0
|
|
|| strcasecmp(t, "tdgradient")==0
|
|
|| strcasecmp(t, "tvgradient")==0
|
|
|| strcasecmp(t, "thgradient")==0) {
|
|
WMPropList *file;
|
|
char *p;
|
|
char *newPath;
|
|
|
|
file = WMGetFromPLArray(value, 1);
|
|
|
|
p = strrchr(WMGetFromPLString(file), '/');
|
|
if (p) {
|
|
copyFile(themeDir, WMGetFromPLString(file));
|
|
|
|
newPath = mystrdup(p+1);
|
|
WMDeleteFromPLArray(value, 1);
|
|
WMInsertInPLArray(value, 1, WMCreatePLString(newPath));
|
|
free(newPath);
|
|
} else {
|
|
findCopyFile(themeDir, WMGetFromPLString(file));
|
|
}
|
|
} else if (strcasecmp(t, "bitmap")==0) {
|
|
WMPropList *file;
|
|
char *p;
|
|
char *newPath;
|
|
|
|
file = WMGetFromPLArray(value, 1);
|
|
|
|
p = strrchr(WMGetFromPLString(file), '/');
|
|
if (p) {
|
|
copyFile(themeDir, WMGetFromPLString(file));
|
|
|
|
newPath = mystrdup(p+1);
|
|
WMDeleteFromPLArray(value, 1);
|
|
WMInsertInPLArray(value, 1, WMCreatePLString(newPath));
|
|
free(newPath);
|
|
} else {
|
|
findCopyFile(themeDir, WMGetFromPLString(file));
|
|
}
|
|
|
|
|
|
file = WMGetFromPLArray(value, 2);
|
|
|
|
p = strrchr(WMGetFromPLString(file), '/');
|
|
if (p) {
|
|
copyFile(themeDir, WMGetFromPLString(file));
|
|
|
|
newPath = mystrdup(p+1);
|
|
WMDeleteFromPLArray(value, 2);
|
|
WMInsertInPLArray(value, 2, WMCreatePLString(newPath));
|
|
free(newPath);
|
|
} else {
|
|
findCopyFile(themeDir, WMGetFromPLString(file));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return themeDir;
|
|
}
|
|
|
|
|
|
int
|
|
main(int argc, char **argv)
|
|
{
|
|
WMPropList *prop, *style, *key, *val;
|
|
char *path;
|
|
int i, theme_too=0;
|
|
int make_pack = 0;
|
|
char *style_file = NULL;
|
|
|
|
|
|
ProgName = argv[0];
|
|
|
|
if (argc>1) {
|
|
for (i=1; i<argc; i++) {
|
|
if (strcmp(argv[i], "-p")==0
|
|
|| strcmp(argv[i], "--pack")==0) {
|
|
make_pack = 1;
|
|
theme_too = 1;
|
|
} else if (strcmp(argv[i], "-t")==0
|
|
|| strcmp(argv[i], "--theme-options")==0) {
|
|
theme_too++;
|
|
} else if (strcmp(argv[i], "--help")==0) {
|
|
print_help();
|
|
exit(0);
|
|
} else if (strcmp(argv[i], "--version")==0) {
|
|
puts(PROG_VERSION);
|
|
exit(0);
|
|
} else {
|
|
if (style_file!=NULL) {
|
|
printf("%s: invalid argument '%s'\n", argv[0],
|
|
style_file[0]=='-' ? style_file : argv[i]);
|
|
printf("Try '%s --help' for more information\n", argv[0]);
|
|
exit(1);
|
|
}
|
|
style_file = argv[i];
|
|
}
|
|
}
|
|
}
|
|
|
|
if (make_pack && !style_file) {
|
|
printf("%s: you must supply a name for the theme pack\n", ProgName);
|
|
exit(1);
|
|
}
|
|
|
|
WMPLSetCaseSensitive(False);
|
|
|
|
path = defaultsPathForDomain("WindowMaker");
|
|
|
|
prop = WMReadPropListFromFile(path);
|
|
if (!prop) {
|
|
printf("%s:could not load WindowMaker configuration file \"%s\".\n",
|
|
ProgName, path);
|
|
exit(1);
|
|
}
|
|
|
|
/* get global value */
|
|
path = globalDefaultsPathForDomain("WindowMaker");
|
|
val = WMReadPropListFromFile(path);
|
|
if (val) {
|
|
WMMergePLDictionaries(val, prop, True);
|
|
WMReleasePropList(prop);
|
|
prop = val;
|
|
}
|
|
|
|
style = WMCreatePLDictionary(NULL, NULL, NULL);
|
|
|
|
|
|
for (i=0; options[i]!=NULL; i++) {
|
|
key = WMCreatePLString(options[i]);
|
|
|
|
val = WMGetFromPLDictionary(prop, key);
|
|
if (val) {
|
|
int j;
|
|
char *str = WMGetFromPLString(key);
|
|
for (j = 0; font_styles[j]!=NULL; j++) {
|
|
if (strcasecmp(str, font_styles[j]) == 0) {
|
|
char *oldfont;
|
|
oldfont = WMGetFromPLString(val);
|
|
if (oldfont[0] == '-') {
|
|
if (!strchr(oldfont, ','))
|
|
{
|
|
char *newfont;
|
|
newfont = xlfdToFc(oldfont);
|
|
val = WMCreatePLString(newfont);
|
|
break;
|
|
} else {
|
|
wwarning("fontsets are not supported. replaced with default %s", default_font);
|
|
val = WMCreatePLString(default_font);
|
|
break;
|
|
}
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
WMPutInPLDictionary(style, key, val);
|
|
}
|
|
}
|
|
|
|
val = WMGetFromPLDictionary(prop, WMCreatePLString("PixmapPath"));
|
|
if (val)
|
|
PixmapPath = val;
|
|
|
|
if (theme_too) {
|
|
for (i=0; theme_options[i]!=NULL; i++) {
|
|
key = WMCreatePLString(theme_options[i]);
|
|
|
|
val = WMGetFromPLDictionary(prop, key);
|
|
if (val)
|
|
WMPutInPLDictionary(style, key, val);
|
|
}
|
|
}
|
|
|
|
if (make_pack) {
|
|
char *path;
|
|
|
|
makeThemePack(style, style_file);
|
|
|
|
path = mymalloc(strlen(ThemePath)+32);
|
|
strcpy(path, ThemePath);
|
|
strcat(path, "/style");
|
|
WMWritePropListToFile(style, path, False);
|
|
wfree(path);
|
|
} else {
|
|
if (style_file) {
|
|
WMWritePropListToFile(style, style_file, False);
|
|
} else {
|
|
puts(WMGetPropListDescription(style, True));
|
|
}
|
|
}
|
|
exit(0);
|
|
}
|
|
|
|
|