~ctwm/ctwm/trunk

/*
 *       Copyright 1988 by Evans & Sutherland Computer Corporation,
 *                          Salt Lake City, Utah
 *  Portions Copyright 1989 by the Massachusetts Institute of Technology
 *                        Cambridge, Massachusetts
 *
 * $XConsortium: twm.c,v 1.124 91/05/08 11:01:54 dave Exp $
 *
 * twm - "Tom's Window Manager"
 *
 * 27-Oct-87 Thomas E. LaStrange        File created
 * 10-Oct-90 David M. Sternlicht        Storing saved colors on root
 *
 * Copyright 1992 Claude Lecommandeur.
 *
 * Do the necessary modification to be integrated in ctwm.
 * Can no longer be used for the standard twm.
 *
 * 22-April-92 Claude Lecommandeur.
 */

#include "ctwm.h"

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <locale.h>

#include <fcntl.h>
#include <X11/Xatom.h>
#include <X11/extensions/shape.h>


#include "ctwm_atoms.h"
#include "ctwm_main.h"
#include "ctwm_takeover.h"
#include "clargs.h"
#include "add_window.h"
#include "gc.h"
#include "parse.h"
#include "version.h"
#include "colormaps.h"
#include "events.h"
#include "util.h"
#include "mask_screen.h"
#include "animate.h"
#include "screen.h"
#include "icons.h"
#include "iconmgr.h"
#include "list.h"
#ifdef SESSION
#include "session.h"
#endif
#include "occupation.h"
#include "otp.h"
#include "cursor.h"
#ifdef WINBOX
#include "windowbox.h"
#endif
#ifdef CAPTIVE
#include "captive.h"
#endif
#ifdef XRANDR
#include "xrandr.h"
#endif
#include "r_area.h"
#include "r_area_list.h"
#include "r_layout.h"
#include "signals.h"
#include "vscreen.h"
#include "win_decorations_init.h"
#include "win_ops.h"
#include "win_regions.h"
#include "win_utils.h"
#include "workspace_manager.h"
#ifdef SOUNDS
#  include "sound.h"
#endif

#include "gram.tab.h"


XtAppContext appContext;        /* Xt application context */
Display *dpy;                   /* which display are we talking to */
Window ResizeWindow;            /* the window we are resizing */

Atom XCTWMAtom[NUM_CTWM_XATOMS]; ///< Our various common atoms

int NumScreens;                 /* number of screens in ScreenList */
bool HasShape;                  /* server supports shape extension? */
int ShapeEventBase, ShapeErrorBase;
ScreenInfo **ScreenList;        /* structures for each screen */
ScreenInfo *Scr = NULL;         /* the cur and prev screens */
int PreviousScreen;             /* last screen that we were on */
static bool cfgerrs = false;    ///< Whether there were config parsing errors

#ifdef CAPTIVE
static Window CreateCaptiveRootWindow(int x, int y,
                                      unsigned int width, unsigned int height);
#endif
ScreenInfo *InitScreenInfo(int scrnum, Window croot, int crootx, int crooty,
                           unsigned int crootw, unsigned int crooth);
static bool MappedNotOverride(Window w);

Cursor  UpperLeftCursor;
Cursor  TopRightCursor,
        TopLeftCursor,
        BottomRightCursor,
        BottomLeftCursor,
        LeftCursor,
        RightCursor,
        TopCursor,
        BottomCursor;

Cursor RightButt;
Cursor MiddleButt;
Cursor LeftButt;

XContext TwmContext;            /* context for twm windows */
XContext MenuContext;           /* context for all menu windows */
XContext ScreenContext;         /* context to get screen data */
XContext ColormapContext;       /* context for colormap operations */

XClassHint NoClass;             /* for applications with no class */

XGCValues Gcv;

char *Home;                     /* the HOME environment variable */
int HomeLen;                    /* length of Home */

bool HandlingEvents = false;    /* are we handling events yet? */

/*
 * Various junk vars for xlib calls.  Many calls have to get passed these
 * pointers to return values into, but in a lot of cases we don't care
 * about some/all of them, and since xlib blindly derefs and stores into
 * them, we can't just pass NULL for the ones we don't care about.  So we
 * make this set of globals to use as standin.  These should never be
 * used or read in our own code; use real vars for the values we DO use
 * from the calls.
 */
Window JunkRoot, JunkChild;
int JunkX, JunkY;
unsigned int JunkWidth, JunkHeight, JunkBW, JunkDepth, JunkMask;

char *ProgramName;
size_t ProgramNameLen;
int Argc;
char **Argv;

bool RestartPreviousState = true;      /* try to restart in previous state */


/// Magic flag for tests.  Nothing else should touch this!
bool ctwm_test = false;

/// Magic callback for tests.  This will trigger right after config file
/// parsing if it's set, and then exit.  Nothing else should ever touch
/// this!
int (*ctwm_test_postparse)(void) = NULL;




/**
 * Start up ctwm.  This is effectively main(), just wrapped for various
 * unimportant reasons.
 */
