// Emacs style mode select   -*- C++ -*- 
//-----------------------------------------------------------------------------
//
// $Id:$
//
// Copyright (C) 1993-1996 by id Software, Inc.
//
// This source is available for distribution and/or modification
// only under the terms of the DOOM Source Code License as
// published by id Software. All rights reserved.
//
// The source is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
// for more details.
//
// $Log:$
//
// DESCRIPTION:
//	DOOM graphics stuff for SDL library
//
//-----------------------------------------------------------------------------

static const char
rcsid[] = "$Id: i_x.c,v 1.6 1997/02/03 22:45:10 b1 Exp $";

#include <stdlib.h>

//#include "SDL.h"

//#include "m_swap.h"
#include "doomstat.h"
#include "i_system.h"
#include "v_video.h"
#include "m_argv.h"
#include "d_main.h"

#include "doomdef.h"
#define WIN32_LEAN_AND_MEAN
#include <windows.h>

typedef struct SURFACE
{
	int w, h;		
	int pitch;		
	unsigned char *pixels;	
	int offset;		
} SURFACE;
 
SURFACE screen;

// Fake mouse handling.
boolean		grabMouse;

// Blocky mode,
// replace each 320x200 pixel with multiply*multiply pixels.
// According to Dave Taylor, it still is a bonehead thing
// to use ....
static int	multiply=2;

void WinError(char *msg);


int BPP;
byte *hicolortable;
short hicolortransmask1,hicolortransmask2;
int		X_width;
int		X_height;
static int disableVerticalMouse = 0;
static int closed=0;
static int windowActive = 0;

HWND win;
static HINSTANCE inst;
static HDC dibDC;
static LOGPALETTE *palette;
static HPALETTE dibPal;
BITMAPINFO *bminfo;
static unsigned char *dibData;
static int bits8;
int palette_color[256];


static int	lastmousex = 0;
static int	lastmousey = 0;
boolean		mousemoved = false;
boolean		shmFinished;



//
//  Translates the key 
//

/*******
int xlatekey(SDL_keysym *key)
{

    int rc;

    switch(key->sym)
    {
      case SDLK_LEFT:	rc = KEY_LEFTARROW;	break;
      case SDLK_RIGHT:	rc = KEY_RIGHTARROW;	break;
      case SDLK_DOWN:	rc = KEY_DOWNARROW;	break;
      case SDLK_UP:	rc = KEY_UPARROW;	break;
      case SDLK_ESCAPE:	rc = KEY_ESCAPE;	break;
      case SDLK_RETURN:	rc = KEY_ENTER;		break;
      case SDLK_TAB:	rc = KEY_TAB;		break;
      case SDLK_F1:	rc = KEY_F1;		break;
      case SDLK_F2:	rc = KEY_F2;		break;
      case SDLK_F3:	rc = KEY_F3;		break;
      case SDLK_F4:	rc = KEY_F4;		break;
      case SDLK_F5:	rc = KEY_F5;		break;
      case SDLK_F6:	rc = KEY_F6;		break;
      case SDLK_F7:	rc = KEY_F7;		break;
      case SDLK_F8:	rc = KEY_F8;		break;
      case SDLK_F9:	rc = KEY_F9;		break;
      case SDLK_F10:	rc = KEY_F10;		break;
      case SDLK_F11:	rc = KEY_F11;		break;
      case SDLK_F12:	rc = KEY_F12;		break;
	
      case SDLK_BACKSPACE:
      case SDLK_DELETE:	rc = KEY_BACKSPACE;	break;

      case SDLK_PAUSE:	rc = KEY_PAUSE;		break;

      case SDLK_EQUALS:	rc = KEY_EQUALS;	break;

      case SDLK_KP_MINUS:
      case SDLK_MINUS:	rc = KEY_MINUS;		break;

      case SDLK_LSHIFT:
      case SDLK_RSHIFT:
	rc = KEY_RSHIFT;
	break;
	
      case 'z':
      case SDLK_LCTRL:
      case SDLK_RCTRL:
	rc = KEY_RCTRL;
	break;
	
      case SDLK_LALT:
      case SDLK_LMETA:
      case SDLK_RALT:
      case SDLK_RMETA:
	rc = KEY_RALT;
	break;
	
      default:
        rc = key->sym;
	break;
    }

    return rc;

}
**********/

