// winmain.cxx	Win32 stuff - part of LinCity
// Copyright (c) I J Peters 1995,1996.  Please read the file 'COPYRIGHT'.

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <string.h>
#include <malloc.h>
#include <memory.h>

#include "lin-city.h"
#include "common.h"
#include "generic.h"
#include "mouse.h"

// Define this to use DIB's instead of DDB's
//#define WIN32_USEDIB

// Global Variables
static char szClassNameWithMenu[] = APPNAME " (with menu)";
static char szClassNameWithoutMenu[] = APPNAME " (without menu)";
static char szAppName[] = APPNAME;	// The name of this application
static char szTitle[]   = APPNAME;	// The title bar text
static HBRUSH hbrBackground = 0;

// Private Function Prototypes
static ATOM MyRegisterClass(CONST WNDCLASS*);
static BOOL InitApplication(HINSTANCE);
static BOOL InitInstance(HINSTANCE, int);
static LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);
static LRESULT CALLBACK About(HWND, UINT, WPARAM, LPARAM);
static BOOL CenterWindow (HWND, HWND);
static HBITMAP InitializeBackingStore (HWND);
static BOOL CopyBackingStoreToScreen (HDC, HWND, LPPAINTSTRUCT);
static void CreateDDB (HWND hWnd);
static void CreateDIB (void);
static void InitializePalette (void);
static void DoSquareMouse (HDC hdc);



//----------------------------------------------------------------------------
//  FUNCTION: WinMain(HANDLE, HANDLE, LPSTR, int)
//
//  PURPOSE: Entry point for the application.
//
//  COMMENTS:
//
//	This function initializes the application and processes the
//	message loop.
//----------------------------------------------------------------------------
int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{
	if (!hPrevInstance) {
		// Perform instance initialization:
		if (!InitApplication(hInstance)) {
			return (FALSE);
		}
	}

	// Perform application initialization, including creating the
	// Lin-City main window.
	if (!InitInstance(hInstance, nCmdShow)) {
		return (FALSE);
	}

	// Load keyboard accelerators (shortkut keys)
	display.hAccelTable = LoadAccelerators (hInstance, szAppName);

	// Take care of any outstanding messages before calling main()
	ProcessPendingEvents ();

	// main() contains main message loop
	char *args[] = { "wlincity" };
	main (1, args);

	// Take care of any outstanding messages after main() finishes.
	ProcessPendingEvents ();

	return 0;
	lpCmdLine; // This will prevent 'unused formal parameter' warnings
}


//----------------------------------------------------------------------------
//  FUNCTION: MyRegisterClass(CONST WNDCLASS*)
//
//  PURPOSE: Registers the window class.
//
//  COMMENTS:
//
// 	This function and its usage is only necessary if you want this code
// 	to be compatible with Win32 systems prior to the 'RegisterClassEx'
//	function that was added to Windows 95. It is important to call this function
// 	so that the application will get 'well formed' small icons associated
// 	with it.
//----------------------------------------------------------------------------
ATOM MyRegisterClass(CONST WNDCLASS *lpwc)
{
	HANDLE  hMod;
	FARPROC proc;
	WNDCLASSEX wcex;

	hMod = GetModuleHandle ("USER32");
	if (hMod != NULL) {
#if defined (UNICODE)
		proc = GetProcAddress ((HMODULE)hMod, "RegisterClassExW");
#else
		proc = GetProcAddress ((HMODULE)hMod, "RegisterClassExA");
#endif
		if (proc != NULL) {

			wcex.style			= lpwc->style;
			wcex.lpfnWndProc	= lpwc->lpfnWndProc;
			wcex.cbClsExtra		= lpwc->cbClsExtra;
			wcex.cbWndExtra		= lpwc->cbWndExtra;
			wcex.hInstance		= lpwc->hInstance;
			wcex.hIcon			= lpwc->hIcon;
			wcex.hCursor		= lpwc->hCursor;
			wcex.hbrBackground	= lpwc->hbrBackground;
			wcex.lpszMenuName	= lpwc->lpszMenuName;
			wcex.lpszClassName	= lpwc->lpszClassName;

			// Added elements for Windows 95:
			wcex.cbSize = sizeof(WNDCLASSEX);
			wcex.hIconSm = LoadIcon(wcex.hInstance, "SMALL");

			// GCS: This typedef is for the typecast...
			typedef int (FAR WINAPI *my_FARPROC)(WNDCLASSEX*);
			return (*((my_FARPROC)(proc)))(&wcex);
		}
	}
	return (RegisterClass(lpwc));
}