int
ctwm_main(int argc, char *argv[])
{
	int numManaged, firstscrn, lastscrn;
	bool FirstScreen;
	bool takeover = true;
	bool nodpyok = false;

	setlocale(LC_ALL, "");

	ProgramName = argv[0];
	ProgramNameLen = strlen(ProgramName);
	Argc = argc;
	Argv = argv;


	/*
	 * Run consistency check.  This is mostly to keep devs from
	 * accidental screwups; if a user ever sees anything from this,
	 * something went very very wrong.
	 */
	chk_keytable_order();

	/*
	 * Parse-out command line args, and check the results.
	 */
	clargs_parse(argc, argv);
	clargs_check();
	/* If we get this far, it was all good */

	/* Some clargs mean we're not actually trying to take over the screen */
	if(CLarg.cfgchk) {
		takeover = false;
	}
#ifdef CAPTIVE
	if(CLarg.is_captive) {
		takeover = false;
	}
#endif

	/* And some mean we actually don't care if we lack an X server */
	if(CLarg.cfgchk) {
		nodpyok = true;
	}

	/* Support for tests: be ready to fake everything */
	if(ctwm_test) {
		takeover = false;
		nodpyok  = true;
	}


	/*
	 * Hook up signal handlers
	 */
	setup_signal_handlers();


	// Various bits of code care about $HOME
	Home = getenv("HOME");
	if(Home == NULL) {
		Home = "./";
	}
	HomeLen = strlen(Home);


	// XXX This is only used in AddWindow(), and is probably bogus to
	// have globally....
	NoClass.res_name = NoName;
	NoClass.res_class = NoName;


	/*
	 * Initialize our X connection and state bits.
	 */
	{
		int zero = 0; // Fakey

		XtToolkitInitialize();
		appContext = XtCreateApplicationContext();

		// Tests don't talk to a real X server.
		// XXX This needs revisiting if we ever get one that _does_.
		// We'll have to add another flag...
		if(!ctwm_test) {
			// Connect
			dpy = XtOpenDisplay(appContext, CLarg.display_name, "twm", "twm",
			                    NULL, 0, &zero, NULL);
		}

		// Failed?  Usually a problem, but somethings we allow faking...
		if(!dpy && !nodpyok) {
			fprintf(stderr, "%s:  unable to open display \"%s\"\n",
			        ProgramName, XDisplayName(CLarg.display_name));
			exit(1);
		}

		if(dpy && fcntl(ConnectionNumber(dpy), F_SETFD, FD_CLOEXEC) == -1) {
			fprintf(stderr,
			        "%s:  unable to mark display connection as close-on-exec\n",
			        ProgramName);
			exit(1);
		}

		if(!dpy && !ctwm_test) {
			// At least warn, except for tests
			fprintf(stderr, "%s: Can't connect to X server, proceeding anyway...\n",
			        ProgramName);
		}
	}


#ifdef SESSION
	// Load session stuff
	if(CLarg.restore_filename) {
		ReadWinConfigFile(CLarg.restore_filename);
	}
#endif


	if(dpy) {
		// Load up info about X extensions
		HasShape = XShapeQueryExtension(dpy, &ShapeEventBase, &ShapeErrorBase);

		// Allocate contexts/atoms/etc we use
		TwmContext = XUniqueContext();
		MenuContext = XUniqueContext();
		ScreenContext = XUniqueContext();
		ColormapContext = XUniqueContext();
		InitWorkSpaceManagerContext();

		// Load up our standard set of atoms
		XInternAtoms(dpy, XCTWMAtomNames, NUM_CTWM_XATOMS, False, XCTWMAtom);

		NumScreens = ScreenCount(dpy);
		PreviousScreen = DefaultScreen(dpy);
	}
	else {
		NumScreens = 1;
		PreviousScreen = 0;
	}

	// Allocate/define common cursors
	NewFontCursor(&TopLeftCursor, "top_left_corner");
	NewFontCursor(&TopRightCursor, "top_right_corner");
	NewFontCursor(&BottomLeftCursor, "bottom_left_corner");
	NewFontCursor(&BottomRightCursor, "bottom_right_corner");
	NewFontCursor(&LeftCursor, "left_side");
	NewFontCursor(&RightCursor, "right_side");
	NewFontCursor(&TopCursor, "top_side");
	NewFontCursor(&BottomCursor, "bottom_side");

	NewFontCursor(&UpperLeftCursor, "top_left_corner");
	NewFontCursor(&RightButt, "rightbutton");
	NewFontCursor(&LeftButt, "leftbutton");
	NewFontCursor(&MiddleButt, "middlebutton");


	// Prep up the per-screen global info
	if(CLarg.MultiScreen) {
		firstscrn = 0;
		lastscrn = NumScreens - 1;
	}
	else if(!dpy) {
		firstscrn = lastscrn = 0;
	}
	else {
		firstscrn = lastscrn = DefaultScreen(dpy);
	}

	// For simplicity, pre-allocate NumScreens ScreenInfo struct pointers
	ScreenList = calloc(NumScreens, sizeof(ScreenInfo *));
	if(ScreenList == NULL) {
		fprintf(stderr, "%s: Unable to allocate memory for screen list, exiting.\n",
		        ProgramName);
		exit(1);
	}


	// Do a little early initialization
#ifdef EWMH
	if(dpy) {
		EwmhInit();
	}
#endif /* EWMH */
#ifdef SOUNDS
	// Needs init'ing before we get to config parsing
	sound_init();
#endif
	InitEvents();



	// Start looping over the screens
	numManaged = 0;
	FirstScreen = true;
	for(int scrnum = firstscrn ; scrnum <= lastscrn; scrnum++) {
		Window croot;
		int crootx, crooty;
		unsigned int crootw, crooth;
		bool screenmasked;
		char *welcomefile;


		/*
		 * First, setup the root window for the screen.
		 */
		if(0) {
			// Dummy
		}
#ifdef CAPTIVE
		else if(CLarg.is_captive) {
			// Captive ctwm.  We make a fake root.
			XWindowAttributes wa;
			if(CLarg.capwin && XGetWindowAttributes(dpy, CLarg.capwin, &wa)) {
				Window junk;
				croot  = CLarg.capwin;
				crootw = wa.width;
				crooth = wa.height;
				XTranslateCoordinates(dpy, CLarg.capwin, wa.root, 0, 0, &crootx, &crooty,
				                      &junk);
			}
			else {
				// Fake up default size.  Probably ideally should be
				// configurable, but even more ideally we wouldn't have
				// captive...
				crootx = crooty = 100;
				crootw = 1280;
				crooth = 768;
				croot = CreateCaptiveRootWindow(crootx, crooty, crootw, crooth);
			}
		}
#endif
		else {
			// Normal; get the real display's root.
			crootx = 0;
			crooty = 0;

			if(dpy) {
				croot  = RootWindow(dpy, scrnum);
				crootw = DisplayWidth(dpy, scrnum);
				crooth = DisplayHeight(dpy, scrnum);
			}
			else {
				croot = None;
				crootw = 1280;
				crooth = 768;
			}
		}



		/*
		 * Create ScreenInfo for this Screen, and populate various
		 * default/initial config.
		 */
		Scr = ScreenList[scrnum] = InitScreenInfo(scrnum, croot,
		                           crootx, crooty, crootw, crooth);
		if(Scr == NULL) {
			fprintf(stderr,
			        "%s: unable to allocate memory for ScreenInfo structure"
			        " for screen %d.\n",
			        ProgramName, scrnum);
			continue;
		}

		// Other misc adjustments to default config.
		Scr->ShowWelcomeWindow = CLarg.ShowWelcomeWindow;



		/*
		 * Figure out the layout of our various monitors if RANDR is
		 * around and can tell us.
		 */
#ifdef XRANDR
		if(dpy) {
			Scr->Layout = XrandrNewLayout(dpy, Scr->XineramaRoot);
		}
#endif
		if(Scr->Layout == NULL) {
			// No RANDR, so as far as we know, the layout is just one
			// monitor with our full size.
			RArea *fs;
			RAreaList *fsl;

			fs = RAreaNewStatic(Scr->rootx, Scr->rooty, Scr->rootw, Scr->rooth);
			fsl = RAreaListNew(1, fs, NULL);
			Scr->Layout = RLayoutNew(fsl);
		}
#ifdef DEBUG
		fprintf(stderr, "Layout: ");
		RLayoutPrint(Scr->Layout);
#endif
		if(RLayoutNumMonitors(Scr->Layout) < 1) {
			fprintf(stderr, "Error: No monitors found on screen %d!\n", scrnum);
			continue;
		}



		// Now we can stash some info about the screen
		if(dpy) {
			Scr->d_depth = DefaultDepth(dpy, scrnum);
			Scr->d_visual = DefaultVisual(dpy, scrnum);
			Scr->RealRoot = RootWindow(dpy, scrnum);
			{
				// Stash these for m4
				Screen *tscr = ScreenOfDisplay(dpy, scrnum);
				Scr->mm_w = tscr->mwidth;
				Scr->mm_h = tscr->mheight;
			}
		}
		else {
			// Standin; fake the values we need in m4 parsing
			Scr->d_visual = calloc(1, sizeof(Visual));
			Scr->d_visual->bits_per_rgb = 8;
			Scr->d_visual->class = TrueColor;
		}


		// Now that we have d_depth...
		Scr->XORvalue = (((unsigned long) 1) << Scr->d_depth) - 1;

#ifdef CAPTIVE
		// Init captive bits.  We stick this name into m4 props, so do it
		// before config processing.
		if(CLarg.is_captive) {
			Scr->CaptiveRoot = croot;
			Scr->captivename = AddToCaptiveList(CLarg.captivename);
			if(Scr->captivename) {
				XmbSetWMProperties(dpy, croot,
				                   Scr->captivename, Scr->captivename,
				                   NULL, 0, NULL, NULL, NULL);
			}
		}
#endif


		// Init some colormap bits.  We need this before we get into the
		// config parsing, since various things in there poke into
		// colormaps.
		{
			// 1 on the root
			Scr->RootColormaps.number_cwins = 1;
			Scr->RootColormaps.cwins = malloc(sizeof(ColormapWindow *));
			Scr->RootColormaps.cwins[0] = CreateColormapWindow(Scr->Root, true,
			                              false);
			Scr->RootColormaps.cwins[0]->visibility = VisibilityPartiallyObscured;

			// Initialize storage for all maps the Screen can hold
			Scr->cmapInfo.cmaps = NULL;
			if(dpy) {
				Scr->cmapInfo.maxCmaps = MaxCmapsOfScreen(ScreenOfDisplay(dpy,
				                         Scr->screen));
			}
			Scr->cmapInfo.root_pushes = 0;
			InstallColormaps(0, &Scr->RootColormaps);

			// Setup which we're using
			Scr->StdCmapInfo.head = Scr->StdCmapInfo.tail
			                        = Scr->StdCmapInfo.mru = NULL;
			Scr->StdCmapInfo.mruindex = 0;
			if(dpy) {
				LocateStandardColormaps();
			}
		}


		// Are we monochrome?  Or do we care this millennium?
		if(CLarg.Monochrome || (dpy && DisplayCells(dpy, scrnum) < 3)) {
			Scr->Monochrome = MONOCHROME;
		}
		else {
			Scr->Monochrome = COLOR;
		}


		// With the colormap/monochrome bits set, we can setup our
		// default color bits.
		GetColor(Scr->Monochrome, &(Scr->Black), "black");
		GetColor(Scr->Monochrome, &(Scr->White), "white");

		Scr->MenuShadowColor = Scr->Black;
		Scr->IconBorderColor = Scr->Black;
		Scr->IconManagerHighlight = Scr->Black;

#define SETFB(fld) Scr->fld.fore = Scr->Black; Scr->fld.back = Scr->White;
		SETFB(DefaultC)
		SETFB(BorderColorC)
		SETFB(BorderTileC)
		SETFB(TitleC)
		SETFB(MenuC)
		SETFB(MenuTitleC)
		SETFB(IconC)
		SETFB(IconManagerC)
		SETFB(workSpaceMgr.windowcp)
		SETFB(workSpaceMgr.curColors)
		SETFB(workSpaceMgr.defColors)
#undef SETFB


		// The first time around, we focus onto the root [of the first
		// Screen].  Maybe we should revisit this...
		if(dpy && FirstScreen) {
			// XXX This func also involves a lot of stuff that isn't
			// setup yet, and probably only works by accident.  Maybe we
			// should just manually extract out the couple bits we
			// actually want to run?
			SetFocus(NULL, CurrentTime);
			FirstScreen = false;
		}

		// Create default icon manager memory bits (in the first
		// workspace)
		AllocateIconManager("TWM", "Icons", "", 1);


		/*
		 * Mask over the screen with our welcome window stuff if we were
		 * asked to on the command line/environment; too early to get
		 * info from config file about it.
		 */
		screenmasked = false;
		if(dpy && takeover && Scr->ShowWelcomeWindow
		                && (welcomefile = getenv("CTWM_WELCOME_FILE"))) {
			screenmasked = true;
			MaskScreen(welcomefile);
		}



		/*
		 * Load up config file
		 */
		{
			bool ok = LoadTwmrc(CLarg.InitFile);

			// cfgchk just displays whether there are errors, then moves
			// on.
			if(CLarg.cfgchk) {
				if(ok) {
					fprintf(stderr, "%d: No errors found\n", scrnum);
				}
				else {
					fprintf(stderr, "%d: Errors found\n", scrnum);
					cfgerrs = true;
				}
				continue;
			}

			// In non-config-check mode, we historically proceed even if
			// there were errors, so keep doing that...
		}


		// For testing, it's useful to do all that initial setup up
		// through parsing, and then inspect Scr and the like.
		// Long-term, IWBNI we had a better way to do all the necessary
		// initialization and then call the parse ourselves at that
		// level.  But for now, provide a callback func that can pass
		// control back to the test code, then just exits.
		if(ctwm_test_postparse != NULL) {
			exit(ctwm_test_postparse());
		}



		/*
		 * Since we've loaded the config, go ahead and take over the
		 * screen.
		 */
		if(takeover) {
			if(takeover_screen(Scr) != true) {
				// Well, move on to the next one, maybe we'll get it...
				if(screenmasked) {
					UnmaskScreen();
				}
				continue;
			}

			// Well, we got this one
			numManaged++;
		}

		// If the config wants us to show the splash screen and we
		// haven't already, do it now.
		if(Scr->ShowWelcomeWindow && !screenmasked) {
			MaskScreen(NULL);
		}



		/*
		 * Do various setup based on the results from the config file.
		 */

		// Few simple var defaults
		if(Scr->ClickToFocus) {
			Scr->FocusRoot  = false;
			Scr->TitleFocus = false;
		}

		if(Scr->use3Dborders) {
			Scr->ClientBorderWidth = false;
		}


		// Now that we know what Border's there may be, create our
		// BorderedLayout.
		Scr->BorderedLayout = RLayoutCopyCropped(Scr->Layout,
		                      Scr->BorderLeft, Scr->BorderRight,
		                      Scr->BorderTop, Scr->BorderBottom);
		if(Scr->BorderedLayout == NULL) {
			Scr->BorderedLayout = Scr->Layout;        // nothing to crop
		}
		else if(Scr->BorderedLayout->monitors->len == 0) {
			fprintf(stderr,
			        "Borders too large! correct BorderLeft, BorderRight, BorderTop and/or BorderBottom parameters\n");
			exit(1);
		}
#ifdef DEBUG
		fprintf(stderr, "Bordered: ");
		RLayoutPrint(Scr->BorderedLayout);
#endif


		/*
		 * Setup stuff relating to VirtualScreens.  If something to do
		 * with it is set in the config, this all implements stuff needed
		 * for that.  If not, InitVirtualScreens() creates a single one
		 * mirroring our real root.
		 */
		InitVirtualScreens(Scr);
#ifdef VSCREEN
#ifdef EWMH
		EwmhInitVirtualRoots(Scr);
#endif /* EWMH */
#endif // vscreen

		// Setup WSM[s] (per-vscreen).  This also sets up the about the
		// workspaces for each vscreen and which is currently displayed.
		ConfigureWorkSpaceManager(Scr);


		/*
		 * Various decoration default overrides for 3d/2d.  Values that
		 * [presumtively] look "nice" on 75/100dpi displays.  -100 is a
		 * sentinel value we set before the config file parsing; since
		 * these defaults differ for 3d vs not, we can't just set them as
		 * default before the parse.
		 */
#define SETDEF(fld, num) if(Scr->fld == -100) { Scr->fld = num; }
		if(Scr->use3Dtitles) {
			SETDEF(FramePadding,  0);
			SETDEF(TitlePadding,  0);
			SETDEF(ButtonIndent,  0);
			SETDEF(TBInfo.border, 0);
		}
		else {
			SETDEF(FramePadding,  2);
			SETDEF(TitlePadding,  8);
			SETDEF(ButtonIndent,  1);
			SETDEF(TBInfo.border, 1);
		}
#undef SETDEF

		// These values are meaningless in !3d cases, so always zero them
		// out.
		if(! Scr->use3Dtitles) {
			Scr->TitleShadowDepth       = 0;
			Scr->TitleButtonShadowDepth = 0;
		}
		if(! Scr->use3Dborders) {
			Scr->BorderShadowDepth = 0;
		}
		if(! Scr->use3Dmenus) {
			Scr->MenuShadowDepth = 0;
		}
		if(! Scr->use3Diconmanagers) {
			Scr->IconManagerShadowDepth = 0;
		}
		if(! Scr->use3Dborders) {
			Scr->ThreeDBorderWidth = 0;
		}

		// Setup colors stuff
		if(!Scr->BeNiceToColormap) {
			// Default pair
			GetShadeColors(&Scr->DefaultC);

			// Various conditionally 3d bits
			if(Scr->use3Dtitles) {
				GetShadeColors(&Scr->TitleC);
			}
			if(Scr->use3Dmenus) {
				GetShadeColors(&Scr->MenuC);
			}
			if(Scr->use3Dmenus) {
				GetShadeColors(&Scr->MenuTitleC);
			}
			if(Scr->use3Dborders) {
				GetShadeColors(&Scr->BorderColorC);
			}
		}

		// Defaults for IconRegion bits that aren't set.
		for(IconRegion *ir = Scr->FirstRegion; ir; ir = ir->next) {
			if(ir->TitleJustification == TJ_UNDEF) {
				ir->TitleJustification = Scr->IconJustification;
			}
			if(ir->Justification == IRJ_UNDEF) {
				ir->Justification = Scr->IconRegionJustification;
			}
			if(ir->Alignement == IRA_UNDEF) {
				ir->Alignement = Scr->IconRegionAlignement;
			}
		}

		// Put the results of SaveColor{} into _MIT_PRIORITY_COLORS.
		assign_var_savecolor();

		// Setup cursor values that weren't give in the config
#define DEFCURSOR(name, val) if(!Scr->name) NewFontCursor(&Scr->name, val)
		DEFCURSOR(FrameCursor,   "top_left_arrow");
		DEFCURSOR(TitleCursor,   "top_left_arrow");
		DEFCURSOR(IconCursor,    "top_left_arrow");
		DEFCURSOR(IconMgrCursor, "top_left_arrow");
		DEFCURSOR(MoveCursor,    "fleur");
		DEFCURSOR(ResizeCursor,  "fleur");
		DEFCURSOR(MenuCursor,    "sb_left_arrow");
		DEFCURSOR(ButtonCursor,  "hand2");
		DEFCURSOR(WaitCursor,    "watch");
		DEFCURSOR(SelectCursor,  "dot");
		DEFCURSOR(DestroyCursor, "pirate");
		DEFCURSOR(AlterCursor,   "question_arrow");
#undef DEFCURSOR

		// Load up fonts for the screen.
		//
		// XXX HaveFonts is kinda stupid, however it gets useful in one
		// place: when loading button bindings, we make some sort of
		// "menu" for things (x-ref GotButton()), and the menu gen code
		// needs to load font stuff, so if that happened in the config
		// process, we would have already run CreateFonts().  Of course,
		// that's a order-dependent bit of the config file parsing too;
		// if you define the fonts too late, they wouldn't have been set
		// by then, and we won't [re]try them now...    arg.
		if(!Scr->HaveFonts) {
			CreateFonts(Scr);
		}

		// Adjust settings for titlebar.  Must follow CreateFonts() call
		// so we know these bits are populated
		Scr->TitleBarFont.y += Scr->FramePadding;
		Scr->TitleHeight = Scr->TitleBarFont.height + Scr->FramePadding * 2;
		if(Scr->use3Dtitles) {
			Scr->TitleHeight += 2 * Scr->TitleShadowDepth;
		}
		/* make title height be odd so buttons look nice and centered */
		if(!(Scr->TitleHeight & 1)) {
			Scr->TitleHeight++;
		}



		/*
		 * Now we can start making various things.
		 */

		// Stash up a ref to our Scr on the root, so we can find the
		// right Scr for events etc.
		XSaveContext(dpy, Scr->Root, ScreenContext, (XPointer) Scr);

		// Setup GC's for drawing, so we can start making stuff we have
		// to actually draw.  Could move earlier, has to preceed a lot of
		// following.
		CreateGCs();

		// Create and draw the menus we config'd
		MakeMenus();

		// Load up the images for titlebar buttons
		InitTitlebarButtons();

		// Allocate controls for WindowRegion's.  Has to follow
		// workspaces setup, but doesn't talk to X.
		CreateWindowRegions();

		// Copy the icon managers over to workspaces past the first as
		// necessary.  AllocateIconManager() and the config parsing
		// already made them on the first WS.
		AllocateOtherIconManagers();

		// Create the windows for our icon managers now that all our
		// tracking for it is setup.
		CreateIconManagers();

		// Create the WSM window (per-vscreen) and stash info on the root
		// about our WS's.
		CreateWorkSpaceManager();

		// Create the f.occupy window
		CreateOccupyWindow();

		// Setup TwmWorkspaces menu.  Needs workspaces setup, as well as
		// menus made.
		MakeWorkspacesMenu();

#ifdef WINBOX
		// setup WindowBox's
		createWindowBoxes();
#endif

		// Initialize Xrm stuff; things with setting occupation etc use
		// Xrm bits.
		XrmInitialize();

#ifdef EWMH
		// Set EWMH-related properties on various root-ish windows, for
		// other programs to read to find out how we view the world.
		EwmhInitScreenLate(Scr);
#endif /* EWMH */


		/*
		 * Look up and handle all the windows on the screen.
		 */
		{
			Window parent, *children;
			unsigned int nchildren;

			XQueryTree(dpy, Scr->Root, &croot, &parent, &children, &nchildren);

			/* Weed out icon windows */
			for(int i = 0; i < nchildren; i++) {
				if(children[i]) {
					XWMHints *wmhintsp = XGetWMHints(dpy, children[i]);

					if(wmhintsp) {
						if(wmhintsp->flags & IconWindowHint) {
							for(int j = 0; j < nchildren; j++) {
								if(children[j] == wmhintsp->icon_window) {
									children[j] = None;
									break;
								}
							}
						}
						XFree(wmhintsp);
					}
				}
			}

			/*
			 * Map all of the non-override windows.  This winds down
			 * into AddWindow() and friends through SimulateMapRequest(),
			 * so this is where we actually adopt the windows on the
			 * screen.
			 */
			for(int i = 0; i < nchildren; i++) {
				if(children[i] && MappedNotOverride(children[i])) {
					XUnmapWindow(dpy, children[i]);
					SimulateMapRequest(children[i]);
				}
			}

			/*
			 * At this point, we've adopted all the windows currently on
			 * the screen (aside from those we're intentionally not).
			 * Note that this happens _before_ the various other windows
			 * we create below, which is why they don't wind up getting
			 * TwmWindow's tied to them or show up in icon managers, etc.
			 * We'd need to actually make it _explicit_ that those
			 * windows aren't tracked by us if we changed that order...
			 */
		}


		// Show the WSM window if we should
		if(Scr->ShowWorkspaceManager && Scr->workSpaceManagerActive) {
			VirtualScreen *vs;
			if(Scr->WindowMask) {
				XRaiseWindow(dpy, Scr->WindowMask);
			}
			for(vs = Scr->vScreenList; vs != NULL; vs = vs->next) {
				SetMapStateProp(vs->wsw->twm_win, NormalState);
				XMapWindow(dpy, vs->wsw->twm_win->frame);
				if(vs->wsw->twm_win->StartSqueezed) {
					Squeeze(vs->wsw->twm_win);
				}
				else {
					XMapWindow(dpy, vs->wsw->w);
				}
				vs->wsw->twm_win->mapped = true;
			}
		}


		/*
		 * Setup the Info window, used for f.identify and f.version.
		 */
		{
			unsigned long valuemask;
			XSetWindowAttributes attributes;

			attributes.border_pixel = Scr->DefaultC.fore;
			attributes.background_pixel = Scr->DefaultC.back;
			attributes.event_mask = (ExposureMask | ButtonPressMask |
			                         KeyPressMask | ButtonReleaseMask);
			NewFontCursor(&attributes.cursor, "hand2");
			valuemask = (CWBorderPixel | CWBackPixel | CWEventMask | CWCursor);
			Scr->InfoWindow.win =
			        XCreateWindow(dpy, Scr->Root, 0, 0,
			                      5, 5,
			                      0, 0,
			                      CopyFromParent, CopyFromParent,
			                      valuemask, &attributes);
		}


		/*
		 * Setup the Size/Position window for showing during resize/move
		 * operations.
		 */
		{
			// Stick the SizeWindow at the top left of the first monitor
			// we found on this Screen.  That _may_ not be (0,0) (imagine
			// a shorter left and taller right monitor, with their bottom
			// edges lined up instead of top), so we have to look up what
			// that coordinate is.  If we're CenterFeedbackWindow'ing,
			// the window will have to move between monitors depending on
			// where the window we're moving is (starts), but
			// MoveResizeSizeWindow() will handle that.  If not, it
			// always stays in the top-left of the first display.
			RArea area = RLayoutGetAreaIndex(Scr->Layout, 0);
			XRectangle ink_rect;
			XRectangle logical_rect;
			unsigned long valuemask;
			XSetWindowAttributes attributes;

			XmbTextExtents(Scr->SizeFont.font_set,
			               " 8888 x 8888 ", 13,
			               &ink_rect, &logical_rect);
			Scr->SizeStringWidth = logical_rect.width;
			valuemask = (CWBorderPixel | CWBackPixel | CWBitGravity);
			attributes.bit_gravity = NorthWestGravity;

			if(Scr->SaveUnder) {
				attributes.save_under = True;
				valuemask |= CWSaveUnder;
			}

			Scr->SizeWindow = XCreateWindow(dpy, Scr->Root,
			                                area.x, area.y,
			                                Scr->SizeStringWidth,
			                                (Scr->SizeFont.height +
			                                 SIZE_VINDENT * 2),
			                                0, 0,
			                                CopyFromParent,
			                                CopyFromParent,
			                                valuemask, &attributes);
		}

		// Create util window used in animation
		Scr->ShapeWindow = XCreateSimpleWindow(dpy, Scr->Root, 0, 0,
		                                       Scr->rootw, Scr->rooth, 0, 0, 0);


		// Clear out the splash screen if we had one
		if(Scr->ShowWelcomeWindow) {
			UnmaskScreen();
		}

		// Done setting up this Screen.  x-ref XXX's about whether this
		// element is worth anything...
		Scr->FirstTime = false;
	} // for each screen on display


	// If we're just checking the config, there's nothing more to do.
	if(CLarg.cfgchk) {
		exit(cfgerrs);
	}


	// We're not much of a window manager if we didn't get stuff to
	// manage...
	if(numManaged == 0) {
		if(CLarg.MultiScreen && NumScreens > 0)
			fprintf(stderr, "%s:  unable to find any unmanaged screens\n",
			        ProgramName);
		exit(1);
	}

#ifdef SESSION
	// Hook up session
	ConnectToSessionManager(CLarg.client_id);
#endif

#ifdef SOUNDS
	// Announce ourselves
	sound_load_list();
	play_startup_sound();
#endif

	// Hard-reset this flag.
	// XXX This doesn't seem right?
	RestartPreviousState = true;

	// Set vars to enable animation bits
	StartAnimation();

	// Main loop.
	HandlingEvents = true;
	HandleEvents();

	// Should never get here...
	fprintf(stderr, "Shouldn't return from HandleEvents()!\n");
	exit(1);
}



