/*
    SDL - Simple DirectMedia Layer
    Copyright (C) 1997, 1998, 1999, 2000, 2001  Sam Lantinga

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 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
    Library General Public License for more details.

    You should have received a copy of the GNU Library General Public
    License along with this library; if not, write to the Free
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

    Sam Lantinga
    slouken@devolution.com
*/

#ifdef SAVE_RCSID
static char rcsid =
 "@(#) $Id$";
#endif

#define DISABLE_X11

#include <stdlib.h>
#include <string.h>
#include <Ph.h>
#include <photon/PpProto.h>
#include <photon/PhWm.h>
#include <photon/wmapi.h>
#include "SDL_version.h"
#include "SDL_error.h"
#include "SDL_timer.h"
#include "SDL_video.h"
#include "SDL_syswm.h"
#include "SDL_events_c.h"
#include "SDL_pixels_c.h"
#include "SDL_ph_modes_c.h"
#include "SDL_ph_wm_c.h"

/* This is necessary for working properly with Enlightenment, etc. */
#define USE_ICON_WINDOW

void ph_SetIcon(_THIS, SDL_Surface *icon, Uint8 *mask)
{

#if 0 /*big*/
	int ncolors;
	PhImage_t *image;
	PgColor_t* palette;

	image = PhCreateImage( image,
                          	icon->w,
                          	icon->h,
                          	Pg_IMAGE_DIRECT_888,
                          	NULL, 0, 0 );

/* ---------------------------------------- */
	SDL_Surface *sicon;
//	XWMHints *wmhints;
//	XImage *icon_image;
//	Pixmap icon_pixmap;
//	Pixmap mask_pixmap;
//	GC GC;
//	XGCValues GCvalues;
	int i, b, dbpp;
	SDL_Rect bounds;
	Uint8 *LSBmask, *color_tried;
	Visual *dvis;

	/* Lock the event thread, in multi-threading environments */
	SDL_Lock_EventThread();

	/* The icon must use the default visual, depth and colormap of the
	   screen, so it might need a conversion */
// ?	dbpp = DefaultDepth(SDL_Display, SDL_Screen);
	switch(dbpp) {
	case 15:
	    dbpp = 16; break;
	case 24:
	    dbpp = 32; break;
	}
	dvis = DefaultVisual(SDL_Display, SDL_Screen);

	/* The Visual struct is supposed to be opaque but we cheat a little */
	sicon = SDL_CreateRGBSurface(SDL_SWSURFACE, icon->w, icon->h,
				     dbpp,
				     dvis->red_mask, dvis->green_mask,
				     dvis->blue_mask, 0);

	if ( sicon == NULL ) {
		goto done;
	}
	/* If we already have allocated colours from the default colormap,
	   copy them */
	if(SDL_Visual == dvis && SDL_XColorMap == SDL_DisplayColormap
	   && this->screen->format->palette && sicon->format->palette) {
	    memcpy(sicon->format->palette->colors,
		   this->screen->format->palette->colors,
		   this->screen->format->palette->ncolors * sizeof(SDL_Color));
	}

	bounds.x = 0;
	bounds.y = 0;
	bounds.w = icon->w;
	bounds.h = icon->h;
	if ( SDL_LowerBlit(icon, &bounds, sicon, &bounds) < 0 )
		goto done;

	/* Lock down the colors used in the colormap */
	color_tried = NULL;
	if ( sicon->format->BitsPerPixel == 8 ) {
		SDL_Palette *palette;
		Uint8 *p;
		XColor wanted;

		palette = sicon->format->palette;
		color_tried = malloc(palette->ncolors);
		if ( color_tried == NULL ) {
			goto done;
		}
		if ( SDL_iconcolors != NULL ) {
			free(SDL_iconcolors);
		}
		SDL_iconcolors = malloc(palette->ncolors
					* sizeof(*SDL_iconcolors));
		if ( SDL_iconcolors == NULL ) {
			free(color_tried);
			goto done;
		}
		memset(color_tried, 0, palette->ncolors);
		memset(SDL_iconcolors, 0,
		       palette->ncolors * sizeof(*SDL_iconcolors));

		p = (Uint8 *)sicon->pixels; 
		for ( i = sicon->w*sicon->h; i > 0; --i, ++p ) {
			if ( ! color_tried[*p] ) {
				wanted.pixel = *p;
				wanted.red   = (palette->colors[*p].r<<8);
				wanted.green = (palette->colors[*p].g<<8);
				wanted.blue  = (palette->colors[*p].b<<8);
				wanted.flags = (DoRed|DoGreen|DoBlue);
				if (XAllocColor(SDL_Display,
						SDL_DisplayColormap, &wanted)) {
					++SDL_iconcolors[wanted.pixel];
				}
				color_tried[*p] = 1;
			}
		}
	}
	if ( color_tried != NULL ) {
		free(color_tried);
	}

	/* Translate mask data to LSB order and set the icon mask */
	i = (sicon->w/8)*sicon->h;
	LSBmask = (Uint8 *)malloc(i);
	if ( LSBmask == NULL ) {
		goto done;
	}
	memset(LSBmask, 0, i);
	while ( --i >= 0 ) {
		for ( b=0; b<8; ++b )
			LSBmask[i] |= (((mask[i]>>b)&0x01)<<(7-b));
	}
	mask_pixmap = XCreatePixmapFromBitmapData(SDL_Display, WMwindow,
					LSBmask, sicon->w, sicon->h, 1L, 0L, 1);

	/* Transfer the image to an X11 pixmap */
	icon_image = XCreateImage(SDL_Display,
			DefaultVisual(SDL_Display, SDL_Screen),
			DefaultDepth(SDL_Display, SDL_Screen),
			ZPixmap, 0, (char *)sicon->pixels, sicon->w, sicon->h,
			((sicon->format)->BytesPerPixel == 3) ? 32 :
				(sicon->format)->BytesPerPixel*8, 0);
	icon_pixmap = XCreatePixmap(SDL_Display, SDL_Root, sicon->w, sicon->h,
			DefaultDepth(SDL_Display, SDL_Screen));
	GC = XCreateGC(SDL_Display, icon_pixmap, 0, &GCvalues);
	XPutImage(SDL_Display, icon_pixmap, GC, icon_image,
					0, 0, 0, 0, sicon->w, sicon->h);
	XFreeGC(SDL_Display, GC);
	XDestroyImage(icon_image);
	free(LSBmask);
	sicon->pixels = NULL;

#ifdef USE_ICON_WINDOW
	/* Create an icon window and set the pixmap as its background */
	icon_window = XCreateSimpleWindow(SDL_Display, SDL_Root,
					0, 0, sicon->w, sicon->h, 0,
					CopyFromParent, CopyFromParent);
	XSetWindowBackgroundPixmap(SDL_Display, icon_window, icon_pixmap);
	XClearWindow(SDL_Display, icon_window);
#endif

	/* Set the window icon to the icon pixmap (and icon window) */
	wmhints = XAllocWMHints();
	wmhints->flags = (IconPixmapHint | IconMaskHint);
	wmhints->icon_pixmap = icon_pixmap;
	wmhints->icon_mask = mask_pixmap;
#ifdef USE_ICON_WINDOW
	wmhints->flags |= IconWindowHint;
	wmhints->icon_window = icon_window;
#endif
	XSetWMHints(SDL_Display, WMwindow, wmhints);
	XFree(wmhints);
	XSync(SDL_Display, False);

  done:
	SDL_Unlock_EventThread();
	if ( sicon != NULL ) {
		SDL_FreeSurface(sicon);
	}
	
#endif /*big*/
	return;
}