//----------------------------------------------------------------------------
//  FUNCTION: InitApplication(HANDLE)
//
//  PURPOSE: Initializes window data and registers window classes
//
//  COMMENTS:
//	   We need two classes -- one which has a menu, one without a menu
//         (for full-screen).  This is registered by calling RegisterClass 
//         for Win 3.1/NT, or MyRegisterClass for Win 95.
//----------------------------------------------------------------------------
BOOL InitApplication(HINSTANCE hInstance)
{
	// If Lin City is already running, focus existing process.
	// Win32 always sets hPrevInstance to NULL, so check w/ FindWindow()
	HWND hwnd = FindWindow (szClassNameWithMenu, NULL);
	if (!hwnd) hwnd = FindWindow (szClassNameWithoutMenu, NULL);
	if (hwnd) {
		// We found another version of ourself. Lets defer to it:
		if (IsIconic(hwnd)) {
			ShowWindow(hwnd, SW_RESTORE);
		}
		SetForegroundWindow (hwnd);
		return FALSE;
	}

	// Create brush for background: Nasty Brown (Lin City color # 105)
	hbrBackground = CreateSolidBrush (RGB (0x4C,0x4C,0));

	// Fill in WNDCLASS for class WITH MENU.
	WNDCLASS  wcWithMenu;
	// wcWithMenu.style		= CS_HREDRAW | CS_VREDRAW;
	wcWithMenu.style		= 0;
	wcWithMenu.lpfnWndProc		= (WNDPROC)WndProc;
	wcWithMenu.cbClsExtra		= 0;
	wcWithMenu.cbWndExtra		= 0;
	wcWithMenu.hInstance		= hInstance;
	wcWithMenu.hIcon		= LoadIcon (hInstance, szAppName);
	wcWithMenu.hCursor		= LoadCursor(NULL, IDC_ARROW);
	// wcWithMenu.hbrBackground	= (HBRUSH)(COLOR_WINDOW+1);
	wcWithMenu.hbrBackground	= hbrBackground;
	if (IS_WIN95) {  // Windows95 has different recommended help menu format.
		wcWithMenu.lpszMenuName	= "WIN95";
	} else {
		wcWithMenu.lpszMenuName	= szAppName;
	}
	wcWithMenu.lpszClassName	= szClassNameWithMenu;

	// Fill in WNDCLASS for class WITH MENU.
	WNDCLASS  wcWithoutMenu;
	wcWithoutMenu.style		= 0;
	wcWithoutMenu.lpfnWndProc	= (WNDPROC)WndProc;
	wcWithoutMenu.cbClsExtra	= 0;
	wcWithoutMenu.cbWndExtra	= 0;
	wcWithoutMenu.hInstance		= hInstance;
	wcWithoutMenu.hIcon		= LoadIcon (hInstance, szAppName);
	wcWithoutMenu.hCursor		= LoadCursor(NULL, IDC_ARROW);
	wcWithoutMenu.hbrBackground	= hbrBackground;
	wcWithoutMenu.lpszMenuName	= "";
	wcWithoutMenu.lpszClassName	= szClassNameWithoutMenu;

	// Register the window classes and return success/failure code.
	if (IS_WIN95) {
		BOOL rv;
		rv = MyRegisterClass(&wcWithMenu);
		if (!rv) return rv;
		rv = MyRegisterClass(&wcWithoutMenu);
		return rv;
	} else {
		BOOL rv;
		rv = RegisterClass(&wcWithMenu);
		if (!rv) return rv;
		rv = RegisterClass(&wcWithoutMenu);
		return rv;
	}
}


//----------------------------------------------------------------------------
//   FUNCTION: InitInstance(HANDLE, int)
//
//   PURPOSE:  Creates main window 
//----------------------------------------------------------------------------
BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
{
	// Determine graphics capabilities
	HDC hDCGlobal = GetDC (NULL);
	INT iRasterCaps;
	iRasterCaps = GetDeviceCaps(hDCGlobal, RASTERCAPS);
	if (iRasterCaps & RC_PALETTE) {
		display.hasPalette = TRUE;
		display.paletteSize = GetDeviceCaps (hDCGlobal, SIZEPALETTE);
		display.defaultPaletteSize = GetDeviceCaps (hDCGlobal, NUMCOLORS);
	} else {
		display.hasPalette = FALSE;
	}
	display.colorDepth = GetDeviceCaps (hDCGlobal, BITSPIXEL);
	ReleaseDC (NULL, hDCGlobal);

	// Decide whether to use DIB's or DDB's
#if defined (WIN32_USEDIB)
	if (display.colorDepth == 8)	// Only use DIB for 256 colors
		display.useDIB = TRUE;
	else
		display.useDIB = FALSE;
#else
	display.useDIB = FALSE;
#endif

	// Do some global initializations
	display.hInst = hInstance;
	display.fullscreen = FALSE;
	//display.fullscreen = TRUE;
	display.screenW = GetSystemMetrics (SM_CXSCREEN);
	display.screenH = GetSystemMetrics (SM_CYSCREEN);
	display.winFullscreenClientW = (INT) GetSystemMetrics (SM_CXFULLSCREEN);
	display.winFullscreenClientH = (INT) GetSystemMetrics (SM_CYFULLSCREEN);
	InitializePalette ();

	// Choose one of Lin City window types
	//    a)  no pix doubling, no border
	//    b)  no pix doubling, 30 pixel border
	//    c)  pix doubling, no border
	if ((display.screenW >= WINWIDTH*2)
		&& display.screenH >= WINHEIGHT*2) {
		pix_double = 1;
		borderx = 0;
		bordery = 0;
	} else if ((display.screenW >= WINWIDTH+(2*BORDERX))
		&& (display.screenH >= WINHEIGHT+(2*BORDERY))) {
		pix_double = 0;
		borderx = BORDERX;
		bordery = BORDERY;
	} else {
		pix_double = 0;
		borderx = 0;
		bordery = 0;
	}
	display.clientW = ((pix_double+1)*WINWIDTH) + (2*borderx);
	display.clientH = ((pix_double+1)*WINHEIGHT) + (2*bordery);

	// Choose one of three client window types
	//    a)  full screen
	//    b)  maximized window
	//    c)  regular window
	// Check regular window first.
	char *szClassName = 0;
	DWORD dwStyle;
	RECT client_size;
	dwStyle = WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX | WS_MAXIMIZEBOX;
	client_size.left = 0;
	client_size.top = 0;
	client_size.right = display.clientW;
	client_size.bottom = display.clientH;
	AdjustWindowRect (&client_size, dwStyle, TRUE);
	if (((client_size.right - client_size.left) <= display.screenW)
	    && ((client_size.bottom - client_size.top) <= display.screenH)) {
		// Use regular (overlapped) window
		szClassName = szClassNameWithMenu;
		if (client_size.left < 0) {
			client_size.right -= client_size.left;
			client_size.left = CW_USEDEFAULT;
		}
		if (client_size.top < 0) {
			client_size.bottom -= client_size.top;
			client_size.top = CW_USEDEFAULT;
		}
	} else {
		// Check maximized by subtracting out the DLGFRAME size.
		// Note that the "obvious" method of calling AdjustWindowRect()
		// with style WS_MAXIMIZE doesn't work!
		int border_x = GetSystemMetrics (SM_CXDLGFRAME);
		int border_y = GetSystemMetrics (SM_CYDLGFRAME);
		if (((client_size.right - client_size.left - 2*border_x) <= display.screenW)
		    && ((client_size.bottom - client_size.top - 2*border_y) <= display.screenH)) {
			// Use maximized window
			szClassName = szClassNameWithMenu;
			// dwStyle |= WS_MAXIMIZE;
			if (client_size.left < 0) {
				client_size.right -= client_size.left;
				client_size.left = CW_USEDEFAULT;
			}
			if (client_size.top < 0) {
				client_size.bottom -= client_size.top;
				client_size.top = CW_USEDEFAULT;
			}
			nCmdShow = SW_SHOWMAXIMIZED;
		} else {
			// Need fullsize window
			szClassName = szClassNameWithoutMenu;
			dwStyle = WS_POPUP;
			client_size.left = 0;
			client_size.top = 0;
			client_size.right = display.screenW;
			client_size.bottom = display.screenH;
		}
	}

	// Create the window
	display.hWnd = CreateWindow (
		szClassName,				// Class name
		szTitle,				// Caption
		dwStyle,				// Style
		client_size.left, client_size.top,	// Position
		client_size.right, client_size.bottom,	// Size
		(HWND)NULL,				// Parent window (no parent)
		(HMENU)NULL,				// use class menu
		(HINSTANCE)hInstance,			// handle to window instance
		(LPVOID)NULL				// no params to pass on
	);
	if (!display.hWnd) {
		return (FALSE);
	}

	// Display the window
	ShowWindow (display.hWnd, nCmdShow);
	UpdateWindow (display.hWnd);

	return (TRUE);
}


