/*****************************************************************************
	Full-Screen Access Demo
	Macintosh DisplayManager 2.0 implementation

	This code is Copyright (c) 1996 by Jon Blossom. All Rights Reserved.
 ****************************************************************************/

#ifndef _WINDOWS

//****************************************************************************
// System includes

#include <QDOffscreen.h>
#include <Video.h>
#include <Displays.h>
#include <Palettes.h>
#include <Timer.h>

//****************************************************************************
// Internal functions

void StealMenuBar(void);
void RestoreMenuBar(void);

void DemoMain(void);

long unsigned GetMillisecondTime(void)
{
	// Get a microsecond-accurate time from the Time Manager
	UnsignedWide Microsecs;
	Microseconds(&Microsecs);

	// TODO: Do this right! And don't use doubles!
	double Time;
	Time = (double)Microsecs.hi * (double)0xFFFFFFFF;
	Time = Time + (double)Microsecs.lo;
	Time = Time / 1000.0;
	while (Time > (double)0xFFFFFFFF)
		Time = Time - (double)0xFFFFFFFF;
	return (long unsigned)Time;
}

//****************************************************************************
// Internal globals

static WindowPtr Window =0;
static PaletteHandle hPalette =0;
static GWorldPtr pOffscreenGWorld =0;
static GDHandle DisplayDevice;

static unsigned short csPreviousMode;
static unsigned long csPreviousData;

static char unsigned *pBits =0;
static long Stride =0;

//****************************************************************************
// Application entry point

int main()
{
	// Initialize the Mac
	MaxApplZone();
	MoreMasters();
	InitGraf(&qd.thePort);
	InitFonts();
	FlushEvents(everyEvent, 0);
	InitWindows();
	InitMenus();
	InitDialogs(0L);
	InitCursor();

	// Check for Display Manager using Gestalt
	long GestaltValue = 0;
	long DisplayManagerVersion = 0;
	Gestalt(gestaltDisplayMgrAttr, &GestaltValue);
	if (GestaltValue & (1<<gestaltDisplayMgrPresent))
		Gestalt(gestaltDisplayMgrVers, &DisplayManagerVersion);

	// If Display Manager 2.x is available, proceed
	if (DisplayManagerVersion >= 0x00020000)
		DemoMain();

	return 0;
}

//****************************************************************************
// Offscreen access

char unsigned *GetOffscreenBits(void)
{
	return pBits;
}

long GetOffscreenStride(void)
{
	return Stride;
}

int OffscreenLock(void)
{
	int ReturnValue = 0;

	pBits = 0;
	Stride = 0;

	// Get the PixMap structure of the offscreen GWorld
	PixMapHandle OffscreenPixMap = GetGWorldPixMap(pOffscreenGWorld);
	if (OffscreenPixMap)
	{
		// Lock the PixMap memory and pull info off the PixMap
		LockPixels(OffscreenPixMap);
		pBits = (char unsigned *)GetPixBaseAddr(OffscreenPixMap);
		Stride = (*OffscreenPixMap)->rowBytes & 0x3FFF;

		ReturnValue = 1;
	}

	return ReturnValue;
}

int OffscreenUnlock(void)
{
	int ReturnValue = 0;

	// Get the PixMap structure of the offscreen GWorld
	PixMapHandle OffscreenPixMap = GetGWorldPixMap(pOffscreenGWorld);
	if (OffscreenPixMap)
	{
		// Unlock the offscreen PixMap and reset the bits and stride
		UnlockPixels(OffscreenPixMap);
		pBits = 0;
		Stride = 0;

		ReturnValue = 1;
	}

	return ReturnValue;
}

//****************************************************************************
// Buffer swapping

void SwapBuffer(void)
{
	// Make sure ctSeed matches so we get a 1:1 blt, even though we
	// have set up everything correctly when creating the GWorld in the
	// first place.
	// Basically, if QuickDraw knows the color tables are the same
	// it will ignore any translation and just copy the bits. This
	// is an extra trick to make sure it's satisfied.
	PixMapHandle OffscreenPixMap = pOffscreenGWorld->portPixMap;
	CTabHandle OffscreenCtab = (*OffscreenPixMap)->pmTable;

	PixMapHandle OnscreenPixMap = ((CWindowPtr)Window)->portPixMap;
	CTabHandle OnscreenCtab = (*OnscreenPixMap)->pmTable;

	(*OffscreenCtab)->ctSeed = (*OnscreenCtab)->ctSeed;

	// Do the blt
	CopyBits(&((GrafPtr)pOffscreenGWorld)->portBits,
		&Window->portBits,
		&Window->portRect, &Window->portRect,
		srcCopy, 0);
}

