void
ExecExitScript()
{
char *file, *paths;
paths = wstrconcat(wusergnusteppath(), "/Library/WindowMaker");
paths = wstrappend(paths, ":"DEF_CONFIG_PATHS);
file = wfindfile(paths, DEF_EXIT_SCRIPT);
wfree(paths);
if (file) {
if (system(file) != 0) {
wsyserror(_("%s:could not execute exit script"), file);
}
#if 0
if (fork()==0) {
execl("/bin/sh", "/bin/sh", "-c", file, NULL);
wsyserror(_("%s:could not execute exit script"), file);
exit(1);
}
#endif
wfree(file);
}
}
int wcopy_file(const char *dir, const char *src_file, const char *dest_file)
{
FILE *src, *dst;
size_t nread, nwritten;
char *dstpath;
struct stat st;
char buf[4096];
/* only to a directory */
if (stat(dir, &st) != 0 || !S_ISDIR(st.st_mode))
return -1;
/* only copy files */
if (stat(src_file, &st) != 0 || !S_ISREG(st.st_mode))
return -1;
do {
src = fopen(src_file, "rb");
} while ((src == NULL) && (errno == EINTR));
if (src == NULL) {
werror(_("Could not open input file \"%s\""), src_file);
return -1;
}
dstpath = wstrconcat(dir, dest_file);
do {
dst = fopen(dstpath, "wb");
} while ((dst == NULL) && (errno == EINTR));
if (dst == NULL) {
werror(_("Could not create target file \"%s\""), dstpath);
wfree(dstpath);
fclose(src);
return -1;
}
do {
nread = fread(buf, 1, sizeof(buf), src);
if (ferror(src))
break;
nwritten = fwrite(buf, 1, nread, dst);
if (ferror(dst) || feof(src) || nread != nwritten)
break;
} while (1);
if (ferror(src) || ferror(dst))
unlink(dstpath);
fclose(src);
fchmod(fileno(dst), st.st_mode);
fsync(fileno(dst));
if (fclose(dst))
wwarning("error occured during fclose(\"%s\")", dstpath);
wfree(dstpath);
return 0;
}
static void updateFrameTitle(_Panel * panel, const char *title, InfoType type)
{
if (type != NoInfo) {
char *tmp;
switch (type) {
case ExecInfo:
tmp = wstrconcat(title, _(": Execute Program"));
break;
case CommandInfo:
tmp = wstrconcat(title, _(": Perform Internal Command"));
break;
case ExternalInfo:
tmp = wstrconcat(title, _(": Open a Submenu"));
break;
case PipeInfo:
tmp = wstrconcat(title, _(": Program Generated Submenu"));
break;
case PLPipeInfo:
tmp = wstrconcat(title, _(": Program Generated Proplist Submenu"));
break;
case DirectoryInfo:
tmp = wstrconcat(title, _(": Directory Contents Menu"));
break;
case WSMenuInfo:
tmp = wstrconcat(title, _(": Open Workspaces Submenu"));
break;
case WWindowListInfo:
tmp = wstrconcat(title, _(": Open Window List Submenu"));
break;
default:
tmp = NULL;
break;
}
WMSetFrameTitle(panel->optionsF, tmp);
wfree(tmp);
} else {
WMSetFrameTitle(panel->optionsF, NULL);
}
}
static void
killCallback(WMenu *menu, WMenuEntry *entry)
{
WApplication *wapp = (WApplication*)entry->clientdata;
WFakeGroupLeader *fPtr;
char *buffer;
if (!WCHECK_STATE(WSTATE_NORMAL))
return;
WCHANGE_STATE(WSTATE_MODAL);
assert(entry->clientdata!=NULL);
buffer = wstrconcat(wapp->app_icon ? wapp->app_icon->wm_class : NULL,
_(" will be forcibly closed.\n"
"Any unsaved changes will be lost.\n"
"Please confirm."));
fPtr = wapp->main_window_desc->fake_group;
wretain(wapp->main_window_desc);
if (wPreferences.dont_confirm_kill
|| wMessageDialog(menu->frame->screen_ptr, _("Kill Application"),
buffer, _("Yes"), _("No"), NULL)==WAPRDefault) {
if (fPtr!=NULL) {
WWindow *wwin, *twin;
wwin = wapp->main_window_desc->screen_ptr->focused_window;
while (wwin) {
twin = wwin->prev;
if (wwin->fake_group == fPtr) {
wClientKill(wwin);
}
wwin = twin;
}
} else if (!wapp->main_window_desc->flags.destroyed) {
wClientKill(wapp->main_window_desc);
}
}
wrelease(wapp->main_window_desc);
wfree(buffer);
WCHANGE_STATE(WSTATE_NORMAL);
}
static void
shellCommandHandler(pid_t pid, unsigned char status, _tuple *data)
{
if (status == 127) {
char *buffer;
buffer = wstrconcat(_("Could not execute command: "), data->command);
wMessageDialog(data->scr, _("Error"), buffer, _("OK"), NULL, NULL);
wfree(buffer);
} else if (status != 127) {
/*
printf("%s: %i\n", data->command, status);
*/
}
wfree(data->command);
wfree(data);
}
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);
}
static void storeCommandInScript(const char *cmd, const char *line)
{
char *path;
FILE *f;
char buffer[128];
mode_t permissions;
/* Calculate permission to be Executable but taking into account user's umask */
permissions = umask(0);
umask(permissions);
permissions = (S_IRWXU | S_IRWXG | S_IRWXO) & (~permissions);
path = wstrconcat(wusergnusteppath(), "/Library/WindowMaker/autostart");
f = fopen(path, "rb");
if (!f) {
f = fopen(path, "wb");
if (!f) {
werror(_("could not create %s"), path);
goto end;
}
fprintf(f, "#!/bin/sh\n");
fputs(line, f);
fputs("\n", f);
} else {
int len = strlen(cmd);
int ok = 0;
char *tmppath;
FILE *fo;
tmppath = wstrconcat(wusergnusteppath(), "/Library/WindowMaker/autostart.tmp");
fo = fopen(tmppath, "wb");
if (!fo) {
werror(_("could not create temporary file %s"), tmppath);
wfree(tmppath);
goto end;
}
while (!feof(f)) {
if (!fgets(buffer, 127, f)) {
break;
}
if (buffer[0] == '\n') {
/* don't write empty lines, else the file will grow
* indefinitely (one '\n' added at end of file on each save).
*/
continue;
}
if (strncmp(buffer, cmd, len) == 0) {
if (!ok) {
fputs(line, fo);
fputs("\n", fo);
ok = 1;
}
} else {
fputs(buffer, fo);
}
}
if (!ok) {
fputs(line, fo);
fputs("\n", fo);
}
fsync(fileno(fo));
fclose(fo);
if (rename(tmppath, path) != 0) {
werror(_("could not rename file %s to %s"), tmppath, path);
}
wfree(tmppath);
}
if (chmod(path, permissions) != 0)
wwarning(_("could not set permission 0%03o on file \"%s\""), permissions, path);
end:
wfree(path);
if (f) {
fsync(fileno(f)); /* this may be rw */
fclose(f);
}
}
static InspectorPanel *createInspectorForWindow(WWindow *wwin, int xpos, int ypos, Bool showSelectPanel)
{
WScreen *scr = wwin->screen_ptr;
InspectorPanel *panel;
Window parent;
char *str = NULL, *tmp = NULL;
int x, y, btn_width, frame_width;
WMButton *selectedBtn = NULL;
spec_text = _("The configuration will apply to all\n"
"windows that have their WM_CLASS\n"
"property set to the above selected\n" "name, when saved.");
panel = wmalloc(sizeof(InspectorPanel));
memset(panel, 0, sizeof(InspectorPanel));
panel->destroyed = 0;
panel->inspected = wwin;
panel->nextPtr = panelList;
panelList = panel;
panel->win = WMCreateWindow(scr->wmscreen, "windowInspector");
WMResizeWidget(panel->win, PWIDTH, PHEIGHT);
/**** create common stuff ****/
/* command buttons */
btn_width = (PWIDTH - (2 * 15) - (2 * 10)) / 3;
panel->saveBtn = WMCreateCommandButton(panel->win);
WMSetButtonAction(panel->saveBtn, saveSettings, panel);
WMMoveWidget(panel->saveBtn, (2 * (btn_width + 10)) + 15, PHEIGHT - 40);
WMSetButtonText(panel->saveBtn, _("Save"));
WMResizeWidget(panel->saveBtn, btn_width, 28);
if (wPreferences.flags.noupdates || !(wwin->wm_class || wwin->wm_instance))
WMSetButtonEnabled(panel->saveBtn, False);
panel->applyBtn = WMCreateCommandButton(panel->win);
WMSetButtonAction(panel->applyBtn, applySettings, panel);
WMMoveWidget(panel->applyBtn, btn_width + 10 + 15, PHEIGHT - 40);
WMSetButtonText(panel->applyBtn, _("Apply"));
WMResizeWidget(panel->applyBtn, btn_width, 28);
panel->revertBtn = WMCreateCommandButton(panel->win);
WMSetButtonAction(panel->revertBtn, revertSettings, panel);
WMMoveWidget(panel->revertBtn, 15, PHEIGHT - 40);
WMSetButtonText(panel->revertBtn, _("Reload"));
WMResizeWidget(panel->revertBtn, btn_width, 28);
/* page selection popup button */
panel->pagePopUp = WMCreatePopUpButton(panel->win);
WMSetPopUpButtonAction(panel->pagePopUp, changePage, panel);
WMMoveWidget(panel->pagePopUp, 25, 15);
WMResizeWidget(panel->pagePopUp, PWIDTH - 50, 20);
WMAddPopUpButtonItem(panel->pagePopUp, _("Window Specification"));
WMAddPopUpButtonItem(panel->pagePopUp, _("Window Attributes"));
WMAddPopUpButtonItem(panel->pagePopUp, _("Advanced Options"));
WMAddPopUpButtonItem(panel->pagePopUp, _("Icon and Initial Workspace"));
WMAddPopUpButtonItem(panel->pagePopUp, _("Application Specific"));
/**** window spec ****/
frame_width = PWIDTH - (2 * 15);
panel->specFrm = WMCreateFrame(panel->win);
WMSetFrameTitle(panel->specFrm, _("Window Specification"));
WMMoveWidget(panel->specFrm, 15, 65);
WMResizeWidget(panel->specFrm, frame_width, 145);
panel->defaultRb = WMCreateRadioButton(panel->specFrm);
WMMoveWidget(panel->defaultRb, 10, 78);
WMResizeWidget(panel->defaultRb, frame_width - (2 * 10), 20);
WMSetButtonText(panel->defaultRb, _("Defaults for all windows"));
WMSetButtonSelected(panel->defaultRb, False);
WMSetButtonAction(panel->defaultRb, selectSpecification, panel);
if (wwin->wm_class && wwin->wm_instance) {
tmp = wstrconcat(wwin->wm_instance, ".");
str = wstrconcat(tmp, wwin->wm_class);
panel->bothRb = WMCreateRadioButton(panel->specFrm);
WMMoveWidget(panel->bothRb, 10, 18);
WMResizeWidget(panel->bothRb, frame_width - (2 * 10), 20);
WMSetButtonText(panel->bothRb, str);
wfree(tmp);
wfree(str);
WMGroupButtons(panel->defaultRb, panel->bothRb);
if (!selectedBtn)
selectedBtn = panel->bothRb;
WMSetButtonAction(panel->bothRb, selectSpecification, panel);
}
if (wwin->wm_instance) {
panel->instRb = WMCreateRadioButton(panel->specFrm);
WMMoveWidget(panel->instRb, 10, 38);
WMResizeWidget(panel->instRb, frame_width - (2 * 10), 20);
WMSetButtonText(panel->instRb, wwin->wm_instance);
WMGroupButtons(panel->defaultRb, panel->instRb);
if (!selectedBtn)
selectedBtn = panel->instRb;
WMSetButtonAction(panel->instRb, selectSpecification, panel);
}
if (wwin->wm_class) {
panel->clsRb = WMCreateRadioButton(panel->specFrm);
WMMoveWidget(panel->clsRb, 10, 58);
WMResizeWidget(panel->clsRb, frame_width - (2 * 10), 20);
WMSetButtonText(panel->clsRb, wwin->wm_class);
WMGroupButtons(panel->defaultRb, panel->clsRb);
if (!selectedBtn)
selectedBtn = panel->clsRb;
WMSetButtonAction(panel->clsRb, selectSpecification, panel);
}
panel->selWinB = WMCreateCommandButton(panel->specFrm);
WMMoveWidget(panel->selWinB, 20, 145 - 24 - 10);
WMResizeWidget(panel->selWinB, frame_width - 2 * 10 - 20, 24);
WMSetButtonText(panel->selWinB, _("Select window"));
WMSetButtonAction(panel->selWinB, selectWindow, panel);
panel->specLbl = WMCreateLabel(panel->win);
WMMoveWidget(panel->specLbl, 15, 210);
WMResizeWidget(panel->specLbl, frame_width, 100);
WMSetLabelText(panel->specLbl, spec_text);
WMSetLabelWraps(panel->specLbl, True);
WMSetLabelTextAlignment(panel->specLbl, WALeft);
/**** attributes ****/
create_tab_window_attributes(wwin, panel, frame_width);
create_tab_window_advanced(wwin, panel, frame_width);
create_tab_icon_workspace(wwin, panel);
create_tab_app_specific(wwin, panel, frame_width);
/* if the window is a transient, don't let it have a miniaturize button */
if (wwin->transient_for != None && wwin->transient_for != scr->root_win)
WMSetButtonEnabled(panel->attrChk[3], False);
else
WMSetButtonEnabled(panel->attrChk[3], True);
if (!wwin->wm_class && !wwin->wm_instance)
WMSetPopUpButtonItemEnabled(panel->pagePopUp, 0, False);
WMRealizeWidget(panel->win);
WMMapSubwidgets(panel->win);
WMMapSubwidgets(panel->specFrm);
WMMapSubwidgets(panel->attrFrm);
WMMapSubwidgets(panel->moreFrm);
WMMapSubwidgets(panel->iconFrm);
WMMapSubwidgets(panel->wsFrm);
if (panel->appFrm)
WMMapSubwidgets(panel->appFrm);
if (showSelectPanel) {
WMSetPopUpButtonSelectedItem(panel->pagePopUp, 0);
changePage(panel->pagePopUp, panel);
} else {
WMSetPopUpButtonSelectedItem(panel->pagePopUp, 1);
changePage(panel->pagePopUp, panel);
}
parent = XCreateSimpleWindow(dpy, scr->root_win, 0, 0, PWIDTH, PHEIGHT, 0, 0, 0);
XSelectInput(dpy, parent, KeyPressMask | KeyReleaseMask);
panel->parent = parent;
XReparentWindow(dpy, WMWidgetXID(panel->win), parent, 0, 0);
WMMapWidget(panel->win);
XSetTransientForHint(dpy, parent, wwin->client_win);
if (xpos == UNDEFINED_POS) {
x = wwin->frame_x + wwin->frame->core->width / 2;
y = wwin->frame_y + wwin->frame->top_width * 2;
if (y + PHEIGHT > scr->scr_height)
y = scr->scr_height - PHEIGHT - 30;
if (x + PWIDTH > scr->scr_width)
x = scr->scr_width - PWIDTH;
} else {
x = xpos;
y = ypos;
}
panel->frame = wManageInternalWindow(scr, parent, wwin->client_win, "Inspector", x, y, PWIDTH, PHEIGHT);
if (!selectedBtn)
selectedBtn = panel->defaultRb;
WMSetButtonSelected(selectedBtn, True);
selectSpecification(selectedBtn, panel);
/* kluge to know who should get the key events */
panel->frame->client_leader = WMWidgetXID(panel->win);
WSETUFLAG(panel->frame, no_closable, 0);
WSETUFLAG(panel->frame, no_close_button, 0);
wWindowUpdateButtonImages(panel->frame);
wFrameWindowShowButton(panel->frame->frame, WFF_RIGHT_BUTTON);
panel->frame->frame->on_click_right = destroyInspector;
wWindowMap(panel->frame);
showIconFor(WMWidgetScreen(panel->alwChk), panel, wwin->wm_instance, wwin->wm_class, UPDATE_TEXT_FIELD);
return panel;
}
static int InitGreet(struct display *d)
{
int pid;
WDMDebug("Greet display=%s\n", d->name);
pipe(pipe_filedes);
pid = fork();
if (pid == -1) { /* error */
WDMError("Greet cannot fork\n");
exit(RESERVER_DISPLAY);
}
if (pid == 0) { /* child */
char **env = NULL;
char *argv[20];
int argc = 1; /* argc = 0 is for command itself */
close(pipe_filedes[0]);
fcntl(pipe_filedes[1], F_SETFD, 0); /* Reset close-on-exec (just in case) */
env = (char **)systemEnv(d, (char *)NULL, FAKEHOME);
if (*wdmLocale)
env = WDMSetEnv(env, "LANG", wdmLocale);
if (*wdmCursorTheme)
env = WDMSetEnv(env, "XCURSOR_THEME", wdmCursorTheme);
if ((argv[0] = strrchr(wdmLogin, '/')) == NULL)
argv[0] = wdmLogin;
else
argv[0]++;
argv[argc++] = wstrconcat("-d", d->name);
if (*wdmWm)
argv[argc++] = wstrconcat("-w", wdmWm);
if (*wdmLogo)
argv[argc++] = wstrconcat("-l", wdmLogo);
if (*wdmHelpFile)
argv[argc++] = wstrconcat("-h", wdmHelpFile);
if (*wdmDefaultUser)
argv[argc++] = "-u";
if (*wdmBg)
argv[argc++] = wstrconcat("-b", wdmBg);
if (*wdmLoginConfig)
argv[argc++] = wstrconcat("-c", wdmLoginConfig);
if (wdmAnimations)
argv[argc++] = "-a";
if (wdmXineramaHead) {
argv[argc] = wmalloc(25); /* much more than length of 64bit integer
converted to string, but it still a hack */
sprintf(argv[argc++], "-x%i", wdmXineramaHead);
}
argv[argc] = wmalloc(25);
sprintf(argv[argc++], "-f%i", pipe_filedes[1]);
argv[argc++] = NULL;
execve(wdmLogin, argv, env);
WDMError("Greet cannot exec %s\n", wdmLogin);
exit(RESERVER_DISPLAY);
}
close(pipe_filedes[1]);
RegisterCloseOnFork(pipe_filedes[0]);
return pid;
}
