/*

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

/* CGX based SDL video driver implementation.

*/

/*

#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

*/

#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_cgxvideo.h"

#include "SDL_cgxwm_c.h"

#include "SDL_amigamouse_c.h"

#include "SDL_amigaevents_c.h"

#include "SDL_cgxmodes_c.h"

#include "SDL_cgximage_c.h"

#include "SDL_cgxyuv_c.h"

#include "SDL_cgxgl_c.h"

/* Initialization/Query functions */

static int CGX_VideoInit(_THIS, SDL_PixelFormat *vformat);

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

static int CGX_ToggleFullScreen(_THIS, int on);

static void CGX_UpdateMouse(_THIS);

static void CGX_VideoQuit(_THIS);

/* CGX driver bootstrap functions */

struct Library *CyberGfxBase=NULL;

struct IntuitionBase *IntuitionBase=NULL;

struct GfxBase *GfxBase=NULL;

static void DestroyScreen(_THIS)

{

if(currently_fullscreen)

{

if(this->hidden->dbuffer)

{

extern struct MsgPort *safeport,*dispport;

this->hidden->dbuffer=0;

if(safeport)

{

while(GetMsg(safeport)!=NULL);

DeleteMsgPort(safeport);

}

if(dispport)

{

while(GetMsg(dispport)!=NULL);

DeleteMsgPort(dispport);

}

this->hidden->SB[0]->sb_DBufInfo->dbi_SafeMessage.mn_ReplyPort=this->hidden->SB[0]->sb_DBufInfo->dbi_DispMessage.mn_ReplyPort=NULL;

this->hidden->SB[1]->sb_DBufInfo->dbi_SafeMessage.mn_ReplyPort=this->hidden->SB[1]->sb_DBufInfo->dbi_DispMessage.mn_ReplyPort=NULL;

if(this->hidden->SB[1])

FreeScreenBuffer(SDL_Display,this->hidden->SB[0]);

if(this->hidden->SB[0])

FreeScreenBuffer(SDL_Display,this->hidden->SB[1]);

this->hidden->SB[0]=this->hidden->SB[1]=NULL;

free(SDL_RastPort);

SDL_RastPort=NULL;

this->hidden->dbuffer=0;

}

CloseScreen(GFX_Display);

}

else

UnlockPubScreen(NULL,GFX_Display);

GFX_Display = NULL;

}

static int CGX_Available(void)

{

struct Library *l;

l = OpenLibrary("cybergraphics.library",NULL);

if ( l != NULL ) {

CloseLibrary(l);

}

return(l != NULL);

}

static void CGX_DeleteDevice(SDL_VideoDevice *device)

{

if ( device ) {

if ( device->hidden ) {

free(device->hidden);

}

if ( device->gl_data ) {

free(device->gl_data);

}

free(device);

}

}

static SDL_VideoDevice *CGX_CreateDevice(int devindex)

{

SDL_VideoDevice *device;

/* 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();

CGX_DeleteDevice(device);

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 = CGX_VideoInit;

device->ListModes = CGX_ListModes;

device->SetVideoMode = CGX_SetVideoMode;

device->ToggleFullScreen = CGX_ToggleFullScreen;

device->UpdateMouse = CGX_UpdateMouse;

#ifdef XFREE86_XV

device->CreateYUVOverlay = X11_CreateYUVOverlay;

#endif

device->SetColors = CGX_SetColors;

device->UpdateRects = NULL;

device->VideoQuit = CGX_VideoQuit;

device->AllocHWSurface = CGX_AllocHWSurface;

device->CheckHWBlit = CGX_CheckHWBlit;

device->FillHWRect = CGX_FillHWRect;

device->SetHWColorKey = CGX_SetHWColorKey;

device->SetHWAlpha = NULL;

device->LockHWSurface = CGX_LockHWSurface;

device->UnlockHWSurface = CGX_UnlockHWSurface;

device->FlipHWSurface = CGX_FlipHWSurface;

device->FreeHWSurface = CGX_FreeHWSurface;

#ifdef HAVE_OPENGL

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->SetIcon = CGX_SetIcon;

device->IconifyWindow = NULL; /* CGX_IconifyWindow; */

device->GrabInput = NULL /* CGX_GrabInput*/;

device->GetWMInfo = CGX_GetWMInfo;

device->FreeWMCursor = amiga_FreeWMCursor;

device->CreateWMCursor = amiga_CreateWMCursor;

device->ShowWMCursor = amiga_ShowWMCursor;

device->WarpWMCursor = amiga_WarpWMCursor;

device->CheckMouseMode = amiga_CheckMouseMode;

device->InitOSKeymap = amiga_InitOSKeymap;

device->PumpEvents = amiga_PumpEvents;

device->free = CGX_DeleteDevice;

return device;

}