void SwapRect(int Left, int Top, int Right, int Bottom)
{
	// Make sure ctSeed matches so we get a 1:1 blt, as above
	PixMapHandle OffscreenPixMap = pOffscreenGWorld->portPixMap;
	CTabHandle OffscreenCtab = (*OffscreenPixMap)->pmTable;

	PixMapHandle OnscreenPixMap = ((CWindowPtr)Window)->portPixMap;
	CTabHandle OnscreenCtab = (*OnscreenPixMap)->pmTable;

	(*OffscreenCtab)->ctSeed = (*OnscreenCtab)->ctSeed;

	Rect BltRect = { Top, Left, Bottom, Right };

	// Do the blt
	CopyBits(&((GrafPtr)pOffscreenGWorld)->portBits,
		&Window->portBits,
		&BltRect, &BltRect,
		srcCopy, 0);
}

//****************************************************************************
// Full Screen initialization

// This structure encapsulates the data sent to the Display Manager list
// enumeration callback function. We fill in the desired values, pass this
// on through the enumeration, and it fills in the csMode and csData info
// we need.
struct DisplayModeRequest
{
	// Returned values
	unsigned short csMode;
	unsigned long csData;

	// Provided values
	long DesiredWidth;
	long DesiredHeight;
	long DesiredDepth;
};

// This function filters through the display modes reported by the Display
// Manager, looking for one that matches the requested resolution. The
// userData pointer will point to a DisplayModeRequest structure.
pascal void DisplayModeCallback(void* userData, DMListIndexType,
	DMDisplayModeListEntryPtr pModeInfo)
{
	DisplayModeRequest *pRequest = (DisplayModeRequest*)userData;

	// Get timing info and make sure this is an OK display mode
	VDTimingInfoRec TimingInfo = *(pModeInfo->displayModeTimingInfo);
	if (TimingInfo.csTimingFlags & 1<<kModeValid)
	{
		// How many modes are being enumerated here?
		unsigned long DepthCount =
			pModeInfo->displayModeDepthBlockInfo->depthBlockCount;

		// Filter through each of the modes provided here
		VDSwitchInfoRec *pSwitchInfo;
		VPBlock *pVPBlockInfo;
		for (short Count = 0; Count < DepthCount; ++Count)
		{
			// This provides the csMode and csData information
			pSwitchInfo =
				pModeInfo->displayModeDepthBlockInfo->
				depthVPBlock[Count].depthSwitchInfo;

			// This tells us the resolution and pixel depth
			pVPBlockInfo =
				pModeInfo->displayModeDepthBlockInfo->
				depthVPBlock[Count].depthVPBlock;

			if (pVPBlockInfo->vpPixelSize == pRequest->DesiredDepth &&
				pVPBlockInfo->vpBounds.right == pRequest->DesiredWidth &&
				pVPBlockInfo->vpBounds.bottom == pRequest->DesiredHeight)
			{
				// Found a mode that matches the request!
				pRequest->csMode = pSwitchInfo->csMode;
				pRequest->csData = pSwitchInfo->csData;
			}
		}
	}
}

