#include <QDOffscreen.h>
#include <QuickDraw.h>
#include <stdarg.h>
#if __option(profile)			// 6/15 Optional profiling support
#include <Console.h>
#include <Profile.h>
#endif
//#include <Disassembler.h>
#include <string.h>
#include <Video.h>
#include <Traps.h>
#include <Assembler.h>
#include <string.h>
#include <Dialogs.h>
#include <Appearance.h>
#include<unistd.h>
#include<Types.h>
#include<Memory.h>
#include<QuickDraw.h>
#include<Fonts.h>
#include<Events.h>
#include<Menus.h>
#include <math.h>
#include <Sound.h>
//#include <URLAccess.h>
#include<Windows.h>
#include<TextEdit.h>
#include <stdlib.h>
#include <Printing.h>
#include <ColorPicker.h>

#define ExtraMasterBlocksNeeded		2
#define	dPrefs	128
#define  iPrefFire		13
#define  iPrefThrust 	9
#define  iPrefLeft		11
#define	 iPrefRight		12
#define	 iPrefShield	10
#define	 iPrefsOk		8
#define wMain	128
#define	sIntro		1
#define sGame		2
#define sHScore		3
#define pShip		130

GammaTblPtr	newGammaTable;
GammaTblPtr	savedGammaTable;
GDHandle	mainDevice;
CTabHandle	mainDeviceColors;
VDGammaRecord	newGamma;
VDSetEntryRecord	setEntriesRec;
unsigned char	*newTable;
unsigned char	*savedTable;
VDGammaRecord	currentGamma;
GammaTblPtr	currentGammaTable;
Boolean	gammaFadedOut;
GWorldPtr		gOffScreen;		// Offscreen Drawing Area
long			gScreenRowBytes,	// RowBytes for offscreen area
				gVideoRowBytes;	// RowBytes for onscreen video
Ptr				gScreenMem,		// BaseAddr for offscreen area
				gVideoMem;		// BaseAddr for onscreen video
				Point			gCenterP,		// Center of offscreen drawing area
				gVidOffset;		// Top,Left of onscreen Play field


typedef struct {
	CWindowRecord 	theWin;
	Boolean			ownStorage;
	Boolean			floating;
	void		(*Dispose)(WindowPtr theWin);
	void		(*Update)(WindowPtr theWin);
	void		(*Activate)(WindowPtr theWin);
	void		(*HandleClick)(WindowPtr theWin, Point where);
	void		(*Draw)(WindowPtr theWin);
	void		(*Idle)(WindowPtr theWin, EventRecord *theEvent);
	void		(*ProcessKey)(EventRecord *theEvent);
	void		(*Save)(WindowPtr theWin, SFReply *itsReply);
} ObjectWindowRecord, *ObjectWindowPtr;
struct prefsRec {
	char	fireKeyByte, fireKeyBit, fireKeyCode, fireKeyAscii;
	char	thrustKeyByte, thrustKeyBit, thrustKeyCode, thrustKeyAscii;
	char	leftKeyByte, leftKeyBit, leftKeyCode, leftKeyAscii;
	char	rightKeyByte, rightKeyBit, rightKeyCode, rightKeyAscii;
	char	shieldKeyByte, shieldKeyBit, shieldKeyCode, shieldKeyAscii;
	short	soundLevel;
	Str31	userName;
	char	reserved[30];
};
short	gLastKeyCode,gLastAsciiCode;
struct dataRec {
	int		ships;
	int		level;
	int		points;
	int		shields;
};

struct gameRec {
	int		InGame;
	struct prefsRec		prefs;
	struct dataRec		data;
	int		state;
	Boolean		running;
};
struct gameRec		game;
WindowPtr theWind;