/* Set window caption */
void ph_SetCaption(_THIS, const char *title, const char *icon)
{
	SDL_Lock_EventThread();
	if ( title != NULL ) {
		PtSetResource(window, Pt_ARG_WINDOW_TITLE, title, 0);
	}
	SDL_Unlock_EventThread();
}

/* Iconify the window (stolen from PhHotKey sources by phearbear ;-) */
int ph_IconifyWindow(_THIS)
{
#if 1 /* Code submitted by Luca <barbato_luca@yahoo.com> */
	WmApiContext_t context=WmCreateContext();
	WmWindowDefinition_t
**wininfo=malloc(sizeof(WmWindowDefinition_t)*2);
	int num;									
	SDL_Lock_EventThread();
	WmGetFocusList(context,2,&num,wininfo);
	WmPerformFrameAction(context, wininfo[0]->rid,Pt_ACTION_MIN);

	WmDestroyContext (context);   
	SDL_Unlock_EventThread();	 
	free(wininfo);		   
	return (0);   
#else
	int result=0;
        int myerr;
        int num;
        PtConnectionClient_t *Client=0;
        WmMsg_t* Message=malloc(sizeof(WmMsg_t));
        WmReply_t *Reply=malloc(sizeof(WmReply_t));
        WmApiContext_t MsgStruct=malloc(sizeof(WmApiContext_t));
        WmWindowDefinition_t **WNDDEF=malloc(sizeof(WmWindowDefinition_t)*2);
	
	SDL_Lock_EventThread();

        PtInit("/dev/photon");

        Client=PtConnectionFindName("pwm",0,0);

        if(!Client)
        {
           return result;
        }

        MsgStruct->input_group=PhInputGroup(0);
        MsgStruct->connection=PtConnectionFindName("pwm",0,0);
        myerr=WmGetFocusList(MsgStruct,2,&num,WNDDEF);

        Message->hdr.type=WM_REQUEST_WIN_ACTION;
        Message->hdr.subtype=Pt_ACTION_MIN;	   
        Message->hdr.rid=WNDDEF[0]->rid;
        myerr=WmSendMessage(Client,Message,Reply,0);

        free(Message);
        free(Reply);

	SDL_Unlock_EventThread();

	return(result);
#endif /* 1 */
}