VideoBootStrap CGX_bootstrap = {

};

#if 0

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

static void create_aux_windows(_THIS)

{

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)

XDestroyWindow(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 = XCreateWindow(SDL_Display, SDL_Root, 0, 0, 32, 32, 0,

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

CWOverrideRedirect | CWBackPixel | CWBorderPixel

| CWColormap,

&xattr);

XSelectInput(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 = XInternAtom(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;

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

}

hints = NULL;

titleprop.value = iconprop.value = NULL;

if(WMwindow) {

/* All window attributes must survive the recreation */

hints = XGetWMHints(SDL_Display, WMwindow);

XGetWMName(SDL_Display, WMwindow, &titleprop);

XGetWMIconName(SDL_Display, WMwindow, &iconprop);

XDestroyWindow(SDL_Display, WMwindow);

}

/* Create the window for windowed management */

/* (reusing the xattr structure above) */

WMwindow = XCreateWindow(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 = XAllocWMHints();

hints->input = True;

hints->flags = InputHint;

}

XSetWMHints(SDL_Display, WMwindow, hints);

XFree(hints);

if(titleprop.value) {

XSetWMName(SDL_Display, WMwindow, &titleprop);

XFree(titleprop.value);

}

if(iconprop.value) {

XSetWMIconName(SDL_Display, WMwindow, &iconprop);

XFree(iconprop.value);

}

XSelectInput(SDL_Display, WMwindow,

FocusChangeMask | KeyPressMask | KeyReleaseMask

| PropertyChangeMask | StructureNotifyMask);

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

{

XClassHint *classhints;

classhints = XAllocClassHint();

if(classhints != NULL) {

classhints->res_name = "SDL_App";

classhints->res_class = "SDL_App";

XSetClassHint(SDL_Display, WMwindow, classhints);

XFree(classhints);

}

}

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

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

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

}

#endif

Uint32 MakeBitMask(_THIS,int type,int format,int *bpp)

{

D(if(type==0)bug("REAL pixel format: "));

if(this->hidden->depth==*bpp)

{

switch(format)

{

case PIXFMT_LUT8:

D(if(type==0)bug("LUT8\n"));

return 0;

case PIXFMT_BGR15:

case PIXFMT_RGB15PC:

switch(type)

{

case 0:

D(bug("RGB15PC/BGR15\n"));

return 31;

case 1:

return 992;

case 2:

return 31744;

}

case PIXFMT_RGB15:

case PIXFMT_BGR15PC:

switch(type)

{

case 0:

D(bug("RGB15/BGR15PC\n"));

return 31744;

case 1:

return 992;

case 2:

return 31;

}

case PIXFMT_BGR16PC:

case PIXFMT_RGB16:

switch(type)

{

case 0:

D(bug("RGB16PC\n"));

return 63488;

case 1:

return 2016;

case 2:

return 31;

}

case PIXFMT_BGR16:

case PIXFMT_RGB16PC:

switch(type)

{

case 0:

D(bug("RGB16PC/BGR16\n"));

return 31;

case 1:

return 2016;

case 2:

return 63488;

}

case PIXFMT_RGB24:

switch(type)

{

case 0:

D(bug("RGB24/BGR24\n"));

return 0xff0000;

case 1:

return 0xff00;

case 2:

return 0xff;

}

case PIXFMT_BGR24:

switch(type)

{

case 0:

D(bug("BGR24\n"));

return 0xff;

case 1:

return 0xff00;

case 2:

return 0xff0000;

}

case PIXFMT_ARGB32:

switch(type)

{

case 0:

D(bug("ARGB32\n"));

return 0xff0000;

case 1:

return 0xff00;

case 2:

return 0xff;

}

case PIXFMT_BGRA32:

switch(type)

{

case 0:

D(bug("BGRA32\n"));

return 0xff00;

case 1:

return 0xff0000;

case 2:

return 0xff000000;

}

case PIXFMT_RGBA32:

switch(type)

{

case 0:

D(bug("RGBA32\n"));

return 0xff000000;

case 1:

return 0xff0000;

case 2:

return 0xff00;

}

default:

D(bug("Unknown pixel format! Default to 24bit\n"));

return (Uint32) (255<<(type*8));

}

}

else

{

D(if(type==0)bug("DIFFERENT from screen.\nAllocated screen format: "));

switch(*bpp)

{

case 32:

D(if(type==0) bug("RGBA32\n"));

switch(type)

{

case 0:

return 0xff000000;

case 1:

return 0xff0000;

case 2:

return 0xff00;

}

break;

case 24:

use_truecolor:

switch(type)

{

case 0:

D(bug("RGB24\n"));

return 0xff0000;

case 1:

return 0xff00;

case 2:

return 0xff;

}

case 16:

case 15:

D(if(type==0) bug("Not supported, switching to 24bit!\n"));

*bpp=24;

goto use_truecolor;

break;

default:

D(if(type==0)bug("This is a chunky display\n"));

// For chunky display mask is always 0;

return 0;

}

}

return 0;

}

static int CGX_VideoInit(_THIS, SDL_PixelFormat *vformat)

{

int i;

if(!(IntuitionBase=(struct IntuitionBase *)OpenLibrary("intuition.library",39L)))

{

SDL_SetError("Couldn't open intuition V39+");

return -1;

}

if(!(GfxBase=(struct GfxBase *)OpenLibrary("graphics.library",39L)))

{

SDL_SetError("Couldn't open graphics V39+");

return -1;

}

if(!(CyberGfxBase=OpenLibrary("cybergraphics.library",40L)))

{

SDL_SetError("Couldn't open cybergraphics.");

return(-1);

}

SDL_Display = LockPubScreen(NULL);

if ( SDL_Display == NULL ) {

SDL_SetError("Couldn't lock the display");

return(-1);

}

if(!IsCyberModeID(GetVPModeID(&SDL_Display->ViewPort)))

{

Uint32 okid=BestCModeIDTags(CYBRBIDTG_NominalWidth,SDL_Display->Width,

CYBRBIDTG_NominalHeight,SDL_Display->Height,

CYBRBIDTG_Depth,8,

TAG_DONE);

UnlockPubScreen(NULL,SDL_Display);

GFX_Display=NULL;

if(okid!=INVALID_ID)

{

GFX_Display=OpenScreenTags(NULL,

SA_Width,SDL_Display->Width,

SA_Height,SDL_Display->Height,

SA_Depth,8,SA_Quiet,TRUE,

SA_ShowTitle,FALSE,

SA_DisplayID,okid,

TAG_DONE);

}

if(!GFX_Display)

{

SDL_SetError("Unable to open a suited CGX display");

return -1;

}

else SDL_Display=GFX_Display;

}

else GFX_Display = SDL_Display;

/* See whether or not we need to swap pixels */

swap_pixels = 0;

// Non e' detto che sia cosi' pero', alcune schede potrebbero gestire i modi in modo differente

if ( SDL_BYTEORDER == SDL_LIL_ENDIAN ) {

swap_pixels = 1;

}

/* Get the available video modes */

if(CGX_GetVideoModes(this) < 0)

return -1;

/* Determine the default screen depth:

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

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

if(this->hidden->visuals[i].depth == GetCyberMapAttr(SDL_Display->RastPort.BitMap,CYBRMATTR_DEPTH))

break;

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

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

i = 0;

}

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

// SDL_XColorMap = SDL_DisplayColormap;

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

D(bug("Setto la profiondita' dello schermo a: %ld\n",this->hidden->depth));

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

{

int form;

APTR handle;

struct DisplayInfo info;

if(!(handle=FindDisplayInfo(this->hidden->visuals[i].visual)))

return -1;

if(!GetDisplayInfoData(handle,(char *)&info,sizeof(struct DisplayInfo),DTAG_DISP,NULL))

return -1;

form=GetCyberIDAttr(CYBRIDATTR_PIXFMT,SDL_Visual);

// In this case I use makebitmask in a way that I'm sure I'll get PIXFMT pixel mask

if ( vformat->BitsPerPixel > 8 )

{

vformat->Rmask = MakeBitMask(this,0,form,&this->hidden->depth);

vformat->Gmask = MakeBitMask(this,1,form,&this->hidden->depth);

vformat->Bmask = MakeBitMask(this,2,form,&this->hidden->depth);

}

}

/* See if we have been passed a window to use */

/* SDL_windowid = getenv("SDL_WINDOWID"); */

SDL_windowid=NULL;

/* Create the fullscreen and managed windows */

// create_aux_windows(this);

/* Create the blank cursor */

SDL_BlankCursor = AllocMem(16,MEMF_CHIP|MEMF_CLEAR);

/* Fill in some window manager capabilities */

this->info.wm_available = 1;

this->info.blit_hw = 1;

this->info.blit_hw_CC = 1;

this->info.blit_sw = 1;

this->info.blit_fill = 1;

this->info.video_mem=2000000; // Not always true but almost any Amiga card has this memory!

this->hidden->same_format=0;

SDL_RastPort=&SDL_Display->RastPort;

/* We're done! */

return(0);

}

void CGX_DestroyWindow(_THIS, SDL_Surface *screen)

{

if ( ! SDL_windowid ) {

/* Hide the managed window */

int was_fullscreen=0;

if ( screen && (screen->flags & SDL_FULLSCREEN) ) {

was_fullscreen=1;

screen->flags &= ~SDL_FULLSCREEN;

// CGX_LeaveFullScreen(this); tolto x crash

}

/* Destroy the output window */

if ( SDL_Window ) {

CloseWindow(SDL_Window);

SDL_Window=NULL;

}

/* Free the colormap entries */

if ( SDL_XPixels ) {

int numcolors;

unsigned long pixel;

if(this->screen->format&&this->hidden->depth==8&&!was_fullscreen)

{

numcolors = 1<<this->screen->format->BitsPerPixel;

if(numcolors>256)

numcolors=256;

for ( pixel=0; pixel<numcolors; pixel++ )

{

if(SDL_XPixels[pixel]>=0)

ReleasePen(GFX_Display->ViewPort.ColorMap,SDL_XPixels[pixel]);

}

}

}

free(SDL_XPixels);

SDL_XPixels = NULL;

}

}

}

