~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