/*

    SDL - Simple DirectMedia Layer

    Copyright (C) 1997-2006 Sam Lantinga

    This library is free software; you can redistribute it and/or

    modify it under the terms of the GNU Lesser General Public

    License as published by the Free Software Foundation; either

    version 2.1 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,

    but WITHOUT ANY WARRANTY; without even the implied warranty of

    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public

    License along with this library; if not, write to the Free Software

    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

    Sam Lantinga

    slouken@libsdl.org

*/

/* X11 based SDL video driver implementation.

   Note:  This implementation does not currently need X11 thread locking,

          since the event thread uses a separate X connection and any

          additional locking necessary is handled internally.  However,

          if full locking is neccessary, take a look at XInitThreads().

*/

#include <stdlib.h>

#include <stdio.h>

#include <unistd.h>

#include <string.h>

#include <sys/ioctl.h>

#ifdef MTRR_SUPPORT

#include <asm/mtrr.h>

#include <sys/fcntl.h>

#endif

#ifdef HAVE_ALLOCA_H

#include <alloca.h>

#endif

#ifdef HAVE_ALLOCA

#define ALLOCA(n) ((void*)alloca(n))

#define FREEA(p)

#else

#define ALLOCA(n) malloc(n)

#define FREEA(p) free(p)

#endif

#include "SDL.h"

#include "SDL_error.h"

#include "SDL_timer.h"

#include "SDL_thread.h"

#include "SDL_video.h"

#include "SDL_mouse.h"

#include "SDL_endian.h"

#include "SDL_sysvideo.h"

#include "SDL_pixels_c.h"

#include "SDL_events_c.h"

#include "SDL_x11video.h"

#include "SDL_x11wm_c.h"

#include "SDL_x11mouse_c.h"

#include "SDL_x11events_c.h"

#include "SDL_x11modes_c.h"

#include "SDL_x11image_c.h"

#include "SDL_x11yuv_c.h"

#include "SDL_x11gl_c.h"

#include "SDL_x11gamma_c.h"

#include "blank_cursor.h"

/* Initialization/Query functions */

static int X11_VideoInit(_THIS, SDL_PixelFormat *vformat);

static SDL_Surface *X11_SetVideoMode(_THIS, SDL_Surface *current, int width, int height, int bpp, Uint32 flags);

static int X11_ToggleFullScreen(_THIS, int on);

static void X11_UpdateMouse(_THIS);

static int X11_SetColors(_THIS, int firstcolor, int ncolors,

			 SDL_Color *colors);

static int X11_SetGammaRamp(_THIS, Uint16 *ramp);

static void X11_VideoQuit(_THIS);

/* X11 driver bootstrap functions */

static int X11_Available(void)

{

	Display *display = NULL;

	if ( SDL_X11_LoadSymbols() ) {

		display = pXOpenDisplay(NULL);

		if ( display != NULL ) {

			pXCloseDisplay(display);

		}

		SDL_X11_UnloadSymbols();

	}

	return(display != NULL);

}

static void X11_DeleteDevice(SDL_VideoDevice *device)

{

	if ( device ) {

		if ( device->hidden ) {

			free(device->hidden);

		}

		if ( device->gl_data ) {

			free(device->gl_data);

		}

		free(device);

		SDL_X11_UnloadSymbols();

	}

}

static SDL_VideoDevice *X11_CreateDevice(int devindex)