static void CGX_SetSizeHints(_THIS, int w, int h, Uint32 flags)

{

if ( flags & SDL_RESIZABLE ) {

WindowLimits(SDL_Window, 32, 32,4096,4096);

} else {

WindowLimits(SDL_Window, w,h,w,h);

}

if ( flags & SDL_FULLSCREEN ) {

flags&=~SDL_RESIZABLE;

} else if ( getenv("SDL_VIDEO_CENTERED") ) {

int display_w, display_h;

display_w = SDL_Display->Width;

display_h = SDL_Display->Height;

ChangeWindowBox(SDL_Window,(display_w - w - SDL_Window->BorderLeft-SDL_Window->BorderRight)/2,

(display_h - h - SDL_Window->BorderTop-SDL_Window->BorderBottom)/2,

w+SDL_Window->BorderLeft+SDL_Window->BorderRight,

h+SDL_Window->BorderTop+SDL_Window->BorderBottom);

}

}

int CGX_CreateWindow(_THIS, SDL_Surface *screen,

int w, int h, int bpp, Uint32 flags)

{

#if 0

int i, depth;

Uint32 vis;

#endif

/* If a window is already present, destroy it and start fresh */

if ( SDL_Window ) {

CGX_DestroyWindow(this, screen);

}

/* See if we have been given a window id */

if ( SDL_windowid ) {

SDL_Window = (struct Window *)atol(SDL_windowid);

} else {

SDL_Window = 0;

}

/* find out which visual we are going to use */

#if 0

/* questo l'ho spostato nell'apertura dello schermo, in quanto su Amiga le finestre

hanno il pixel mode degli schermi.

*/

if ( flags & SDL_OPENGL ) {

SDL_SetError("OpenGL not supported by the Amiga SDL!");

return -1;

}

else {

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

if ( this->hidden->visuals[i].depth == bpp ) /* era .depth */

break;

}

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

SDL_SetError("No matching visual for requested depth");

return -1; /* should never happen */

}

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

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

}