void GammaFadeOut(void);
void GammaFadeIn(void);
void doDrawWindow(void);
pascal short MyVideoStatus(short refNum, short code, Ptr param);
void MyCopyBits(void);
void DrawStatusBar(short, short);
void MyCopyRect(register Rect *r);
void doMyDraw(WindowPtr theWin);
void doInitialize (void);
void FeedbackKey(DialogPtr dp, short itemNbr, short keyCode, short asciiCode);
pascal	Boolean	RemapDialogHook(WindowPtr dp,EventRecord *ep,int *ip);
void RegisterKey(short itemNbr, short keyCode, short asciiCode);
void doEvent(EventRecord *theEvent);
void doSetKeys(void);
void doGame(void);
void doNewShip(void);
void drawship(int x1, int y1, int x2, int y2);
/*
void drawship(int x1, int y1, int x2, int y2)
{
        
        myPic = GetPicture(pShip);
        SetRect(&picRect, x1, y1, x2, y2);
        DrawPicture(myPic, &picRect);
}*/

void doNewShip (void) {
        PicHandle myPic;
        Rect    picRect;
        myPic = GetPicture(pShip);
//        SetRect(&picRect, x1, y1, x2, y2);
        SetRect(&picRect, 310, 230, 345, 265);
   
        DrawPicture(myPic, &picRect);

//    drawship(310, 230, 345, 265);
}

void doGame (void) {
	short	i;
	CGrafPtr		curPort;
	GDHandle		curDevice;
	short			eMask;

	GetGWorld(&curPort,&curDevice);

	SetGWorld(gOffScreen,NULL);

//	TextFont(geneva);
	TextSize(9);
	TextFace(0);
//	TextMode(notSrcCopy);
//	PaintRect(&gOffScreen->portRect);

	doNewShip();
}

main (void) {
	short	windowCode;
	EventRecord	theEvent;
	Boolean		ok;

	doInitialize();
//	doSetKeys();
	doDrawWindow();
	game.state=sIntro;

	game.running = true;
	do {
		ok = WaitNextEvent(everyEvent,&theEvent,0L,NULL);
		if (ok) {
			// Handle the Event
			doEvent(&theEvent);
		//	SysBeep(1);
		}
		else
		;	// Nothing happened, kick back...
		//	IdleObjects(&theEvent);
	} while (game.running);
}

void MyCopyRect(register Rect *r)
{
	register Ptr	scrnPtr, vidPtr;
	register long	vidRowBytesOffset,scrnRowBytesOffset;
	register short	y,x;
	char			mmode;

	scrnPtr = gScreenMem;
	scrnPtr += r->left + (gScreenRowBytes *r->top);
	scrnRowBytesOffset = gScreenRowBytes - (r->right - r->left);

	vidPtr = gVideoMem + (gVidOffset.v * gVideoRowBytes) + gVidOffset.h;
	vidPtr += (r->left-32) + ((r->top-32)*gVideoRowBytes);
	vidRowBytesOffset = gVideoRowBytes - (r->right - r->left);

	// When drawing to onscreen video, we must temporarily switch to
	// 32bit memory, since video address will generally be > 8 megs
	//
	mmode = true32b;
	SwapMMUMode(&mmode);
	y = r->bottom - r->top;
	while (y--) {
		x = r->right - r->left;
		while (x--) {
			SysBeep(1);
			asm {
				//movei	(scrnPtr)+,(vidPtr)+
			}
		}
		scrnPtr += scrnRowBytesOffset;
		vidPtr += vidRowBytesOffset;
	}
	SwapMMUMode(&mmode);
}