void I_ShutdownGraphics(void)
{
 // SDL_Quit();
}



//
// I_StartFrame
//
void I_StartFrame (void)
{
    // er?

}

/* This processes SDL events */
/*****
void I_GetEvent(SDL_Event *Event)
{
    Uint8 buttonstate;
    event_t event;

    switch (Event->type)
    {
      case SDL_KEYDOWN:
	event.type = ev_keydown;
	event.data1 = xlatekey(&Event->key.keysym);
	D_PostEvent(&event);
        break;
      case SDL_KEYUP:
	event.type = ev_keyup;
	event.data1 = xlatekey(&Event->key.keysym);
	D_PostEvent(&event);
	break;
      case SDL_QUIT:
	I_Quit();
	break;
    }
}

*******/




void I_GetEvent(void)
{
    MSG msg;
    POINT point;
    static LONG prevX, prevY;
    static int hadMouse = 0;
    event_t event;
    RECT rect;
    int lb, rb;
    static int prevlb = 0, prevrb = 0;
    
    /* Dispatch all messages: */
    while ( PeekMessage(&msg, NULL, 0, 0xFFFFFFFF, PM_REMOVE) )
    {
        TranslateMessage (&msg) ;
        DispatchMessage (&msg) ;
    }

    /* Check mouse and generate events if necessary: */
    if ( !GetCursorPos(&point) )
        WinError("GetCursorPos() failed");
    if ( hadMouse && windowActive)
    {
        lb = (GetAsyncKeyState(VK_LBUTTON) < 0);
        rb = (GetAsyncKeyState(VK_RBUTTON) < 0);
            
        if ( (prevX != point.x) || (prevY != point.y) ||
             (prevlb != lb) || (prevrb != rb) )
        {
            event.type = ev_mouse;
            event.data1 = lb | (rb << 1);
            event.data2 = (point.x - prevX)*9;
            if ( disableVerticalMouse )
                event.data3 = 0;
            else
                event.data3 = (prevY - point.y)*9;
            prevX = point.x;
            prevY = point.y;
            prevlb = lb;
            prevrb = rb;
            D_PostEvent(&event);
        }

        if ( grabMouse )
        {
            GetWindowRect(win, &rect);
            if ( !SetCursorPos((rect.left + rect.right) / 2,
                               (rect.top + rect.bottom) / 2) )
                WinError("SetCursorPos() failed");
            prevX = (rect.left + rect.right) / 2;
            prevY = (rect.top + rect.bottom) / 2;
        }
    }
    else
    {
        prevX = point.x;
        prevY = point.y;
        hadMouse = 1;
    }        
}



//
// I_StartTic
//
void I_StartTic (void)
{
//    SDL_Event Event;

//    while ( SDL_PollEvent(&Event) )
//	I_GetEvent(&Event);
    I_GetEvent();

}


//
// I_UpdateNoBlit
//
void I_UpdateNoBlit (void)
{
    // what is this?
}

//
// I_ReadScreen
//
void I_ReadScreen (byte* scr)
{
    memcpy (scr, screens[0], SCREENWIDTH*SCREENHEIGHT);
}


//
// I_SetPalette
//

typedef struct SDL_Color
{
	byte r;
	byte g;
	byte b;
	byte unused;
} SDL_Color; 

SDL_Color colors[256];

void I_SetPalette (byte* palette)
{
    int i;
    RGBQUAD *rgb;

// 
//    for ( i=0; i<256; ++i ) {
//	colors[i].r = gammatable[usegamma][*palette++];
//	colors[i].g = gammatable[usegamma][*palette++];
//	colors[i].b = gammatable[usegamma][*palette++];
//	colors[i].unused = 0;
//    }
//    SDL_SetColors(screen, colors, 0, 256);

    rgb = bminfo->bmiColors;
    for ( i = 0; i < 256; i++ )
    {
      rgb->rgbRed = gammatable[usegamma][*palette++];
      rgb->rgbGreen = gammatable[usegamma][*palette++];
      rgb->rgbBlue = gammatable[usegamma][*palette++];
      rgb->rgbReserved = 0;
      rgb++;
    };


}



int makecol(int r, int g, int b)
{
  //  assert(BPP==2);
    return (b >> 3) | ((g >> 3) << 5) | ((r >> 3) << 10);
}