{

	SDL_VideoDevice *device = NULL;

	if ( SDL_X11_LoadSymbols() ) {

		/* Initialize all variables that we clean on shutdown */

		device = (SDL_VideoDevice *)malloc(sizeof(SDL_VideoDevice));

		if ( device ) {

			memset(device, 0, (sizeof *device));

			device->hidden = (struct SDL_PrivateVideoData *)

					malloc((sizeof *device->hidden));

			device->gl_data = (struct SDL_PrivateGLData *)

					malloc((sizeof *device->gl_data));

		}

		if ( (device == NULL) || (device->hidden == NULL) ||

		                         (device->gl_data == NULL) ) {

			SDL_OutOfMemory();

			X11_DeleteDevice(device); /* calls SDL_X11_UnloadSymbols(). */

			return(0);

		}

		memset(device->hidden, 0, (sizeof *device->hidden));

		memset(device->gl_data, 0, (sizeof *device->gl_data));

		/* Set the driver flags */

		device->handles_any_size = 1;

		/* Set the function pointers */

		device->VideoInit = X11_VideoInit;

		device->ListModes = X11_ListModes;

		device->SetVideoMode = X11_SetVideoMode;

		device->ToggleFullScreen = X11_ToggleFullScreen;

		device->UpdateMouse = X11_UpdateMouse;

#ifdef XFREE86_XV

		device->CreateYUVOverlay = X11_CreateYUVOverlay;

#endif

		device->SetColors = X11_SetColors;

		device->UpdateRects = NULL;

		device->VideoQuit = X11_VideoQuit;

		device->AllocHWSurface = X11_AllocHWSurface;

		device->CheckHWBlit = NULL;

		device->FillHWRect = NULL;

		device->SetHWColorKey = NULL;

		device->SetHWAlpha = NULL;

		device->LockHWSurface = X11_LockHWSurface;

		device->UnlockHWSurface = X11_UnlockHWSurface;

		device->FlipHWSurface = X11_FlipHWSurface;

		device->FreeHWSurface = X11_FreeHWSurface;

		device->SetGamma = X11_SetVidModeGamma;

		device->GetGamma = X11_GetVidModeGamma;

		device->SetGammaRamp = X11_SetGammaRamp;

		device->GetGammaRamp = NULL;

#ifdef HAVE_OPENGL_X11

		device->GL_LoadLibrary = X11_GL_LoadLibrary;

		device->GL_GetProcAddress = X11_GL_GetProcAddress;

		device->GL_GetAttribute = X11_GL_GetAttribute;

		device->GL_MakeCurrent = X11_GL_MakeCurrent;

		device->GL_SwapBuffers = X11_GL_SwapBuffers;

#endif

		device->SetCaption = X11_SetCaption;

		device->SetIcon = X11_SetIcon;

		device->IconifyWindow = X11_IconifyWindow;

		device->GrabInput = X11_GrabInput;

		device->GetWMInfo = X11_GetWMInfo;

		device->FreeWMCursor = X11_FreeWMCursor;

		device->CreateWMCursor = X11_CreateWMCursor;

		device->ShowWMCursor = X11_ShowWMCursor;

		device->WarpWMCursor = X11_WarpWMCursor;

		device->CheckMouseMode = X11_CheckMouseMode;

		device->InitOSKeymap = X11_InitOSKeymap;

		device->PumpEvents = X11_PumpEvents;

		device->free = X11_DeleteDevice;

	}

	return device;

}

VideoBootStrap X11_bootstrap = {

	"x11", "X Window System",

	X11_Available, X11_CreateDevice

};

/* Normal X11 error handler routine */

static int (*X_handler)(Display *, XErrorEvent *) = NULL;

static int x_errhandler(Display *d, XErrorEvent *e)

{

#ifdef XFREE86_VM

	extern int vm_error;

#endif

#ifdef XFREE86_DGAMOUSE

	extern int dga_error;

#endif

#ifdef XFREE86_VM

	/* VidMode errors are non-fatal. :) */

	/* Are the errors offset by one from the error base?

	   e.g. the error base is 143, the code is 148, and the

	        actual error is XF86VidModeExtensionDisabled (4) ?

	 */

        if ( (vm_error >= 0) &&

	     (((e->error_code == BadRequest)&&(e->request_code == vm_error)) ||

	      ((e->error_code > vm_error) &&

	       (e->error_code <= (vm_error+XF86VidModeNumberErrors)))) ) {

#ifdef XFREE86_DEBUG

{ char errmsg[1024];

  pXGetErrorText(d, e->error_code, errmsg, sizeof(errmsg));

printf("VidMode error: %s\n", errmsg);

}

#endif

        	return(0);

        }

#endif /* XFREE86_VM */

#ifdef XFREE86_DGAMOUSE

	/* DGA errors can be non-fatal. :) */

        if ( (dga_error >= 0) &&

	     ((e->error_code > dga_error) &&

	      (e->error_code <= (dga_error+XF86DGANumberErrors))) ) {

#ifdef XFREE86_DEBUG

{ char errmsg[1024];

  pXGetErrorText(d, e->error_code, errmsg, sizeof(errmsg));

printf("DGA error: %s\n", errmsg);

}

#endif

        	return(0);

        }

#endif /* XFREE86_DGAMOUSE */

	return(X_handler(d,e));

}

/* X11 I/O error handler routine */

static int (*XIO_handler)(Display *) = NULL;

static int xio_errhandler(Display *d)

{

	/* Ack!  Lost X11 connection! */

	/* We will crash if we try to clean up our display */

	if ( current_video->hidden->Ximage ) {

		SDL_VideoSurface->pixels = NULL;

	}

	current_video->hidden->X11_Display = NULL;

	/* Continue with the standard X11 error handler */

	return(XIO_handler(d));

}

static int (*Xext_handler)(Display *,char *,char *) = NULL;

static int xext_errhandler(Display *d, char *ext_name, char *reason)