void doEvent(EventRecord *theEvent)
{
	short	ch, windowCode;
	
	switch (theEvent->what) {
	
	case mouseDown:
		// Find out where the mouse went down
		windowCode = FindWindow (theEvent->where, &theWind);

	  	switch (windowCode) {
		case inSysWindow: 	// Desk Accessory?
		    SystemClick (theEvent, theWind);
		    break;
		    
		case inMenuBar:		// Menu Bar?
//		  	MyAdjustMenus();
//		    MyHandleMenu(MenuSelect(theEvent->where));
		    break;

		default:			// Cursor was inside our window
			// If the window isn't in the front
			if (theWind != FrontWindow())
				// Make it so...
				SelectWindow(theWind);
			else {	

				// Window is already in the front, handle the click
				switch (windowCode) {

				case inContent:		// Content area?
					if (((WindowPeek) theWind)->refCon == 128)
						((ObjectWindowPtr) theWind)->HandleClick(theWind, theEvent->where);
					break;

				case inDrag:		// Dragbar?
					{
					//	Rect	dragRect;
					//	dragRect = screenBits.bounds;
					//	// Handle the dragging of the window
					//	DragWindow(theWindow, theEvent->where, &dragRect);
					;
					}
					break;

				 case inGoAway:						// close box?
					// Only Grid Windows can be closed
				  	if (((WindowPeek) theWind)->refCon == 128) {

						// Handle the mouse tracking for the close box
				  		if (TrackGoAway(theWind, theEvent->where))
							// If mouse is released inside the close box
							// Hide or close the window
							((ObjectWindowPtr) theWind)->Dispose(theWind);
					}
				  	break;

				case inGrow:						// Grow box?
					{
						long	growResult;
						Rect	growRect;
						//SetRect(&growRect,20,20,
						//		screenBits.bounds.right,screenBits.bounds.bottom);

						// Handle the mouse tracking for the resizing
					//	growResult = GrowWindow(theWind,theEvent->where,&growRect);

						// Change the size of the window
						//SizeWindow(theWindow,LoWord(growResult),HiWord(growResult),true);

						// Redraw the window
						SetPort(theWind);
					  	InvalRect(&theWind->portRect);
					}
					break;
				}
			}
			break;
		}
		break;
	
		case keyUp:
		case keyDown: 
		case autoKey:
			// Was the cmd-key being held down?  If so, process menu bar short cuts.
		    if ((theEvent->modifiers & cmdKey) != 0) {
		   //   MyAdjustMenus();
		//  MyHandleMenu(MenuKey((char) (theEvent->message & charCodeMask)));
		;}
		else {
			SysBeep(1);
			//theWind = FrontWindow();
			ch = theEvent->message & charCodeMask;
		//	switch (game.state) {
		//	case sIntro:
			if (game.state == sIntro) {
				switch (ch) {
				case '0':
				case '1':
				case '2':
				case '3':
				case '4':
				case '5':
				case '6':
				case '7':
				case '8':
				case '9':
					game.prefs.soundLevel = ch - '0';
					if (game.prefs.soundLevel > 7)
						game.prefs.soundLevel = 7;
//					SetSoundVol(game.prefs.soundLevel);
//					PlaySound(S_Shield, 2);
//					SavePreferences();
					break;
				case 'p':
				case 'P':
					doGame();
					break;
				case 'k':
				case 'K':
					doSetKeys();
					break;
				case 'q':
				case 'Q':
				case 27:
					game.running = false;
					break;
				}
		}
		break;
	}
	// Does a window need to be redrawn?
	case updateEvt:
		theWind = (WindowPtr) theEvent->message;
		if (((WindowPeek) theWind)->refCon == wMain)
			((ObjectWindowPtr) theWind)->Update(theWind);
	    break;

	// Has a window been activated or deactivated?
	case activateEvt:
		theWind = (WindowPtr) theEvent->message;

		// Force it to be redrawn
		if (((WindowPeek) theWind)->refCon == wMain)
			((ObjectWindowPtr) theWind)->Activate(theWind);

		break;
    }
}


void DrawStatusBar(short curLevel, short maxLevel)
{
	CGrafPtr		curPort;
	GDHandle		curDevice;
	Rect			r,r2;
	RGBColor		saveColor,foreColor;

	GetGWorld(&curPort,&curDevice);
	SetGWorld(gOffScreen,NULL);

	SetRect(&r,0,0,412,2);

	// Position within 512x384 Rectangle
	OffsetRect(&r,(512-412)/2,384-8);

	// Position within offscreen video area (which is scaled to monitor size)
	// But max 640 x 480
	OffsetRect(&r,(gOffScreen->portRect.right - 512)/2,
				  (gOffScreen->portRect.bottom - 384)/2);

	GetForeColor(&saveColor);
	foreColor.red = 0x0000;
	foreColor.green = 0x9999;
	foreColor.blue = 0xCCCC;
	RGBForeColor(&foreColor);
	PaintRect(&r);
	r2 = r;
	r2.right -= (r2.right-r2.left)-(((r2.right-r2.left)*curLevel)/maxLevel);
	foreColor.green = 0;
	RGBForeColor(&foreColor);
	PaintRect(&r2);
	RGBForeColor(&saveColor);

	SetGWorld(curPort,curDevice);

	MyCopyRect(&r);
}