SDL_Visual = vis;

this->hidden->depth = depth;

D(bug("Setto la profiondita' dello schermo a: %ld\n",this->hidden->depth));

#endif

/* Allocate the new pixel format for this video mode */

{

Uint32 form;

APTR handle;

struct DisplayInfo info;

if(!(handle=FindDisplayInfo(SDL_Visual)))

return -1;

if(!GetDisplayInfoData(handle,(char *)&info,sizeof(struct DisplayInfo),DTAG_DISP,NULL))

return -1;

form=GetCyberIDAttr(CYBRIDATTR_PIXFMT,SDL_Visual);

if(flags&SDL_HWSURFACE)

{

if(bpp!=this->hidden->depth)

{

bpp=this->hidden->depth;

D(bug("Accel forces bpp to be equal (%ld)\n",bpp));

}

}

D(bug("BEFORE screen allocation: bpp:%ld (real:%ld)\n",bpp,this->hidden->depth));

/* With this call if needed I'll revert the wanted bpp to a bpp best suited for the display, actually occurs

only with requested format 15/16bit and display format != 15/16bit

*/

if ( ! SDL_ReallocFormat(screen, bpp,

MakeBitMask(this,0,form,&bpp), MakeBitMask(this,1,form,&bpp), MakeBitMask(this,2,form,&bpp), 0) )

return -1;

D(bug("AFTER screen allocation: bpp:%ld (real:%ld)\n",bpp,this->hidden->depth));

}