/**
 * Initialize ScreenInfo for a Screen.  This allocates the struct,
 * assigns in the info we pass it about the screen and dimensions, and
 * then puts in our various default/fallback/sentinel/etc values to
 * prepare it for later use.
 *
 * It is intentional that this doesn't do any of the initialization that
 * involves calling out to X functions; it operates as a pure function.
 * This makes it easier to use it to fake up a ScreenInfo for something
 * that isn't actually an X Screen, for testing etc.
 *
 * \param scrnum The Screen number (e.g, :0.0 -> 0)
 * \param croot  The X Window for the Screen's root window
 * \param crootx Root X coordinate
 * \param crooty Root Y coordinate
 * \param crootw Root width
 * \param crooth Root height
 * \return Allocated and populated ScreenInfo
 */
ScreenInfo *
InitScreenInfo(int scrnum, Window croot, int crootx, int crooty,
               unsigned int crootw, unsigned int crooth)
{
	ScreenInfo *scr;
	scr = calloc(1, sizeof(ScreenInfo));
	if(scr == NULL) {
		return NULL;
	}
	// Because of calloc(), it's already all 0 bytes, which are NULL and
	// false and 0 and similar.  Some following initializations are
	// nugatory because of that, but are left for clarity.

	// Poison the global Scr to protect against typos
#define Scr StupidProgrammer


	// Basic pieces about the X screen we're talking about, and some
	// derived dimension-related bits.
	scr->screen = scrnum;
	scr->XineramaRoot = scr->Root = croot;
	scr->rootx = crootx;
	scr->rooty = crooty;
	scr->rootw = crootw;
	scr->rooth = crooth;

#ifdef CAPTIVE
	scr->crootx = crootx;
	scr->crooty = crooty;
	scr->crootw = crootw;
	scr->crooth = crooth;
#endif

	// Don't allow icon titles wider than the screen
	scr->MaxIconTitleWidth = scr->rootw;

	// Attempt to come up with a sane default for the max sizes.  Start
	// by limiting so that a window with its left/top on the right/bottom
	// edge of the screen can't extend further than X can address (signed
	// 16-bit).  However, when your screen size starts approaching that
	// limit, reducing the max window sizes too much gets stupid too, so
	// set an arbitrary floor on how low this will take it.
	// MaxWindowSize in the config will override whatever's here anyway.
	scr->MaxWindowWidth  = 32767 - (scr->rootx + scr->rootw);
	scr->MaxWindowHeight = 32767 - (scr->rooty + scr->rooth);
	if(scr->MaxWindowWidth < 4096) {
		scr->MaxWindowWidth = 4096;
	}
	if(scr->MaxWindowHeight < 4096) {
		scr->MaxWindowHeight = 4096;
	}


	// Flags used in the code to keep track of where in various processes
	// (especially startup) we are.
	scr->HaveFonts = false;

	// Flag which basically means "initial screen setup time".
	// XXX Not clear to what extent this should even exist; a lot of
	// uses are fairly bogus.
	scr->FirstTime = true;

	// Sentinel values for defaulting config values
	scr->FramePadding = -100;
	scr->TitlePadding = -100;
	scr->ButtonIndent = -100;
	scr->TBInfo.border = -100;

	// Default values for all sorts of config params
	scr->SizeStringOffset = 0;
	scr->ThreeDBorderWidth = 6;
	scr->BorderWidth = BW;
	scr->IconBorderWidth = BW;
	scr->NumAutoRaises = 0;
	scr->NumAutoLowers = 0;
	scr->TransientOnTop = 30;
	scr->NoDefaults = false;
	scr->UsePPosition = PPOS_OFF;
	scr->UseSunkTitlePixmap = false;
	scr->FocusRoot = true;
	scr->WarpCursor = false;
	scr->ForceIcon = false;
	scr->NoGrabServer = true;
	scr->NoRaiseMove = false;
	scr->NoRaiseResize = false;
	scr->NoRaiseDeicon = false;
	scr->RaiseOnWarp = true;
	scr->DontMoveOff = false;
	scr->DoZoom = false;
	scr->TitleFocus = true;
	scr->IconManagerFocus = true;
	scr->StayUpMenus = false;
	scr->WarpToDefaultMenuEntry = false;
	scr->ClickToFocus = false;
	scr->SloppyFocus = false;
	scr->SaveWorkspaceFocus = false;
	scr->NoIconTitlebar = false;
	scr->NoTitlebar = false;
	scr->DecorateTransients = true;
	scr->IconifyByUnmapping = false;
	scr->ShowIconManager = false;
	scr->ShowWorkspaceManager = false;
	scr->WMgrButtonShadowDepth = 2;
	scr->WMgrVertButtonIndent  = 5;
	scr->WMgrHorizButtonIndent = 5;
	scr->BorderShadowDepth = 2;
	scr->TitleShadowDepth = 2;
	scr->TitleButtonShadowDepth = 2;
	scr->MenuShadowDepth = 2;
	scr->IconManagerShadowDepth = 2;
	scr->AutoOccupy = false;
	scr->TransientHasOccupation = false;
	scr->DontPaintRootWindow = false;
	scr->IconManagerDontShow = false;
	scr->BackingStore = false;
	scr->SaveUnder = true;
	scr->RandomPlacement = RP_ALL;
	scr->RandomDisplacementX = 30;
	scr->RandomDisplacementY = 30;
	scr->DoOpaqueMove = true;
	scr->OpaqueMove = false;
	scr->OpaqueMoveThreshold = 200;
	scr->OpaqueResize = false;
	scr->DoOpaqueResize = true;
	scr->OpaqueResizeThreshold = 1000;
	scr->Highlight = true;
	scr->StackMode = true;
	scr->TitleHighlight = true;
	scr->MoveDelta = 1;
	scr->MoveOffResistance = -1;
	scr->MovePackResistance = 20;
	scr->ZoomCount = 8;
	scr->SortIconMgr = true;
	scr->Shadow = true;
	scr->InterpolateMenuColors = false;
	scr->NoIconManagers = false;
	scr->ClientBorderWidth = false;
	scr->SqueezeTitle = false;
	scr->FirstTime = true;
	scr->CaseSensitive = true;
	scr->WarpUnmapped = false;
	scr->WindowRingAll = false;
	scr->WarpRingAnyWhere = true;
	scr->ShortAllWindowsMenus = false;
	scr->use3Diconmanagers = false;
	scr->use3Dmenus = false;
	scr->use3Dtitles = false;
	scr->use3Dborders = false;
	scr->use3Dwmap = false;
	scr->SunkFocusWindowTitle = false;
	scr->ClearShadowContrast = 50;
	scr->DarkShadowContrast  = 40;
	scr->BeNiceToColormap = false;
	scr->BorderCursors = false;
	scr->IconJustification = TJ_CENTER;
	scr->IconRegionJustification = IRJ_CENTER;
	scr->IconRegionAlignement = IRA_CENTER;
	scr->TitleJustification = TJ_LEFT;
	scr->IconifyStyle = ICONIFY_NORMAL;
	scr->ReallyMoveInWorkspaceManager = false;
	scr->ShowWinWhenMovingInWmgr = false;
	scr->ReverseCurrentWorkspace = false;
	scr->DontWarpCursorInWMap = false;
	scr->XMoveGrid = 1;
	scr->YMoveGrid = 1;
	scr->CenterFeedbackWindow = false;
	scr->ShrinkIconTitles = false;
	scr->AutoRaiseIcons = false;
	scr->AutoFocusToTransients = false;
	scr->OpenWindowTimeout = 0;
	scr->RaiseWhenAutoUnSqueeze = false;
	scr->RaiseOnClick = false;
	scr->RaiseOnClickButton = 1;
	scr->IgnoreModifier = 0;
	scr->IgnoreCaseInMenuSelection = false;
	scr->PackNewWindows = false;
	scr->AlwaysSqueezeToGravity = false;
	scr->NoWarpToMenuTitle = false;
	scr->DontToggleWorkspaceManagerState = false;
	scr->NameDecorations = true;
	scr->ForceFocus = false;
	scr->BorderTop    = 0;
	scr->BorderBottom = 0;
	scr->BorderLeft   = 0;
	scr->BorderRight  = 0;
	scr->PixmapDirectory   = PIXMAP_DIRECTORY;
#ifdef EWMH
	scr->PreferredIconWidth = 48;
	scr->PreferredIconHeight = 48;

	scr->ewmh_CLIENT_LIST_used = 0;
	scr->ewmh_CLIENT_LIST_size = 16;
	scr->ewmh_CLIENT_LIST = calloc(scr->ewmh_CLIENT_LIST_size,
	                               sizeof(scr->ewmh_CLIENT_LIST[0]));
	if(scr->ewmh_CLIENT_LIST == NULL) {
		free(scr);
		return NULL;
	}
#endif

	// OTP structure bits
	OtpScrInitData(scr);


	// WorkSpaceManager stuff
	scr->workSpaceMgr.initialstate  = WMS_map;
	scr->workSpaceMgr.buttonStyle   = STYLE_NORMAL;
	scr->workSpaceMgr.vspace        = scr->WMgrVertButtonIndent;
	scr->workSpaceMgr.hspace        = scr->WMgrHorizButtonIndent;

	scr->workSpaceMgr.occupyWindow = calloc(1, sizeof(OccupyWindow));
	scr->workSpaceMgr.occupyWindow->vspace    = scr->WMgrVertButtonIndent;
	scr->workSpaceMgr.occupyWindow->hspace    = scr->WMgrHorizButtonIndent;
	scr->workSpaceMgr.occupyWindow->name      = "Occupy Window";
	scr->workSpaceMgr.occupyWindow->icon_name = "Occupy Window Icon";

	scr->workSpaceMgr.name      = "WorkSpaceManager";
	scr->workSpaceMgr.icon_name = "WorkSpaceManager Icon";


	// Setup default fonts in case the config file doesn't
#define DEFAULT_NICE_FONT "-*-helvetica-bold-r-normal-*-*-120-*"
#define DEFAULT_FAST_FONT "-misc-fixed-medium-r-semicondensed--13-120-75-75-c-60-*"
#define SETFONT(fld, var) (scr->fld##Font.basename = DEFAULT_##var##_FONT)

	SETFONT(TitleBar,    NICE);
	SETFONT(Menu,        NICE);
	SETFONT(Icon,        NICE);
	SETFONT(Size,        FAST);
	SETFONT(IconManager, NICE);
	SETFONT(Default,     FAST);
	scr->workSpaceMgr.windowFont.basename =
	        "-adobe-courier-medium-r-normal--10-100-75-75-m-60-iso8859-1";

#undef SETFONT
#undef DEFAULT_FAST_FONT
#undef DEFAULT_NICE_FONT


	// Set some fallback values that we set from the X server, for
	// special cases where we may not actually be talking to one.
	scr->d_depth = 24;
	scr->RealRoot = croot;
	scr->mm_w = 406; // 16 in
	scr->mm_h = 229; // 9 in
	scr->Monochrome = COLOR;

	// Cleanup poisoning
#undef Scr
	return scr;
}