//----------------------------------------------------------------------------
//  FUNCTION: MainLoop ()
//----------------------------------------------------------------------------
void MainLoop (void)
{
	MSG msg;
	while (GetMessage(&msg, NULL, 0, 0)) {
		if (!TranslateAccelerator (msg.hwnd, (HACCEL)display.hAccelTable, &msg)) {
			TranslateMessage(&msg);
			DispatchMessage(&msg);
		}
	}
}


//----------------------------------------------------------------------------
//  FUNCTION: ProcessNextEvent ()
//            Wait for a message if necessary,
//            then process all messages.
//----------------------------------------------------------------------------
void ProcessNextEvent (void)
{
	MSG msg;
	if (GetMessage (&msg, NULL, 0, 0)) {
		if (!TranslateAccelerator (msg.hwnd, (HACCEL)display.hAccelTable, &msg)) {
			TranslateMessage(&msg);
			DispatchMessage(&msg);
		}
	}
	ProcessPendingEvents ();
}


//----------------------------------------------------------------------------
//  FUNCTION: ProcessPendingEvents ()
//            Process all outstanding messages.
//----------------------------------------------------------------------------
void ProcessPendingEvents (void)
{
	MSG msg;
	while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) {
		if (!TranslateAccelerator (msg.hwnd, (HACCEL)display.hAccelTable, &msg)) {
			TranslateMessage(&msg);
			DispatchMessage(&msg);
		}
	}
}


//----------------------------------------------------------------------------
//  FUNCTION: EnableWindowsMenuItems ()
//  FUNCTION: DisableWindowsMenuItems ()
//            Enable and Disable "Load" and "Save" items
//----------------------------------------------------------------------------
void EnableWindowsMenuItems (void)
{
	HMENU hMenu = GetMenu (display.hWnd);
	EnableMenuItem (hMenu, IDM_OPEN, MF_BYCOMMAND | MF_ENABLED);
	EnableMenuItem (hMenu, IDM_SAVE, MF_BYCOMMAND | MF_ENABLED);
	EnableMenuItem (hMenu, IDM_HELPCONTENTS, MF_BYCOMMAND | MF_ENABLED);
}

void DisableWindowsMenuItems (void)
{
	HMENU hMenu = GetMenu (display.hWnd);
	EnableMenuItem (hMenu, IDM_OPEN, MF_BYCOMMAND | MF_GRAYED);
	EnableMenuItem (hMenu, IDM_SAVE, MF_BYCOMMAND | MF_GRAYED);
	EnableMenuItem (hMenu, IDM_HELPCONTENTS, MF_BYCOMMAND | MF_GRAYED);
}


//----------------------------------------------------------------------------
//  FUNCTION: HandleMouse ()
//----------------------------------------------------------------------------
void HandleMouse ()
{
	MSG msg;
	while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) {
		if (!TranslateAccelerator (msg.hwnd, (HACCEL)display.hAccelTable, &msg)) {
			TranslateMessage(&msg);
			DispatchMessage(&msg);
			// We can ignore mouse moves, while we are processing events,
			// But we can't ignore clicks
			if (cs_current_mouse_button != cs_mouse_button)
				cs_mouse_handler (cs_current_mouse_button,
						cs_current_mouse_x - cs_mouse_x,
						cs_current_mouse_y - cs_mouse_y);
		}
	}
	// Now take care of the last mouse move/click
	if (cs_current_mouse_x != cs_mouse_x 
			|| cs_current_mouse_y != cs_mouse_y
			|| cs_current_mouse_button != cs_mouse_button)
		cs_mouse_handler (cs_current_mouse_button,
				cs_current_mouse_x - cs_mouse_x,
				cs_current_mouse_y - cs_mouse_y);
}


//----------------------------------------------------------------------------
//  FUNCTION: GetKeystroke ()
//----------------------------------------------------------------------------
char GetKeystroke()
{
	char key;
	ProcessPendingEvents ();
	key = x_key_value;
	x_key_value = 0;
	return key;
}