/* Create the appropriate colormap */

/*

if ( SDL_XColorMap != SDL_DisplayColormap ) {

XFreeColormap(SDL_Display, SDL_XColorMap);

}

*/

if ( GetCyberMapAttr(SDL_Display->RastPort.BitMap,CYBRMATTR_PIXFMT)==PIXFMT_LUT8 || bpp==8 ) {

int ncolors;

D(bug("Alloco XPixels x la palette...\n"));

/* Allocate the pixel flags */

if(bpp==8)

ncolors=256;

else

ncolors = 1 << screen->format->BitsPerPixel;

SDL_XPixels = (Sint32 *)malloc(ncolors * sizeof(Sint32));

if(SDL_XPixels == NULL) {

SDL_OutOfMemory();

return -1;

}

memset(SDL_XPixels, -1, ncolors * sizeof(Sint32));

/* always allocate a private colormap on non-default visuals */

if(bpp==8)

flags |= SDL_HWPALETTE;

if ( flags & SDL_HWPALETTE ) {

screen->flags |= SDL_HWPALETTE;

/*

SDL_XColorMap = XCreateColormap(SDL_Display, SDL_Root,

SDL_Visual, AllocAll);

*/

} else {

/*

SDL_XColorMap = SDL_DisplayColormap;

*/

} else {

/*

SDL_XColorMap = XCreateColormap(SDL_Display, SDL_Root,

SDL_Visual, AllocNone);

*/

}

/* Recreate the auxiliary windows, if needed (required for GL) */

/*

if ( vis_change )

create_aux_windows(this);

*/

/* resize the (possibly new) window manager window */

/* Create (or use) the X11 display window */

if ( !SDL_windowid ) {

if ( flags & SDL_OPENGL ) {

return(-1);

}

else

{

if(flags & SDL_FULLSCREEN)

{

SDL_Window = OpenWindowTags(NULL,WA_Width,w,WA_Height,h,

WA_Flags,WFLG_ACTIVATE|WFLG_RMBTRAP|WFLG_BORDERLESS|WFLG_BACKDROP|WFLG_REPORTMOUSE,

WA_IDCMP,IDCMP_RAWKEY|IDCMP_MOUSEBUTTONS|IDCMP_MOUSEMOVE,

WA_CustomScreen,(ULONG)SDL_Display,

TAG_DONE);

D(bug("Apro finestra backdrop %ldx%ld su %lx!\n",w,h,SDL_Display));

}

else

{

SDL_Window = OpenWindowTags(NULL,WA_InnerWidth,w,WA_InnerHeight,h,

WA_Flags,WFLG_REPORTMOUSE|WFLG_ACTIVATE|WFLG_RMBTRAP | ((flags&SDL_NOFRAME) ? 0 : (WFLG_DEPTHGADGET|WFLG_CLOSEGADGET|WFLG_DRAGBAR | ((flags&SDL_RESIZABLE) ? WFLG_SIZEGADGET|WFLG_SIZEBBOTTOM : 0))),

WA_IDCMP,IDCMP_RAWKEY|IDCMP_CLOSEWINDOW|IDCMP_MOUSEBUTTONS|IDCMP_NEWSIZE|IDCMP_MOUSEMOVE,

WA_PubScreen,(ULONG)SDL_Display,

TAG_DONE);

D(bug("Apro finestra %ldx%ld sul wb!\n",w,h));

}

}

/* Only manage our input if we own the window */

/*

XSelectInput(SDL_Display, SDL_Window,

( EnterWindowMask | LeaveWindowMask

| ButtonPressMask | ButtonReleaseMask

| PointerMotionMask | ExposureMask ));

*/

if(!SDL_Window)

return -1;

}

this->hidden->BytesPerPixel=GetCyberMapAttr(SDL_Window->RPort->BitMap,CYBRMATTR_BPPIX);

if(screen->flags & SDL_DOUBLEBUF)

{

if(SDL_RastPort=malloc(sizeof(struct RastPort)))

{

InitRastPort(SDL_RastPort);

SDL_RastPort->BitMap=this->hidden->SB[1]->sb_BitMap;

}

else

return -1;

}

else SDL_RastPort=SDL_Window->RPort;

#if 0

if(screen->flags & SDL_HWPALETTE) {

/* Since the full-screen window might have got a nonzero background

colour (0 is white on some displays), we should reset the

background to 0 here since that is what the user expects

with a private colormap */

SetAPen(SDL_Window->RPort,0);

RectFill(SDL_Window->RPort,SDL_Window->BorderLeft,SDL_Window->BorderTop,w+SDL_Window->BorderLeft,h+SDL_Window->BorderTop);

}

#endif

if(flags&SDL_HWSURFACE)

screen->flags|=SDL_HWSURFACE;

if( !SDL_windowid ) {

CGX_SetSizeHints(this, w, h, flags);

current_w = w;

current_h = h;

}

/* Set our colormaps when not setting a GL mode */

/*

if ( ! (flags & SDL_OPENGL) ) {

XSetWindowColormap(SDL_Display, SDL_Window, SDL_XColorMap);

}

*/

/* Map them both and go fullscreen, if requested */

if ( ! SDL_windowid ) {

if ( flags & SDL_FULLSCREEN ) {

screen->flags |= SDL_FULLSCREEN;

currently_fullscreen=1;

// CGX_EnterFullScreen(this); Ci siamo gia'!

} else {

screen->flags &= ~SDL_FULLSCREEN;

}

screen->w = w;

screen->h = h;

screen->pitch = SDL_CalculatePitch(screen);

CGX_ResizeImage(this, screen, flags);

return(0);

}

int CGX_ResizeWindow(_THIS,

SDL_Surface *screen, int w, int h, Uint32 flags)

{

if ( ! SDL_windowid ) {

/* Resize the window manager window */

CGX_SetSizeHints(this, w, h, flags);

current_w = w;

current_h = h;

ChangeWindowBox(SDL_Window,SDL_Window->LeftEdge,SDL_Window->TopEdge, w+SDL_Window->BorderLeft+SDL_Window->BorderRight,

h+SDL_Window->BorderTop+SDL_Window->BorderBottom);

/* Resize the fullscreen and display windows */

/*

if ( flags & SDL_FULLSCREEN ) {

if ( screen->flags & SDL_FULLSCREEN ) {

CGX_ResizeFullScreen(this);

} else {

screen->flags |= SDL_FULLSCREEN;

CGX_EnterFullScreen(this);

}

if ( screen->flags & SDL_FULLSCREEN ) {

screen->flags &= ~SDL_FULLSCREEN;

CGX_LeaveFullScreen(this);

}

*/

screen->w = w;

screen->h = h;

screen->pitch = SDL_CalculatePitch(screen);

CGX_ResizeImage(this, screen, flags);

}

return(0);

}

static SDL_Surface *CGX_SetVideoMode(_THIS, SDL_Surface *current,

int width, int height, int bpp, Uint32 flags)

{

Uint32 saved_flags;

/* Lock the event thread, in multi-threading environments */

SDL_Lock_EventThread();

// Check if the window needs to be closed or can be resized

if( (flags&SDL_FULLSCREEN) || (current->flags&SDL_FULLSCREEN && !(flags&SDL_FULLSCREEN)))

needcreate=1;

// Check if we need to close an already existing videomode...

if(current->flags&SDL_FULLSCREEN && !(flags&SDL_FULLSCREEN))

{

CGX_DestroyImage(this,current);

CGX_DestroyWindow(this,current);

DestroyScreen(this);

D(bug("Distrutte immagine, finestra e schermo!\n"));

GFX_Display=SDL_Display=LockPubScreen(NULL);

bpp=this->hidden->depth=GetCyberMapAttr(SDL_Display->RastPort.BitMap,CYBRMATTR_DEPTH);

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

if ( this->hidden->visuals[i].depth == bpp ) /* era .depth */

break;

}