/*		xpltwin.c			Paul Albrecht			May 1989
 
	Copyright (C) Paul Albrecht 1988.  All rights reserved.

	Last Update:	May 21, 1989
	EMACS_MODES:	tabstop=4


	Make an window for xplt to plot in.

	This version modified 16 November 1989 by G. Moody to accept
	geometry arguments as for X Toolkit applications.  (This program
	does not use the X Toolkit and does not accept any other Toolkit
	options, nor does it support retrieval of geometry specifications
	from resource files.)  Usage:
	   xpltwin [ -g WIDTHxHEIGHT+-XOFF+-YOFF ] [ NAME ]
	The geometry can also be specified by the XPGEOMETRY environment
	variable.  Note that successful use of negative offsets requires
	that DSP_WIDTH and DSP_HEIGHT be correct for the display;  it should
	be possible to get this information from the X server.
*/

	
#include	"plt.h"
#include	<signal.h>
#include	<X11/X.h>
#include	<X11/Xlib.h>
#include	"X11/Xutil.h"
#include	<X11/Xatom.h>

#define DSP_WIDTH	1152
#define DSP_HEIGHT	900

typedef struct	{
	Display		*dpy;
	int			screen;
	Window		root;
	Window		window;
	GC			gc;
	char		*name;
	Pixmap		pixmap;
	int			pixmapWidth;
	int			pixmapHeight;
	Atom		atom;
	} GfxData, *Gfx;


Window	WindowFind();


main( argc, argv )
char	*argv[];
{
GfxData		gfxData;
char		*dpyName, *geometry, *getenv();
int		x = -10, y = 120, xDim = 500, yDim = 340;

	dpyName = getenv( "XPD" );
	if( dpyName != 0 && *dpyName == 0 )
		dpyName = 0;

	bzero( (char *)&gfxData, sizeof(gfxData) );

	gfxData.dpy = XOpenDisplay( dpyName );
	if( gfxData.dpy == 0 ) {
		fprintf( stderr, "Can't open display %s\n", XDisplayName(dpyName) );
		exit( 1 );
	}

	gfxData.screen = DefaultScreen( gfxData.dpy );
	gfxData.root = RootWindow( gfxData.dpy, gfxData.screen );
	gfxData.gc = DefaultGCOfScreen( ScreenOfDisplay(gfxData.dpy,gfxData.screen) );
	if (geometry = getenv("XPGEOMETRY"))
	    sscanf(geometry, "%dx%d%d%d", &xDim, &yDim, &x, &y);
	if (argc > 2 && argv[1][0] == '-' && argv[1][1] == 'g') {
	    sscanf(argv[2], "%dx%d%d%d", &xDim, &yDim, &x, &y);
	    argc -= 2;
	    argv += 2;
	}
	if (x < 0) x = DSP_WIDTH - xDim + x;
	if (y < 0) y = DSP_HEIGHT - yDim + y;

	gfxData.name = (argc > 1) ? argv[1] : "Plt Window";

	if( strcmp(gfxData.name,"debug") == 0 ) {
		WindowCreate( &gfxData, x, y, xDim, yDim);
		WindowMaintain( &gfxData );
	}

	if( fork() == 0 ) {
		WindowCreate( &gfxData, x, y, xDim, yDim);
		WindowMaintain( &gfxData );
	}
	else
		printf( "Created window \"%s\"\n", gfxData.name );
}


/**********************************************************************************/


WindowCreate( gfx, x, y, xDim, yDim )
Gfx		gfx;
int		x, y, xDim, yDim;
{
XEvent				event;
XWindowAttributes	attributes;
char				atomName[100];


	gfx->window = XCreateSimpleWindow( gfx->dpy, gfx->root, x, y, xDim, yDim, 1,
			BlackPixel(gfx->dpy,gfx->screen), WhitePixel(gfx->dpy,gfx->screen) );

	if( gfx->window == 0 ) {
		fprintf( stderr, "Can't create window %s", gfx->name );
		exit( 1 );
	}

	XSetStandardProperties( gfx->dpy, gfx->window, gfx->name, gfx->name,
			(Pixmap)0, (char **)0, 0, (XSizeHints *)0 );

	sprintf( atomName, "_xpltwin_%d_%s", gfx->screen, gfx->name );
	gfx->atom = XInternAtom( gfx->dpy, atomName, False );

	XGetWindowAttributes( gfx->dpy, gfx->window, &attributes );
	WindowConfigure( gfx, attributes.width, attributes.height );

	XMapWindow( gfx->dpy, gfx->window );
	XFlush( gfx->dpy );
	XSync( gfx->dpy, NO );

	XSelectInput( gfx->dpy, gfx->window, ExposureMask );

	while( XCheckWindowEvent(gfx->dpy,gfx->window,ExposureMask,&event) == 0
			 || event.type != Expose );
}