Boolean IsGammaFaded()
{
	return gammaFadedOut;
}

void doInitialize (void) {
	short i;
	
	InitGraf(&qd.thePort);
	InitFonts();
	FlushEvents(everyEvent, 0);
	InitWindows();
	InitMenus();
	TEInit();
	InitDialogs(0L);
	InitCursor();
	
	MaxApplZone();
	
	i = ExtraMasterBlocksNeeded;
	while (i--)
		MoreMasters();
}

void FeedbackKey(DialogPtr dp, short itemNbr, short keyCode, short asciiCode)
{
	short		iKind;
	long			amount;
	Handle		iHandle;
	Rect			iRect;
	StringPtr	p, asciiStr=(StringPtr) "  ";

	p = NULL;
	GetDialogItem(dp, itemNbr, &iKind, &iHandle, &iRect);

	// Convert Non-Printable Keys to Words
	switch (keyCode) {
	case 0x24:
		p = "\pReturn";
		break;
	case 0x31:
		p = "\pSpace";
		break;
	case 0x33:
		p = "\pDelete";
		break;
	case 0x35:
		p = "\pEsc";	
		break;
	case 0x37:
		p = "\pCmd";
		break;
	case 0x38:
		p = "\pShift";
		break;
	case 0x3D:
	case 0x3A:
		p = "\pOption";
		break;
	case 0x3E:
	case 0x3B:
		p = "\pControl";
		break;
	case 0x47:
		p = "\pClear";
		break;
	case 0x4C:
		p = "\pEnter";
		break;
	case 0x7B:
		p = "\pLeft";
		break;
	case 0x7C:
		p = "\pRight";
		break;
	case 0x7E:
		p = "\pUp";
		break;
	case 0x7D:
		p = "\pDown";
		break;
	default:
		p = asciiStr;
		asciiStr[0] = 1;
		asciiStr[1] = asciiCode;
		break;
	
	}
	SetDialogItemText(iHandle, p);
}


void doSetKeys(void) {
	GrafPtr		savePort;
	DialogPtr	dlog;
	short		itemHit,t;
	Handle		h;
	Rect		r;
	Str63		theText;

	GetPort(&savePort);
	if ((dlog = GetNewDialog(dPrefs,NULL,(WindowPtr) -1)) == NULL)
		return;

	ShowWindow(dlog);
	SetPort(dlog);

	ShowCursor();

	FeedbackKey(dlog, iPrefFire, game.prefs.fireKeyCode, game.prefs.fireKeyAscii);
	FeedbackKey(dlog, iPrefThrust, game.prefs.thrustKeyCode, game.prefs.thrustKeyAscii);
	FeedbackKey(dlog, iPrefLeft, game.prefs.leftKeyCode, game.prefs.leftKeyAscii);
	FeedbackKey(dlog, iPrefRight, game.prefs.rightKeyCode, game.prefs.rightKeyAscii);
	FeedbackKey(dlog, iPrefShield, game.prefs.shieldKeyCode, game.prefs.shieldKeyAscii);

//	SelIText(dlog, iPrefFire, 0,32767);

	do {
		ModalDialog(NewModalFilterProc(RemapDialogHook), &itemHit);
		switch (itemHit) {
		case iPrefFire:
		case iPrefThrust:
		case iPrefShield:
		case iPrefLeft:
		case iPrefRight:
			//SelIText(dp, itemHit, 0, 32767);
			break;
		default:
			break;
		}
	} while (itemHit != iPrefsOk);

	HideCursor();

	DisposeDialog(dlog);

	SetPort(savePort);

//	SavePreferences();
}

