/****************************************************************************
*                xwindows.c
*
*  This module implements X-windows specific routines.
*
*  from Persistence of Vision Raytracer
*  Copyright 1993 Persistence of Vision Team
*---------------------------------------------------------------------------
*  NOTICE: This source code file is provided so that users may experiment
*  with enhancements to POV-Ray and to port the software to platforms other 
*  than those supported by the POV-Ray Team.  There are strict rules under
*  which you are permitted to use this file.  The rules are in the file
*  named POVLEGAL.DOC which should be distributed with this file. If 
*  POVLEGAL.DOC is not available or for more info please contact the POV-Ray
*  Team Coordinator by leaving a message in CompuServe's Graphics Developer's
*  Forum.  The latest version of POV-Ray may be found there as well.
*
* This program is based on the popular DKB raytracer version 2.12.
* DKBTrace was originally written by David K. Buck.
* DKBTrace Ver 2.0-2.12 were written by David K. Buck & Aaron A. Collins.
*
*****************************************************************************/


 /*
 * Here are some routines I wrote which implement +d option on unix computers
 * running X-windows. For now, only black and white output is supported. If I
 * get access to a computer with a color monitor, I'll probably add support
 * for colors to my routines.
 * 
 * In future I'll probably add some more dithering methods. I have tested these
 * routines on SUN 3 and SUN 4. I'm using the tvtwm window manager.
 * 
 * If you have some suggestions to my source code or if you change anything,
 * please let me know. I can be reached at the following address: Marek
 * Rzewuski, Avstikkeren 11, 1156 Oslo 11, Norway or marekr@ifi.uio.no on
 * Internet.
 */

/*
 * 91-07-29 Allan H. Wax (Wax.OSBU_South@Xerox.COM) Hacked this module so it
 * can be used with either a colour or B&W screen. Made all variables local
 * to this routine (no need for more globals if no one ever uses them). Fixed
 * bug in refresh routine. Use dither from colorx.c. Use xpov.icon instead of
 * theIcon.
 */

#include <stdio.h>
#include <X11/Xlib.h>		/* some Xlib stuff */
#include <X11/Xutil.h>
#include <X11/Xos.h>
#include <X11/Xatom.h>
#include "xpov.icn"
#include <math.h>

#include "frame.h"
#include "povproto.h"

#define 	BORDER_WIDTH	2
#define	EV_MASK	(ButtonPressMask | \
		 KeyPressMask	 | \
		 ExposureMask    | \
		 StructureNotifyMask)

static Display *theDisplay;
static int      theScreen;
static int      theDepth;
static unsigned long theBlackPixel;
static unsigned long theWhitePixel;
static XEvent   theEvent;
static Window   theWindow, openWindow();
static GC       theGC;
static unsigned char *bitmap;	/* pointer to our picture bitmap */
static unsigned char *bitmapPos;/* position to the last drawn pixel in our
				 * bitmap */


static char    *display_name = 0;
static int     disp_wide, disp_high;
static XImage  *xi;
static char    *data;
static XGCValues gcvalues;
static long     colorpixels[256];
static Bool     iscolor;
static int 	screen_open = 0;

struct {
    void            (*Init) ();
    void            (*Close) ();
    void            (*Finished) ();
    void            (*Plot) ();
}               display;

/* global POVRay variables */

extern FRAME    Frame;
extern unsigned int Options;
extern char     DisplayFormat;
extern int      First_Line;

/*
 * Sets up a connection to the X server and stores informations about the
 * enviroment
 */

static          initX()
{
    theDisplay = XOpenDisplay(NULL);
    if (theDisplay == NULL) {
	fprintf(stderr, "ERROR: Cannot establish a connection to the X server %s\n",
		XDisplayName(NULL));
	exit(1);
    }
    theScreen = DefaultScreen(theDisplay);
    theDepth = DefaultDepth(theDisplay, theScreen);
    theWhitePixel = WhitePixel(theDisplay, theScreen);
    theBlackPixel = BlackPixel(theDisplay, theScreen);
}

/*
 * This procedure will do the following things: 1) 	Set up attributes
 * desired for the window 2)	Set up an icon to our window. 3) 	Send
 * hints to the window manager. 4) 	Open a window on the display 5)	Tell
 * the X to place the window on the screen 6)	Flush out all the queued up X
 * requests to the X server
 */

