/*

SDL - Simple DirectMedia Layer

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

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

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

/*

* CGX based SDL video driver implementation by Gabriele Greco

* gabriele.greco@aruba.it

*/

#include "SDL_timer.h"

#include "SDL_thread.h"

#include "SDL_video.h"

#include "SDL_mouse.h"

#include "../SDL_sysvideo.h"

#include "../SDL_pixels_c.h"

#include "../../events/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"

/* 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 int CGX_SetColors (_THIS, int firstcolor, int ncolors,

SDL_Color * colors);

static void CGX_VideoQuit (_THIS);

/* CGX driver bootstrap functions */

struct Library *CyberGfxBase = NULL;

struct IntuitionBase *IntuitionBase = NULL;

struct GfxBase *GfxBase = NULL;

int

CGX_SetGamma (_THIS, float red, float green, float blue)

return -1;

}

int

CGX_GetGamma (_THIS, float red, float green, float blue)

return -1;

}

int

CGX_SetGammaRamp (_THIS, Uint16 * ramp)

{

#if 0

Int i, ncolors;

XColor xcmap[256];

/* See if actually setting the gamma is supported */

if (SDL_Visual->class != DirectColor) {

SDL_SetError ("Gamma correction not supported on this visual");

return (-1);

}

/* Calculate the appropriate palette for the given gamma ramp */

ncolors = SDL_Visual->map_entries;

for (i = 0; i < ncolors; ++i) {

Uint8 c = (256 * i / ncolors);

xcmap[i].pixel = SDL_MapRGB (this->screen->format, c, c, c);

xcmap[i].red = ramp[0 * 256 + c];

xcmap[i].green = ramp[1 * 256 + c];

xcmap[i].blue = ramp[2 * 256 + c];

xcmap[i].flags = (DoRed | DoGreen | DoBlue);

}

XStoreColors (GFX_Display, SDL_XColorMap, xcmap, ncolors);

XSync (GFX_Display, False);

return (0);

#else

SDL_SetError ("Gamma correction not supported on this visual");

return (-1);

#endif

}

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[1]);

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

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

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

if (SDL_RastPort && SDL_RastPort != &SDL_Display->RastPort)

SDL_free (SDL_RastPort);

SDL_RastPort = NULL;

}

CloseScreen (GFX_Display);

currently_fullscreen = 0;

} else if (GFX_Display)

UnlockPubScreen (NULL, GFX_Display);

GFX_Display = NULL;

}

static int

CGX_Available (void)

if (l != NULL) {

D (bug ("CGX video device AVAILABLE\n"));

CloseLibrary (l);

}

D (

else

bug ("**CGX video device UNAVAILABLE\n"));

}

static void

CGX_DeleteDevice (SDL_VideoDevice * device)

if (device) {

if (device->hidden) {

SDL_free (device->hidden);

}

if (device->gl_data) {

SDL_free (device->gl_data);

}

SDL_free (device);

}

}

static SDL_VideoDevice *

CGX_CreateDevice (int devindex)

SDL_VideoDevice *device;

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

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

if (device) {

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

device->hidden = (struct SDL_PrivateVideoData *)

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

device->gl_data = (struct SDL_PrivateGLData *)

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

}

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

(device->gl_data == NULL)) {

D (bug ("Unable to create video device!\n"));

SDL_OutOfMemory ();

CGX_DeleteDevice (device);

return (0);

}

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

SDL_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;

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;

device->SetGamma = CGX_SetGamma;

device->GetGamma = CGX_GetGamma;

device->SetGammaRamp = CGX_SetGammaRamp;

device->GetGammaRamp = NULL;

device->GL_LoadLibrary = CGX_GL_LoadLibrary;

device->GL_GetProcAddress = CGX_GL_GetProcAddress;

device->GL_GetAttribute = CGX_GL_GetAttribute;

device->GL_MakeCurrent = CGX_GL_MakeCurrent;

device->GL_SwapBuffers = CGX_GL_SwapBuffers;

device->SetIcon = CGX_SetIcon;

device->SetCaption = CGX_SetCaption;

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 = {

};

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"));

return 0;

}

}

return 0;

}

static int

CGX_VideoInit (_THIS, SDL_PixelFormat * vformat)

int i;

struct Library *RTGBase;

D (bug ("VideoInit... Opening libraries\n"));

if (!IntuitionBase) {

if (!

(IntuitionBase =

(struct IntuitionBase *) OpenLibrary ("intuition.library",

39L))) {

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

return -1;

}

}

if (!GfxBase) {

if (!

(GfxBase =

(struct GfxBase *) OpenLibrary ("graphics.library", 39L))) {

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

return -1;

}

}

if (!CyberGfxBase) {

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

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

return (-1);

}

}

if (RTGBase = OpenLibrary ("libs:picasso96/rtg.library", 0L)) {

extern int use_picasso96;

CloseLibrary (RTGBase);

use_picasso96 = 1;

}