int TranslateKey(unsigned k)
{
/*wtf?    if ( (k >= VK_0) && (k <= VK_9) )*/
    if ( (k >= 0x30) && (k <= 0x39) )
        return (k - 0x30 + '0');
    if ( (k >= 0x41) && (k <= 0x5a) )
        return (k - 0x41 + 'a');

#define K(a,b) case a: return b;    
    switch ( k )
    {
        K(VK_LEFT, KEY_LEFTARROW);
        K(VK_RIGHT, KEY_RIGHTARROW);
        K(VK_UP, KEY_UPARROW);
        K(VK_DOWN, KEY_DOWNARROW);
        K(VK_BACK, KEY_BACKSPACE);
        K(VK_TAB, KEY_TAB);
        K(VK_RETURN, KEY_ENTER);
        K(VK_SHIFT, KEY_RSHIFT);
        K(VK_CONTROL, KEY_RCTRL);
        K(VK_MENU, KEY_RALT);
        K(VK_PAUSE, KEY_PAUSE);
        K(VK_ESCAPE, KEY_ESCAPE);
        K(VK_SPACE, ' ');
        K(VK_DELETE, KEY_BACKSPACE);
        K(VK_ADD, '+');
        K(VK_SUBTRACT, KEY_MINUS);
        K(0xBC, ',');
        K(0xBE, '.');
        K(VK_F1, KEY_F1);
        K(VK_F2, KEY_F2);
        K(VK_F3, KEY_F3);
        K(VK_F4, KEY_F4);
        K(VK_F5, KEY_F5);
        K(VK_F6, KEY_F6);
        K(VK_F7, KEY_F7);
        K(VK_F8, KEY_F8);
        K(VK_F9, KEY_F9);
        K(VK_F10, KEY_F10);
        K(VK_F11, KEY_F11);
        K(VK_F12, KEY_F12);
    }

    return 0;
}

void WinError(char *msg)
{
    printf("Windows Error: %s, GetLastError(): %u\n", msg, GetLastError());
    exit(EXIT_FAILURE);
}

static LRESULT CALLBACK WndProc(HWND hwnd, UINT message,
                                WPARAM wparam, LPARAM lparam);

void BlitDIB(void)
{
    RECT rect;

    GetClientRect(win, &rect);
    if ( StretchDIBits(dibDC, rect.left, rect.top, rect.right-rect.left,
                       rect.bottom-rect.top, 0, 0, SCREENWIDTH*2,
                       SCREENHEIGHT*2, dibData, bminfo, DIB_RGB_COLORS,
                         SRCCOPY)
             == GDI_ERROR )
          WinError("StrecthDIBits failed");
        
    GdiFlush();    
}
 