{

#ifdef XFREE86_DEBUG

	printf("Xext error inside SDL (may be harmless):\n");

	printf("  Extension \"%s\" %s on display \"%s\".\n",

	       ext_name, reason, pXDisplayString(d));

#endif

	if (strcmp(reason, "missing") == 0) {

		/*

		 * Since the query itself, elsewhere, can handle a missing extension

		 *  and the default behaviour in Xlib is to write to stderr, which

		 *  generates unnecessary bug reports, we just ignore these.

		 */

		return 0;

	}

	/* Everything else goes to the default handler... */

	return Xext_handler(d, ext_name, reason);

}

/* Create auxiliary (toplevel) windows with the current visual */

static void create_aux_windows(_THIS)

{

    char * savedclassname = NULL;

    XSetWindowAttributes xattr;

    XWMHints *hints;

    XTextProperty titleprop, iconprop;

    int def_vis = (SDL_Visual == DefaultVisual(SDL_Display, SDL_Screen));

    /* Don't create any extra windows if we are being managed */

    if ( SDL_windowid ) {

	FSwindow = 0;

	WMwindow = strtol(SDL_windowid, NULL, 0);

        return;

    }

    if(FSwindow)

	pXDestroyWindow(SDL_Display, FSwindow);

    xattr.override_redirect = True;

    xattr.background_pixel = def_vis ? BlackPixel(SDL_Display, SDL_Screen) : 0;

    xattr.border_pixel = 0;

    xattr.colormap = SDL_XColorMap;

    FSwindow = pXCreateWindow(SDL_Display, SDL_Root,

                             xinerama_x, xinerama_y, 32, 32, 0,

			     this->hidden->depth, InputOutput, SDL_Visual,

			     CWOverrideRedirect | CWBackPixel | CWBorderPixel

			     | CWColormap,

			     &xattr);

    pXSelectInput(SDL_Display, FSwindow, StructureNotifyMask);

    /* Tell KDE to keep the fullscreen window on top */

    {

	XEvent ev;

	long mask;

	memset(&ev, 0, sizeof(ev));

	ev.xclient.type = ClientMessage;

	ev.xclient.window = SDL_Root;

	ev.xclient.message_type = pXInternAtom(SDL_Display,

					      "KWM_KEEP_ON_TOP", False);

	ev.xclient.format = 32;

	ev.xclient.data.l[0] = FSwindow;

	ev.xclient.data.l[1] = CurrentTime;

	mask = SubstructureRedirectMask;

	pXSendEvent(SDL_Display, SDL_Root, False, mask, &ev);

    }

    hints = NULL;

    titleprop.value = iconprop.value = NULL;

    if(WMwindow) {

	/* All window attributes must survive the recreation */

	hints = pXGetWMHints(SDL_Display, WMwindow);

	pXGetWMName(SDL_Display, WMwindow, &titleprop);

	pXGetWMIconName(SDL_Display, WMwindow, &iconprop);

	pXDestroyWindow(SDL_Display, WMwindow);

    }

    /* Create the window for windowed management */

    /* (reusing the xattr structure above) */

    WMwindow = pXCreateWindow(SDL_Display, SDL_Root, 0, 0, 32, 32, 0,

			     this->hidden->depth, InputOutput, SDL_Visual,

			     CWBackPixel | CWBorderPixel | CWColormap,

			     &xattr);

    /* Set the input hints so we get keyboard input */

    if(!hints) {

	hints = pXAllocWMHints();

	hints->input = True;

	hints->flags = InputHint;

    }

    pXSetWMHints(SDL_Display, WMwindow, hints);

    pXFree(hints);

    if(titleprop.value) {

	pXSetWMName(SDL_Display, WMwindow, &titleprop);

	pXFree(titleprop.value);

    }

    if(iconprop.value) {

	pXSetWMIconName(SDL_Display, WMwindow, &iconprop);

	pXFree(iconprop.value);

    }

    pXSelectInput(SDL_Display, WMwindow,

		 FocusChangeMask | KeyPressMask | KeyReleaseMask

		 | PropertyChangeMask | StructureNotifyMask | KeymapStateMask);

    /* Set the class hints so we can get an icon (AfterStep) */

    {

	XClassHint *classhints;

	classhints = pXAllocClassHint();

	if(classhints != NULL) {

            char *classname = getenv("SDL_VIDEO_X11_WMCLASS");

            if ( ! classname ) {

                classname = "SDL_App";

            }

	    savedclassname = strdup(classname);

	    classhints->res_name = classname;

	    classhints->res_class = classname;

	    pXSetClassHint(SDL_Display, WMwindow, classhints);

	    pXFree(classhints);

	}

    }

    /* Setup the communication with the IM server */

    SDL_IM = NULL;

    SDL_IC = NULL;

    #ifdef X_HAVE_UTF8_STRING

    SDL_IM = pXOpenIM(SDL_Display, NULL, savedclassname, savedclassname);

    if (SDL_IM == NULL) {

	SDL_SetError("no input method could be opened");

    } else {

	SDL_IC = pXCreateIC(SDL_IM,

			XNClientWindow, WMwindow,

			XNFocusWindow, WMwindow,

			XNInputStyle, XIMPreeditNothing  | XIMStatusNothing,

			XNResourceName, savedclassname,

			XNResourceClass, savedclassname,

			NULL);

	if (SDL_IC == NULL) {

		SDL_SetError("no input context could be created");

		pXCloseIM(SDL_IM);

		SDL_IM = NULL;

	}

    }

    #endif

    free(savedclassname);

    /* Allow the window to be deleted by the window manager */

    WM_DELETE_WINDOW = pXInternAtom(SDL_Display, "WM_DELETE_WINDOW", False);

    pXSetWMProtocols(SDL_Display, WMwindow, &WM_DELETE_WINDOW, 1);

}