static Window   openWindow(x, y, width, height, flag, theNewGC)
int             x, y;
int             width, height;
int             flag;
GC             *theNewGC;
{
    XSetWindowAttributes theWindowAttributes;
    XSizeHints      theSizeHints;
    unsigned long   theWindowMask;
    Window          theNewWindow;
    Pixmap          theIconPixmap;
    XWMHints        theWMHints;


    /*
     * Set up some attributes for the window. Override_redirect tells the
     * window manager to deal width the window or leave it alone
     */

    theWindowAttributes.border_pixel = theBlackPixel;
    theWindowAttributes.background_pixel = theWhitePixel;
    theWindowAttributes.override_redirect = False;
    theWindowMask = CWBackPixel | CWBorderPixel | CWOverrideRedirect;

    /* Now, open out window */

    theNewWindow = XCreateWindow(theDisplay,
				 RootWindow(theDisplay, theScreen),
				 x, y,
				 width, height,
				 BORDER_WIDTH,
				 theDepth,
				 InputOutput,
				 CopyFromParent,
				 theWindowMask,
				 &theWindowAttributes);

    /* Create one iconbitmap */

    theIconPixmap = XCreateBitmapFromData(theDisplay,
					  theNewWindow,
					  xpov_bits,
					  xpov_width,
					  xpov_height);

    /*
     * Now tell the window manager where on screen we should place our
     * window.
     */

    theWMHints.icon_pixmap = theIconPixmap;
    theWMHints.initial_state = NormalState;	/* we don't want an iconized
						 * window when it's created */
    theWMHints.flags = IconPixmapHint | StateHint;

    XSetWMHints(theDisplay, theNewWindow, &theWMHints);

    theSizeHints.flags = PPosition | PSize;
    theSizeHints.x = x;
    theSizeHints.y = y;
    theSizeHints.width = width;
    theSizeHints.height = height;
    /*
     * theSizeHints.min_width	= width; theSizeHints.min_height	=
     * height; theSizeHints.max_width	= width; theSizeHints.max_height =
     * height;
     */

    XSetNormalHints(theDisplay, theNewWindow, &theSizeHints);


    if (createGC(theNewWindow, theNewGC) == 0) {
	XDestroyWindow(theDisplay, theNewWindow);
	return ((Window) 0);
    }

    /* make a name for our window */

    XStoreName(theDisplay, theNewWindow, "POVRay \0");

    /*
     * Now, could we please see the window on the screen? Until now, we have
     * dealed with a window which has been created but noe appeared on the
     * screen. Maping the window places it visibly	on the screen
     */

    XMapWindow(theDisplay, theNewWindow);
    XFlush(theDisplay);
    return (theNewWindow);
}

static          refreshWindow(theExposedWindow)
Window          theExposedWindow;
{
    int             i = 0, x = 0, y = First_Line;
    register unsigned char *dummy = bitmap;
    while (dummy != bitmapPos) {
	/* draw until most current pixel is drawn */
	if (*dummy)
	    XDrawPoint(theDisplay, theWindow, theGC, x, y);
	if (x == Frame.Screen_Width) {
	    x = 0;
	    y++;
	}
	else {
	    dummy++;
	    x++;
	    i++;
	}
    }
    XFlush(theDisplay);
}

/* Creates a new graphics context */

static int      createGC(theNewWindow, theNewGC)
Window          theNewWindow;
GC             *theNewGC;
{
    XGCValues       theGCValues;
    *theNewGC = XCreateGC(theDisplay,
			  theNewWindow,
			  (unsigned long) 0,
			  &theGCValues);

    if (*theNewGC == 0) {
	return (0);		/* error */
    }
    else {			/* set foreground and background defaults for
				 * the new GC */
	XSetForeground(theDisplay,
		       *theNewGC,
		       theBlackPixel);

	XSetBackground(theDisplay,
		       *theNewGC,
		       theWhitePixel);

	return (1);		/* OK */
    }
}

static          initEvents(theWindow)
Window          theWindow;
{
    XSelectInput(theDisplay,
		 theWindow,
		 EV_MASK);
}

void            BWFinished()
{

}


void            BWInit()
{
    int             i;

    /*
     * set some room for a bitmap for our picture. I've got to "remember" the
     * whole picture bacuse of resizing of the window, overlapping etc. Then
     * I've got to refresh the picture. This should be easy to convert to an
     * "color version" in future
     */

    bitmap = (unsigned char *) malloc(sizeof(unsigned char) *
				(Frame.Screen_Width * Frame.Screen_Height));
    bitmapPos = bitmap;
    if (bitmap == NULL)
	printf("ERROR: Can not allocate the buffer..\n");

    for (i = 0; i < (Frame.Screen_Width * Frame.Screen_Height); i++) {
	*bitmapPos++ = 0;
    }
    bitmapPos = bitmap;
    initX();
    theWindow = openWindow(0, 0, Frame.Screen_Width, Frame.Screen_Height, 0, &theGC);
    initEvents(theWindow);
    XFlush(theDisplay);
    XNextEvent(theDisplay, &theEvent);
    XFlush(theDisplay);
}				/* end of display initilazation */

