/*
 * $XConsortium: GetPRoot.c,v 1.8 88/10/22 10:00:55 rws Exp $
 *
 * Copyright 1988 Massachusetts Institute of Technology
 *
 *
 *				 W A R N I N G
 *
 * This is experimental code for implementing pseudo-root windows as specified
 * by the Inter-Client Communications Conventions Manual.  The interfaces that
 * it provides should be considered private to the MIT implementation of Xlib
 * and are SUBJECT TO CHANGE WITHOUT NOTICE.  They should not be incorporated
 * into any toolkits or applications.  When they change, no effort will be
 * made to provide backwards compatibility.
 *
 * Current questions about the implementation are delimited by triple X's.
 *
 * If you think this all sounds severe, you're right.
 */

#include "copyright.h"

#include <stdio.h>
#include "Xlibint.h"
#include <X11/Xos.h>
#include "Xatom.h"
#define NEED_PSEUDOROOT_PROTOCOL
#include "PseudoRoot.h"


/*
 * routines to convert protocol data structures (arrays of unsigned longs)
 * to the client data structures specified in the ICCCM.
 */

static Status PseudoScreenProtocolToClient (p, c, n)
    register xPseudoScreen *p;
    register PseudoScreen *c;
    register int n;
{
    if (!c || !p) {
	return False;
    }

    for (; n > 0; n--, c++, p++) {
	/*
	 * If your C compiler rearranges fields within structures, you will
	 * have to change the definition of protocol structure to be an array 
	 * of unsigned longs to which you assign using macros.
	 */
	c->root = p->root;
	c->width = p->width;
	c->height = p->height;
	c->mwidth = p->mwidth;
	c->mheight = p->mheight;
	c->root_depth = p->root_depth;
	c->root_visual = p->root_visual;
	c->cmap = p->cmap;
	c->white_pixel = p->white_pixel;
	c->black_pixel = p->black_pixel;
	c->max_maps = p->max_maps;
	c->min_maps = p->min_maps;
	c->backing_store = p->backing_store;
	c->save_unders = p->save_unders;
	c->root_input_mask = p->root_input_mask;
	c->depths = p->depths;
    }

    return True;
}

static Status PseudoDepthProtocolToClient (p, c, n)
    register xPseudoDepth *p;
    register PseudoDepth *c;
    register int n;
{
    if (!c || !p) {
	return False;
    }

    for (; n > 0; n--, c++, p++) {
	/*
	 * If your C compiler rearranges fields within structures, you will
	 * have to change the definition of protocol structure to be an array 
	 * of unsigned longs to which you assign using macros.
	 */
	c->depth = p->depth;
	c->nvisuals = p->nvisuals;
	c->visuals = p->visuals;
    }

    return True;
}

static Status PseudoVisualProtocolToClient (p, c, n)
    register xPseudoVisual *p;
    register PseudoVisual *c;
    register int n;
{
    if (!c || !p) {
	return False;
    }

    for (; n > 0; n--, c++, p++) {
	/*
	 * If your C compiler rearranges fields within structures, you will
	 * have to change the definition of protocol structure to be an array 
	 * of unsigned longs to which you assign using macros.
	 */
	c->visualid = p->visualid;
	c->class = p->class;
	c->bits_per_rgb = p->bits_per_rgb;
	c->map_entries = p->map_entries;
	c->red_mask = p->red_mask;
	c->green_mask = p->green_mask;
	c->blue_mask = p->blue_mask;
    }

    return True;
}


/*
 * routines to retrieve the protocol data structures from properties on the
 * screen's root window; the final implementation will probably want to make
 * them atomic by adding the appropriate GrabServer calls
 */

