static void files_list(xmpp_stanza_t *stanza) {
int rc; /* Return code */
rc = pthread_mutex_lock(&mutex);
wsyserr(rc != 0, "pthread_mutex_lock");
char *error_attr = xmpp_stanza_get_attribute(stanza, "error"); /* error attribute */
wfatal(error_attr == NULL, "no error attribute in files stanza");
if (strcmp(error_attr, "0") != 0) {
wlog("Error in attributes: %s", error_attr);
} else {
char *path_attr = xmpp_stanza_get_attribute(stanza, "path"); /* path attribute */
wfatal(path_attr == NULL, "xmpp_stanza_get_attribute [attribute = path]");
xmpp_stanza_t *child = xmpp_stanza_get_children(stanza);
while (child != NULL) {
elem_t *elem = (elem_t *)malloc(sizeof(elem_t));
wsyserr(elem == NULL, "malloc");
elem->next = NULL;
char *name = xmpp_stanza_get_name(child);
wfatal(name == NULL, "xmpp_stanza_get_name");
if (strcmp(name, "directory") == 0) {
elem->type = DIR;
} else if (strcmp(name, "file") == 0) {
elem->type = REG;
} else {
werr("Unknown name: %s", name);
}
char *filename_attr = xmpp_stanza_get_attribute(child, "filename");
wfatal(filename_attr == NULL, "xmpp_stanza_get_attribute [attribute = filename]");
elem->filename = strdup(filename_attr);
wsyserr(elem->filename == NULL, "strdup");
/* Add elem in list */
if (root == NULL) {
root = elem;
} else {
last->next = elem;
}
last = elem;
child = xmpp_stanza_get_next(child);
}
}
/* Data set */
signal_list = true;
rc = pthread_cond_signal(&cond);
wsyserr(rc != 0, "pthread_cond_signal");
rc = pthread_mutex_unlock(&mutex);
wsyserr(rc != 0, "pthread_mutex_unlock");
}
static void files_attr(xmpp_stanza_t *stanza) {
int rc; /* Return code */
rc = pthread_mutex_lock(&mutex);
wsyserr(rc != 0, "pthread_mutex_lock");
char *error_attr = xmpp_stanza_get_attribute(stanza, "error"); /* error attribute */
wfatal(error_attr == NULL, "no error attribute in files stanza");
if (strcmp(error_attr, "0") != 0) {
wlog("Error in attributes: %s", error_attr);
attributes.is_valid = -1;
} else {
char *type_attr = xmpp_stanza_get_attribute(stanza, "type"); /* type attribute */
wfatal(type_attr == NULL, "no type attribute in files stanza");
if (strcmp(type_attr, "directory") == 0) {
attributes.is_valid = 1;
attributes.type = DIR;
} else if (strcmp(type_attr, "file") == 0) {
attributes.is_valid = 1;
attributes.type = REG;
} else {
werr("Unknown type: %s", type_attr);
attributes.is_valid = -1;
}
char *size_attr = xmpp_stanza_get_attribute(stanza, "size"); /* size */
if (size_attr == NULL) {
werr("xmpp_stanza_get_attribute attribute = size (%s)", xmpp_stanza_get_attribute(stanza, "path"));
attributes.size = 0;
} else {
char *endptr; /* strtol endptr */
long int size = strtol(size_attr, &endptr, 10);
if (*endptr != '\0') {
werr("strtol error: str = %s, val = %ld", size_attr, size);
attributes.size = 0;
}
attributes.size = size;
}
}
signal_attr = true;
rc = pthread_cond_signal(&cond);
wsyserr(rc != 0, "pthread_cond_signal");
rc = pthread_mutex_unlock(&mutex);
wsyserr(rc != 0, "pthread_mutex_unlock");
}
void
check_defaults()
{
char *path;
path = wdefaultspathfordomain("WindowMaker");
if (access(path, R_OK)!=0) {
#if 0
wfatal(_("could not find user GNUstep directory (%s).\n"
"Make sure you have installed Window Maker correctly and run wmaker.inst"),
path);
exit(1);
#else
wwarning(_("could not find user GNUstep directory (%s)."), path);
if (system("wmaker.inst --batch") != 0) {
wwarning(_("There was an error while creating GNUstep directory, please "
"make sure you have installed Window Maker correctly and run wmaker.inst"));
} else {
wwarning(_("%s directory created with default configuration."), path);
}
#endif
}
wfree(path);
}
void
Restart(char *manager, Bool abortOnFailure)
{
char *prog=NULL;
char *argv[MAX_RESTART_ARGS];
int i;
if (manager && manager[0]!=0) {
prog = argv[0] = strtok(manager, " ");
for (i=1; i<MAX_RESTART_ARGS; i++) {
argv[i]=strtok(NULL, " ");
if (argv[i]==NULL) {
break;
}
}
}
if (dpy) {
#ifdef XSMP_ENABLED
wSessionDisconnectManager();
#endif
XCloseDisplay(dpy);
dpy = NULL;
}
if (!prog) {
execvp(Arguments[0], Arguments);
wfatal(_("failed to restart Window Maker."));
} else {
execvp(prog, argv);
wsyserror(_("could not exec %s"), prog);
}
if (abortOnFailure)
exit(7);
}
static void files_read(xmpp_stanza_t *stanza) {
int rc;
rc = pthread_mutex_lock(&mutex);
wsyserr(rc != 0, "pthread_mutex_lock");
char *text = xmpp_stanza_get_text(stanza);
if(text == NULL) {
werr("xmpp_stanza_get_text returned NULL (%s, error %s)", xmpp_stanza_get_attribute(stanza, "path"), xmpp_stanza_get_attribute(stanza, "error"));
read_data = strdup ("");
}
else
{
int dec_size = strlen(text) * 3 / 4 + 1;
uint8_t *dec_text = (uint8_t *)calloc(dec_size, sizeof(uint8_t));
rc = base64_decode(dec_text, text, dec_size);
wfatal(rc < 0, "base64_decode");
if (read_data != NULL) {
free(read_data);
}
read_data = strdup((char *)dec_text);
wsyserr(read_data == NULL, "strdup");
free(text);
free(dec_text);
}
signal_read = true;
rc = pthread_cond_signal(&cond);
wsyserr(rc != 0, "pthread_cond_signal");
rc = pthread_mutex_unlock(&mutex);
wsyserr(rc != 0, "pthread_mutex_unlock");
}
void files(const char *from, const char *to, int error, xmpp_stanza_t *stanza,
xmpp_conn_t *const conn, void *const userdata)
{
wlog("files()");
if (error == 0) {
char *action_attr = xmpp_stanza_get_attribute(stanza, "action"); /* action attribute */
if (action_attr == NULL) {
werr("xmpp_stanza_get_attribute attribute = action");
}
wfatal(action_attr == NULL, "xmpp_stanza_get_attribute [attribute = action]");
if (strcmp(action_attr, "attributes") == 0) {
files_attr(stanza);
} else if (strcmp(action_attr, "list") == 0) {
files_list(stanza);
} else if (strncasecmp(action_attr, "read", 4) == 0) {
files_read(stanza);
} else {
werr("Unknown action: %s", action_attr);
}
} else {
werr("error stanza %s %s", xmpp_stanza_get_attribute(stanza, "path"), xmpp_stanza_get_attribute(stanza, "action"));
}
wlog("Return from files()");
}
int main(int argc, char **argv)
{
Display *dpy;
WMWindow *win;
WMScreen *scr;
WMButton *lab, *l0 = NULL;
WMLabel *pos;
int x, y, c;
char buf[20];
WMInitializeApplication("FontView", &argc, argv);
dpy = XOpenDisplay("");
if (!dpy) {
wfatal("cant open display");
exit(0);
}
scr = WMCreateSimpleApplicationScreen(dpy);
win = WMCreateWindow(scr, "main");
WMResizeWidget(win, 20 * 33, 20 + 20 * 9);
WMSetWindowTitle(win, "Font Chars");
WMSetWindowCloseAction(win, quit, NULL);
pos = WMCreateLabel(win);
WMResizeWidget(pos, 20 * 33, 20);
WMMoveWidget(pos, 10, 5);
c = 0;
for (y = 0; y < 8; y++) {
for (x = 0; x < 32; x++, c++) {
lab = WMCreateCustomButton(win, WBBStateLightMask);
WMResizeWidget(lab, 20, 20);
WMMoveWidget(lab, 10 + x * 20, 30 + y * 20);
sprintf(buf, "%c", c);
WMSetButtonText(lab, buf);
WMSetButtonAction(lab, show, pos);
WMHangData(lab, (void *)(uintptr_t) c);
if (c > 0) {
WMGroupButtons(l0, lab);
} else {
l0 = lab;
}
}
}
WMRealizeWidget(win);
WMMapSubwidgets(win);
WMMapWidget(win);
WMScreenMainLoop(scr);
return 0;
}
/*
*----------------------------------------------------------------------
* handleSig--
* general signal handler. Exits the program gently.
*----------------------------------------------------------------------
*/
static RETSIGTYPE handleSig(int sig)
{
wfatal("got signal %i", sig);
/* Setting the signal behaviour back to default and then reraising the
* signal is a cleaner way to make program exit and core dump than calling
* abort(), since it correctly returns from the signal handler and sets
* the flags accordingly. -Dan
*/
if (sig == SIGSEGV || sig == SIGFPE || sig == SIGBUS || sig == SIGILL || sig == SIGABRT) {
signal(sig, SIG_DFL);
kill(getpid(), sig);
return;
}
wAbort(0);
}
int showCrashDialog(int sig)
{
int crashAction;
dpy = XOpenDisplay(NULL);
if (dpy) {
/* XXX TODO make sure that window states are saved and restored via netwm */
XGrabServer(dpy);
crashAction = wShowCrashingDialogPanel(sig);
XCloseDisplay(dpy);
dpy = NULL;
} else {
wsyserror(_("cannot open connection for crashing dialog panel. Aborting."));
crashAction = WMAbort;
}
if (crashAction == WMStartAlternate)
{
int i;
wmessage(_("trying to start alternate window manager..."));
for (i=0; i<WMGetArrayItemCount(wPreferences.fallbackWMs); i++) {
Restart(WMGetFromArray(wPreferences.fallbackWMs, i), False);
}
wfatal(_("failed to start alternate window manager. Aborting."));
return 0;
}
else if (crashAction == WMAbort)
return 0;
else
return 1;
}
int main(int argc, char **argv)
{
Display *dpy;
WMScreen *scr;
char *path;
int i;
char *display_name = "";
wsetabort(wAbort);
memset(DeadHandlers, 0, sizeof(DeadHandlers));
WMInitializeApplication("WPrefs", &argc, argv);
WMSetResourcePath(RESOURCE_PATH);
path = WMPathForResourceOfType("WPrefs.tiff", NULL);
if (!path) {
/* maybe it is run directly from the source directory */
WMSetResourcePath(".");
path = WMPathForResourceOfType("WPrefs.tiff", NULL);
if (!path) {
WMSetResourcePath("..");
}
}
if (path) {
wfree(path);
}
if (argc > 1) {
for (i = 1; i < argc; i++) {
if (strcmp(argv[i], "-version") == 0 || strcmp(argv[i], "--version") == 0) {
printf("WPrefs (Window Maker) %s\n", VERSION);
exit(0);
} else if (strcmp(argv[i], "-display") == 0) {
i++;
if (i >= argc) {
wwarning(_("too few arguments for %s"), argv[i - 1]);
exit(0);
}
display_name = argv[i];
} else {
print_help(argv[0]);
exit(0);
}
}
}
setlocale(LC_ALL, "");
#ifdef I18N
if (getenv("NLSPATH"))
bindtextdomain("WPrefs", getenv("NLSPATH"));
else
bindtextdomain("WPrefs", LOCALEDIR);
bind_textdomain_codeset("WPrefs", "UTF-8");
textdomain("WPrefs");
if (!XSupportsLocale()) {
wwarning(_("X server does not support locale"));
}
if (XSetLocaleModifiers("") == NULL) {
wwarning(_("cannot set locale modifiers"));
}
#endif
dpy = XOpenDisplay(display_name);
if (!dpy) {
wfatal(_("could not open display %s"), XDisplayName(display_name));
exit(0);
}
#if 0
XSynchronize(dpy, 1);
#endif
scr = WMCreateScreen(dpy, DefaultScreen(dpy));
if (!scr) {
wfatal(_("could not initialize application"));
exit(0);
}
xext_xkb_supported = XkbQueryExtension(dpy, NULL, NULL, NULL, NULL, NULL);
WMPLSetCaseSensitive(False);
Initialize(scr);
while (1) {
XEvent event;
WMNextEvent(dpy, &event);
while (DeadChildrenCount-- > 0) {
int i;
for (i = 0; i < MAX_DEATHS; i++) {
if (DeadChildren[i] == DeadHandlers[i].pid) {
(*DeadHandlers[i].handler) (DeadHandlers[i].data);
DeadHandlers[i].pid = 0;
}
}
}
WMHandleEvent(&event);
}
}
/*
*----------------------------------------------------------
* StartUp--
* starts the window manager and setup global data.
* Called from main() at startup.
*
* Side effects:
* global data declared in main.c is initialized
*----------------------------------------------------------
*/
void StartUp(Bool defaultScreenOnly)
{
struct sigaction sig_action;
int i, j, max;
char **formats;
Atom atom[wlengthof(atomNames)];
/*
* Ignore CapsLock in modifiers
*/
w_global.shortcut.modifiers_mask = 0xff & ~LockMask;
getOffendingModifiers();
/*
* Ignore NumLock and ScrollLock too
*/
w_global.shortcut.modifiers_mask &= ~(_NumLockMask | _ScrollLockMask);
memset(&wKeyBindings, 0, sizeof(wKeyBindings));
w_global.context.client_win = XUniqueContext();
w_global.context.app_win = XUniqueContext();
w_global.context.stack = XUniqueContext();
/* _XA_VERSION = XInternAtom(dpy, "VERSION", False); */
#ifdef HAVE_XINTERNATOMS
XInternAtoms(dpy, atomNames, wlengthof(atomNames), False, atom);
#else
{
int i;
for (i = 0; i < wlengthof(atomNames); i++)
atom[i] = XInternAtom(dpy, atomNames[i], False);
}
#endif
w_global.atom.wm.state = atom[0];
w_global.atom.wm.change_state = atom[1];
w_global.atom.wm.protocols = atom[2];
w_global.atom.wm.take_focus = atom[3];
w_global.atom.wm.delete_window = atom[4];
w_global.atom.wm.save_yourself = atom[5];
w_global.atom.wm.client_leader = atom[6];
w_global.atom.wm.colormap_windows = atom[7];
w_global.atom.wm.colormap_notify = atom[8];
w_global.atom.wmaker.menu = atom[9];
w_global.atom.wmaker.state = atom[10];
w_global.atom.wmaker.wm_protocols = atom[11];
w_global.atom.wmaker.wm_function = atom[12];
w_global.atom.wmaker.noticeboard = atom[13];
w_global.atom.wmaker.command = atom[14];
w_global.atom.wmaker.icon_size = atom[15];
w_global.atom.wmaker.icon_tile = atom[16];
w_global.atom.gnustep.wm_attr = atom[17];
w_global.atom.gnustep.wm_miniaturize_window = atom[18];
w_global.atom.gnustep.titlebar_state = atom[19];
w_global.atom.wm.ignore_focus_events = atom[20];
#ifdef XDND
wXDNDInitializeAtoms();
#endif
/* cursors */
wPreferences.cursor[WCUR_NORMAL] = None; /* inherit from root */
wPreferences.cursor[WCUR_ROOT] = XCreateFontCursor(dpy, XC_left_ptr);
wPreferences.cursor[WCUR_ARROW] = XCreateFontCursor(dpy, XC_top_left_arrow);
wPreferences.cursor[WCUR_MOVE] = XCreateFontCursor(dpy, XC_fleur);
wPreferences.cursor[WCUR_RESIZE] = XCreateFontCursor(dpy, XC_sizing);
wPreferences.cursor[WCUR_TOPLEFTRESIZE] = XCreateFontCursor(dpy, XC_top_left_corner);
wPreferences.cursor[WCUR_TOPRIGHTRESIZE] = XCreateFontCursor(dpy, XC_top_right_corner);
wPreferences.cursor[WCUR_BOTTOMLEFTRESIZE] = XCreateFontCursor(dpy, XC_bottom_left_corner);
wPreferences.cursor[WCUR_BOTTOMRIGHTRESIZE] = XCreateFontCursor(dpy, XC_bottom_right_corner);
wPreferences.cursor[WCUR_VERTICALRESIZE] = XCreateFontCursor(dpy, XC_sb_v_double_arrow);
wPreferences.cursor[WCUR_HORIZONRESIZE] = XCreateFontCursor(dpy, XC_sb_h_double_arrow);
wPreferences.cursor[WCUR_WAIT] = XCreateFontCursor(dpy, XC_watch);
wPreferences.cursor[WCUR_QUESTION] = XCreateFontCursor(dpy, XC_question_arrow);
wPreferences.cursor[WCUR_TEXT] = XCreateFontCursor(dpy, XC_xterm); /* odd name??? */
wPreferences.cursor[WCUR_SELECT] = XCreateFontCursor(dpy, XC_cross);
Pixmap cur = XCreatePixmap(dpy, DefaultRootWindow(dpy), 16, 16, 1);
GC gc = XCreateGC(dpy, cur, 0, NULL);
XColor black;
memset(&black, 0, sizeof(XColor));
XSetForeground(dpy, gc, 0);
XFillRectangle(dpy, cur, gc, 0, 0, 16, 16);
XFreeGC(dpy, gc);
wPreferences.cursor[WCUR_EMPTY] = XCreatePixmapCursor(dpy, cur, cur, &black, &black, 0, 0);
XFreePixmap(dpy, cur);
/* emergency exit... */
sig_action.sa_handler = handleSig;
sigemptyset(&sig_action.sa_mask);
sig_action.sa_flags = SA_RESTART;
sigaction(SIGQUIT, &sig_action, NULL);
/* instead of catching these, we let the default handler abort the
* program. The new monitor process will take appropriate action
* when it detects the crash.
sigaction(SIGSEGV, &sig_action, NULL);
sigaction(SIGBUS, &sig_action, NULL);
sigaction(SIGFPE, &sig_action, NULL);
sigaction(SIGABRT, &sig_action, NULL);
*/
sig_action.sa_handler = handleExitSig;
/* Here we set SA_RESTART for safety, because SIGUSR1 may not be handled
* immediately. -Dan */
sig_action.sa_flags = SA_RESTART;
sigaction(SIGTERM, &sig_action, NULL);
sigaction(SIGINT, &sig_action, NULL);
sigaction(SIGHUP, &sig_action, NULL);
sigaction(SIGUSR1, &sig_action, NULL);
sigaction(SIGUSR2, &sig_action, NULL);
/* ignore dead pipe */
/* Because POSIX mandates that only signal with handlers are reset
* accross an exec*(), we do not want to propagate ignoring SIGPIPEs
* to children. Hence the dummy handler.
* Philippe Troin <*****@*****.**>
*/
sig_action.sa_handler = &dummyHandler;
sig_action.sa_flags = SA_RESTART;
sigaction(SIGPIPE, &sig_action, NULL);
/* handle dead children */
sig_action.sa_handler = buryChild;
sig_action.sa_flags = SA_NOCLDSTOP | SA_RESTART;
sigaction(SIGCHLD, &sig_action, NULL);
/* Now we unblock all signals, that may have been blocked by the parent
* who exec()-ed us. This can happen for example if Window Maker crashes
* and restarts itself or another window manager from the signal handler.
* In this case, the new proccess inherits the blocked signal mask and
* will no longer react to that signal, until unblocked.
* This is because the signal handler of the proccess who crashed (parent)
* didn't return, and the signal remained blocked. -Dan
*/
sigfillset(&sig_action.sa_mask);
sigprocmask(SIG_UNBLOCK, &sig_action.sa_mask, NULL);
/* handle X shutdowns a such */
XSetIOErrorHandler(handleXIO);
/* set hook for out event dispatcher in WINGs event dispatcher */
WMHookEventHandler(DispatchEvent);
/* initialize defaults stuff */
w_global.domain.wmaker = wDefaultsInitDomain("WindowMaker", True);
if (!w_global.domain.wmaker->dictionary)
wwarning(_("could not read domain \"%s\" from defaults database"), "WindowMaker");
/* read defaults that don't change until a restart and are
* screen independent */
wReadStaticDefaults(w_global.domain.wmaker ? w_global.domain.wmaker->dictionary : NULL);
/* check sanity of some values */
if (wPreferences.icon_size < 16) {
wwarning(_("icon size is configured to %i, but it's too small. Using 16 instead"),
wPreferences.icon_size);
wPreferences.icon_size = 16;
}
/* init other domains */
w_global.domain.root_menu = wDefaultsInitDomain("WMRootMenu", False);
if (!w_global.domain.root_menu->dictionary)
wwarning(_("could not read domain \"%s\" from defaults database"), "WMRootMenu");
wDefaultsMergeGlobalMenus(w_global.domain.root_menu);
w_global.domain.window_attr = wDefaultsInitDomain("WMWindowAttributes", True);
if (!w_global.domain.window_attr->dictionary)
wwarning(_("could not read domain \"%s\" from defaults database"), "WMWindowAttributes");
XSetErrorHandler((XErrorHandler) catchXError);
#ifdef USE_XSHAPE
/* ignore j */
w_global.xext.shape.supported = XShapeQueryExtension(dpy, &w_global.xext.shape.event_base, &j);
#endif
#ifdef USE_XRANDR
w_global.xext.randr.supported = XRRQueryExtension(dpy, &w_global.xext.randr.event_base, &j);
#endif
#ifdef KEEP_XKB_LOCK_STATUS
w_global.xext.xkb.supported = XkbQueryExtension(dpy, NULL, &w_global.xext.xkb.event_base, NULL, NULL, NULL);
if (wPreferences.modelock && !w_global.xext.xkb.supported) {
wwarning(_("XKB is not supported. KbdModeLock is automatically disabled."));
wPreferences.modelock = 0;
}
#endif
if (defaultScreenOnly)
max = 1;
else
max = ScreenCount(dpy);
wScreen = wmalloc(sizeof(WScreen *) * max);
w_global.screen_count = 0;
/* Check if TIFF images are supported */
formats = RSupportedFileFormats();
if (formats) {
for (i = 0; formats[i] != NULL; i++) {
if (strcmp(formats[i], "TIFF") == 0) {
wPreferences.supports_tiff = 1;
break;
}
}
}
/* manage the screens */
for (j = 0; j < max; j++) {
if (defaultScreenOnly || max == 1) {
wScreen[w_global.screen_count] = wScreenInit(DefaultScreen(dpy));
if (!wScreen[w_global.screen_count]) {
wfatal(_("it seems that there is already a window manager running"));
Exit(1);
}
} else {
wScreen[w_global.screen_count] = wScreenInit(j);
if (!wScreen[w_global.screen_count]) {
wwarning(_("could not manage screen %i"), j);
continue;
}
}
w_global.screen_count++;
}
InitializeSwitchMenu();
/* initialize/restore state for the screens */
for (j = 0; j < w_global.screen_count; j++) {
int lastDesktop;
lastDesktop = wNETWMGetCurrentDesktopFromHint(wScreen[j]);
wScreenRestoreState(wScreen[j]);
/* manage all windows that were already here before us */
if (!wPreferences.flags.nodock && wScreen[j]->dock)
wScreen[j]->last_dock = wScreen[j]->dock;
manageAllWindows(wScreen[j], wPreferences.flags.restarting == 2);
/* restore saved menus */
wMenuRestoreState(wScreen[j]);
/* If we're not restarting, restore session */
if (wPreferences.flags.restarting == 0 && !wPreferences.flags.norestore)
wSessionRestoreState(wScreen[j]);
if (!wPreferences.flags.noautolaunch) {
/* auto-launch apps */
if (!wPreferences.flags.nodock && wScreen[j]->dock) {
wScreen[j]->last_dock = wScreen[j]->dock;
wDockDoAutoLaunch(wScreen[j]->dock, 0);
}
/* auto-launch apps in clip */
if (!wPreferences.flags.noclip) {
int i;
for (i = 0; i < w_global.workspace.count; i++) {
if (w_global.workspace.array[i]->clip) {
wScreen[j]->last_dock = w_global.workspace.array[i]->clip;
wDockDoAutoLaunch(w_global.workspace.array[i]->clip, i);
}
}
}
/* auto-launch apps in drawers */
if (!wPreferences.flags.nodrawer) {
WDrawerChain *dc;
for (dc = wScreen[j]->drawers; dc; dc = dc->next) {
wScreen[j]->last_dock = dc->adrawer;
wDockDoAutoLaunch(dc->adrawer, 0);
}
}
}
/* go to workspace where we were before restart */
if (lastDesktop >= 0)
wWorkspaceForceChange(wScreen[j], lastDesktop);
else
wSessionRestoreLastWorkspace(wScreen[j]);
}
if (w_global.screen_count == 0) {
wfatal(_("could not manage any screen"));
Exit(1);
}
#ifndef HAVE_INOTIFY
/* setup defaults file polling */
if (!wPreferences.flags.nopolling && !wPreferences.flags.noupdates)
WMAddTimerHandler(3000, wDefaultsCheckDomains, NULL);
#endif
}