void            BWClose()
{
    sleep(10);			/* an simple delay. 10 seconds. */
    XDestroyWindow(theDisplay, theWindow);
    XFlush(theDisplay);
    XCloseDisplay(theDisplay);
    free(bitmap);
}

void            BWPlot(x, y, Red, Green, Blue)
int             x, y;
unsigned char   Red, Green, Blue;
{
    unsigned char   color;
    long            thePixel;
    /* lets find if there are some events waiting for us */

    while (XPending(theDisplay) > 0) {	/* now deal with the events.. */
	XNextEvent(theDisplay, &theEvent);

	switch (theEvent.type) {
	  case Expose:
	    /* printf("Window is exposed.\n"); */
	    refreshWindow(theEvent.xany.window);
	    break;

	  case MapNotify:
	    /* printf("The window is mapped.\n"); */
	    refreshWindow(theEvent.xany.window);
	    break;

	  case ButtonPress:
	    /* printf("A mouse button was pressed.\n"); */
	    break;

	  case ConfigureNotify:
	    /* printf("The window configuration has been changed\n"); */
	    refreshWindow(theEvent.xany.window);
	    break;
	}
    }
    if (dither(x, y, Red, Green, Blue)) {
	thePixel = BlackPixel(theDisplay, theScreen);
	XDrawPoint(theDisplay, theWindow, theGC, x, y);
	XFlush(theDisplay);
    }
    else {
	thePixel = WhitePixel(theDisplay, theScreen);
    }
    *bitmapPos++ = thePixel;
}

/* so we can get at the dimensions */
extern FRAME    Frame;

/* x11 stuff */

static Bool     evtPred(d, e, a)
Display        *d;
XEvent         *e;
char           *a;
{
    return (True);
}

static void     BuildColormap()
{
    XColor          tmp;
    register unsigned short r, g, b, i;
    Colormap        cmap;

    /*
     * build a colormap that will contain 216, or 6^3 colors. We won't do
     * anything clever like adding extra grays in the leftover space.
     * Remember, this was written in a few hours.
     */
    cmap = DefaultColormap(theDisplay, theScreen);

    i = 0;
    for (r = 0; r < 6; r++) {
	for (g = 0; g < 6; g++) {
	    for (b = 0; b < 6; b++, i++) {
		tmp.red = (r * 36) << 8;
		tmp.green = (g * 36) << 8;
		tmp.blue = (b * 36) << 8;
		tmp.flags = DoRed | DoGreen | DoBlue;
		if (!XAllocColor(theDisplay, cmap, &tmp))
		    goto crap_out;
		colorpixels[i] = tmp.pixel;
	    }
	}
    }
crap_out:			/* couldn't get what we wanted.  Boo-hoo. */
    if (i != 216)
	fprintf(stderr, "warning: could only get %d colors.\n", i);
}

void            ColourFinished()
{
    XEvent         *report;
    /* do nothing.  I suppose we could wait... */
    while (1) {
	XNextEvent(theDisplay, &report);
	XPutImage(theDisplay, theWindow, theGC, xi, 0, 0, 0, 0, Frame.Screen_Width,
		  Frame.Screen_Height);
    }
}

void            display_close()
{
	if(screen_open)
   		 (display.Close) ();
}

void            display_plot(x, y, Red, Green, Blue)
int             x, y;
unsigned char   Red, Green, Blue;
{
    (display.Plot) (x, y, Red, Green, Blue);
}

void            display_finished()
{
	if(screen_open)
    		(display.Finished) ();
}

void            ColourInit()
{
    Pixmap          icon;
    XSizeHints      hints;
    long            size, i;
    XSetWindowAttributes attrib;

    if ((theDisplay = XOpenDisplay(display_name)) == NULL) {
	fprintf(stderr, "Can't open X server %s.\n",
		XDisplayName(display_name));
	exit(1);
    }
    theScreen = DefaultScreen(theDisplay);

    /* screen dimensions */
    disp_wide = DisplayWidth(theDisplay, theScreen);
    disp_high = DisplayHeight(theDisplay, theScreen);

    theWindow = XCreateSimpleWindow(theDisplay, RootWindow(theDisplay, theScreen),
			      (disp_wide - Frame.Screen_Width) / 2,
			      (disp_high - Frame.Screen_Height) / 2,
			      Frame.Screen_Width,
			      Frame.Screen_Height, 2 /* border width */ ,
			  BlackPixel(theDisplay, theScreen), WhitePixel(theDisplay, theScreen));

    /* create a graphics context for drawing */
    gcvalues.function = GXcopy;
    theGC = XCreateGC(theDisplay, theWindow, GCFunction, &gcvalues);

    /* make a cute icon */
    icon = XCreateBitmapFromData(theDisplay, theWindow, xpov_bits, xpov_width,
				 xpov_height);

    /* give a few clues about ourself */
    hints.flags = PPosition | PSize | PMinSize;
    hints.x = (disp_wide - Frame.Screen_Width) / 2;
    hints.y = (disp_high - Frame.Screen_Height) / 2;
    hints.width = Frame.Screen_Width;
    hints.height = Frame.Screen_Height;
    hints.min_width = 32;
    hints.min_height = 32;

    XSetStandardProperties(theDisplay, theWindow, "povray", "povray", icon, NULL, 0,
			   &hints);

    /* only want to know about expose events */
    XSelectInput(theDisplay, theWindow, ExposureMask);
    XMapWindow(theDisplay, theWindow);

    BuildColormap();

    size = Frame.Screen_Width * Frame.Screen_Height;
    data = (char *) XtMalloc(size);
    for (i = 0; i < size; i++)
	data[i] = 0;
    xi = XCreateImage(theDisplay, DefaultVisual(theDisplay, theScreen), 8, ZPixmap, 0, data,
	    Frame.Screen_Width, Frame.Screen_Height, 8, Frame.Screen_Width);
};