void I_InitGraphics(void)
{
    static int firsttime=1;
    
    WNDCLASS wc;
    unsigned i, x, y, j;
    WORD *d;
    unsigned char *b;
    int bits;
    int frameX, frameY, capY;
    RECT rect;
    int width, height;
    RGBQUAD *rgb;
    int retval;

    if (!firsttime)
	return;
    firsttime = 0;

    if (M_CheckParm("-2"))
	multiply = 2;

    if (M_CheckParm("-3"))
	multiply = 3;

    if (M_CheckParm("-4"))
	multiply = 4;

    X_width = SCREENWIDTH * multiply;
    X_height = SCREENHEIGHT * multiply;

    // check if the user wants to grab the mouse (quite unnice)
    grabMouse = !!M_CheckParm("-grabmouse");

    /* [Petteri] New: Option to disable mouse vertical movement - useful
       for players used to Quake: */
    disableVerticalMouse = !!M_CheckParm("-novertmouse");

    /* Build and initialize the window: */
    
    inst = (HINSTANCE) GetModuleHandle(NULL);

    frameX = GetSystemMetrics(SM_CXFRAME);
    frameY = GetSystemMetrics(SM_CYFRAME);
    capY = GetSystemMetrics(SM_CYCAPTION);

    wc.style = CS_HREDRAW | CS_VREDRAW;
    wc.lpfnWndProc = WndProc;
    wc.cbClsExtra = 0;
    wc.cbWndExtra = 0;
    wc.hInstance = inst;
    wc.hIcon = NULL;
    if ( grabMouse )
        wc.hCursor = LoadCursor( 0, IDC_ARROW );
    else
        wc.hCursor = LoadCursor( 0, IDC_ARROW );
    /*wc.hbrBackground = GetStockObject( WHITE_BRUSH );*/
    wc.hbrBackground = NULL;    
    wc.lpszMenuName = NULL;
    wc.lpszClassName = "DoomWindowClass";

    retval= RegisterClass(&wc);

    width = X_width + 2*frameX;
    height = X_height + 2*frameY + capY;

    win = CreateWindow("DoomWindowClass", "NTDOOM",
                       WS_OVERLAPPEDWINDOW | WS_VISIBLE, 200, 200, width, height,
                       NULL, NULL, inst, NULL);

    /* Display the window: */
    ShowWindow(win, SW_SHOW);
    UpdateWindow(win);

    GetClientRect(win, &rect);
    printf("I_InitGraphics: Client area: %ux%u\n",
            rect.right-rect.left, rect.bottom-rect.top);

    if ( (rect.right-rect.left) != X_width )
    {
        printf("I_InitGraphics: Fixing width\n");
        width += X_width - (rect.right-rect.left);
        MoveWindow(win, 0, 0, width, height, TRUE);
    }
    if ( (rect.bottom-rect.top) != X_height )
    {
        printf("I_InitGraphics: Fixing height\n");
        height += X_height - (rect.bottom-rect.top);
        MoveWindow(win, 0, 0, width, height, TRUE);
    }

    GetClientRect(win, &rect);
    printf("I_InitGraphics: Client area: %ux%u\n",
            rect.right-rect.left, rect.bottom-rect.top);    
        
    dibDC = GetDC(win);
    BPP=1;
    bits = 8; //GetDeviceCaps(dibDC, BITSPIXEL);
    printf("I_InitGraphics: %i bpp screen\n", bits);

    if ( BPP == 1 )
        bminfo = malloc(sizeof(BITMAPINFOHEADER) + 4*256);
    else
        bminfo = malloc(sizeof(BITMAPINFOHEADER));
        

    if ( BPP == 1 )
    {
       rgb = bminfo->bmiColors;
       for ( i = 0; i < 256; i++ )
       {
          rgb->rgbRed = i;
          rgb->rgbGreen = i;
          rgb->rgbBlue = i;
          rgb->rgbReserved = 0;
          rgb++;
       }
    }
    
    bminfo->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
    bminfo->bmiHeader.biWidth = 640; X_width;
    bminfo->bmiHeader.biHeight = -400 ;X_height;
    bminfo->bmiHeader.biPlanes = 1;
    if ( BPP == 1 )
        bminfo->bmiHeader.biBitCount = 8;
    else
        bminfo->bmiHeader.biBitCount = 16;
    bminfo->bmiHeader.biCompression = BI_RGB;
    bminfo->bmiHeader.biSizeImage = 0;
    bminfo->bmiHeader.biXPelsPerMeter = 0;
    bminfo->bmiHeader.biYPelsPerMeter = 0;
    bminfo->bmiHeader.biClrUsed = 0;
    bminfo->bmiHeader.biClrImportant = 0;
    
    dibData = malloc(640*400*BPP);

//    BlitDIB();

    screen.pixels=(unsigned char *) (dibData);
    screen.h=400;
    screen.w=640;
    screen.pitch=640;
       
  //  screens[0] = malloc(320*200);

    /* Build magic highcolor table: */
    if (BPP==2)
    {
        byte *tempptr, *tempptr2;

        tempptr=hicolortable=(byte *)malloc(256*32*9);
        
        for (i=0;i<32;i++)
        {
            for (j=0;j<256;j++)
            {
                *tempptr=j*gammatable[3][i*(256/32)]/256;
                tempptr++;
            }
        }
        for (i=1;i<=8;i++)
        {
            tempptr2=hicolortable;
            for (j=0;j<(256*32);j++)
            {
                *tempptr=(byte)(((int)(*tempptr2))*(8-i)/8);
                tempptr++; tempptr2++;
            }
        }
        hicolortransmask1=makecol(127,127,127);
        hicolortransmask2=makecol(63,63,63);
    }    
}