#ifdef CAPTIVE
/**
 * Create a new window to use for a captive ctwm.
 */
static Window
CreateCaptiveRootWindow(int x, int y,
                        unsigned int width, unsigned int height)
{
	int         scrnum;
	Window      ret;
	XWMHints    wmhints;

	scrnum = DefaultScreen(dpy);
	ret = XCreateSimpleWindow(dpy, RootWindow(dpy, scrnum),
	                          x, y, width, height, 2, WhitePixel(dpy, scrnum),
	                          BlackPixel(dpy, scrnum));
	wmhints.initial_state = NormalState;
	wmhints.input         = True;
	wmhints.flags         = InputHint | StateHint;

	XmbSetWMProperties(dpy, ret, "Captive ctwm", NULL, NULL, 0, NULL,
	                   &wmhints, NULL);
	XChangeProperty(dpy, ret, XA_WM_CTWM_ROOT, XA_WINDOW, 32,
	                PropModeReplace, (unsigned char *) &ret, 1);
	XSelectInput(dpy, ret, StructureNotifyMask);
	XMapWindow(dpy, ret);
	return (ret);
}
#endif



/**
 * Return true if a window is not set to override_redirect ("Hey!  WM!
 * Leave those wins alone!"), and isn't unmapped.  Used during startup to
 * fake mapping for wins that should be up.
 */
static bool
MappedNotOverride(Window w)
{
	XWindowAttributes wa;

	XGetWindowAttributes(dpy, w, &wa);
	return ((wa.map_state != IsUnmapped) && (wa.override_redirect != True));
}