void            ColourClose()
{
    sleep(10);
    XDestroyImage(xi);
    XtFree(data);
    XDestroyWindow(theDisplay, theWindow);
    XCloseDisplay(theDisplay);
}

 /* static */ int dither(x, y, Red, Green, Blue)
register unsigned int x, y;
unsigned char   Red, Green, Blue;
{
    /*
     * Perform ordered dithering for halftone screen. For details, see
     * Graphics Gems, Ed. Andrew Glassner, p. 176-178 Floyd-Steinberg dither
     * would look better, but we would need more saved state, making the
     * coding a lot uglier.  Since this is just a display hack and not an
     * image processing package, I don't bother.
     */
    static unsigned int dm[] = {
	0, 192, 48, 240, 12, 204, 60, 252,
	128, 64, 176, 112, 140, 76, 188, 124,
	32, 224, 16, 208, 44, 236, 28, 220,
	160, 96, 144, 80, 172, 108, 156, 92,
	8, 200, 56, 248, 4, 196, 52, 244,
	136, 72, 184, 120, 132, 68, 180, 116,
	40, 232, 24, 216, 36, 228, 20, 212,
	168, 104, 152, 88, 164, 100, 148, 84
    };
    register unsigned long luminence =
    (307 * Red + 599 * Green + 118 * Blue) / 1024;
    return (luminence < dm[(x & 7) + ((y & 7) << 3)]);
}

void            ColourPlot(x, y, Red, Green, Blue)
int             x, y;
unsigned char   Red, Green, Blue;
{
    long            thePixel;
    int             r, g, b;
    XEvent          report;
    int             luminence;

    /* scale rgb to be in our 216 color space */
    r = (Red * 216) / (256 * 36);
    g = (Green * 216) / (256 * 36);
    b = (Blue * 216) / (256 * 36);

    /* find the pixel we got */
    thePixel = colorpixels[(r * 36) + (g * 6) + b];
    XPutPixel(xi, x, y, thePixel);
    /* on each pixel, copy a scanline.  Inefficient, but so what?  See above. */
    XPutImage(theDisplay, theWindow, theGC, xi, 0, y, 0, y, Frame.Screen_Width, 1);

    /* poll for exposure events */
    if (XCheckIfEvent(theDisplay, &report, evtPred, "blah")) {
	XPutImage(theDisplay, theWindow, theGC, xi, 0, 0, 0, 0, Frame.Screen_Width, y + 1);
    }
}

void unix_init_POVRAY PARAMS((void))
{
}

int             matherr(x)
struct exception *x;
{
    switch (x->type) {
      case DOMAIN:
      case OVERFLOW:
	x->retval = 1.0e17;
	break;

      case SING:
      case UNDERFLOW:
	x->retval = 0.0;
	break;

      default:
	break;
    }
    return (1);
}

extern void     BWInit(), BWClose(), BWFinished(), BWPlot();

void            display_init()
{
    Pixmap          icon;
    XSizeHints      hints;
    long            size, i;
    XSetWindowAttributes attrib;

    if ((theDisplay = XOpenDisplay(display_name)) == NULL) {
	fprintf(stderr, "Can't open X server %s.\n",
		XDisplayName(display_name));
	exit(1);
    }
    
    screen_open = 1;
    
    theScreen = DefaultScreen(theDisplay);
    iscolor = (XDisplayCells(theDisplay, theScreen) > 2);

    if (iscolor) {
	display.Init = ColourInit;
	display.Close = ColourClose;
	display.Finished = ColourFinished;
	display.Plot = ColourPlot;
    }
    else {
	display.Init = BWInit;
	display.Close = BWClose;
	display.Finished = BWFinished;
	display.Plot = BWPlot;
    }

    XCloseDisplay(theDisplay);
    (display.Init) ();

}