D (bug ("Library intialized, locking screen...\n"));

SDL_Display = LockPubScreen (NULL);

if (SDL_Display == NULL) {

D (bug ("Cannot lock display...\n"));

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

return (-1);

}

this->info.current_w = SDL_Display->Width;

this->info.current_h = SDL_Display->Height;

D (bug ("Checking if we are using a CGX native display...\n"));

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

Uint32 okid =

BestCModeIDTags (CYBRBIDTG_NominalWidth, SDL_Display->Width,

CYBRBIDTG_NominalHeight, SDL_Display->Height,

CYBRBIDTG_Depth, 8,

TAG_DONE);

D (bug ("Default visual is not CGX native!\n"));

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;

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

D (bug ("Init: Setting screen depth to: %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))) {

D (bug ("Unable to get visual info...\n"));

return -1;

}

if (!GetDisplayInfoData

(handle, (char *) &info, sizeof (struct DisplayInfo), DTAG_DISP,

NULL)) {

D (bug ("Unable to get visual info data...\n"));

return -1;

}

// 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 */

/* 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! */

D (bug ("End of CGX_VideoInit\n"));

}

void

CGX_DestroyWindow (_THIS, SDL_Surface * screen)

D (bug ("Destroy Window...\n"));

if (!SDL_windowid) {

/* Hide the managed window */

int was_fullscreen = 0;

/* Clean up OpenGL */

if (screen) {

screen->flags &= ~SDL_INTERNALOPENGL;

}

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;

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

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

if (SDL_XPixels[pixel] >= 0)

ReleasePen (GFX_Display->ViewPort.

ColorMap, SDL_XPixels[pixel]);

}

}

}

SDL_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 (SDL_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;

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

}

#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_INTERNALOPENGL ) {

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 ("Setting screen depth to: %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;

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));

/*

if ( SDL_XColorMap != SDL_DisplayColormap ) {

XFreeColormap(SDL_Display, SDL_XColorMap);

}

*/

if (GetCyberMapAttr (SDL_Display->RastPort.BitMap, CYBRMATTR_PIXFMT) ==

PIXFMT_LUT8 || bpp == 8) {

int ncolors, i;

D (bug ("XPixels palette allocation...\n"));

/* Allocate the pixel flags */

if (bpp == 8)

ncolors = 256;

else

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

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

if (SDL_XPixels == NULL) {

SDL_OutOfMemory ();

return -1;

}

for (i = 0; i < ncolors; i++)

SDL_XPixels[i] = -1;

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

if (bpp == 8)

flags |= SDL_HWPALETTE;

if (flags & SDL_HWPALETTE)

screen->flags |= SDL_HWPALETTE;

}

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

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

if (!SDL_windowid) {

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

("Opening backdrop window %ldx%ld on display %lx!\n", w, h,

SDL_Display));

} else {

/* Create GimmeZeroZero window when OpenGL is used */

unsigned long gzz = FALSE;

if (flags & SDL_INTERNALOPENGL) {

gzz = TRUE;

}

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, WA_GimmeZeroZero,

gzz, TAG_DONE);

D (bug ("Opening WB window of size: %ldx%ld!\n", w, h));

}

if (!SDL_Window)

return -1;

}

this->hidden->BytesPerPixel =

GetCyberMapAttr (SDL_Window->RPort->BitMap, CYBRMATTR_BPPIX);

if (screen->flags & SDL_DOUBLEBUF) {

if (SDL_RastPort = SDL_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 (flags & SDL_HWSURFACE)

screen->flags |= SDL_HWSURFACE;

if (!SDL_windowid) {

CGX_SetSizeHints (this, w, h, flags);

}

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

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);

/* Make OpenGL Context if needed */

if (flags & SDL_INTERNALOPENGL) {

if (this->gl_data->gl_active == 0) {

if (CGX_GL_Init (this) < 0)

return -1;

else

screen->flags |= SDL_INTERNALOPENGL;

} else {

if (CGX_GL_Update (this) < 0)

return -1;

else

screen->flags |= SDL_INTERNALOPENGL;

}

}

}

int

CGX_ResizeWindow (_THIS, SDL_Surface * screen, int w, int h, Uint32 flags)

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

if (!SDL_windowid) {

/* Resize the window manager window */

CGX_SetSizeHints (this, w, h, flags);

ChangeWindowBox (SDL_Window, SDL_Window->LeftEdge,

SDL_Window->TopEdge,

w + SDL_Window->BorderLeft +

SDL_Window->BorderRight,

h + SDL_Window->BorderTop +

SDL_Window->BorderBottom);

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;

int needcreate = 0;

/* 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 && current->flags & SDL_FULLSCREEN

&& !(flags & SDL_FULLSCREEN)))

needcreate = 1;