static int X11_VideoInit(_THIS, SDL_PixelFormat *vformat)

{

	char *display;

	int i;

	/* Open the X11 display */

	display = NULL;		/* Get it from DISPLAY environment variable */

	if ( (strncmp(pXDisplayName(display), ":", 1) == 0) ||

	     (strncmp(pXDisplayName(display), "unix:", 5) == 0) ) {

		local_X11 = 1;

	} else {

		local_X11 = 0;

	}

	SDL_Display = pXOpenDisplay(display);

#if defined(__osf__) && defined(X11_DYNAMIC)

	/* On Tru64 if linking without -lX11, it fails and you get following message.

	 * Xlib: connection to ":0.0" refused by server

	 * Xlib: XDM authorization key matches an existing client!

	 *

	 * It succeeds if retrying 1 second later

	 * or if running xhost +localhost on shell.

	 *

	 */

	if ( SDL_Display == NULL ) {

		SDL_Delay(1000);

		SDL_Display = pXOpenDisplay(display);

	}

#endif

	if ( SDL_Display == NULL ) {

		SDL_SetError("Couldn't open X11 display");

		return(-1);

	}

#ifdef X11_DEBUG

	pXSynchronize(SDL_Display, True);

#endif

	/* Create an alternate X display for graphics updates -- allows us

	   to do graphics updates in a separate thread from event handling.

	   Thread-safe X11 doesn't seem to exist.

	 */

	GFX_Display = pXOpenDisplay(display);

	if ( GFX_Display == NULL ) {

		SDL_SetError("Couldn't open X11 display");

		return(-1);

	}

	/* Set the normal X error handler */

	X_handler = pXSetErrorHandler(x_errhandler);

	/* Set the error handler if we lose the X display */

	XIO_handler = pXSetIOErrorHandler(xio_errhandler);

	/* Set the X extension error handler */

	Xext_handler = pXSetExtensionErrorHandler(xext_errhandler);

	/* use default screen (from $DISPLAY) */

	SDL_Screen = DefaultScreen(SDL_Display);

#ifndef NO_SHARED_MEMORY

	/* Check for MIT shared memory extension */

	use_mitshm = 0;

	if ( local_X11 ) {

		use_mitshm = pXShmQueryExtension(SDL_Display);

	}

#endif /* NO_SHARED_MEMORY */

	/* Get the available video modes */

	if(X11_GetVideoModes(this) < 0)

	    return -1;

	/* Determine the default screen depth:

	   Use the default visual (or at least one with the same depth) */

	SDL_DisplayColormap = DefaultColormap(SDL_Display, SDL_Screen);

	for(i = 0; i < this->hidden->nvisuals; i++)

	    if(this->hidden->visuals[i].depth == DefaultDepth(SDL_Display,

							      SDL_Screen))

		break;

	if(i == this->hidden->nvisuals) {

	    /* default visual was useless, take the deepest one instead */

	    i = 0;

	}

	SDL_Visual = this->hidden->visuals[i].visual;

	if ( SDL_Visual == DefaultVisual(SDL_Display, SDL_Screen) ) {

	    SDL_XColorMap = SDL_DisplayColormap;

	} else {

	    SDL_XColorMap = pXCreateColormap(SDL_Display, SDL_Root,

					    SDL_Visual, AllocNone);

	}

	this->hidden->depth = this->hidden->visuals[i].depth;

	vformat->BitsPerPixel = this->hidden->visuals[i].bpp;