/usr/src/RPM/BUILD/ctwm-4.1.0/ctwm_main.c

Go to the documentation of this file.

/*
 *       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));
}