int BeginFullScreen(int Width, int Height, int Depth)
{
	// Hide the menu bar
	StealMenuBar();

	// Create a window of the requested size
	Rect WindowRect = { 0, 0, Height, Width };
	Window = NewCWindow(0, &WindowRect, "\pFullScreen",
		TRUE, plainDBox,
		WindowPtr(-1), FALSE, 0);
	if (!Window)
		goto Failure;

	// Set up a palette with a gray wash
	hPalette = NewPalette(256, 0, pmExplicit | pmAnimated, 0);
	if (!hPalette)
		goto Failure;

	RGBColor Color;
	int i;
	for (i=0; i<256; ++i)
	{
		Color.red= i << 8;
		Color.green = i << 8;
		Color.blue = i << 8;

		SetEntryColor(hPalette, i, &Color);
	}

	// Force 0 and 255 to White and Black
	SetEntryUsage(hPalette, 0, pmExplicit | pmAnimated | pmWhite, 0);
	SetEntryUsage(hPalette, 255, pmExplicit | pmAnimated | pmBlack, 0);

	SetPalette(Window, hPalette, TRUE);

	// Store information about the current display settings
	DisplayDevice = GetMainDevice();
	if (!DisplayDevice)
		goto Failure;

	csPreviousMode = -1;
	csPreviousData = -1;

	VDSwitchInfoRec DisplayInfo;
	OSErr MacError = DMGetDisplayMode(DisplayDevice, &DisplayInfo);
	if (MacError != noErr)
		goto Failure;

	csPreviousMode = DisplayInfo.csMode;
	csPreviousData = DisplayInfo.csData;

	// Get the display ID for the main display
	DisplayIDType DisplayID;
	DMGetDisplayIDByGDevice(DisplayDevice, &DisplayID, FALSE);

	// Use it to get a list of available modes from the Display Manager
	DMListIndexType DisplayModeCount = 0;
	DMListType DisplayModeList;
	MacError = DMNewDisplayModeList(DisplayID, 0, 0,
		&DisplayModeCount, &DisplayModeList);
	if (MacError != noErr)
		goto Failure;

	// Create a callback function pointer to filter available modes
	DMDisplayModeListIteratorUPP uppDisplayModeCallback =
		NewDMDisplayModeListIteratorProc(DisplayModeCallback);
	if (!uppDisplayModeCallback)
	{
		// Aborting - let go of the mode list
		DMDisposeList(DisplayModeList);
		goto Failure;
	}

	// Go through the list, comparing each available mode with
	// this mode request
	DisplayModeRequest ModeRequest;
	ModeRequest.csMode = -1;
	ModeRequest.csData = -1;
	ModeRequest.DesiredWidth = Width;
	ModeRequest.DesiredHeight = Height;
	ModeRequest.DesiredDepth = Depth;

	for (short Count = 0; Count < DisplayModeCount; ++Count)
	{
		DMGetIndexedDisplayModeFromList(DisplayModeList, Count,
			0, uppDisplayModeCallback, (void*)&ModeRequest);
	}

	// Done with the list
	DMDisposeList(DisplayModeList);

	// Done with the callback
	DisposeRoutineDescriptor(uppDisplayModeCallback);

	// If we found a mode fitting the request, switch to it!
	if (ModeRequest.csMode == -1 || ModeRequest.csData == -1)
		goto Failure;

	DisplayInfo.csMode = ModeRequest.csMode;
	DisplayInfo.csData = ModeRequest.csData;

	unsigned long Mode = DisplayInfo.csMode;
	MacError = DMSetDisplayMode(DisplayDevice,
		DisplayInfo.csData, &Mode,
		(unsigned long)&DisplayInfo,
		0);
	if (MacError != noErr)
		goto Failure;

	// Create a matching GWorld using current device and window
	CGrafPtr CurrentPort = (CWindowPtr)Window;
	
	PixMapHandle CurrentPixMap = CurrentPort->portPixMap;
	CTabHandle ColorTable = (*CurrentPixMap)->pmTable;

	NewGWorld(&pOffscreenGWorld, (short)Depth,
		&CurrentPort->portRect, ColorTable,
		DisplayDevice, noNewDevice);
	if (!pOffscreenGWorld)
		goto Failure;

	// Success!
	return 1;

Failure:
	RestoreMenuBar();
	return 0;
}

//****************************************************************************
// Full Screen clean-up

void EndFullScreen(void)
{
	if (Window)
	{
		DisposeWindow(Window);
		Window = 0;
	}
	
	if (pOffscreenGWorld)
	{
		DisposeGWorld(pOffscreenGWorld);
		pOffscreenGWorld = 0;
	}

	if (csPreviousMode != -1 && csPreviousData != -1)
	{
		// Set the display back to its starting place
		VDSwitchInfoRec OriginalInfo;
		OriginalInfo.csMode = csPreviousMode;
		OriginalInfo.csData = csPreviousData;

		unsigned long Mode = csPreviousMode;
		DMSetDisplayMode(DisplayDevice,
			csPreviousData, &Mode,
			(unsigned long)&OriginalInfo,
			0);
	}

	RestoreMenuBar();
}

//****************************************************************************
// Menu bar manipulation functions

static short _OldMBarHeight = 0;
static RgnHandle _OldDesktopRgn = 0;

void StealMenuBar(void)
{
	RgnHandle DesktopRgn;

	if (_OldMBarHeight == 0)
	{
		// Get and copy the current gray region
		DesktopRgn = LMGetGrayRgn();
		_OldDesktopRgn = NewRgn();
		CopyRgn(DesktopRgn, _OldDesktopRgn);
		
		// Fudge the menu bar height
		_OldMBarHeight = GetMBarHeight();
		LMSetMBarHeight(0);

		// Turn the gray into the old gray region plus the menu bar region
		Rect MenuRect;
		MenuRect.left = 0;
		MenuRect.top = 0;
		MenuRect.right = qd.screenBits.bounds.right;
		MenuRect.bottom = _OldMBarHeight;
		RgnHandle MenuRgn = NewRgn();
		RectRgn(MenuRgn, &MenuRect);

		UnionRgn(_OldDesktopRgn, MenuRgn, DesktopRgn);
		DisposeRgn(MenuRgn);
	}
}

void RestoreMenuBar(void)
{
	if (_OldMBarHeight && _OldDesktopRgn)
	{
		// Restore the menu bar height
		LMSetMBarHeight(_OldMBarHeight);
		_OldMBarHeight = 0;

		// Restore the old desktop region
		CopyRgn(_OldDesktopRgn, LMGetGrayRgn());
		DisposeRgn(_OldDesktopRgn);
		_OldDesktopRgn = 0;
		
		// Redraw the menu bar
		HiliteMenu(0);
		DrawMenuBar();
	}
}

#endif // not _WINDOWS