pascal	Boolean	RemapDialogHook(WindowPtr dp,EventRecord *ep,int *ip)
{
	short	stroke;
	short	editField;

	switch(ep->what) {
		case keyDown:
			if ((ep->message & charCodeMask) != '\t') {
				// record actual keystroke
				gLastKeyCode = (ep->message & keyCodeMask) >> 8;
				gLastAsciiCode = (ep->message & charCodeMask);
				editField = ((DialogPeek) dp)->editField+1;
				RegisterKey(editField, gLastKeyCode, gLastAsciiCode);
				FeedbackKey(dp, editField, gLastKeyCode, gLastAsciiCode);
				return TRUE;
			}
			return FALSE;
		case updateEvt:
			break;
		case nullEvent:
			// On idle, check for the following keys
			stroke = 0;
			if (ep->modifiers & cmdKey) {
				stroke = 0x37;
			}
			else if (ep->modifiers & shiftKey) {
				stroke = 0x38;
			}
			else if (ep->modifiers & optionKey) {
				stroke = 0x3A;
			}
			else if (ep->modifiers & controlKey) {
				stroke = 0x3B;
			}
			if (stroke) {
				editField = ((DialogPeek) dp)->editField+1;
				gLastKeyCode = stroke;	// !! Record It
				RegisterKey(editField, gLastKeyCode, 0);
				FeedbackKey(dp, editField, gLastKeyCode, 0);
			}
			break;
		default:
			break;
	}
	return FALSE;
}

void RegisterKey(short itemNbr, short keyCode, short asciiCode)
{
	switch (itemNbr) {
	case iPrefFire:	
		game.prefs.fireKeyByte = keyCode >> 3;
		game.prefs.fireKeyBit = (1 << (keyCode & 7));
		game.prefs.fireKeyCode = keyCode;
		game.prefs.fireKeyAscii = asciiCode;
		break;
	case iPrefThrust:
		game.prefs.thrustKeyByte = keyCode >> 3;
		game.prefs.thrustKeyBit = (1 << (keyCode & 7));
		game.prefs.thrustKeyCode = keyCode;
		game.prefs.thrustKeyAscii = asciiCode;
		break;
	case iPrefLeft:
		game.prefs.leftKeyByte = keyCode >> 3;
		game.prefs.leftKeyBit = (1 << (keyCode & 7));
		game.prefs.leftKeyCode = keyCode;
		game.prefs.leftKeyAscii = asciiCode;
		break;
	case iPrefRight:
		game.prefs.rightKeyByte = keyCode >> 3;
		game.prefs.rightKeyBit = (1 << (keyCode & 7));
		game.prefs.rightKeyCode = keyCode;
		game.prefs.rightKeyAscii = asciiCode;
		break;
	case iPrefShield:
		game.prefs.shieldKeyByte = keyCode >> 3;
		game.prefs.shieldKeyBit = (1 << (keyCode & 7));
		game.prefs.shieldKeyCode = keyCode;
		game.prefs.shieldKeyAscii = asciiCode;
		break;
	}
}

void doDrawWindow(void) {
	int		x;
	short			oldMBarHeight;	// Old Menu Bar Height
	
	theWind = GetNewWindow(128, 0L, (WindowPtr)-1L);
	((ObjectWindowPtr) theWind)->Draw = doMyDraw;
/*	((ObjectWindowPtr) theWind)->HandleClick = MyHandleClick;
	((ObjectWindowPtr) theWind)->Idle = MyIdle;
	((ObjectWindowPtr) theWind)->ProcessKey = MyProcessKey;
*/	
	MoveWindow(theWind, theWind->portRect.left, theWind->portRect.top, false);
	SizeWindow(theWind, theWind->portRect.right - theWind->portRect.left, theWind->portRect.bottom - theWind->portRect.top, false);
	MoveWindow(theWind, 0, 0, false);
	SizeWindow(theWind, 640, 480, false);
	
	ShowWindow(theWind);
	SetPort(theWind);
	PaintRect(&theWind->portRect);
	HideCursor();
	
//	oldMBarHeight = MBarHeight;
//	MBarHeight = 0;
	RectRgn(theWind->visRgn,&theWind->portRect);
//		DrawStatusBar(0, 100);
/*

	for (x=0;x<100;x++) {
		DrawStatusBar(x, 100);
		sleep(1);
	}
*/
}