static LRESULT CALLBACK WndProc(HWND hwnd, UINT message,
                                WPARAM wparam, LPARAM lparam)
{
    event_t event;
    RECT rect;
    
    switch ( message )
    {        
        case WM_DESTROY:
            if ( grabMouse )
            {
                ClipCursor(NULL);
                ShowCursor(TRUE);
            }
            printf("WM_DESTROY\n");
            PostQuitMessage(0);
            closed = 1;
            break;

        case WM_MOVE:
            GetWindowRect(win, &rect);
            printf("%u,%u - %u, %u\n",
                    rect.left,rect.top,rect.right,rect.bottom);
            ClipCursor(&rect);
            break;

        case WM_ACTIVATE:
            printf("WM_ACTIVATE %u\n", (unsigned) LOWORD(wparam));
            if ( LOWORD(wparam) )
            {
                if ( !windowActive )
                {
                    if ( grabMouse )
                    {
                        ClipCursor(NULL); /* helps with Win95? */
                        GetWindowRect(win, &rect);
                        printf("%u,%u - %u, %u\n",
                                rect.left,rect.top,rect.right,rect.bottom);
                        ClipCursor(&rect);
                        ShowCursor(FALSE);
                    }                    
                }
                windowActive = 1;
                if ( bits8 )
                {
                    if ( SetPaletteEntries(dibPal, 0, 256, palette->palPalEntry) != 256 )
                        WinError("SetPaletteEntries failed");
                    if ( !UnrealizeObject(dibPal) )
                        WinError("UnrealizeObject failed");
                    if ( SelectPalette(dibDC, dibPal, FALSE) == NULL )
                        WinError("SelectPalette failed");
                }
            }
            else
            {
                if ( grabMouse )
                {
                    ClipCursor(NULL);
                    ShowCursor(TRUE);
                }
                windowActive = 0;
            }
            return DefWindowProc(hwnd, message, wparam, lparam);

        case WM_KEYDOWN:
            event.type = ev_keydown;
            event.data1 = TranslateKey(wparam);
            if ( event.data1 != 0 )
                D_PostEvent(&event);
            break;

        case WM_KEYUP:
            event.type = ev_keyup;
            event.data1 = TranslateKey(wparam);
            if ( event.data1 != 0 )
                D_PostEvent(&event);
            break;            
            
        default:
            return(DefWindowProc(hwnd, message, wparam, lparam));
    }

    return 0;
}