SDL_GrabMode ph_GrabInputNoLock(_THIS, SDL_GrabMode mode)
{
#if 0 /*big*/
	int numtries, result;

	if ( this->screen == NULL ) {
		return(SDL_GRAB_OFF);
	}
	if ( ! SDL_Window ) {
		return(mode);	/* Will be set later on mode switch */
	}
	if ( mode == SDL_GRAB_OFF ) {
		XUngrabPointer(SDL_Display, CurrentTime);
		if ( this->screen->flags & SDL_FULLSCREEN ) {
			/* Rebind the mouse to the fullscreen window */
			for ( numtries = 0; numtries < 10; ++numtries ) {
				result = XGrabPointer(SDL_Display, FSwindow,
						True, 0,
						GrabModeAsync, GrabModeAsync,
						FSwindow, None, CurrentTime);
				if ( result == AlreadyGrabbed ) {
					break;
				}
				SDL_Delay(100);
			}
		}
#ifdef GRAB_FULLSCREEN
		if ( !(this->screen->flags & SDL_FULLSCREEN) )
#endif
		XUngrabKeyboard(SDL_Display, CurrentTime);
	} else {
		if ( this->screen->flags & SDL_FULLSCREEN ) {
			/* Unbind the mouse from the fullscreen window */
			XUngrabPointer(SDL_Display, CurrentTime);
		}
		/* Try to grab the mouse */
		for ( numtries = 0; numtries < 10; ++numtries ) {
			result = XGrabPointer(SDL_Display, SDL_Window, True, 0,
						GrabModeAsync, GrabModeAsync,
						SDL_Window, None, CurrentTime);
			if ( result != AlreadyGrabbed ) {
				break;
			}
			SDL_Delay(100);
		}
#ifdef GRAB_FULLSCREEN
		if ( !(this->screen->flags & SDL_FULLSCREEN) )
#endif
		XGrabKeyboard(SDL_Display, WMwindow, True,
			GrabModeAsync, GrabModeAsync, CurrentTime);
	}
	XSync(SDL_Display, False);


#endif /*big*/
	return(mode);
}

SDL_GrabMode ph_GrabInput(_THIS, SDL_GrabMode mode)
{
#if 0
	SDL_Lock_EventThread();
	mode = X11_GrabInputNoLock(this, mode);
	SDL_Unlock_EventThread();
#endif
	return(mode);
}

/* If 'info' is the right version, this function fills it and returns 1.
   Otherwise, in case of a version mismatch, it returns -1.
*/
static void lock_display(void)
{
	SDL_Lock_EventThread();
}
static void unlock_display(void)
{
#if 0
	/* Make sure any X11 transactions are completed */
	SDL_VideoDevice *this = current_video;
	XSync(SDL_Display, False);
#endif
	SDL_Unlock_EventThread();
}
int ph_GetWMInfo(_THIS, SDL_SysWMinfo *info)
{
#if 0
	if ( info->version.major <= SDL_MAJOR_VERSION ) {
		info->subsystem = SDL_SYSWM_X11;
		info->info.x11.display = SDL_Display;
		info->info.x11.window = SDL_Window;
		if ( SDL_VERSIONNUM(info->version.major,
		                    info->version.minor,
		                    info->version.patch) >= 1002 ) {
			info->info.x11.fswindow = FSwindow;
			info->info.x11.wmwindow = WMwindow;
		}
		info->info.x11.lock_func = lock_display;
		info->info.x11.unlock_func = unlock_display;
		return(1);
	} else {
		SDL_SetError("Application not compiled with SDL %d.%d\n",
					SDL_MAJOR_VERSION, SDL_MINOR_VERSION);
		return(-1);
	}
#endif
   return -1; // for now ...
}