//----------------------------------------------------------------------------
//  FUNCTION: WndProc(HWND, unsigned, WORD, LONG)
//
//  PURPOSE:  Processes messages for the main window.
//----------------------------------------------------------------------------
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
	int wmId, wmEvent;

	switch (message) { 

		case WM_COMMAND:
		{
			wmId	= LOWORD(wParam); // Remember, these are...
			wmEvent = HIWORD(wParam); // ...different for Win32!

			//Parse the menu selections:
			switch (wmId) {

				case IDM_OPEN:
					load_flag = 1;
					DisableWindowsMenuItems ();
					break;

				case IDM_SAVE:
					save_flag = 1;
					DisableWindowsMenuItems ();
					break;

				case IDM_EXIT:
					// GCS FIX: I'm still not quite satisfied with this...
					// x_key_value = 'q';
					DestroyWindow (hWnd);
					break;

				case IDM_ABOUT:
					DialogBox(display.hInst, "AboutBox", hWnd, (DLGPROC)About);
					break;

				case IDM_HELPCONTENTS:
					help_flag = 1;
					DisableWindowsMenuItems ();
					activate_help("index.hlp");
					break;

				default:
					return (DefWindowProc(hWnd, message, wParam, lParam));
			}
		}
		break;

		case WM_KEYDOWN:
		{
			int nVirtKey = (int) wParam;
			// LPARAM lKeyData = lParam;
			x_key_shifted = (GetKeyState (VK_SHIFT) & 0x80000000) ? TRUE : FALSE;
			switch (nVirtKey)
			{
				case VK_LEFT:
					x_key_value = 1;
				break;
 
				case VK_DOWN:
					x_key_value = 2;
				break;

				case VK_UP:
					x_key_value = 3;
				break;

				case VK_RIGHT:
					x_key_value = 4;
				break;
			}
		}
		break;

		case WM_CHAR:
		{
			TCHAR chCharCode = (TCHAR) wParam;	// character code
			LPARAM lKeyData = lParam;			// key data
			if (chCharCode == 8) {				// Fix backspace
				chCharCode = 127;
			}
			x_key_value = chCharCode;
		}
		break;

		case WM_NCRBUTTONUP: // RightClick on windows non-client area
		{
			if (IS_WIN95 && SendMessage(hWnd, WM_NCHITTEST, 0, lParam) == HTSYSMENU)
			{
				// The user has clicked the right button on the applications
				// 'System Menu'. Here is where you would alter the default
				// system menu to reflect your application. Notice how the
				// explorer deals with this. For this app, we aren't doing
				// anything
				return (DefWindowProc(hWnd, message, wParam, lParam));
			} else {
				// Nothing we are interested in, allow default handling...
				return (DefWindowProc(hWnd, message, wParam, lParam));
			}
		}
		break;

		case WM_RBUTTONDOWN: // RightClick in windows client area
		{
			cs_current_mouse_x = UnAdjustX (LOWORD (lParam));
			cs_current_mouse_y = UnAdjustY (HIWORD (lParam));
			cs_current_mouse_button = MOUSE_RIGHTBUTTON;
			cs_mouse_shifted = (wParam & MK_SHIFT) ? 1 : 0;
		}
		break;

		case WM_LBUTTONDOWN: // Left Click in windows client area
		{
			cs_current_mouse_x = UnAdjustX (LOWORD (lParam));
			cs_current_mouse_y = UnAdjustY (HIWORD (lParam));
			cs_current_mouse_button = MOUSE_LEFTBUTTON;
			cs_mouse_shifted = (wParam & MK_SHIFT) ? 1 : 0;
		}
		break;

		case WM_RBUTTONUP:
		case WM_LBUTTONUP:
		{
			cs_current_mouse_x = UnAdjustX (LOWORD (lParam));
			cs_current_mouse_y = UnAdjustY (HIWORD (lParam));
			cs_current_mouse_button = 0;
			cs_mouse_shifted = (wParam & MK_SHIFT) ? 1 : 0;
		}
		break;

		case WM_MOUSEMOVE:
		{
			cs_current_mouse_x = UnAdjustX (LOWORD(lParam));
			cs_current_mouse_y = UnAdjustY (HIWORD(lParam));
			cs_mouse_shifted = (wParam & MK_SHIFT) ? 1 : 0;
		}
		break;
 
		case WM_DISPLAYCHANGE: // Only comes through on plug'n'play systems
		{
			SIZE szScreen;
			BOOL fChanged = (BOOL)wParam;

			szScreen.cx = LOWORD(lParam);
			szScreen.cy = HIWORD(lParam);
			
			if (fChanged) {
				// The display 'has' changed. szScreen reflects the
				// new size.
				MessageBox (GetFocus(), "Display Changed", szAppName, 0);
			} else {
				// The display 'is' changing. szScreen reflects the
				// original size.
				MessageBeep(0);
			}
		}
		break;

		case WM_PAINT:
		{
			PAINTSTRUCT	ps;
			HDC			hdc;

			hdc = BeginPaint (hWnd, &ps);
			CopyBackingStoreToScreen (hdc, hWnd, &ps);
			EndPaint (hWnd, &ps);
		}
		break;

		case WM_CREATE:		// Create client area
		{
			InitializeBackingStore (hWnd);
		}
		break;

		case WM_DESTROY:
		{
			// PostQuitMessage(0);
			exit (0);	// OK??
		}
		break;

		case WM_SIZE:		// Resize window
		default:
			return (DefWindowProc(hWnd, message, wParam, lParam));
	}
	return (0);
}


//----------------------------------------------------------------------------
//  FUNCTION: InitializeBackingStore ()
//----------------------------------------------------------------------------
HBITMAP InitializeBackingStore (HWND hWnd)
{
	RECT rc;

	// Set up the remaining global variables
	GetClientRect(hWnd, &rc);
	display.winW = rc.right-rc.left;
	display.winH = rc.bottom-rc.top;

	InitializePalette ();
	CreateDDB (hWnd);
	if (display.useDIB) {
		CreateDIB ();
	}
	display.hSaveUnderHdc = 0;
	display.hSaveUnderBitmap = 0;

	return 0;
}