//
// I_FinishUpdate
//
void I_FinishUpdate (void)
{

    static int	lasttic;
    int		tics;
    int		i;

    // draws little dots on the bottom of the screen
    if (devparm)
    { i = I_GetTime();
	
	  tics = i - lasttic;
	  lasttic = i;
	  if (tics > 20)
	    tics = 20;

	  for (i=0 ; i<tics*2 ; i+=2)
	    screens[0][ (SCREENHEIGHT-1)*SCREENWIDTH + i] = 0xff;
	  for ( ; i<20*2 ; i+=2)
	    screens[0][ (SCREENHEIGHT-1)*SCREENWIDTH + i] = 0x0;
    }

    // scales the screen size before blitting it
    if (multiply == 1)
    {
	  unsigned char *olineptr;
	  unsigned char *ilineptr;
	  int y;

	  ilineptr = (unsigned char *) screens[0];
	  olineptr = (unsigned char *) screen.pixels;

	  y = SCREENHEIGHT;
	  while (y--)
	  {
	    memcpy(olineptr, ilineptr, screen.w);
	    ilineptr += SCREENWIDTH;
	    olineptr += screen.pitch;
	  }
    }
    else if (multiply == 2)
    {
	unsigned int *olineptrs[2];
	unsigned int *ilineptr;
	int x, y, i;
	unsigned int twoopixels;
	unsigned int twomoreopixels;
	unsigned int fouripixels;

	ilineptr = (unsigned int *) (screens[0]);
	for (i=0 ; i<2 ; i++) {
	    olineptrs[i] =
		(unsigned int *)&((byte *)screen.pixels)[i*screen.pitch];
        }

	y = SCREENHEIGHT;
	while (y--)
	{
	    x = SCREENWIDTH;
	    do
	    {
		fouripixels = *ilineptr++;
		twoopixels =	(fouripixels & 0xff000000)
		    |	((fouripixels>>8) & 0xffff00)
		    |	((fouripixels>>16) & 0xff);
		twomoreopixels =	((fouripixels<<16) & 0xff000000)
		    |	((fouripixels<<8) & 0xffff00)
		    |	(fouripixels & 0xff);
		*olineptrs[0]++ = twomoreopixels;
		*olineptrs[1]++ = twomoreopixels;
		*olineptrs[0]++ = twoopixels;
		*olineptrs[1]++ = twoopixels;
	    } while (x-=4);
	    olineptrs[0] += screen.pitch/4;
	    olineptrs[1] += screen.pitch/4;
	}

    }
    else if (multiply == 3)
    {
	unsigned int *olineptrs[3];
	unsigned int *ilineptr;
	int x, y, i;
	unsigned int fouropixels[3];
	unsigned int fouripixels;

	ilineptr = (unsigned int *) (screens[0]);
	for (i=0 ; i<3 ; i++) {
	    olineptrs[i] = 
		(unsigned int *)&((byte *)screen.pixels)[i*screen.pitch];
        }

	y = SCREENHEIGHT;
	while (y--)
	{
	    x = SCREENWIDTH;
	    do
	    {
		fouripixels = *ilineptr++;
		fouropixels[0] = (fouripixels & 0xff000000)
		    |	((fouripixels>>8) & 0xff0000)
		    |	((fouripixels>>16) & 0xffff);
		fouropixels[1] = ((fouripixels<<8) & 0xff000000)
		    |	(fouripixels & 0xffff00)
		    |	((fouripixels>>8) & 0xff);
		fouropixels[2] = ((fouripixels<<16) & 0xffff0000)
		    |	((fouripixels<<8) & 0xff00)
		    |	(fouripixels & 0xff);
		*olineptrs[0]++ = fouropixels[2];
		*olineptrs[1]++ = fouropixels[2];
		*olineptrs[2]++ = fouropixels[2];
		*olineptrs[0]++ = fouropixels[1];
		*olineptrs[1]++ = fouropixels[1];
		*olineptrs[2]++ = fouropixels[1];
		*olineptrs[0]++ = fouropixels[0];
		*olineptrs[1]++ = fouropixels[0];
		*olineptrs[2]++ = fouropixels[0];
	    } while (x-=4);
	    olineptrs[0] += 2*screen.pitch/4;
	    olineptrs[1] += 2*screen.pitch/4;
	    olineptrs[2] += 2*screen.pitch/4;
	}

    }
   BlitDIB();
}




/**
void I_InitGraphics(void)
{

    static int	firsttime=1;
    int video_w, video_h, w, h;
    byte video_bpp;
    unsigned int video_flags;

    if (!firsttime)
	return;
    firsttime = 0;

    video_flags = (SDL_SWSURFACE|SDL_HWPALETTE);
    if (!!M_CheckParm("-fullscreen"))
        video_flags |= SDL_FULLSCREEN;

    if (M_CheckParm("-2"))
	multiply = 2;

    if (M_CheckParm("-3"))
	multiply = 3;

    // check if the user wants to grab the mouse (quite unnice)
    grabMouse = !!M_CheckParm("-grabmouse");

    video_w = w = SCREENWIDTH * multiply;
    video_h = h = SCREENHEIGHT * multiply;
    video_bpp = 8;

 
    if ( multiply > 3 ) {
        I_Error("Smallest available mode (%dx%d) is too large!",
						video_w, video_h);
    }
    screen = SDL_SetVideoMode(video_w, video_h, 8, video_flags);
    if ( screen == NULL ) {
        I_Error("Could not set %dx%d video mode: %s", video_w, video_h,
							SDL_GetError());
    }
    SDL_ShowCursor(0);
    SDL_WM_SetCaption("MenuetOS-DOOM", "doom");

     w = SCREENWIDTH * multiply;
    h = SCREENHEIGHT * multiply;
    if (multiply == 1 && !SDL_MUSTLOCK(screen) ) {
	screens[0] = (unsigned char *) screen->pixels;
    } else {
	screens[0] = (unsigned char *) malloc (SCREENWIDTH * SCREENHEIGHT);
        if ( screens[0] == NULL )
            I_Error("Couldn't allocate screen memory");
    }
}
*****/