static Status GetPseudoScreen (dpy, w, propName, ps)
    Display *dpy;
    Window w;
    char *propName;
    PseudoScreen *ps;
{
    Atom screenProp, screenType, actual_type;
    xPseudoScreen *xps = NULL;
    int actual_format;
    unsigned long nitems, bytesafter;
    Status status;

    /*
     * get atoms for the screen type and indicated property in that order
     * so as to minimize unused atoms in the server
     */
    if ((screenType = XInternAtom (dpy, PSEUDO_SCREEN_TYPE, True)) == None ||
	(screenProp = XInternAtom (dpy, propName, True)) == None) {
	return False;
    }

    if (XGetWindowProperty (dpy, w, screenProp, 0L,
			    (long) (SIZEOF(xPseudoScreen) >> 2L), False,
			    screenType, &actual_type, &actual_format,
			    &nitems, &bytesafter, (unsigned char **) &xps) !=
	Success) {
	return False;
    }

    if (actual_type != screenType || actual_format != PSEUDO_SCREEN_FORMAT) {
	status = False;
    } else {
	status = PseudoScreenProtocolToClient (xps, ps, 1);
    }
    free ((char *) xps);
    return status;
}

static Status GetPseudoDepths (dpy, w, depthsProp, depthsType,
			       ndepthsPtr, pdPtr)
    Display *dpy;
    Window w;
    Atom depthsProp, depthsType;
    int *ndepthsPtr;
    PseudoDepth **pdPtr;
{
    xPseudoDepth *xpd = NULL;
    PseudoDepth *pd = NULL;
    Atom actual_type;
    int actual_format;
    unsigned long nitems, bytesafter;
    Status status;
    int ndepths;

    /*
     * XXX - this routine should probably grab the server to be atomic; the
     * spec doesn't provide a field indicating how many depths there are, so
     * we have to go figure it out ourselves.  That is fine, except that it
     * isn't symmetric with the way visuals are counted within PseudoDepths.
     */

    if (XGetWindowProperty (dpy, w, depthsProp, 0L, 0L, False, depthsType,
			    &actual_type, &actual_format, &nitems, &bytesafter,
			    (unsigned char **) &xpd) != Success) {
	return False;
    }

    if (xpd) {
	free ((char *) xpd);
	xpd = NULL;
    }

    if (actual_type != depthsType || actual_format != PSEUDO_DEPTHS_FORMAT) {
	return False;
    }

    ndepths = bytesafter / SIZEOF(xPseudoDepth);

    if (XGetWindowProperty (dpy, w, depthsProp, 0L, 
			    (long) (ndepths * SIZEOF(xPseudoDepth)) >> 2L,
			    False, depthsType, &actual_type, &actual_format,
			    &nitems, &bytesafter, (unsigned char **) &xpd) !=
	Success) {
	return False;
    }

    if (actual_type != depthsType || actual_format != PSEUDO_DEPTHS_FORMAT) {
	status = False;
    } else {
	pd = (PseudoDepth *) Xcalloc (ndepths, sizeof(PseudoDepth));
	if (pd) {
	    status = PseudoDepthProtocolToClient (xpd, pd, ndepths);
	} else {
	    status = False;
	}
    }
    free ((char *) xpd);
    if (status) {
	*ndepthsPtr = ndepths;
	*pdPtr = pd;
    }
    return status;
}