//----------------------------------------------------------------------------
//  FUNCTION: InitializePalette ()
//----------------------------------------------------------------------------
void InitializePalette (void) {
	INT iLoop;

	display.hPal = 0;
	display.pLogPal = 0;

	// Clear out palette arrays
	for (iLoop = 0; iLoop < 256; iLoop++) {
		display.colorrefPal [iLoop] = 0;
		display.brushPal [iLoop] = 0;
	}

	// If the device uses a palette (e.g. 8 bit display),
	// we need to create an HPALETTE for the HDC.
	if (display.hasPalette) {

		// Allocate memory for LOGPALETTE
		display.pLogPal = (NPLOGPALETTE) LocalAlloc (LMEM_FIXED,
				  (sizeof (LOGPALETTE) +
				  (sizeof (PALETTEENTRY) * (display.paletteSize))));
		if (!display.pLogPal) {
			MessageBox(display.hWnd, "Not enough memory for logical palette.", NULL, MB_OK | MB_ICONHAND);
			PostQuitMessage (0) ;
			exit (-1);
		}

		display.pLogPal->palVersion    = 0x300;
		display.pLogPal->palNumEntries = display.paletteSize;

		// Fill palette with system colors by default
		for (iLoop = 0; iLoop < display.paletteSize; iLoop++) {
				*((WORD *) (&display.pLogPal->palPalEntry[iLoop].peRed)) = (WORD)iLoop;
				display.pLogPal->palPalEntry[iLoop].peBlue  = 0;
				display.pLogPal->palPalEntry[iLoop].peFlags = PC_EXPLICIT;
		}

		// Convert LOGPALETTE into HPALETTE
		display.hPal = CreatePalette ((LPLOGPALETTE) display.pLogPal);
	}
}
			
//----------------------------------------------------------------------------
//  FUNCTION: CreateDIB ()
//----------------------------------------------------------------------------
void CreateDIB (void)
{
	// Let's create a 256 color DIB, just for testing!
	ULONG		sizBMI;
	INT			iNumClr = 256;
	INT			iLoop;

	// Get memory for 256 color BITMAPINFO
	sizBMI = sizeof(BITMAPINFOHEADER) + sizeof(RGBQUAD) * iNumClr;
	if ((display.pbminfo = (PBITMAPINFO) GlobalAlloc (GMEM_FIXED | GMEM_ZEROINIT, sizBMI)) == NULL) {
		MessageBox(display.hWnd, "Failed in Memory Allocation for bminfo!", "Error", MB_OK);
		exit (-1);
	}

	// Fill in bitmap info
	display.pbminfo->bmiHeader.biSize = 0x28;						// GDI need this to work
//	display.pbminfo->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);	// GDI need this to work
	display.pbminfo->bmiHeader.biWidth = display.winW;
	display.pbminfo->bmiHeader.biHeight = display.winH;
	display.pbminfo->bmiHeader.biPlanes = 1;
	display.pbminfo->bmiHeader.biBitCount = 8;
	display.pbminfo->bmiHeader.biCompression = BI_RGB;
	display.pbminfo->bmiHeader.biSizeImage = display.winW * display.winH;	// One byte per pixel
	display.pbminfo->bmiHeader.biXPelsPerMeter = 0;
	display.pbminfo->bmiHeader.biYPelsPerMeter = 0;
	display.pbminfo->bmiHeader.biClrUsed = 0;
	display.pbminfo->bmiHeader.biClrImportant = 0;

#if defined (commentout)
	// Fill in colormap w/ default colors
	// FillBMIColors (&display.pbminfo->bmiColors[0]);
#endif

	// Fill in colormap w/ black
	for (iLoop = 0; iNumClr; iLoop++) {
		display.pbminfo->bmiColors[iLoop].rgbRed = 0;
		display.pbminfo->bmiColors[iLoop].rgbGreen = 0;
		display.pbminfo->bmiColors[iLoop].rgbBlue = 0;
		display.pbminfo->bmiColors[iLoop].rgbReserved = 0;
	}

	// CreateDIBSection() will allocate the pBits.
	display.hDIB = CreateDIBSection (display.hdcMem, display.pbminfo,
			DIB_RGB_COLORS, (void**)(&display.pBits), NULL, 0);
}


//----------------------------------------------------------------------------
//  FUNCTION: CreateDDB ()
//----------------------------------------------------------------------------
void CreateDDB (HWND hWnd)
{
	HDC hdc;
	HBITMAP	hBitmapOri;
	HPALETTE hPalOld;

	hdc = GetDC(hWnd);
	if (display.hasPalette) {
		hPalOld = SelectPalette(hdc, (HPALETTE)display.hPal, FALSE);
		if (RealizePalette(hdc)) {
			UpdateColors (hdc);
		}
	}

	// Before an application can use a memory device 
	// context for drawing operations, it must select 
	// a bitmap of the correct width and height into 
	// the device context. Once a bitmap has been selected, 
	// the device context can be used to prepare images 
	// that will be copied to the screen or printed. 
	display.hdcMem = CreateCompatibleDC(hdc);
	if (display.hasPalette) {
		display.hPaletteMemOri = SelectPalette(display.hdcMem, (HPALETTE)display.hPal, FALSE);
		RealizePalette (display.hdcMem);
	}
	display.hBitmap = CreateCompatibleBitmap(hdc, display.winW, display.winH);
	hBitmapOri = (HBITMAP)SelectObject(display.hdcMem, display.hBitmap);

	// Write that nasty brown color into the backing store
	RECT rect = { 0, 0, display.winW, display.winH };
	HBRUSH hbr, hbrOld;
	hbr = hbrBackground;
	hbrOld = (HBRUSH)SelectObject (hdc, hbr);				// Select brush
	FillRect (display.hdcMem, &rect, (HBRUSH)hbr);			// Draw rectangle
	hbr = (HBRUSH)SelectObject (display.hdcMem, hbrOld);	// Unselect brush

#if defined (commentout)
	// Debugging code, writes pattern to backing store
	for (i = 0; i < display.winW; i++) {
		for (int j = 0; j < display.winH; j++) {
		//	SetPixel (display.hdcMem, i, j, RGB(((i+j)%256), 0, 0));
			SetPixel (display.hdcMem, i, j, PALETTEINDEX((i+j) % 256));
		}
	}
#endif

#if defined (commentout)
	// GCS: For now, just keep the old bitmap around.
	//      I'll use it to swap out the full-sized color bitmap
	//      when I do a SetDIBits/GetDIBits.
	display.hBitmapOri = hBitmapOri;
#endif

#if defined (commentout)
	// GCS: Instead of reselecting the default bitmap back into the hdc,
	//      I'm gonna delete it. Any problems with this??
	DeleteObject (hBitmapOri);
#endif

	ReleaseDC(hWnd, hdc);
}


