static void make_keys(void)
{
if (dWorkspaces != NULL)
return;
dWorkspaces = WMCreatePLString("Workspaces");
dName = WMCreatePLString("Name");
dClip = WMCreatePLString("Clip");
}
static WMPropList*
getColor(WMPropList *texture)
{
WMPropList *value, *type;
char *str;
type = WMGetFromPLArray(texture, 0);
if (!type)
return NULL;
value = NULL;
str = WMGetFromPLString(type);
if (strcasecmp(str, "solid")==0) {
value = WMGetFromPLArray(texture, 1);
} else if (strcasecmp(str, "dgradient")==0
|| strcasecmp(str, "hgradient")==0
|| strcasecmp(str, "vgradient")==0) {
WMPropList *c1, *c2;
int r1, g1, b1, r2, g2, b2;
char buffer[32];
c1 = WMGetFromPLArray(texture, 1);
c2 = WMGetFromPLArray(texture, 2);
if (!dpy) {
if (sscanf(WMGetFromPLString(c1), "#%2x%2x%2x", &r1, &g1, &b1)==3
&& sscanf(WMGetFromPLString(c2), "#%2x%2x%2x", &r2, &g2, &b2)==3) {
sprintf(buffer, "#%02x%02x%02x", (r1+r2)/2, (g1+g2)/2,
(b1+b2)/2);
value = WMCreatePLString(buffer);
} else {
value = c1;
}
} else {
XColor color1;
XColor color2;
XParseColor(dpy, DefaultColormap(dpy, DefaultScreen(dpy)),
WMGetFromPLString(c1), &color1);
XParseColor(dpy, DefaultColormap(dpy, DefaultScreen(dpy)),
WMGetFromPLString(c2), &color2);
sprintf(buffer, "#%02x%02x%02x",
(color1.red+color2.red)>>9,
(color1.green+color2.green)>>9,
(color1.blue+color2.blue)>>9);
value = WMCreatePLString(buffer);
}
} else if (strcasecmp(str, "mdgradient")==0
static WMPropList *processSubmenu(WEditMenu * menu)
{
WEditMenuItem *item;
WMPropList *pmenu;
WMPropList *pl;
char *s;
int i;
s = WGetEditMenuTitle(menu);
pl = WMCreatePLString(s);
pmenu = WMCreatePLArray(pl, NULL);
i = 0;
while ((item = WGetEditMenuItem(menu, i++))) {
WEditMenu *submenu;
s = WGetEditMenuItemTitle(item);
submenu = WGetEditMenuSubmenu(item);
if (submenu) {
pl = processSubmenu(submenu);
} else {
pl = processData(s, WGetEditMenuItemData(item));
}
if (!pl)
continue;
WMAddToPLArray(pmenu, pl);
}
return pmenu;
}
/*
* struct *s;
* WDMCheckPLDictionary(pl, spec, &s);
*/
Bool WDMCheckPLDictionary(WMPropList * pl, void *def, void *target)
{
WDMDictionarySpec *spec = (WDMDictionarySpec *) def;
WDMDictionaryStruct *fields = spec->fields;
void **data = (void **)target;
WMPropList *key = NULL, *value = NULL;
Bool plok;
WDMDebug("WDMCheckPLDictionary(%p, %p, %p)\n", (void *)pl, def, target);
plok = pl && WMIsPLDictionary(pl);
*data = (void *)wmalloc(spec->size);
memset(*data, 0, spec->size);
while (fields->key) {
key = WMCreatePLString(fields->key);
value = plok ? WMGetFromPLDictionary(pl, key) : NULL;
(*fields->checker) (value, fields->data, (void *)((unsigned char *)*data + fields->offset));
WMReleasePropList(key);
key = NULL;
fields++;
}
return True;
}
void wWorkspaceSaveState(WMPropList * old_state)
{
WMPropList *parr, *pstr, *wks_state, *old_wks_state, *foo, *bar;
int i;
make_keys();
old_wks_state = WMGetFromPLDictionary(old_state, dWorkspaces);
parr = WMCreatePLArray(NULL);
for (i = 0; i < w_global.workspace.count; i++) {
pstr = WMCreatePLString(w_global.workspace.array[i]->name);
wks_state = WMCreatePLDictionary(dName, pstr, NULL);
WMReleasePropList(pstr);
if (!wPreferences.flags.noclip) {
pstr = wClipSaveWorkspaceState(i);
WMPutInPLDictionary(wks_state, dClip, pstr);
WMReleasePropList(pstr);
} else if (old_wks_state != NULL) {
if ((foo = WMGetFromPLArray(old_wks_state, i)) != NULL) {
if ((bar = WMGetFromPLDictionary(foo, dClip)) != NULL) {
WMPutInPLDictionary(wks_state, dClip, bar);
}
}
}
WMAddToPLArray(parr, wks_state);
WMReleasePropList(wks_state);
}
WMPutInPLDictionary(w_global.session_state, dWorkspaces, parr);
WMReleasePropList(parr);
}
void
hackPathInTexture(WMPropList *texture, char *prefix)
{
WMPropList *type;
char *t;
/* get texture type */
type = WMGetFromPLArray(texture, 0);
t = WMGetFromPLString(type);
if (t == NULL)
return;
if (strcasecmp(t, "tpixmap")==0
|| strcasecmp(t, "spixmap")==0
|| strcasecmp(t, "mpixmap")==0
|| strcasecmp(t, "cpixmap")==0
|| strcasecmp(t, "tvgradient")==0
|| strcasecmp(t, "thgradient")==0
|| strcasecmp(t, "tdgradient")==0) {
WMPropList *file;
char buffer[4018];
/* get pixmap file path */
file = WMGetFromPLArray(texture, 1);
sprintf(buffer, "%s/%s", prefix, WMGetFromPLString(file));
/* replace path with full path */
WMDeleteFromPLArray(texture, 1);
WMInsertInPLArray(texture, 1, WMCreatePLString(buffer));
} else if (strcasecmp(t, "bitmap") == 0) {
WMPropList *file;
char buffer[4018];
/* get bitmap file path */
file = WMGetFromPLArray(texture, 1);
sprintf(buffer, "%s/%s", prefix, WMGetFromPLString(file));
/* replace path with full path */
WMDeleteFromPLArray(texture, 1);
WMInsertInPLArray(texture, 1, WMCreatePLString(buffer));
/* get mask file path */
file = WMGetFromPLArray(texture, 2);
sprintf(buffer, "%s/%s", prefix, WMGetFromPLString(file));
/* replace path with full path */
WMDeleteFromPLArray(texture, 2);
WMInsertInPLArray(texture, 2, WMCreatePLString(buffer));
}
}
/* This function save the application icon and store the path in the Dictionary */
static void wApplicationSaveIconPathFor(const char *iconPath, const char *wm_instance, const char *wm_class)
{
WMPropList *dict = w_global.domain.window_attr->dictionary;
WMPropList *adict, *key, *iconk;
WMPropList *val;
char *tmp;
tmp = get_name_for_instance_class(wm_instance, wm_class);
key = WMCreatePLString(tmp);
wfree(tmp);
adict = WMGetFromPLDictionary(dict, key);
iconk = WMCreatePLString("Icon");
if (adict) {
val = WMGetFromPLDictionary(adict, iconk);
} else {
/* no dictionary for app, so create one */
adict = WMCreatePLDictionary(NULL, NULL);
WMPutInPLDictionary(dict, key, adict);
WMReleasePropList(adict);
val = NULL;
}
if (!val) {
val = WMCreatePLString(iconPath);
WMPutInPLDictionary(adict, iconk, val);
WMReleasePropList(val);
} else {
val = NULL;
}
WMReleasePropList(key);
WMReleasePropList(iconk);
if (val && !wPreferences.flags.noupdates)
UpdateDomainFile(w_global.domain.window_attr);
}
int main(int argc, char **argv)
{
char path[PATH_MAX];
WMPropList *key, *value, *dict;
int ch;
struct option longopts[] = {
{ "version", no_argument, NULL, 'v' },
{ "help", no_argument, NULL, 'h' },
{ NULL, 0, NULL, 0 }
};
prog_name = argv[0];
while ((ch = getopt_long(argc, argv, "hv", longopts, NULL)) != -1)
switch(ch) {
case 'v':
printf("%s (Window Maker %s)\n", prog_name, VERSION);
return 0;
/* NOTREACHED */
case 'h':
print_help(1, 0);
/* NOTREACHED */
case 0:
break;
default:
print_help(0, 1);
/* NOTREACHED */
}
argc -= optind;
argv += optind;
if (argc != 2)
print_help(0, 1);
key = WMCreatePLString(argv[1]);
snprintf(path, sizeof(path), "%s", wdefaultspathfordomain(argv[0]));
dict = WMReadPropListFromFile(path);
if (dict == NULL)
return 1; /* bad domain */
value = WMGetFromPLDictionary(dict, key);
if (value == NULL)
return 2; /* bad key */
printf("%s\n", WMGetPropListDescription(value, True));
return 0;
}
static void
storeData(_Panel *panel)
{
WMPropList *list;
WMPropList *tmp;
int i;
char *p;
list = WMCreatePLArray(NULL, NULL);
for (i=0; i<WMGetListNumberOfRows(panel->icoL); i++) {
p = WMGetListItem(panel->icoL, i)->text;
tmp = WMCreatePLString(p);
WMAddToPLArray(list, tmp);
}
SetObjectForKey(list, "IconPath");
list = WMCreatePLArray(NULL, NULL);
for (i=0; i<WMGetListNumberOfRows(panel->pixL); i++) {
p = WMGetListItem(panel->pixL, i)->text;
tmp = WMCreatePLString(p);
WMAddToPLArray(list, tmp);
}
SetObjectForKey(list, "PixmapPath");
}
static void
showData(_Panel *panel)
{
char *gspath;
char *menuPath;
WMPropList *pmenu;
gspath = wusergnusteppath();
menuPath = wmalloc(strlen(gspath)+32);
strcpy(menuPath, gspath);
strcat(menuPath, "/Defaults/WMRootMenu");
pmenu = WMReadPropListFromFile(menuPath);
if (!pmenu || !WMIsPLArray(pmenu)) {
int res;
res = WMRunAlertPanel(WMWidgetScreen(panel->parent), panel->parent,
_("Warning"),
_("The menu file format currently in use is not supported\n"
"by this tool. Do you want to discard the current menu\n"
"to use this tool?"),
_("Yes, Discard and Update"),
_("No, Keep Current Menu"), NULL);
if (res == WAPRDefault) {
pmenu = getDefaultMenu(panel);
if (!pmenu) {
pmenu = WMCreatePLArray(WMCreatePLString("Applications"),
NULL);
}
} else {
panel->dontSave = True;
return;
}
}
panel->menuPath = menuPath;
buildMenuFromPL(panel, pmenu);
WMReleasePropList(pmenu);
}
static WMPropList *processData(const char *title, ItemData * data)
{
WMPropList *item;
char *s1;
static WMPropList *pscut = NULL;
static WMPropList *pomenu = NULL;
static WMPropList *poplmenu = NULL;
int i;
if (data == NULL)
return NULL;
if (!pscut) {
pscut = WMCreatePLString("SHORTCUT");
pomenu = WMCreatePLString("OPEN_MENU");
poplmenu = WMCreatePLString("OPEN_PLMENU");
}
item = WMCreatePLArray(WMCreatePLString(title), NULL);
switch (data->type) {
case ExecInfo:
if (data->param.exec.command == NULL)
goto return_null;
#if 1
if (strpbrk(data->param.exec.command, "&$*|><?`=;")) {
s1 = "SHEXEC";
} else {
s1 = "EXEC";
}
#else
s1 = "SHEXEC";
#endif
if (notblank(data->param.exec.shortcut)) {
WMAddToPLArray(item, pscut);
WMAddToPLArray(item, WMCreatePLString(data->param.exec.shortcut));
}
WMAddToPLArray(item, WMCreatePLString(s1));
WMAddToPLArray(item, WMCreatePLString(data->param.exec.command));
break;
case CommandInfo:
if (notblank(data->param.command.shortcut)) {
WMAddToPLArray(item, pscut);
WMAddToPLArray(item, WMCreatePLString(data->param.command.shortcut));
}
i = data->param.command.command;
WMAddToPLArray(item, WMCreatePLString(commandNames[i]));
switch (i) {
case 3:
case 4:
if (data->param.command.parameter) {
WMAddToPLArray(item, WMCreatePLString(data->param.command.parameter));
}
break;
case 6: /* restart */
if (data->param.command.parameter) {
WMAddToPLArray(item, WMCreatePLString(data->param.command.parameter));
}
break;
}
break;
case PipeInfo:
case PLPipeInfo:
if (!data->param.pipe.command)
goto return_null;
if (data->type == PLPipeInfo)
WMAddToPLArray(item, poplmenu);
else
WMAddToPLArray(item, pomenu);
if (data->param.pipe.cached)
s1 = wstrconcat("| ", data->param.pipe.command);
else
s1 = wstrconcat("|| ", data->param.pipe.command);
WMAddToPLArray(item, WMCreatePLString(s1));
wfree(s1);
break;
case ExternalInfo:
if (!data->param.external.path)
goto return_null;
WMAddToPLArray(item, pomenu);
WMAddToPLArray(item, WMCreatePLString(data->param.external.path));
break;
case DirectoryInfo:
{
int l;
char *tmp;
if (!data->param.directory.directory || !data->param.directory.command)
goto return_null;
l = strlen(data->param.directory.directory);
l += strlen(data->param.directory.command);
l += 32;
WMAddToPLArray(item, pomenu);
tmp = wmalloc(l);
sprintf(tmp, "%s%s WITH %s",
data->param.directory.stripExt ? "-noext " : "",
data->param.directory.directory, data->param.directory.command);
WMAddToPLArray(item, WMCreatePLString(tmp));
wfree(tmp);
}
break;
case WSMenuInfo:
WMAddToPLArray(item, WMCreatePLString("WORKSPACE_MENU"));
break;
case WWindowListInfo:
WMAddToPLArray(item, WMCreatePLString("WINDOWS_MENU"));
break;
default:
assert(0);
break;
}
return item;
return_null:
WMReleasePropList(item);
return NULL;
}
static void showData(_Panel * panel)
{
const char *gspath;
char *menuPath, *labelText;
char buf[1024];
WMPropList *pmenu;
gspath = wusergnusteppath();
menuPath = wmalloc(strlen(gspath) + 32);
strcpy(menuPath, gspath);
strcat(menuPath, "/Defaults/WMRootMenu");
pmenu = WMReadPropListFromFile(menuPath);
/* check if WMRootMenu references another file, and if so,
if that file is in proplist format */
while (WMIsPLString(pmenu)) {
char *path = NULL;
path = wexpandpath(WMGetFromPLString(pmenu));
if (access(path, F_OK) < 0)
path = wfindfile(DEF_CONFIG_PATHS, path);
/* TODO: if needed, concatenate locale suffix to path.
See getLocalizedMenuFile() in src/rootmenu.c. */
if (!path)
break;
if (access(path, W_OK) < 0) {
snprintf(buf, 1024,
_("The menu file \"%s\" referenced by "
"WMRootMenu is read-only.\n"
"You cannot use WPrefs to modify it."),
path);
WMRunAlertPanel(WMWidgetScreen(panel->parent),
panel->parent,
_("Warning"), buf,
_("OK"), NULL, NULL);
panel->dontSave = True;
wfree(path);
return;
}
pmenu = WMReadPropListFromFile(path);
menuPath = path;
}
if (!pmenu || !WMIsPLArray(pmenu)) {
int res;
res = WMRunAlertPanel(WMWidgetScreen(panel->parent), panel->parent,
_("Warning"),
_("The menu file format currently in use is not supported\n"
"by this tool. Do you want to discard the current menu\n"
"to use this tool?"),
_("Yes, Discard and Update"), _("No, Keep Current Menu"), NULL);
if (res == WAPRDefault) {
pmenu = getDefaultMenu(panel);
if (!pmenu) {
pmenu = WMCreatePLArray(WMCreatePLString("Applications"), NULL);
}
} else {
panel->dontSave = True;
return;
}
}
panel->menuPath = menuPath;
snprintf(buf, 1024,
_("\n\nWhen saved, the menu will be written to the file\n\"%s\"."),
menuPath);
labelText = WMGetLabelText(panel->sections[NoInfo][0]);
labelText = wstrconcat(labelText, buf);
WMSetLabelText(panel->sections[NoInfo][0], labelText);
wfree(labelText);
buildMenuFromPL(panel, pmenu);
WMReleasePropList(pmenu);
}
int main(int argc, char **argv)
{
WMPropList *prop, *style, *key, *val;
char *path;
int i, ch, theme_too = 0, make_pack = 0;
char *style_file = NULL;
struct option longopts[] = {
{ "pack", no_argument, NULL, 'p' },
{ "theme-options", no_argument, NULL, 't' },
{ "version", no_argument, NULL, 'v' },
{ "help", no_argument, NULL, 'h' },
{ NULL, 0, NULL, 0 }
};
prog_name = argv[0];
while ((ch = getopt_long(argc, argv, "ptvh", longopts, NULL)) != -1)
switch(ch) {
case 'v':
printf("%s (Window Maker %s)\n", prog_name, VERSION);
return 0;
/* NOTREACHED */
case 'h':
print_help(1, 0);
/* NOTREACHED */
case 'p':
make_pack = 1;
theme_too = 1;
break;
case 't':
theme_too = 1;
case 0:
break;
default:
print_help(0, 1);
/* NOTREACHED */
}
/* At most one non-option ARGV-element is accepted (the theme name) */
if (argc - optind > 1)
print_help(0, 1);
if (argc - optind == 1)
style_file = argv[argc - 1];
if (make_pack && !style_file) {
printf("%s: you must supply a name for the theme pack\n", prog_name);
return 1;
}
WMPLSetCaseSensitive(False);
path = wdefaultspathfordomain("WindowMaker");
prop = WMReadPropListFromFile(path);
if (!prop) {
printf("%s: could not load WindowMaker configuration file \"%s\".\n", prog_name, path);
return 1;
}
/* get global value */
path = wglobaldefaultspathfordomain("WindowMaker");
val = WMReadPropListFromFile(path);
if (val) {
WMMergePLDictionaries(val, prop, True);
WMReleasePropList(prop);
prop = val;
}
style = WMCreatePLDictionary(NULL, NULL);
for (i = 0; options[i] != NULL; i++) {
key = WMCreatePLString(options[i]);
val = WMGetFromPLDictionary(prop, key);
if (val) {
WMRetainPropList(val);
if (isFontOption(options[i])) {
char *newfont, *oldfont;
oldfont = WMGetFromPLString(val);
newfont = convertFont(oldfont, False);
/* newfont is a reference to old if conversion is not needed */
if (newfont != oldfont) {
WMReleasePropList(val);
val = WMCreatePLString(newfont);
wfree(newfont);
}
}
WMPutInPLDictionary(style, key, val);
WMReleasePropList(val);
}
WMReleasePropList(key);
}
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 = wmalloc(strlen(ThemePath) + 32);
strcpy(path, ThemePath);
strcat(path, "/style");
WMWritePropListToFile(style, path);
wfree(path);
} else {
if (style_file) {
WMWritePropListToFile(style, style_file);
} else {
puts(WMGetPropListDescription(style, True));
}
}
return 0;
}
static void makeThemePack(WMPropList * style, const char *themeName)
{
WMPropList *keys;
WMPropList *key;
WMPropList *value;
int i;
size_t themeNameLen;
char *themeDir;
const char *user_base;
user_base = wusergnusteppath();
if (user_base == NULL)
return;
themeNameLen = strlen(user_base) + sizeof(THEME_SUBPATH) + strlen(themeName) + sizeof(THEME_EXTDIR) + 1;
themeDir = wmalloc(themeNameLen);
snprintf(themeDir, themeNameLen,
"%s" THEME_SUBPATH "%s" THEME_EXTDIR,
user_base, themeName);
ThemePath = themeDir;
if (!wmkdirhier(themeDir)) {
wwarning("Could not make theme dir %s\n", themeDir);
return;
}
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) {
newPath = wstrdup(p + 1);
wcopy_file(themeDir, WMGetFromPLString(file), newPath);
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) {
newPath = wstrdup(p + 1);
wcopy_file(themeDir, WMGetFromPLString(file), newPath);
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) {
newPath = wstrdup(p + 1);
wcopy_file(themeDir, WMGetFromPLString(file), newPath);
WMDeleteFromPLArray(value, 2);
WMInsertInPLArray(value, 2, WMCreatePLString(newPath));
free(newPath);
} else {
findCopyFile(themeDir, WMGetFromPLString(file));
}
}
}
}
WMReleasePropList(keys);
}
int main(int argc, char **argv)
{
WMPropList *window_name, *icon_key, *window_attrs, *icon_value;
WMPropList *all_windows, *iconset, *keylist;
char *path;
int i, ch;
struct option longopts[] = {
{ "version", no_argument, NULL, 'v' },
{ "help", no_argument, NULL, 'h' },
{ NULL, 0, NULL, 0 }
};
prog_name = argv[0];
while ((ch = getopt_long(argc, argv, "hv", longopts, NULL)) != -1)
switch(ch) {
case 'v':
printf("%s (Window Maker %s)\n", prog_name, VERSION);
return 0;
/* NOTREACHED */
case 'h':
print_help(1, 0);
/* NOTREACHED */
case 0:
break;
default:
print_help(0, 1);
/* NOTREACHED */
}
argc -= optind;
argv += optind;
path = wdefaultspathfordomain("WMWindowAttributes");
all_windows = WMReadPropListFromFile(path);
if (!all_windows) {
printf("%s: could not load WindowMaker configuration file \"%s\".\n", prog_name, path);
return 1;
}
iconset = WMCreatePLDictionary(NULL, NULL);
keylist = WMGetPLDictionaryKeys(all_windows);
icon_key = WMCreatePLString("Icon");
for (i = 0; i < WMGetPropListItemCount(keylist); i++) {
WMPropList *icondic;
window_name = WMGetFromPLArray(keylist, i);
if (!WMIsPLString(window_name))
continue;
window_attrs = WMGetFromPLDictionary(all_windows, window_name);
if (window_attrs && WMIsPLDictionary(window_attrs)) {
icon_value = WMGetFromPLDictionary(window_attrs, icon_key);
if (icon_value) {
icondic = WMCreatePLDictionary(icon_key, icon_value, NULL);
WMPutInPLDictionary(iconset, window_name, icondic);
}
}
}
if (argc == 1) {
WMWritePropListToFile(iconset, argv[0]);
} else {
puts(WMGetPropListDescription(iconset, True));
}
return 0;
}
int
main(int argc, char **argv)
{
WMPropList *window_name, *icon_key, *window_attrs, *icon_value;
WMPropList *all_windows, *iconset, *keylist;
int i;
char *path = NULL;
ProgName = argv[0];
if (argc < 2) {
printf("%s: missing argument\n", ProgName);
printf("Try '%s --help' for more information\n", ProgName);
}
for (i = 1; i < argc; i++) {
if (strcmp(argv[i], "-h")==0
|| strcmp(argv[i], "--help")==0) {
print_help();
exit(0);
} else if (strcmp(argv[i], "--version")==0) {
puts(PROG_VERSION);
exit(0);
} else {
if (path) {
printf("%s: invalid argument '%s'\n", ProgName, argv[i]);
printf("Try '%s --help' for more information\n", ProgName);
exit(1);
}
path = argv[i];
}
}
path = defaultsPathForDomain("WMWindowAttributes");
all_windows = WMReadPropListFromFile(path);
if (!all_windows) {
printf("%s:could not load WindowMaker configuration file \"%s\".\n",
ProgName, path);
exit(1);
}
iconset = WMReadPropListFromFile(argv[1]);
if (!iconset) {
printf("%s:could not load icon set file \"%s\".\n", ProgName, argv[1]);
exit(1);
}
keylist = WMGetPLDictionaryKeys(iconset);
icon_key = WMCreatePLString("Icon");
for (i=0; i<WMGetPropListItemCount(keylist); i++) {
window_name = WMGetFromPLArray(keylist, i);
if (!WMIsPLString(window_name))
continue;
icon_value = WMGetFromPLDictionary(iconset, window_name);
if (!icon_value || !WMIsPLDictionary(icon_value))
continue;
window_attrs = WMGetFromPLDictionary(all_windows, window_name);
if (window_attrs) {
if (WMIsPLDictionary(window_attrs)) {
WMMergePLDictionaries(window_attrs, icon_value, True);
}
} else {
WMPutInPLDictionary(all_windows, window_name, icon_value);
}
}
WMWritePropListToFile(all_windows, path, True);
exit(0);
}
static void saveSettings(WMWidget *button, void *client_data)
{
InspectorPanel *panel = (InspectorPanel *) client_data;
WWindow *wwin = panel->inspected;
WDDomain *db = w_global.domain.window_attr;
WMPropList *dict = NULL;
WMPropList *winDic, *appDic, *value, *value1, *key = NULL, *key2;
char *icon_file, *buf1, *buf2;
int flags = 0, i = 0, different = 0, different2 = 0;
/* Save will apply the changes and save them */
applySettings(panel->applyBtn, panel);
if (WMGetButtonSelected(panel->instRb) != 0) {
key = WMCreatePLString(wwin->wm_instance);
} else if (WMGetButtonSelected(panel->clsRb) != 0) {
key = WMCreatePLString(wwin->wm_class);
} else if (WMGetButtonSelected(panel->bothRb) != 0) {
buf1 = StrConcatDot(wwin->wm_instance, wwin->wm_class);
key = WMCreatePLString(buf1);
wfree(buf1);
} else if (WMGetButtonSelected(panel->defaultRb) != 0) {
key = WMRetainPropList(AnyWindow);
flags = UPDATE_DEFAULTS;
}
if (!key)
return;
dict = db->dictionary;
if (!dict) {
dict = WMCreatePLDictionary(NULL, NULL);
if (dict) {
db->dictionary = dict;
} else {
WMReleasePropList(key);
return;
}
}
if (showIconFor(WMWidgetScreen(button), panel, NULL, NULL, USE_TEXT_FIELD) < 0)
return;
WMPLSetCaseSensitive(True);
winDic = WMCreatePLDictionary(NULL, NULL);
appDic = WMCreatePLDictionary(NULL, NULL);
/* Save the icon info */
/* The flag "Ignore client suplied icon is not selected" */
buf1 = wmalloc(4);
snprintf(buf1, 4, "%s", (WMGetButtonSelected(panel->alwChk) != 0) ? "Yes" : "No");
value1 = WMCreatePLString(buf1);
different |= insertAttribute(dict, winDic, AAlwaysUserIcon, value1, flags);
WMReleasePropList(value1);
wfree(buf1);
/* The icon filename (if exists) */
icon_file = WMGetTextFieldText(panel->fileText);
if (icon_file != NULL) {
if (icon_file[0] != '\0') {
value = WMCreatePLString(icon_file);
different |= insertAttribute(dict, winDic, AIcon, value, flags);
different2 |= insertAttribute(dict, appDic, AIcon, value, flags);
WMReleasePropList(value);
}
wfree(icon_file);
}
i = WMGetPopUpButtonSelectedItem(panel->wsP) - 1;
if (i >= 0 && i < w_global.workspace.count) {
value = WMCreatePLString(w_global.workspace.array[i]->name);
different |= insertAttribute(dict, winDic, AStartWorkspace, value, flags);
WMReleasePropList(value);
}
flags |= IS_BOOLEAN;
value = (WMGetButtonSelected(panel->attrChk[0]) != 0) ? Yes : No;
different |= insertAttribute(dict, winDic, ANoTitlebar, value, flags);
value = (WMGetButtonSelected(panel->attrChk[1]) != 0) ? Yes : No;
different |= insertAttribute(dict, winDic, ANoResizebar, value, flags);
value = (WMGetButtonSelected(panel->attrChk[2]) != 0) ? Yes : No;
different |= insertAttribute(dict, winDic, ANoCloseButton, value, flags);
value = (WMGetButtonSelected(panel->attrChk[3]) != 0) ? Yes : No;
different |= insertAttribute(dict, winDic, ANoMiniaturizeButton, value, flags);
value = (WMGetButtonSelected(panel->attrChk[4]) != 0) ? Yes : No;
different |= insertAttribute(dict, winDic, ANoBorder, value, flags);
value = (WMGetButtonSelected(panel->attrChk[5]) != 0) ? Yes : No;
different |= insertAttribute(dict, winDic, AKeepOnTop, value, flags);
value = (WMGetButtonSelected(panel->attrChk[6]) != 0) ? Yes : No;
different |= insertAttribute(dict, winDic, AKeepOnBottom, value, flags);
value = (WMGetButtonSelected(panel->attrChk[7]) != 0) ? Yes : No;
different |= insertAttribute(dict, winDic, AOmnipresent, value, flags);
value = (WMGetButtonSelected(panel->attrChk[8]) != 0) ? Yes : No;
different |= insertAttribute(dict, winDic, AStartMiniaturized, value, flags);
value = (WMGetButtonSelected(panel->attrChk[9]) != 0) ? Yes : No;
different |= insertAttribute(dict, winDic, AStartMaximized, value, flags);
value = (WMGetButtonSelected(panel->attrChk[10]) != 0) ? Yes : No;
different |= insertAttribute(dict, winDic, AFullMaximize, value, flags);
value = (WMGetButtonSelected(panel->moreChk[0]) != 0) ? Yes : No;
different |= insertAttribute(dict, winDic, ANoKeyBindings, value, flags);
value = (WMGetButtonSelected(panel->moreChk[1]) != 0) ? Yes : No;
different |= insertAttribute(dict, winDic, ANoMouseBindings, value, flags);
value = (WMGetButtonSelected(panel->moreChk[2]) != 0) ? Yes : No;
different |= insertAttribute(dict, winDic, ASkipWindowList, value, flags);
value = (WMGetButtonSelected(panel->moreChk[3]) != 0) ? Yes : No;
different |= insertAttribute(dict, winDic, ASkipSwitchPanel, value, flags);
value = (WMGetButtonSelected(panel->moreChk[4]) != 0) ? Yes : No;
different |= insertAttribute(dict, winDic, AUnfocusable, value, flags);
value = (WMGetButtonSelected(panel->moreChk[5]) != 0) ? Yes : No;
different |= insertAttribute(dict, winDic, AKeepInsideScreen, value, flags);
value = (WMGetButtonSelected(panel->moreChk[6]) != 0) ? Yes : No;
different |= insertAttribute(dict, winDic, ANoHideOthers, value, flags);
value = (WMGetButtonSelected(panel->moreChk[7]) != 0) ? Yes : No;
different |= insertAttribute(dict, winDic, ADontSaveSession, value, flags);
value = (WMGetButtonSelected(panel->moreChk[8]) != 0) ? Yes : No;
different |= insertAttribute(dict, winDic, AEmulateAppIcon, value, flags);
value = (WMGetButtonSelected(panel->moreChk[9]) != 0) ? Yes : No;
different |= insertAttribute(dict, winDic, AFocusAcrossWorkspace, value, flags);
value = (WMGetButtonSelected(panel->moreChk[10]) != 0) ? Yes : No;
different |= insertAttribute(dict, winDic, ANoMiniaturizable, value, flags);
#ifdef XKB_BUTTON_HINT
value = (WMGetButtonSelected(panel->moreChk[11]) != 0) ? Yes : No;
different |= insertAttribute(dict, winDic, ANoLanguageButton, value, flags);
#endif
if (wwin->main_window != None && wApplicationOf(wwin->main_window) != NULL) {
value = (WMGetButtonSelected(panel->appChk[0]) != 0) ? Yes : No;
different2 |= insertAttribute(dict, appDic, AStartHidden, value, flags);
value = (WMGetButtonSelected(panel->appChk[1]) != 0) ? Yes : No;
different2 |= insertAttribute(dict, appDic, ANoAppIcon, value, flags);
value = (WMGetButtonSelected(panel->appChk[2]) != 0) ? Yes : No;
different2 |= insertAttribute(dict, appDic, ASharedAppIcon, value, flags);
}
if (wwin->fake_group) {
key2 = WMCreatePLString(wwin->fake_group->identifier);
if (WMIsPropListEqualTo(key, key2)) {
WMMergePLDictionaries(winDic, appDic, True);
different |= different2;
} else {
WMRemoveFromPLDictionary(dict, key2);
if (different2)
WMPutInPLDictionary(dict, key2, appDic);
}
WMReleasePropList(key2);
} else if (wwin->main_window != wwin->client_win) {
WApplication *wapp = wApplicationOf(wwin->main_window);
if (wapp) {
buf2 = StrConcatDot(wapp->main_window_desc->wm_instance,
wapp->main_window_desc->wm_class);
key2 = WMCreatePLString(buf2);
wfree(buf2);
if (WMIsPropListEqualTo(key, key2)) {
WMMergePLDictionaries(winDic, appDic, True);
different |= different2;
} else {
WMRemoveFromPLDictionary(dict, key2);
if (different2)
WMPutInPLDictionary(dict, key2, appDic);
}
WMReleasePropList(key2);
}
} else {
WMMergePLDictionaries(winDic, appDic, True);
different |= different2;
}
WMReleasePropList(appDic);
WMRemoveFromPLDictionary(dict, key);
if (different)
WMPutInPLDictionary(dict, key, winDic);
WMReleasePropList(key);
WMReleasePropList(winDic);
UpdateDomainFile(db);
/* clean up */
WMPLSetCaseSensitive(False);
}
static void make_keys(void)
{
if (ANoTitlebar != NULL)
return;
AIcon = WMCreatePLString("Icon");
ANoTitlebar = WMCreatePLString("NoTitlebar");
ANoResizebar = WMCreatePLString("NoResizebar");
ANoMiniaturizeButton = WMCreatePLString("NoMiniaturizeButton");
ANoCloseButton = WMCreatePLString("NoCloseButton");
ANoBorder = WMCreatePLString("NoBorder");
ANoHideOthers = WMCreatePLString("NoHideOthers");
ANoMouseBindings = WMCreatePLString("NoMouseBindings");
ANoKeyBindings = WMCreatePLString("NoKeyBindings");
ANoAppIcon = WMCreatePLString("NoAppIcon");
AKeepOnTop = WMCreatePLString("KeepOnTop");
AKeepOnBottom = WMCreatePLString("KeepOnBottom");
AOmnipresent = WMCreatePLString("Omnipresent");
ASkipWindowList = WMCreatePLString("SkipWindowList");
ASkipSwitchPanel = WMCreatePLString("SkipSwitchPanel");
AKeepInsideScreen = WMCreatePLString("KeepInsideScreen");
AUnfocusable = WMCreatePLString("Unfocusable");
AFocusAcrossWorkspace = WMCreatePLString("FocusAcrossWorkspace");
AAlwaysUserIcon = WMCreatePLString("AlwaysUserIcon");
AStartMiniaturized = WMCreatePLString("StartMiniaturized");
AStartMaximized = WMCreatePLString("StartMaximized");
AStartHidden = WMCreatePLString("StartHidden");
ADontSaveSession = WMCreatePLString("DontSaveSession");
AEmulateAppIcon = WMCreatePLString("EmulateAppIcon");
AFullMaximize = WMCreatePLString("FullMaximize");
ASharedAppIcon = WMCreatePLString("SharedAppIcon");
ANoMiniaturizable = WMCreatePLString("NoMiniaturizable");
#ifdef XKB_BUTTON_HINT
ANoLanguageButton = WMCreatePLString("NoLanguageButton");
#endif
AStartWorkspace = WMCreatePLString("StartWorkspace");
AnyWindow = WMCreatePLString("*");
EmptyString = WMCreatePLString("");
Yes = WMCreatePLString("Yes");
No = WMCreatePLString("No");
}
/* creates the proplist menu out of the abstract menu representation in `menu'.
*/
static void assemblePLMenuFunc(WMTreeNode *aNode, void *data)
{
WMMenuEntry *wm;
WMPropList *pl;
int pDepth, cDepth;
wm = (WMMenuEntry *)WMGetDataForTreeNode(aNode);
cDepth = WMGetTreeNodeDepth(aNode);
pDepth = *(int *)data;
if (pDepth > cDepth) { /* just ascended out of a/several submenu(s) */
WMPropList *last, *but; /* merge the tail up to the current position */
int i;
for (i = pDepth - cDepth; i > 0; i--) {
last = WMPopFromArray(plMenuNodes);
but = WMPopFromArray(plMenuNodes);
WMAddToPLArray(but, last);
WMAddToArray(plMenuNodes, but);
}
}
if (!wm->CmdLine) { /* new submenu */
WMAddToArray(plMenuNodes, WMCreatePLArray(WMCreatePLString(wm->Name), NULL));
} else { /* new menu item */
pl = WMPopFromArray(plMenuNodes);
if (wm->Flags & F_RESTART_OTHER) { /* RESTART, somewm */
char buf[1024];
memset(buf, 0, sizeof(buf));
snprintf(buf, sizeof(buf), "%s %s", _("Restart"), wm->Name);
WMAddToPLArray(pl, WMCreatePLArray(
WMCreatePLString(buf),
WMCreatePLString("RESTART"),
WMCreatePLString(wm->CmdLine),
NULL)
);
} else if (wm->Flags & F_RESTART_SELF) {/* RESTART */
WMAddToPLArray(pl, WMCreatePLArray(
WMCreatePLString(_("Restart Window Maker")),
WMCreatePLString("RESTART"),
NULL)
);
} else if (wm->Flags & F_QUIT) { /* EXIT */
WMAddToPLArray(pl, WMCreatePLArray(
WMCreatePLString(_("Exit Window Maker")),
WMCreatePLString("EXIT"),
NULL)
);
} else { /* plain simple command */
char buf[1024];
memset(buf, 0, sizeof(buf));
if (wm->Flags & F_TERMINAL) /* XXX: quoting! */
snprintf(buf, sizeof(buf), "%s -e \"%s\"", terminal, wm->CmdLine);
else
snprintf(buf, sizeof(buf), "%s", wm->CmdLine);
WMAddToPLArray(pl, WMCreatePLArray(
WMCreatePLString(wm->Name),
WMCreatePLString("SHEXEC"),
WMCreatePLString(buf),
NULL)
);
}
WMAddToArray(plMenuNodes, pl);
}
*(int *)data = cDepth;
return;
}