static Status GetPseudoVisuals (dpy, w, visualsProp, visualsType,
				nvisualsPtr, pvPtr)
    Display *dpy;
    Window w;
    Atom visualsProp, visualsType;
    int *nvisualsPtr;
    PseudoVisual **pvPtr;
{
    xPseudoVisual *xpv = NULL;
    PseudoVisual *pv = NULL;
    Atom actual_type;
    int actual_format;
    unsigned long nitems, bytesafter;
    Status status;
    int nvisuals;

    /*
     * XXX - this routine should probably grab the server to be atomic, or it
     * should believe the PseudoDepth's notion of how many visuals there are;
     * except that the PseudoScreen doesn't record how many depths there are.
     */

    if (XGetWindowProperty (dpy, w, visualsProp, 0L, 0L, False, visualsType,
			    &actual_type, &actual_format, &nitems, &bytesafter,
			    (unsigned char **) &xpv) != Success) {
	return False;
    }

    if (xpv) {
	free ((char *) xpv);
	xpv = NULL;
    }

    if (actual_type != visualsType || actual_format != PSEUDO_DEPTHS_FORMAT) {
	return False;
    }

    nvisuals = bytesafter / SIZEOF(xPseudoVisual);

    if (XGetWindowProperty (dpy, w, visualsProp, 0L, 
			    (long) (nvisuals * SIZEOF(xPseudoVisual)) >> 2L,
			    False, visualsType, &actual_type, &actual_format,
			    &nitems, &bytesafter, (unsigned char **) &xpv) !=
	Success) {
	return False;
    }

    if (actual_type != visualsType || actual_format != PSEUDO_VISUALS_FORMAT) {
	status = False;
    } else {
	pv = (PseudoVisual *) Xcalloc (nvisuals, sizeof(PseudoVisual));
	if (pv) {
	    status = PseudoVisualProtocolToClient (xpv, pv, nvisuals);
	} else {
	    status = False;
	}
    }
    free ((char *) xpv);
    if (status) {
	*nvisualsPtr = nvisuals;
	*pvPtr = pv;
    }
    return status;
}



/*
 * semi-public interfaces.  Again, these routines are subject to change without
 * notice and should not be incorporated into any toolkit or application.  They
 * exist solely for prototyping the ICCCM functionality.
 *
 *     _XGetPseudoRootData        fetch appropriate data from the properties
 *     _XGetPseudoRoot            replace screen information
 *
 */

Status _XGetPseudoRootData (dpy, w, propName, ps,
			    depthsPtr, visualsListPtr, ndepthsPtr)
    Display *dpy;			/* connection to server */
    Window w;				/* window from which to get info */
    char *propName;			/* prop containing info */
    PseudoScreen *ps;			/* where to fill in info */
    PseudoDepth **depthsPtr;		/* new depths */
    PseudoVisual ***visualsListPtr;	/* new visuals for each depth */
    int *ndepthsPtr;			/* number of new depths */
{
    Atom depthsType = None;
    int ndepths = 0;
    PseudoDepth *depths = NULL;
    PseudoVisual **visualsList = NULL;
    

    /*
     * fill in the pseudo screen
     */
    if (!GetPseudoScreen (dpy, w, propName, ps)) {
	return False;
    }

    /*
     * now, check to see if we need to get the depths structure
     */
    if (ps->depths != None) {
	Atom visualsType = None;	/* if necessary */
	int i;				/* iterator, temp variable */

	depthsType = XInternAtom (dpy, PSEUDO_DEPTHS_TYPE, True);
	if (depthsType == None) {
	    return False;
	}

	if (!GetPseudoDepths (dpy, w, ps->depths, depthsType,
			      &ndepths, &depths)) {
	    return False;
	}

	/*
	 * get new visual info for depths that want it
	 */
	visualsList = (PseudoVisual **) Xmalloc (ndepths *
						 sizeof (PseudoVisual **));
	if (!visualsList) {
	    free ((char *) depths);
	    return False;
	}

	/* get the visual atom in case */
	visualsType = XInternAtom (dpy, PSEUDO_VISUALS_TYPE, False);
	if (visualsType == None) {
	    free ((char *) visualsList);
	    free ((char *) depths);
	    return False;
	}

	for (i = 0; i < ndepths; i++) {
	    if (depths[i].visuals == None) {
		visualsList[i] = NULL;
	    } else {
		int nvisuals = 0;
		PseudoVisual *visuals = NULL;

		/* get the visuals for this depth */
		if (!GetPseudoVisuals (dpy, w, depths[i].visuals, visualsType,
				       &nvisuals, &visuals)) {
		    while (--i > 0) {
			if (depths[i].visuals)
			  free ((char *) visualsList[i]);
		    }
		    free ((char *) visualsList);
		    free ((char *) depths);
		    return False;
		}
		visualsList[i] = visuals;
		if (depths[i].nvisuals != nvisuals) {
		    /*
		     * XXX - should this just be a failure instead?
		     */
		    depths[i].nvisuals = nvisuals;
		}
	    }
	}
    }

    *depthsPtr = depths;
    *visualsListPtr = visualsList;
    *ndepthsPtr = ndepths;
    return True;
}