//----------------------------------------------------------------------------
//  FUNCTION: CopyBackingStoreToScreen ()
//----------------------------------------------------------------------------
BOOL CopyBackingStoreToScreen(HDC hdc, HWND hWnd, LPPAINTSTRUCT ps)
{
	HPALETTE hPalOld, hPalOldMem;

	// Is this necessary???
	if (display.hasPalette) {
		hPalOldMem = SelectPalette(display.hdcMem, (HPALETTE)display.hPal, FALSE);
		RealizePalette(display.hdcMem);
		hPalOld = SelectPalette(hdc, (HPALETTE)display.hPal, FALSE);
		RealizePalette(hdc);
	}

	// Copy DIB into DDB
	if (display.useDIB) {
		if (SetDIBits (display.hdcMem, display.hBitmap, 0, 
				display.pbminfo->bmiHeader.biHeight, (LPSTR)display.pBits, 
				display.pbminfo, DIB_RGB_COLORS) == 0) {
			MessageBox (display.hWnd, "Failed in SetDIBits!", "Error", MB_OK);
			exit (-1);
		}
	}

	// Blast DDB onto screen
	if (!BitBlt(hdc, ps->rcPaint.left, ps->rcPaint.top,
			(int)ps->rcPaint.right - ps->rcPaint.left,
			(int)ps->rcPaint.bottom - ps->rcPaint.top,
			display.hdcMem, ps->rcPaint.left, 
			ps->rcPaint.top, SRCCOPY)) {
		MessageBox (NULL, "BitBlt failed!", "Failure!", MB_OK);
	}

	// Draw square mouse
	if (cs_square_mouse_visible) {
		DoSquareMouse (hdc);
	}

	if (display.hasPalette) {
		display.hPal = SelectPalette(display.hdcMem, hPalOldMem, FALSE);
		display.hPal = SelectPalette(hdc, hPalOld, FALSE);
	}

	return TRUE;
}

//----------------------------------------------------------------------------
//  FUNCTION: DoSquareMouse ()
//----------------------------------------------------------------------------
void DoSquareMouse (HDC hdc)
{
  RECT rect;
  int size = (main_types[selected_type].size)*16;

  // Select Brush
  HBRUSH hbr, hbrOld;
  hbr = GetPaletteBrush (white(31));
  hbrOld = (HBRUSH)SelectObject (hdc, hbr);

  // Top rectangle
  rect.left = AdjustX (omx-2);
  rect.top = AdjustY (omy-2);
  rect.right = AdjustX (omx+size+1);
  rect.bottom = AdjustY (omy-1);
  FillRect (hdc, &rect, hbr);

  // Left rectangle
  rect.left = AdjustX (omx-2);
  rect.top = AdjustY (omy);
  rect.right = AdjustX (omx-1);
  rect.bottom = AdjustY (omy+size-1);
  FillRect (hdc, &rect, hbr);

  // Right rectangle
  rect.left = AdjustX (omx+size);
  rect.top = AdjustY (omy);
  rect.right = AdjustX (omx+size+1);
  rect.bottom = AdjustY (omy+size-1);
  FillRect (hdc, &rect, hbr);

  // Bottom rectangle
  rect.left = AdjustX (omx-2);
  rect.top = AdjustY (omy+size);
  rect.right = AdjustX (omx+size+1);
  rect.bottom = AdjustY (omy+size+1);
  FillRect (hdc, &rect, hbr);

  // Unselect brush
  hbr = (HBRUSH)SelectObject (display.hdcMem, hbrOld);
}

//----------------------------------------------------------------------------
//  FUNCTION: CopyPixmapToScreen ()
//----------------------------------------------------------------------------
#if defined (USE_PIXMAPS)
void CopyPixmapToScreen (int t2, int src_x, int src_y, int width, int height,
						 int dst_x, int dst_y)
{
	HDC hdcPixmap;
	RECT rect;

	// Calculate update rectangle
	rect.left = AdjustX (dst_x);
	rect.top = AdjustY (dst_y);
	rect.right = AdjustX (dst_x + width + 1);
	rect.bottom = AdjustY (dst_y + height + 1);

	// Copy bitmap
	if (display.useDIB) {
		HBITMAP hOldBitmap, hOldBitmapMem;
		hdcPixmap = CreateCompatibleDC(display.hdcMem);
		hOldBitmap = (HBITMAP)SelectObject(hdcPixmap, icon_pixmap[t2]);
		hOldBitmapMem = (HBITMAP)SelectObject(display.hdcMem, display.hDIB);
		BitBlt (display.hdcMem, dst_x, dst_y, width, height, hdcPixmap, 
				src_x, src_y, SRCCOPY);
		icon_pixmap[t2] = (HBITMAP)SelectObject(hdcPixmap, hOldBitmap);
		display.hDIB = (HBITMAP)SelectObject(display.hdcMem, hOldBitmapMem);
		DeleteDC (hdcPixmap);
	} else {
		HBITMAP hOldBitmap;
		hdcPixmap = CreateCompatibleDC(display.hdcMem);
		hOldBitmap = (HBITMAP)SelectObject(hdcPixmap, icon_pixmap[t2]);
		BitBlt (display.hdcMem, AdjustX (dst_x), AdjustY (dst_y), 
				width << pix_double, height << pix_double, hdcPixmap,
				src_x << pix_double, src_y << pix_double, SRCCOPY);
		icon_pixmap[t2] = (HBITMAP)SelectObject(hdcPixmap, hOldBitmap);
		DeleteDC (hdcPixmap);
	}

	// Queue up refresh
	InvalidateRect (display.hWnd, &rect, FALSE);
#if defined (commentout)
	// Refresh now!!
	UpdateWindow (display.hWnd);
#endif
}
#endif