void MyCopyBits(void)
{
	register Ptr	scrnPtr, vidPtr;
	register long	vidRowBytesOffset,scrnRowBytesOffset;
	register short	y,x;
	char			mmode;

	// otherwise, assume 640 x 480

	scrnPtr = gScreenMem;
	//scrnPtr += IconWidth + (gScreenRowBytes << 5);
	scrnRowBytesOffset = gScreenRowBytes - 640;

	vidPtr = gVideoMem + (gVidOffset.v * gVideoRowBytes) + gVidOffset.h;
	vidRowBytesOffset = gVideoRowBytes - 640;

	// When drawing to onscreen video, we must temporarily switch to
	// 32bit memory, since video address will generally be > 8 megs
	//
	mmode = true32b;
	SwapMMUMode(&mmode);
	y = 480;
	while (y--) {
		asm {
			// 160 Occurences 160 x 4 = 640
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			addi	scrnPtr,vidPtr,2
			
//			add.l	vidRowBytesOffset, vidPtr,2
//			add.l	scrnRowBytesOffset, scrnPtr
		}
	}
	SwapMMUMode(&mmode);
}


void doMyDraw (WindowPtr theWind) {
	extern Ptr	gVideoMem,gScreenMem;
//	extern WindowPtr theWind;
	if (gVideoMem && gScreenMem)
		MyCopyBits();
	else
		PaintRect(&theWind->portRect);
}

void GammaFadeOut (void)
{
QDErr	error;
short	count;
long	fadeAmount;
short	channelIndex;
Ptr	csPtr;
long tableSize;

if (IsGammaFaded())
	return;

mainDevice = GetMainDevice();

//error = MyVideoStatus( (**mainDevice).gdRefNum, cscGetGamma,
//			(Ptr)&currentGamma );

	/* Grab a pointer to the main deviceÕs gamma table */
	currentGammaTable = (GammaTblPtr)currentGamma.csGTable;

	// JAB 12/23/93
//	if (currentGammaTable->gDataWidth > 16)
//		return;
	tableSize = (long) currentGammaTable->gDataCnt * (currentGammaTable->gDataWidth <= 8? 1 : 2);

	/* Alloc mem for new gamma table */
	savedGammaTable = (GammaTblPtr)NewPtr( sizeof (GammaTbl) +
			tableSize * currentGammaTable->gChanCnt +
			currentGammaTable->gFormulaSize );

	/* Copy main deviceÕs gamma into new gamma except for table itself */
	BlockMove( (Ptr)currentGammaTable, (Ptr)savedGammaTable,
			sizeof (GammaTbl) + tableSize * currentGammaTable->gChanCnt +
			currentGammaTable->gFormulaSize );

	/* Alloc mem for new gamma table */
	newGammaTable = (GammaTblPtr)NewPtr( sizeof (GammaTbl) +
			tableSize * currentGammaTable->gChanCnt +
			currentGammaTable->gFormulaSize );

	/* Copy main deviceÕs gamma into new gamma except for table itself */
	BlockMove( (Ptr)savedGammaTable, (Ptr)newGammaTable,
			sizeof (GammaTbl) );

	/* Fade out the screen */
	for (fadeAmount = 100; fadeAmount >= 0; fadeAmount -= 4)
	{
		/* Get pointers to the actual tables */
		newTable = (unsigned char *)&newGammaTable->gFormulaData +
				newGammaTable->gFormulaSize;
		savedTable = (unsigned char *)&savedGammaTable->gFormulaData +
				savedGammaTable->gFormulaSize;

		/* For each channel in the table, fade it */
		for (channelIndex = 0; channelIndex < savedGammaTable->gChanCnt; ++channelIndex)
		{
			/* For each entry in each table channel, fade it */
			if (savedGammaTable->gDataWidth <= 8) {
				for (count = 0; count < savedGammaTable->gDataCnt; count++)
					newTable[count] = savedTable[count] * fadeAmount / 100L;
			}
			else {
				unsigned short *nt,*st;
				nt = (unsigned short *) &newTable[0];
				st = (unsigned short *) &savedTable[0];
				for (count = 0; count < savedGammaTable->gDataCnt; count++)
					nt[count] = st[count] * fadeAmount / 100L;
			}
			/* Point to the next channels */
			newTable += newGammaTable->gDataCnt;
			savedTable += savedGammaTable->gDataCnt;
		}

		/* Write the new gamma table to the main device */
		newGamma.csGTable = (Ptr)newGammaTable;
		csPtr = (Ptr) &newGamma;
		error = Control( (**mainDevice).gdRefNum, cscSetGamma, (Ptr) &csPtr );

		/* Force the main device to use the new gamma table */
		mainDeviceColors = (**(**mainDevice).gdPMap).pmTable;
		setEntriesRec.csTable = (ColorSpec *)&(**mainDeviceColors).ctTable;
		setEntriesRec.csStart = 0;
		setEntriesRec.csCount = (**mainDeviceColors).ctSize;
		csPtr = (Ptr) &setEntriesRec;
		error = Control ((**mainDevice).gdRefNum, cscSetEntries, (Ptr) &csPtr);
	}
	gammaFadedOut = true;
}