/**********************************************************************************/


WindowMaintain( gfx )
register Gfx	gfx;
{
XEvent		event;

	signal( SIGHUP, SIG_IGN );
	signal( SIGINT, SIG_IGN );

	XSelectInput( gfx->dpy, gfx->window, ExposureMask|StructureNotifyMask );

	while( YES ) {
		XNextEvent( gfx->dpy, &event );
		switch( event.type ) {
			case Expose:			
			case GraphicsExpose:
				WindowExpose( gfx, (XExposeEvent *)(&event) );
				break;
			case ConfigureNotify: {
				XConfigureEvent 	*config = (XConfigureEvent *)(&event);
				WindowConfigure( gfx, config->width, config->height );
				break;
			}
			case DestroyNotify:
				WindowPropertiesRemove( gfx );				
				exit( 0 );
				break;
		}
	}
}



WindowExpose( gfx, event )
Gfx				gfx;
XExposeEvent	*event;
{
XEvent	anotherEvent;

	if( gfx->pixmap == 0 )
		return;

	if( event != 0  )
		XCopyArea( gfx->dpy, gfx->pixmap, gfx->window, gfx->gc,
			event->x, event->y,	event->width, event->height, event->x, event->y );

	while( XCheckWindowEvent(gfx->dpy,gfx->window,ExposureMask,&anotherEvent) != 0 )
		WindowExpose( gfx, (XExposeEvent *)(&anotherEvent) );
}



WindowConfigure( gfx, width, height )
Gfx		gfx;
int		width, height;
{
Drawable	drawable[2];
Pixmap		newPixmap;

	if( gfx->pixmapWidth == width && gfx->pixmapHeight == height )
		return;

	newPixmap = XCreatePixmap( gfx->dpy, gfx->window, width, height,
		DefaultDepth(gfx->dpy,gfx->screen) );
	if( newPixmap == 0 ) {
		fprintf( stderr, "Warning: cannot allocate backup storage for plt window" );
		return;
	}

	if( gfx->pixmap != 0 ) {
		XCopyArea( gfx->dpy, gfx->pixmap, newPixmap, gfx->gc, 0, 0,
			gfx->pixmapWidth, gfx->pixmapHeight, 0, 0 );
		XFreePixmap( gfx->dpy, gfx->pixmap );
	}

	gfx->pixmap = newPixmap;
	gfx->pixmapWidth = width;
	gfx->pixmapHeight = height;

	drawable[0] = gfx->window;
	drawable[1] = (gfx->pixmap == 0 ? gfx->window : gfx->pixmap);
	XChangeProperty( gfx->dpy, gfx->root, gfx->atom, XA_DRAWABLE, 32, 
				PropModeReplace, (char *)drawable, 2 );
	XChangeProperty( gfx->dpy, gfx->window, gfx->atom, XA_DRAWABLE, 32, 
				PropModeReplace, (char *)drawable, 2 );
}


WindowPropertiesRemove( gfx )
Gfx			gfx;
{
Drawable	*drawables;
Atom		pltWindowAtom, actualType;
long		nItems, bytesAfter;
int			actualFormat;
char		atomName[100];

	drawables = 0;
	sprintf( atomName, "_xpltwin_%d_%s", gfx->screen, gfx->name );
	pltWindowAtom = XInternAtom( gfx->dpy, atomName, True );
	if( pltWindowAtom == None )
		goto RETURN;

	XGetWindowProperty( gfx->dpy, gfx->root, pltWindowAtom, 0, 2, False,
		XA_DRAWABLE, &actualType, &actualFormat, &nItems, &bytesAfter,
			   (unsigned char **)&drawables );

	if( actualType != XA_DRAWABLE || actualFormat != 32 || nItems != 2 )
		goto RETURN;

	if( gfx->window == drawables[0] )
		XDeleteProperty( gfx->dpy, gfx->window, pltWindowAtom );

RETURN:
	if( drawables != 0 )
		XFree( drawables );
	return;
}