//----------------------------------------------------------------------------
//  FUNCTION: About(HWND, unsigned, WORD, LONG)
//
//  PURPOSE:  Processes messages for "About" dialog box
// 		This version allows greater flexibility over the contents of the 'About' box,
// 		by pulling out values from the 'Version' resource.
//
//  MESSAGES:
//
//	WM_INITDIALOG - initialize dialog box
//	WM_COMMAND	- Input received
//
//----------------------------------------------------------------------------
LRESULT CALLBACK About(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
	static  HFONT hfontDlg;		// Font for dialog text
	static	HFONT hFinePrint;	// Font for 'fine print' in dialog
	DWORD   dwVerInfoSize;		// Size of version information block
	LPSTR   lpVersion;			// String pointer to 'version' text
	DWORD   dwVerHnd=0;			// An 'ignored' parameter, always '0'
	UINT	uVersionLen;
	WORD	wRootLen;
	BOOL	bRetCode;
	int	 i;
	char	szFullPath[256];
	char	szResult[256];
	char	szGetName[256];
	DWORD	dwVersion;
	char	szVersion[40];
	DWORD	dwResult;

	switch (message) {
		case WM_INITDIALOG:
			ShowWindow (hDlg, SW_HIDE);
			hfontDlg = CreateFont(16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
				VARIABLE_PITCH | FF_SWISS, "");
			hFinePrint = CreateFont(16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
				VARIABLE_PITCH | FF_SWISS, "");
			CenterWindow (hDlg, GetWindow (hDlg, GW_OWNER));
			GetModuleFileName (display.hInst, szFullPath, sizeof(szFullPath));

			// Now lets dive in and pull out the version information:
			dwVerInfoSize = GetFileVersionInfoSize(szFullPath, &dwVerHnd);
			if (dwVerInfoSize) {
				LPSTR   lpstrVffInfo;
				HANDLE  hMem;
				hMem = GlobalAlloc(GMEM_MOVEABLE, dwVerInfoSize);
				lpstrVffInfo  = (char*) GlobalLock(hMem);
				GetFileVersionInfo(szFullPath, dwVerHnd, dwVerInfoSize, lpstrVffInfo);
				// The below 'hex' value looks a little confusing, but
				// essentially what it is, is the hexidecimal representation
				// of a couple different values that represent the language
				// and character set that we are wanting string values for.
				// 040904E4 is a very common one, because it means:
				//   US English, Windows MultiLingual characterset
				// Or to pull it all apart:
				// 04------		= SUBLANG_ENGLISH_USA
				// --09----		= LANG_ENGLISH
				// ----04E4 = 1252 = Codepage for Windows:Multilingual
				lstrcpy(szGetName, "\\StringFileInfo\\040904E4\\");	 
				wRootLen = lstrlen(szGetName); // Save this position
			
				// Set the title of the dialog:
				lstrcat (szGetName, "ProductName");
				bRetCode = VerQueryValue((LPVOID)lpstrVffInfo,
					(LPSTR)szGetName,
//					(LPVOID)&lpVersion,
					(LPVOID*)&lpVersion,
					(UINT *)&uVersionLen);
				lstrcpy(szResult, "About ");
				lstrcat(szResult, lpVersion);
				SetWindowText (hDlg, szResult);

				// Walk through the dialog items that we want to replace:
				for (i = DLG_VERFIRST; i <= DLG_VERLAST; i++) {
					GetDlgItemText(hDlg, i, szResult, sizeof(szResult));
					szGetName[wRootLen] = (char)0;
					lstrcat (szGetName, szResult);
					uVersionLen   = 0;
					lpVersion	 = NULL;
					bRetCode	  =  VerQueryValue((LPVOID)lpstrVffInfo,
						(LPSTR)szGetName,
//						(LPVOID)&lpVersion,
						(LPVOID*)&lpVersion,
						(UINT *)&uVersionLen);

					if ( bRetCode && uVersionLen && lpVersion) {
					// Replace dialog item text with version info
						lstrcpy(szResult, lpVersion);
						SetDlgItemText(hDlg, i, szResult);
					} else {
						dwResult = GetLastError();
						wsprintf (szResult, "Error %lu", dwResult);
						SetDlgItemText (hDlg, i, szResult);
					}
					SendMessage (GetDlgItem (hDlg, i), WM_SETFONT, 
						(UINT)((i==DLG_VERLAST)?hFinePrint:hfontDlg),
						TRUE);
				} // for (i = DLG_VERFIRST; i <= DLG_VERLAST; i++)


				GlobalUnlock(hMem);
				GlobalFree(hMem);

			} else {
				// No version information available.
			} // if (dwVerInfoSize)

			SendMessage (GetDlgItem (hDlg, IDC_LABEL), WM_SETFONT,
				(WPARAM)hfontDlg,(LPARAM)TRUE);

			// We are  using GetVersion rather then GetVersionEx
			// because earlier versions of Windows NT and Win32s
			// didn't include GetVersionEx:
			dwVersion = GetVersion();

			if (dwVersion < 0x80000000) {
				// Windows NT
				wsprintf (szVersion, "Microsoft Windows NT %u.%u (Build: %u)",
					(DWORD)(LOBYTE(LOWORD(dwVersion))),
					(DWORD)(HIBYTE(LOWORD(dwVersion))),
					(DWORD)(HIWORD(dwVersion)) );
			} else if (LOBYTE(LOWORD(dwVersion))<4) {
				// Win32s
				wsprintf (szVersion, "Microsoft Win32s %u.%u (Build: %u)",
					(DWORD)(LOBYTE(LOWORD(dwVersion))),
					(DWORD)(HIBYTE(LOWORD(dwVersion))),
					(DWORD)(HIWORD(dwVersion) & ~0x8000) );
			} else {
				// Windows 95
				wsprintf (szVersion, "Microsoft Windows 95 %u.%u",
					(DWORD)(LOBYTE(LOWORD(dwVersion))),
					(DWORD)(HIBYTE(LOWORD(dwVersion))) );
			}

			SetWindowText (GetDlgItem(hDlg, IDC_OSVERSION), szVersion);
			ShowWindow (hDlg, SW_SHOW);
			return (TRUE);

		case WM_COMMAND:
			if (LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL) {
				EndDialog(hDlg, TRUE);
				DeleteObject (hfontDlg);
				DeleteObject (hFinePrint);
				return (TRUE);
			}
			break;
	}

	return FALSE;
}