void GammaFadeIn(void)
{
	long             fadeAmount;
	unsigned char    *newTable;
	unsigned char    *savedTable;
	short            count;
	short            channelIndex;
	VDGammaRecord    newGamma;
	Ptr				 csPtr;
	QDErr			error;
	VDSetEntryRecord setEntriesRec;

	// SysBeep(1);

	if (!IsGammaFaded())
		return;

	/* Fade in the screen */
	for (fadeAmount = 0; fadeAmount <= 100; fadeAmount += 4)
	{
		/* Get pointers to the actual tables */
		newTable = (unsigned char *)&newGammaTable->gFormulaData +
				newGammaTable->gFormulaSize;
		savedTable = (unsigned char *)&savedGammaTable->gFormulaData +
				savedGammaTable->gFormulaSize;

		/* For each channel in the table, fade it */
		for (channelIndex = 0; channelIndex < savedGammaTable->gChanCnt; ++channelIndex)
		{
			/* For each entry in each table channel, fade it */
			if (savedGammaTable->gDataWidth <= 8) {
				for (count = 0; count < savedGammaTable->gDataCnt; count++)
					newTable[count] = savedTable[count] * fadeAmount / 100L;
			}
			else {
				unsigned short *nt,*st;
				nt = (unsigned short *) &newTable[0];
				st = (unsigned short *) &savedTable[0];
				for (count = 0; count < savedGammaTable->gDataCnt; count++)
					nt[count] = st[count] * fadeAmount / 100L;
			}

			/* Point to the next channels */
			newTable += newGammaTable->gDataCnt;
			savedTable += savedGammaTable->gDataCnt;
		}

		/* Write the new gamma table to the main device */
		newGamma.csGTable = (Ptr) newGammaTable;
		csPtr = (Ptr) &newGamma;
		error = Control ((**mainDevice).gdRefNum, cscSetGamma, (Ptr) &csPtr);

		/* Force the main device to use the new gamma table */
		mainDeviceColors = (**(**mainDevice).gdPMap).pmTable;
		setEntriesRec.csTable = (ColorSpec *)&(**mainDeviceColors).ctTable;
		setEntriesRec.csStart = 0;
		setEntriesRec.csCount = (**mainDeviceColors).ctSize;
		csPtr = (Ptr) &setEntriesRec;
		error = Control ((**mainDevice).gdRefNum, cscSetEntries, (Ptr) &csPtr);
	}

//	DisposPtr( (Ptr)newGammaTable );
//	DisposPtr( (Ptr)savedGammaTable );

	gammaFadedOut = 0;
}



pascal short MyVideoStatus (short refNum, short code, Ptr param)
{
	struct	CntrlParam	sBlock;
	short	result;
	int		y;
	
	sBlock.ioCRefNum = refNum;
	sBlock.csCode = code;
	*((long *) &sBlock.csParam[0]) = (long) param;
/*
	asm {
		li		sBlock, a0
		dc.w	0xA005
		stw		sp, r0
		move.w	a0, result			
	}
*//*	asm {
		lea		sBlock, a0
		dc.w	0xA005
		addi	(sp)+,a0
		move.w	d0, result			
	}*/
	return result;
}