Status _XGetPseudoRoot (dpy, propName)
    Display *dpy;			/* connection with *real* root */
    char *propName;			/* property name with info on it */
{
    Window w;				/* window from which to get info */
    PseudoScreen pscreen;		/* struct for getting data from prop */
    int ndepths;			/* result of fetching */
    PseudoDepth *depths = NULL;		/* for array of depth infos */
    PseudoVisual **visualsList = NULL;	/* one per depth */
    int i, j;				/* iterator, temp variable */
    Screen *sp;				/* for bashing display info */
    int screenno;			/* screen number used */
    Depth *newDepths = NULL;		/* new array */
    Status retval = False;		/* be pessimistic */
    int root_depth = 0;			/* depth of root visual */
    Visual *root_visual = NULL;		/* for setting screen field */
    int nd;				/* count of depths */
    Depth *d;				/* temp variable */

/*
 * The following grossness is to cope with an schain botch compiler error
 * in native 4.3bsd which has been fixed in 4.3+tahoe.  This is one of the
 * few times where a goto might be better....
 * Effective arglist is (retval,newDepths,depths,ndepths,visualsList)
 */
#define   FREE_RETURN()	\
    {									\
	if (newDepths) {						\
	    Depth *d;							\
									\
	    for (i = 0, d = newDepths; i < ndepths; i++, d++) {		\
		if (d->visuals) free ((char *) d->visuals);		\
	    }								\
	    free ((char *) newDepths);					\
	}								\
	if (depths) free ((char *) depths);				\
	if (visualsList) free ((char *) visualsList);			\
	return retval;							\
    }
/*enddef*/

    /*
     * This implementation builds shadow versions of the Depths and Visuals
     * data structures so that it can always back out and fail gracefully.
     */
    screenno = DefaultScreen (dpy);
    w = RootWindow (dpy, screenno);
    sp = ScreenOfDisplay (dpy, screenno);

    /*
     * fetch the relevant data off of the root window
     */
    if (!_XGetPseudoRootData (dpy, w, propName, &pscreen,
			      &depths, &visualsList, &ndepths)) {
	return False;
    }


    /*
     * create new Depths and Visuals lists if needed
     */
    if (pscreen.depths != None) {
	/* the following will be used to replace dpy->depths */
	newDepths = (Depth *) Xcalloc (ndepths, sizeof(Depth));
	if (!newDepths) {
	    return False;
	}

	/* run down list of depths building visual arrays */
	for (i = 0; i < ndepths; i++) {
	    Depth *d = newDepths + i;
	    PseudoDepth *pd = depths + i;

	    d->depth = pd->depth;
	    d->nvisuals = pd->nvisuals;
	    d->visuals = NULL;
	    /*
	     * if there is no PseudoVisual, then copy the real Visuals
	     */
	    if (pd->visuals == None) {
		/* scan list of real depths look for a match */
		for (j = 0; j < sp->ndepths; j++) {
		    Depth *realD = sp->depths + j;

		    if (realD->depth == d->depth) {
			d->nvisuals = realD->nvisuals;
			d->visuals = (Visual *) Xmalloc (d->nvisuals *
							 sizeof(Visual));
			if (!d->visuals) 
			    FREE_RETURN();
			bcopy ((char *) realD->visuals,
			       (char *) d->visuals,
			       d->nvisuals * sizeof(Visual));
		    }			/* end if - got real depth */
		}			/* end for - iter over real depths */
		if (!d->visuals) {
		    /* XXX isn't this really an error? */
		    d->nvisuals = 0;
		}
	    } else {
		/* 
		 * if there are PseudoVisuals then convert them
		 */
		d->visuals = (Visual *) Xmalloc (d->nvisuals * sizeof(Visual));
		if (!d->visuals) 
		    FREE_RETURN();
		for (j = 0; j < d->nvisuals; j++) {
		    Visual *v = d->visuals + j;
		    PseudoVisual *pv = visualsList[i] + j;

		    v->ext_data = NULL;
		    v->visualid = pv->visualid;
		    v->class = pv->class;
		    v->red_mask = pv->red_mask;
		    v->green_mask = pv->green_mask;
		    v->blue_mask = pv->blue_mask;
		    v->bits_per_rgb = pv->bits_per_rgb;
		    v->map_entries = pv->map_entries;
		}			/* end for - copy pseudo to real */
	    }				/* end if - make visuals for depth */
	}				/* end for - iter over pseudodepths */
    }					/* end if - if pseudodepths */
	
    /*
     * we now have a new Depth array with visuals hung off it; check to make
     * sure that it is okay; also, find root_depth
     */

    {
	if (pscreen.depths == None) {
	    nd = sp->ndepths;
	    d = sp->depths;
	} else {
	    nd = ndepths;
	    d = newDepths;
	}

	/* walk depths lists looking for root_visual */
	for (i = 0; i < nd; i++, d++) {
	    Visual *v = d->visuals;

	    for (j = 0; j < d->nvisuals; j++) {
		if (v[j].visualid == pscreen.root_visual) {
		    root_depth = d->depth;
		    root_visual = &v[j];
		    i = nd;	/* break */
		    break;
		}
	    }
	}
	if (root_depth == 0) {
	    FREE_RETURN();
	}
    }


    /*
     * we think everything is okay, so bash the appropriate structures
     */

    /* don't need to change sp->ext_data */
    /* don't need to change sp->display */

    /*
     * XXX - if the program managing the pseudo root doesn't catch 
     * ConfigureNotify events and reset the width and height fields,
     * applications will get very confused.
     */
    sp->root = pscreen.root;
    sp->width = pscreen.width;
    sp->height = pscreen.height;
    sp->mwidth = pscreen.mwidth;
    sp->mheight = pscreen.mheight;

    if (pscreen.depths != None) {
	Depth *d;

	for (i = 0, d = sp->depths; i < sp->ndepths; i++, d++) {
	    if (d->visuals) free ((char *) d->visuals);
	}
	free ((char *) sp->depths);
	sp->ndepths = ndepths;
	sp->depths = newDepths;
	newDepths = NULL;		/* so that we don't free it */
    }

    sp->root_depth = root_depth;
    sp->root_visual = root_visual;

    sp->cmap = pscreen.cmap;
    sp->white_pixel = pscreen.white_pixel;
    sp->black_pixel = pscreen.black_pixel;
    sp->max_maps = pscreen.max_maps;
    sp->min_maps = pscreen.min_maps;
    {
	XGCValues gcv;
	gcv.foreground = pscreen.black_pixel;
	gcv.background = pscreen.white_pixel;
	XChangeGC (dpy, sp->default_gc, GCForeground|GCBackground, &gcv);
    }

    sp->backing_store = pscreen.backing_store;
    sp->save_unders = pscreen.save_unders;
    {
	/*
	 * XXX - spec says to get this from pscreen.root_input_mask but that
	 * doesn't account for other applications that select on the root; if
	 * we don't query then nested applications that care will get confused.
	 */
	XWindowAttributes attr;
	if (XGetWindowAttributes (dpy, sp->root, &attr)) {
	    sp->root_input_mask = attr.all_event_masks;
	}
    }

    retval = True;

    FREE_RETURN();

#undef FREE_RETURN
}