//----------------------------------------------------------------------------
//   FUNCTION: CenterWindow(HWND, HWND)
//
//   PURPOSE: Centers one window over another. 
//
//   COMMENTS:
//
//		In this function, we save the instance handle in a global variable and
//		create and display the main program window.
//
// 		This functionwill center one window over another ensuring that 
//		the placement of the window is within the 'working area', meaning 
//		that it is both within the display limits of the screen, and not 
//		obscured by the tray or other framing elements of the desktop.
//----------------------------------------------------------------------------
BOOL CenterWindow (HWND hwndChild, HWND hwndParent)
{
	RECT	rChild, rParent, rWorkArea;
	int	 wChild, hChild, wParent, hParent;
	int	 xNew, yNew;
	BOOL 	bResult;

	// Get the Height and Width of the child window
	GetWindowRect (hwndChild, &rChild);
	wChild = rChild.right - rChild.left;
	hChild = rChild.bottom - rChild.top;

	// Get the Height and Width of the parent window
	GetWindowRect (hwndParent, &rParent);
	wParent = rParent.right - rParent.left;
	hParent = rParent.bottom - rParent.top;

	// Get the limits of the 'workarea'
	bResult = SystemParametersInfo(
		SPI_GETWORKAREA,	// system parameter to query or set
		sizeof(RECT),
		&rWorkArea,
		0);
	if (!bResult) {
		rWorkArea.left = rWorkArea.top = 0;
		rWorkArea.right = GetSystemMetrics(SM_CXSCREEN);
		rWorkArea.bottom = GetSystemMetrics(SM_CYSCREEN);
	}

	// Calculate new X position, then adjust for workarea
	xNew = rParent.left + ((wParent - wChild) /2);
	if (xNew < rWorkArea.left) {
		xNew = rWorkArea.left;
	} else if ((xNew+wChild) > rWorkArea.right) {
		xNew = rWorkArea.right - wChild;
	}

	// Calculate new Y position, then adjust for workarea
	yNew = rParent.top  + ((hParent - hChild) /2);
	if (yNew < rWorkArea.top) {
		yNew = rWorkArea.top;
	} else if ((yNew+hChild) > rWorkArea.bottom) {
		yNew = rWorkArea.bottom - hChild;
	}

	// Set it, and return
	return SetWindowPos (hwndChild, NULL, xNew, yNew, 0, 0, SWP_NOSIZE | SWP_NOZORDER);
}


//----------------------------------------------------------------------------
//   FUNCTION: AddPaletteEntry ()
//----------------------------------------------------------------------------
void AddPaletteEntry (int col, int red, int grn, int blu)
{
	red = (red * 255) / 60;
	if (red > 255) red = 255;
	grn = (grn * 255) / 60;
	if (grn > 255) grn = 255;
	blu = (blu * 255) / 60;
	if (blu > 255) blu = 255;

	display.colorrefPal[col] = RGB(red, grn, blu);

	if (display.brushPal[col]) {
		DeleteObject (display.brushPal[col]);
		display.brushPal[col] = 0;
	}

	if (display.hasPalette) {
		display.pLogPal->palPalEntry[col].peRed = red;
		display.pLogPal->palPalEntry[col].peGreen = grn;
		display.pLogPal->palPalEntry[col].peBlue = blu;
		display.pLogPal->palPalEntry[col].peFlags = PC_NOCOLLAPSE;
	}

	if (display.useDIB) {
		display.pbminfo->bmiColors[col].rgbRed = red;
		display.pbminfo->bmiColors[col].rgbGreen = grn;
		display.pbminfo->bmiColors[col].rgbBlue = blu;
		display.pbminfo->bmiColors[col].rgbReserved = 0;
	}
}


//----------------------------------------------------------------------------
//  FUNCTION: UpdatePalette ()
//----------------------------------------------------------------------------
void UpdatePalette (void)
{
	if (display.hasPalette) {
		// Make a new HPALETTE and select to hdcGlobal and hdcMem
		HPALETTE hPalNew;
		hPalNew = CreatePalette ((LPLOGPALETTE) display.pLogPal);
		SelectPalette (display.hdcMem, hPalNew, FALSE);
		RealizePalette(display.hdcMem);
		DeleteObject (display.hPal);
		display.hPal = hPalNew;
	}
}

#if defined (commentout)
static void GetFullscreenOption (void)
{
	char foo[100];

	DWORD bytesRead = GetPrivateProfileString (
		"Display",			// points to section name 
		"Full Screen",		// points to key name 
		"",					// points to default string 
		foo,				// points to destination buffer 
		99,					// size of destination buffer 
		"LINCITY.INI"	 	// points to initialization filename 
	);

	if (bytesRead > 0) {
		if (((_stricmp (foo, "TRUE")) == 0)
				|| ((_stricmp (foo, "T")) == 0)
				|| ((_stricmp (foo, "YES")) == 0)
				|| ((_stricmp (foo, "Y")) == 0)
				|| ((_stricmp (foo, "1")) == 0)) {
			int x = 0;
		} else if (((_stricmp (foo, "FALSE")) == 0)
				|| ((_stricmp (foo, "F")) == 0)
				|| ((_stricmp (foo, "NO")) == 0)
				|| ((_stricmp (foo, "N")) == 0)
				|| ((_stricmp (foo, "0")) == 0)) {
			int y = 9;
		}
	}
}
#endif