(svn r3281) -Feature: [OSX] added native cocoa sound and video drivers (egladil)

	you can still use SDL drivers if you like and you have to run "make upgradeconf" to start using the cocoa drivers (or manually write WITH_COCOA:=1)
	since SDL breaks the cocoa drivers, you can't compile with both SDL and cocoa support
	Using cocoa drivers makes it easier to make universal binaries and it solves:
	-FS#18 [OSX] SDL is weird in universal binaries
	-FS#2  [OSX] lazy pointer crash on exit
	-FS#10 [OSX] linking error when linking statically to SDL 1.2.8 (needless to explain this, but it means it should be able to compile statically with the default settings now)
	-[ 1215073 ] Switching to large size out of fullscreen crashes
	Using SDL drivers will still have those issues though

2 files changed, 2243 insertions, 0 deletions

diff --git a/video/cocoa_v.h b/video/cocoa_v.h
new file mode 100644
index 000000000..2d32e0a57
--- /dev/null
+++ b/video/cocoa_v.h
@@ -0,0 +1,130 @@
+
+#ifndef VIDEO_COCOA_H
+#define VIDEO_COCOA_H
+
+#include "../hal.h"
+
+extern const HalVideoDriver _cocoa_video_driver;
+
+/* From SDL_QuartzKeys.h */
+/* These are the Macintosh key scancode constants -- from Inside Macintosh */
+
+#define QZ_ESCAPE		0x35
+#define QZ_F1			0x7A
+#define QZ_F2			0x78
+#define QZ_F3			0x63
+#define QZ_F4			0x76
+#define QZ_F5			0x60
+#define QZ_F6			0x61
+#define QZ_F7			0x62
+#define QZ_F8			0x64
+#define QZ_F9			0x65
+#define QZ_F10			0x6D
+#define QZ_F11			0x67
+#define QZ_F12			0x6F
+#define QZ_PRINT		0x69
+#define QZ_SCROLLOCK    0x6B
+#define QZ_PAUSE		0x71
+#define QZ_POWER		0x7F
+#define QZ_BACKQUOTE	0x32
+#define QZ_1			0x12
+#define QZ_2			0x13
+#define QZ_3			0x14
+#define QZ_4			0x15
+#define QZ_5			0x17
+#define QZ_6			0x16
+#define QZ_7			0x1A
+#define QZ_8			0x1C
+#define QZ_9			0x19
+#define QZ_0			0x1D
+#define QZ_MINUS		0x1B
+#define QZ_EQUALS		0x18
+#define QZ_BACKSPACE	0x33
+#define QZ_INSERT		0x72
+#define QZ_HOME			0x73
+#define QZ_PAGEUP		0x74
+#define QZ_NUMLOCK		0x47
+#define QZ_KP_EQUALS	0x51
+#define QZ_KP_DIVIDE	0x4B
+#define QZ_KP_MULTIPLY	0x43
+#define QZ_TAB			0x30
+#define QZ_q			0x0C
+#define QZ_w			0x0D
+#define QZ_e			0x0E
+#define QZ_r			0x0F
+#define QZ_t			0x11
+#define QZ_y			0x10
+#define QZ_u			0x20
+#define QZ_i			0x22
+#define QZ_o			0x1F
+#define QZ_p			0x23
+#define QZ_LEFTBRACKET	0x21
+#define QZ_RIGHTBRACKET	0x1E
+#define QZ_BACKSLASH	0x2A
+#define QZ_DELETE		0x75
+#define QZ_END			0x77
+#define QZ_PAGEDOWN		0x79
+#define QZ_KP7			0x59
+#define QZ_KP8			0x5B
+#define QZ_KP9			0x5C
+#define QZ_KP_MINUS		0x4E
+#define QZ_CAPSLOCK		0x39
+#define QZ_a			0x00
+#define QZ_s			0x01
+#define QZ_d			0x02
+#define QZ_f			0x03
+#define QZ_g			0x05
+#define QZ_h			0x04
+#define QZ_j			0x26
+#define QZ_k			0x28
+#define QZ_l			0x25
+#define QZ_SEMICOLON	0x29
+#define QZ_QUOTE		0x27
+#define QZ_RETURN		0x24
+#define QZ_KP4			0x56
+#define QZ_KP5			0x57
+#define QZ_KP6			0x58
+#define QZ_KP_PLUS		0x45
+#define QZ_LSHIFT		0x38
+#define QZ_z			0x06
+#define QZ_x			0x07
+#define QZ_c			0x08
+#define QZ_v			0x09
+#define QZ_b			0x0B
+#define QZ_n			0x2D
+#define QZ_m			0x2E
+#define QZ_COMMA		0x2B
+#define QZ_PERIOD		0x2F
+#define QZ_SLASH		0x2C
+#if 1	/* Panther now defines right side keys */
+#define QZ_RSHIFT		0x3C
+#endif
+#define QZ_UP			0x7E
+#define QZ_KP1			0x53
+#define QZ_KP2			0x54
+#define QZ_KP3			0x55
+#define QZ_KP_ENTER		0x4C
+#define QZ_LCTRL		0x3B
+#define QZ_LALT			0x3A
+#define QZ_LMETA		0x37
+#define QZ_SPACE		0x31
+#if 1	/* Panther now defines right side keys */
+#define QZ_RMETA		0x36
+#define QZ_RALT			0x3D
+#define QZ_RCTRL		0x3E
+#endif
+#define QZ_LEFT			0x7B
+#define QZ_DOWN			0x7D
+#define QZ_RIGHT		0x7C
+#define QZ_KP0			0x52
+#define QZ_KP_PERIOD	0x41
+
+/* Wierd, these keys are on my iBook under MacOS X */
+#define QZ_IBOOK_ENTER		0x34
+#define QZ_IBOOK_LEFT		0x3B
+#define QZ_IBOOK_RIGHT		0x3C
+#define QZ_IBOOK_DOWN		0x3D
+#define QZ_IBOOK_UP			0x3E
+
+
+#endif
diff --git a/video/cocoa_v.m b/video/cocoa_v.m
new file mode 100644
index 000000000..2dbc2c478
--- /dev/null
+++ b/video/cocoa_v.m
@@ -0,0 +1,2113 @@
+/******************************************************************************************
+ *                             Cocoa video driver                                         *
+ * Known things left to do:                                                               *
+ *  Nothing at the moment.                                                                *
+ ******************************************************************************************/
+
+#ifdef WITH_COCOA
+
+#import <Cocoa/Cocoa.h>
+#import <sys/time.h> /* gettimeofday */
+#import <sys/param.h> /* for MAXPATHLEN */
+#import <unistd.h>
+
+/* Portions of CPS.h */
+typedef struct CPSProcessSerNum
+{
+	UInt32          lo;
+	UInt32          hi;
+} CPSProcessSerNum;
+
+extern OSErr    CPSGetCurrentProcess( CPSProcessSerNum *psn);
+extern OSErr    CPSEnableForegroundOperation( CPSProcessSerNum *psn, UInt32 _arg2, UInt32 _arg3, UInt32 _arg4, UInt32 _arg5);
+extern OSErr    CPSSetFrontProcess( CPSProcessSerNum *psn);
+
+/* From Menus.h (according to Xcode Developer Documentation) */
+extern void ShowMenuBar(void);
+extern void HideMenuBar(void);
+
+/* Disables a warning. This is needed since the method exists but has been dropped from the header, supposedly as of 10.4. */
+@interface NSApplication(NSAppleMenu)
+- (void)setAppleMenu:(NSMenu *)menu;
+@end
+
+
+/* Name conflict */
+#define Rect		OTTDRect
+#define Point		OTTDPoint
+/* Defined in ppc/param.h or i386/param.h included from sys/param.h */
+#undef ALIGN
+/* Defined in stdbool.h */
+#ifndef __cplusplus
+# ifndef __BEOS__
+#  undef bool
+#  undef false
+#  undef true
+# endif
+#endif
+
+#include "../stdafx.h"
+#include "../openttd.h"
+#include "../debug.h"
+#include "../functions.h"
+#include "../gfx.h"
+#include "../macros.h"
+#include "../sdl.h"
+#include "../window.h"
+#include "../network.h"
+#include "../variables.h"
+#include "../os/macosx/splash.h"
+
+#include "cocoa_v.h"
+
+#undef Point
+#undef Rect
+
+
+/* Subclass of NSWindow to fix genie effect and support resize events  */
+@interface OTTD_QuartzWindow : NSWindow
+- (void)miniaturize:(id)sender;
+- (void)display;
+- (void)setFrame:(NSRect)frameRect display:(BOOL)flag;
+- (void)appDidHide:(NSNotification*)note;
+- (void)appWillUnhide:(NSNotification*)note;
+- (void)appDidUnhide:(NSNotification*)note;
+- (id)initWithContentRect:(NSRect)contentRect styleMask:(unsigned int)styleMask backing:(NSBackingStoreType)backingType defer:(BOOL)flag;
+@end
+
+/* Delegate for our NSWindow to send ask for quit on close */
+@interface OTTD_QuartzWindowDelegate : NSObject
+- (BOOL)windowShouldClose:(id)sender;
+@end
+
+@interface OTTDMain : NSObject
+@end
+
+
+/*
+		Structure for rez switch gamma fades
+		We can hide the monitor flicker by setting the gamma tables to 0
+*/
+#define QZ_GAMMA_TABLE_SIZE 256
+
+typedef struct {
+	CGGammaValue red[QZ_GAMMA_TABLE_SIZE];
+	CGGammaValue green[QZ_GAMMA_TABLE_SIZE];
+	CGGammaValue blue[QZ_GAMMA_TABLE_SIZE];
+} OTTD_QuartzGammaTable;
+
+/*
+    Add methods to get at private members of NSScreen.
+    Since there is a bug in Apple's screen switching code
+    that does not update this variable when switching
+    to fullscreen, we'll set it manually (but only for the
+    main screen).
+*/
+@interface NSScreen (NSScreenAccess)
+		- (void) setFrame:(NSRect)frame;
+@end
+
+@implementation NSScreen (NSScreenAccess)
+- (void) setFrame:(NSRect)frame;
+{
+	_frame = frame;
+}
+@end
+
+
+static void QZ_Draw(void);
+static void QZ_UnsetVideoMode (void);
+static void QZ_UpdatePalette(uint start, uint count);
+static void QZ_WarpCursor (int x, int y);
+void QZ_ShowMouse (void);
+void QZ_HideMouse (void);
+static void CocoaVideoFullScreen(bool full_screen);
+
+
+static NSAutoreleasePool *_ottd_autorelease_pool;
+static OTTDMain *_ottd_main;
+
+
+static struct CocoaVideoData {
+	bool isset;
+	bool issetting;
+
+	CGDirectDisplayID  display_id;         /* 0 == main display (only support single display) */
+	CFDictionaryRef    mode;               /* current mode of the display */
+	CFDictionaryRef    save_mode;          /* original mode of the display */
+	CFArrayRef         mode_list;          /* list of available fullscreen modes */
+	CGDirectPaletteRef palette;            /* palette of an 8-bit display */
+
+	uint32 device_width;
+	uint32 device_height;
+	uint32 device_bpp;
+
+	void *realpixels;
+	uint8 *pixels;
+	uint32 width;
+	uint32 height;
+	uint32 pitch;
+	bool fullscreen;
+
+	unsigned int current_mods;
+	bool tab_is_down;
+	bool emulating_right_button;
+
+	bool cursor_visible;
+	bool active;
+
+#ifdef _DEBUG
+	uint32 tEvent;
+#endif
+
+	OTTD_QuartzWindow *window;
+	NSQuickDrawView *qdview;
+
+#define MAX_DIRTY_RECTS 100
+	OTTDRect dirty_rects[MAX_DIRTY_RECTS];
+	int num_dirty_rects;
+
+	uint16 palette16[256];
+	uint32 palette32[256];
+} _cocoa_video_data;
+
+
+
+
+
+
+/******************************************************************************************
+ *                             Game loop and accessories                                  *
+ ******************************************************************************************/
+
+static uint32 GetTick(void)
+{
+	struct timeval tim;
+
+	gettimeofday(&tim, NULL);
+	return tim.tv_usec / 1000 + tim.tv_sec * 1000;
+}
+
+static void QZ_CheckPaletteAnim(void)
+{
+	if (_pal_last_dirty != -1) {
+		QZ_UpdatePalette(_pal_first_dirty, _pal_last_dirty - _pal_first_dirty + 1);
+		_pal_last_dirty = -1;
+	}
+}
+
+
+
+extern void DoExitSave(void);
+
+static void QZ_AskQuit(void)
+{
+	if (_game_mode == GM_MENU) { // do not ask to quit on the main screen
+		_exit_game = true;
+	} else if (_patches.autosave_on_exit) {
+		DoExitSave();
+		_exit_game = true;
+	} else
+		AskExitGame();
+}
+
+
+
+typedef struct VkMapping {
+	unsigned short vk_from;
+	byte map_to;
+} VkMapping;
+
+#define AS(x, z) {x, z}
+
+static const VkMapping _vk_mapping[] = {
+	AS(10,				WKC_BACKQUOTE),		// key left of '1'
+	// Pageup stuff + up/down
+	//AM(SDLK_PAGEUP, SDLK_PAGEDOWN, WKC_PAGEUP, WKC_PAGEDOWN),  <==== Does this include HOME/END?
+	AS(QZ_PAGEUP,		WKC_PAGEUP),
+	AS(QZ_PAGEDOWN,		WKC_PAGEDOWN),
+
+	AS(QZ_UP,			WKC_UP),
+	AS(QZ_DOWN,			WKC_DOWN),
+	AS(QZ_LEFT,			WKC_LEFT),
+	AS(QZ_RIGHT,		WKC_RIGHT),
+
+	AS(QZ_HOME,			WKC_HOME),
+	AS(QZ_END,			WKC_END),
+
+	AS(QZ_INSERT,		WKC_INSERT),
+	AS(QZ_DELETE,		WKC_DELETE),
+
+	// Letters. QZ_[a-z] is not in numerical order so we can't use AM(...)
+	AS(QZ_a,			'A'),
+	AS(QZ_b,			'B'),
+	AS(QZ_c,			'C'),
+	AS(QZ_d,			'D'),
+	AS(QZ_e,			'E'),
+	AS(QZ_f,			'F'),
+	AS(QZ_g,			'G'),
+	AS(QZ_h,			'H'),
+	AS(QZ_i,			'I'),
+	AS(QZ_j,			'J'),
+	AS(QZ_k,			'K'),
+	AS(QZ_l,			'L'),
+	AS(QZ_m,			'M'),
+	AS(QZ_n,			'N'),
+	AS(QZ_o,			'O'),
+	AS(QZ_p,			'P'),
+	AS(QZ_q,			'Q'),
+	AS(QZ_r,			'R'),
+	AS(QZ_s,			'S'),
+	AS(QZ_t,			'T'),
+	AS(QZ_u,			'U'),
+	AS(QZ_v,			'V'),
+	AS(QZ_w,			'W'),
+	AS(QZ_x,			'X'),
+	AS(QZ_y,			'Y'),
+	AS(QZ_z,			'Z'),
+	// Same thing for digits
+	AS(QZ_0,			'0'),
+	AS(QZ_1,			'1'),
+	AS(QZ_2,			'2'),
+	AS(QZ_3,			'3'),
+	AS(QZ_4,			'4'),
+	AS(QZ_5,			'5'),
+	AS(QZ_6,			'6'),
+	AS(QZ_7,			'7'),
+	AS(QZ_8,			'8'),
+	AS(QZ_9,			'9'),
+
+	AS(QZ_ESCAPE,		WKC_ESC),
+	AS(QZ_PAUSE,  		WKC_PAUSE),
+	AS(QZ_BACKSPACE,	WKC_BACKSPACE),
+
+	AS(QZ_SPACE,		WKC_SPACE),
+	AS(QZ_RETURN,		WKC_RETURN),
+	AS(QZ_TAB,			WKC_TAB),
+
+	// Function keys
+	AS(QZ_F1,			WKC_F1),
+	AS(QZ_F2,			WKC_F2),
+	AS(QZ_F3,			WKC_F3),
+	AS(QZ_F4,			WKC_F4),
+	AS(QZ_F5,			WKC_F5),
+	AS(QZ_F6,			WKC_F6),
+	AS(QZ_F7,			WKC_F7),
+	AS(QZ_F8,			WKC_F8),
+	AS(QZ_F9,			WKC_F9),
+	AS(QZ_F10,			WKC_F10),
+	AS(QZ_F11,			WKC_F11),
+	AS(QZ_F12,			WKC_F12),
+
+	// Numeric part.
+	AS(QZ_KP0,				WKC_NUM_0),
+	AS(QZ_KP1,				WKC_NUM_1),
+	AS(QZ_KP2,				WKC_NUM_2),
+	AS(QZ_KP3,				WKC_NUM_3),
+	AS(QZ_KP4,				WKC_NUM_4),
+	AS(QZ_KP5,				WKC_NUM_5),
+	AS(QZ_KP6,				WKC_NUM_6),
+	AS(QZ_KP7,				WKC_NUM_7),
+	AS(QZ_KP8,				WKC_NUM_8),
+	AS(QZ_KP9,				WKC_NUM_9),
+	AS(QZ_KP_DIVIDE,		WKC_NUM_DIV),
+	AS(QZ_KP_MULTIPLY,		WKC_NUM_MUL),
+	AS(QZ_KP_MINUS,			WKC_NUM_MINUS),
+	AS(QZ_KP_PLUS,			WKC_NUM_PLUS),
+	AS(QZ_KP_ENTER,			WKC_NUM_ENTER),
+	AS(QZ_KP_PERIOD,		WKC_NUM_DECIMAL)
+};
+
+
+static uint32 QZ_MapKey(unsigned short sym)
+{
+	const VkMapping *map;
+	uint32 key = 0;
+
+	for (map = _vk_mapping; map != endof(_vk_mapping); ++map) {
+		if(sym == map->vk_from) {
+			key = map->map_to;
+			break;
+		}
+	}
+
+	if(_cocoa_video_data.current_mods & NSShiftKeyMask)
+		key|= WKC_SHIFT;
+	if(_cocoa_video_data.current_mods & NSControlKeyMask)
+		key|= WKC_CTRL;
+	if(_cocoa_video_data.current_mods & NSAlternateKeyMask)
+		key|= WKC_ALT;
+	if(_cocoa_video_data.current_mods & NSCommandKeyMask)
+		key|= WKC_META;
+
+	return key << 16;
+}
+
+static void QZ_KeyEvent(unsigned short keycode, unsigned short unicode, BOOL down)
+{
+	switch(keycode)
+	{
+		case QZ_UP:
+			SB(_dirkeys, 1, 1, down);
+			break;
+		case QZ_DOWN:
+			SB(_dirkeys, 3, 1, down);
+			break;
+		case QZ_LEFT:
+			SB(_dirkeys, 0, 1, down);
+			break;
+		case QZ_RIGHT:
+			SB(_dirkeys, 2, 1, down);
+			break;
+		case QZ_TAB:
+			_cocoa_video_data.tab_is_down = down;
+			break;
+		case QZ_RETURN:
+		case QZ_f:
+			if(down && ((_cocoa_video_data.current_mods & NSControlKeyMask) || (_cocoa_video_data.current_mods & NSCommandKeyMask)))
+				CocoaVideoFullScreen(!_fullscreen);
+
+	}
+
+	if(down) {
+		_pressed_key = QZ_MapKey(keycode) | unicode;
+		DEBUG(driver, 2)("cocoa_v: QZ_KeyEvent: %x (%x), down, mapping: %x", keycode, unicode, _pressed_key);
+	} else {
+		DEBUG(driver, 2)("cocoa_v: QZ_KeyEvent: %x (%x), up", keycode, unicode);
+	}
+}
+
+static void QZ_DoUnsidedModifiers (unsigned int newMods) {
+
+	const int mapping[] = { QZ_CAPSLOCK, QZ_LSHIFT, QZ_LCTRL, QZ_LALT, QZ_LMETA };
+
+	int i;
+	int bit;
+
+	if (_cocoa_video_data.current_mods == newMods)
+		return;
+
+	/* Iterate through the bits, testing each against the current modifiers */
+	for (i = 0, bit = NSAlphaShiftKeyMask; bit <= NSCommandKeyMask; bit <<= 1, ++i) {
+		unsigned int currentMask, newMask;
+
+		currentMask = _cocoa_video_data.current_mods & bit;
+		newMask     = newMods & bit;
+
+		if ( currentMask && currentMask != newMask ) {     /* modifier up event */
+			/* If this was Caps Lock, we need some additional voodoo to make SDL happy (is this needed in ottd?) */
+			if (bit == NSAlphaShiftKeyMask)
+				QZ_KeyEvent(mapping[i], 0, YES);
+			QZ_KeyEvent(mapping[i], 0, NO);
+		}
+		else if ( newMask && currentMask != newMask ) {     /* modifier down event */
+			QZ_KeyEvent(mapping[i], 0, YES);
+			/* If this was Caps Lock, we need some additional voodoo to make SDL happy (is this needed in ottd?) */
+			if (bit == NSAlphaShiftKeyMask)
+				QZ_KeyEvent(mapping[i], 0, NO);
+		}
+	}
+
+	_cocoa_video_data.current_mods = newMods;
+}
+
+static void QZ_MouseMovedEvent(int x, int y)
+{
+	int dx, dy;
+
+	if (_cursor.fix_at) {
+		dx = x - _cursor.pos.x;
+		dy = y - _cursor.pos.y;
+		if (dx != 0 || dy != 0) {
+			_cursor.delta.x += dx;
+			_cursor.delta.y += dy;
+
+			QZ_WarpCursor(_cursor.pos.x, _cursor.pos.y);
+		}
+	} else {
+		_cursor.delta.x = x - _cursor.pos.x;
+		_cursor.delta.y = y - _cursor.pos.y;
+		_cursor.pos.x = x;
+		_cursor.pos.y = y;
+		_cursor.dirty = true;
+	}
+}
+
+void QZ_MouseButtonEvent( int button, BOOL down )
+{
+	switch(button) {
+		case 0:
+			if(down) {
+				_left_button_down = true;
+			} else {
+				_left_button_down = false;
+				_left_button_clicked = false;
+			}
+			break;
+		case 1:
+			if(down) {
+				_right_button_down = true;
+				_right_button_clicked = true;
+			} else {
+				_right_button_down = false;
+			}
+			break;
+	}
+}
+
+
+static inline NSPoint QZ_GetMouseLocation(NSEvent *event)
+{
+	NSPoint pt;
+
+	if(_cocoa_video_data.fullscreen) {
+		pt = [ NSEvent mouseLocation ];
+		pt.y = _cocoa_video_data.height - pt.y;
+	} else {
+		pt = [event locationInWindow];
+		pt = [_cocoa_video_data.qdview convertPoint:pt fromView:nil];
+	}
+
+	return pt;
+}
+
+static bool QZ_MouseIsInsideView(NSPoint *pt)
+{
+	if(_cocoa_video_data.fullscreen)
+		return pt->x >= 0 && pt->y >= 0 && pt->x < _cocoa_video_data.width && pt->y < _cocoa_video_data.height;
+	else
+		return [ _cocoa_video_data.qdview mouse:*pt inRect:[ _cocoa_video_data.qdview bounds ] ];
+}
+
+
+static bool QZ_PollEvent(void)
+{
+	NSEvent *event;
+	NSPoint pt;
+	NSString *chars;
+#ifdef _DEBUG
+	uint32 et0, et;
+#endif
+
+#ifdef _DEBUG
+	et0 = GetTick();
+#endif
+	event = [ NSApp nextEventMatchingMask:NSAnyEventMask
+			untilDate: [ NSDate distantPast ]
+			inMode: NSDefaultRunLoopMode dequeue:YES ];
+#ifdef _DEBUG
+	et = GetTick();
+	_cocoa_video_data.tEvent+= et - et0;
+#endif
+
+	if(event == nil)
+		return false;
+	if(!_cocoa_video_data.active) {
+		QZ_ShowMouse();
+		[NSApp sendEvent:event];
+		return true;
+	}
+
+	QZ_DoUnsidedModifiers( [ event modifierFlags ] );
+
+	switch ([event type]) {
+		case NSMouseMoved:
+		case NSOtherMouseDragged:
+		case NSRightMouseDragged:
+		case NSLeftMouseDragged:
+			pt = QZ_GetMouseLocation(event);
+			if(!QZ_MouseIsInsideView(&pt) && !_cocoa_video_data.emulating_right_button) {
+				QZ_ShowMouse();
+				[NSApp sendEvent:event];
+				break;
+			}
+
+			QZ_HideMouse();
+			QZ_MouseMovedEvent((int) pt.x, (int) pt.y);
+			break;
+
+		case NSLeftMouseDown:
+			if(!([ event modifierFlags ] & NSCommandKeyMask) || !QZ_MouseIsInsideView(&pt))
+				[NSApp sendEvent:event];
+
+			pt = QZ_GetMouseLocation(event);
+			if(!QZ_MouseIsInsideView(&pt)) {
+				QZ_ShowMouse();
+				break;
+			}
+
+			QZ_HideMouse();
+			QZ_MouseMovedEvent((int) pt.x, (int) pt.y);
+
+			/* Right mouse button emulation */
+			if([ event modifierFlags ] & NSCommandKeyMask) {
+				_cocoa_video_data.emulating_right_button = true;
+				QZ_MouseButtonEvent(1, YES);
+			} else
+				QZ_MouseButtonEvent(0, YES);
+			break;
+		case NSLeftMouseUp:
+			[NSApp sendEvent:event];
+
+			pt = QZ_GetMouseLocation(event);
+			if(!QZ_MouseIsInsideView(&pt)) {
+				QZ_ShowMouse();
+				break;
+			}
+
+			QZ_HideMouse();
+			QZ_MouseMovedEvent((int) pt.x, (int) pt.y);
+
+			/* Right mouse button emulation */
+			if(_cocoa_video_data.emulating_right_button) {
+				_cocoa_video_data.emulating_right_button = false;
+				QZ_MouseButtonEvent(1, NO);
+			} else
+				QZ_MouseButtonEvent(0, NO);
+			break;
+
+		case NSRightMouseDown:
+			pt = QZ_GetMouseLocation(event);
+			if(!QZ_MouseIsInsideView(&pt)) {
+				QZ_ShowMouse();
+				[NSApp sendEvent:event];
+				break;
+			}
+
+			QZ_HideMouse();
+			QZ_MouseMovedEvent((int) pt.x, (int) pt.y);
+			QZ_MouseButtonEvent(1, YES);
+			break;
+		case NSRightMouseUp:
+			pt = QZ_GetMouseLocation(event);
+			if(!QZ_MouseIsInsideView(&pt)) {
+				QZ_ShowMouse();
+				[NSApp sendEvent:event];
+				break;
+			}
+
+			QZ_HideMouse();
+			QZ_MouseMovedEvent((int) pt.x, (int) pt.y);
+			QZ_MouseButtonEvent(1, NO);
+			break;
+
+		/* This is not needed since openttd currently only use two buttons */
+		/*
+		case NSOtherMouseDown:
+			pt = QZ_GetMouseLocation(event);
+			if(!QZ_MouseIsInsideView(&pt)) {
+				QZ_ShowMouse();
+				[NSApp sendEvent:event];
+				break;
+			}
+
+			QZ_HideMouse();
+			QZ_MouseMovedEvent((int) pt.x, (int) pt.y);
+			QZ_MouseButtonEvent([ event buttonNumber ], YES);
+			break;
+		case NSOtherMouseUp:
+			pt = QZ_GetMouseLocation(event);
+			if(!QZ_MouseIsInsideView(&pt)) {
+				QZ_ShowMouse();
+				[NSApp sendEvent:event];
+				break;
+			}
+
+			QZ_HideMouse();
+			QZ_MouseMovedEvent((int) pt.x, (int) pt.y);
+			QZ_MouseButtonEvent([ event buttonNumber ], NO);
+			break;
+		*/
+		case NSKeyDown:
+			/* Quit, hide and minimize */
+			switch([event keyCode]) {
+				case QZ_q:
+				case QZ_h:
+				case QZ_m:
+					if([ event modifierFlags ] & NSCommandKeyMask)
+						[NSApp sendEvent:event];
+					break;
+			}
+
+			chars = [ event characters ];
+			QZ_KeyEvent([event keyCode], [ chars length ] ? [ chars characterAtIndex:0 ] : 0, YES);
+			break;
+
+		case NSKeyUp:
+			/* Quit, hide and minimize */
+			switch([event keyCode]) {
+				case QZ_q:
+				case QZ_h:
+				case QZ_m:
+					if([ event modifierFlags ] & NSCommandKeyMask)
+						[NSApp sendEvent:event];
+					break;
+			}
+
+			chars = [ event characters ];
+			QZ_KeyEvent([event keyCode], [ chars length ] ? [ chars characterAtIndex:0 ] : 0, NO);
+			break;
+
+		case NSScrollWheel:
+			if ( [ event deltaX ] > 0.0 || [ event deltaY ] > 0.0 ) /* Scroll up */
+				_cursor.wheel--;
+			else /* Scroll down */
+				_cursor.wheel++;
+			break;
+
+		default:
+			[NSApp sendEvent:event];
+	}
+
+	return true;
+}
+
+
+
+
+static void QZ_GameLoop(void)
+{
+	uint32 next_tick = GetTick() + 30;
+	uint32 cur_ticks;
+	uint32 pal_tick = 0;
+#ifdef _DEBUG
+	uint32 et0, et, st0, st;
+#endif
+	int i;
+
+	DEBUG(driver, 1)("cocoa_v: QZ_GameLoop");
+
+#ifdef _DEBUG
+	et0 = GetTick();
+	st = 0;
+#endif
+
+	_screen.dst_ptr = _cocoa_video_data.pixels;
+	DisplaySplashImage();
+	QZ_CheckPaletteAnim();
+	QZ_Draw();
+	CSleep(1);
+
+	for(i = 0; i < 2; i++)
+		GameLoop();
+
+	_screen.dst_ptr = _cocoa_video_data.pixels;
+	UpdateWindows();
+	QZ_CheckPaletteAnim();
+	QZ_Draw();
+	CSleep(1);
+
+	while(1) {
+		InteractiveRandom(); // randomness
+
+		while (QZ_PollEvent()) {}
+
+		if (_exit_game)
+			break;
+
+#if defined(_DEBUG)
+		if(_cocoa_video_data.current_mods & NSShiftKeyMask)
+#else
+		if (_cocoa_video_data.tab_is_down)
+#endif
+		{
+			if (!_networking && _game_mode != GM_MENU) _fast_forward |= 2;
+		} else if (_fast_forward & 2) {
+			_fast_forward = 0;
+		}
+
+		cur_ticks = GetTick();
+		if ((_fast_forward && !_pause) || cur_ticks > next_tick)
+			next_tick = cur_ticks;
+
+		if (cur_ticks == next_tick) {
+			next_tick += 30;
+
+			_ctrl_pressed = !!(_cocoa_video_data.current_mods & NSControlKeyMask);
+			_shift_pressed = !!(_cocoa_video_data.current_mods & NSShiftKeyMask);
+#ifdef _DEBUG
+			_dbg_screen_rect = !!(_cocoa_video_data.current_mods & NSAlphaShiftKeyMask);
+#endif
+
+			GameLoop();
+
+			_screen.dst_ptr = _cocoa_video_data.pixels;
+			UpdateWindows();
+			if (++pal_tick > 4) {
+				QZ_CheckPaletteAnim();
+				pal_tick = 1;
+			}
+			QZ_Draw();
+		} else {
+#ifdef _DEBUG
+			st0 = GetTick();
+#endif
+			CSleep(1);
+#ifdef _DEBUG
+			st+= GetTick() - st0;
+#endif
+			_screen.dst_ptr = _cocoa_video_data.pixels;
+			DrawTextMessage();
+			DrawMouseCursor();
+			QZ_Draw();
+		}
+	}
+
+#ifdef _DEBUG
+	et = GetTick();
+
+	DEBUG(driver, 1)("cocoa_v: nextEventMatchingMask took %i ms total", _cocoa_video_data.tEvent);
+	DEBUG(driver, 1)("cocoa_v: game loop took %i ms total (%i ms without sleep)", et - et0, (et - et0) - st);
+	DEBUG(driver, 1)("cocoa_v: (nextEventMatchingMask total)/(game loop total) is %f%%", (double) _cocoa_video_data.tEvent / (double) (et - et0) * 100);
+	DEBUG(driver, 1)("cocoa_v: (nextEventMatchingMask total)/(game loop without sleep total) is %f%%", (double) _cocoa_video_data.tEvent / (double) ((et - et0) - st) * 100);
+#endif
+}
+
+
+
+
+
+
+
+
+
+
+/******************************************************************************************
+ *                             Windowed mode                                              *
+ ******************************************************************************************/
+
+/*
+    This function makes the *game region* of the window 100% opaque.
+    The genie effect uses the alpha component. Otherwise,
+    it doesn't seem to matter what value it has.
+*/
+static void QZ_SetPortAlphaOpaque (void) {
+	if (_cocoa_video_data.device_bpp == 32) {
+		uint32    *pixels = (uint32*) _cocoa_video_data.realpixels;
+		uint32    rowPixels = _cocoa_video_data.pitch / 4;
+		uint32    i, j;
+
+		for (i = 0; i < _cocoa_video_data.height; i++)
+			for (j = 0; j < _cocoa_video_data.width; j++) {
+			pixels[ (i * rowPixels) + j ] |= 0xFF000000;
+		}
+	}
+}
+
+
+@implementation OTTD_QuartzWindow
+
+/* we override these methods to fix the miniaturize animation/dock icon bug */
+- (void)miniaturize:(id)sender
+{
+	/* make the alpha channel opaque so anim won't have holes in it */
+	QZ_SetPortAlphaOpaque ();
+
+	/* window is hidden now */
+	_cocoa_video_data.active = false;
+
+	QZ_ShowMouse();
+
+	[ super miniaturize:sender ];
+}
+
+- (void)display
+{
+    /*
+	This method fires just before the window deminaturizes from the Dock.
+
+	We'll save the current visible surface, let the window manager redraw any
+	UI elements, and restore the surface. This way, no expose event
+	is required, and the deminiaturize works perfectly.
+	*/
+
+	QZ_SetPortAlphaOpaque ();
+
+	/* save current visible surface */
+	[ self cacheImageInRect:[ _cocoa_video_data.qdview frame ] ];
+
+	/* let the window manager redraw controls, border, etc */
+	[ super display ];
+
+	/* restore visible surface */
+	[ self restoreCachedImage ];
+
+	/* window is visible again */
+	_cocoa_video_data.active = true;
+}
+
+- (void)setFrame:(NSRect)frameRect display:(BOOL)flag
+{
+	NSRect newViewFrame;
+	CGrafPtr thePort;
+
+	[ super setFrame:frameRect display:flag ];
+
+	/* Don't do anything if the window is currently beign created */
+    if(_cocoa_video_data.issetting)
+    	return;
+
+	if(_cocoa_video_data.window == nil)
+		return;
+
+	newViewFrame = [ _cocoa_video_data.qdview frame ];
+
+	/* Update the pixels and pitch */
+	thePort = [ _cocoa_video_data.qdview qdPort ];
+	LockPortBits ( thePort );
+
+	_cocoa_video_data.realpixels = GetPixBaseAddr ( GetPortPixMap ( thePort ) );
+	_cocoa_video_data.pitch  = GetPixRowBytes ( GetPortPixMap ( thePort ) );
+
+	/*
+		_cocoa_video_data.realpixels now points to the window's pixels
+		We want it to point to the *view's* pixels
+	*/
+	{
+		int vOffset = [ _cocoa_video_data.window frame ].size.height - newViewFrame.size.height - newViewFrame.origin.y;
+		int hOffset = newViewFrame.origin.x;
+
+		_cocoa_video_data.realpixels = (uint8 *) _cocoa_video_data.realpixels + (vOffset * _cocoa_video_data.pitch) + hOffset * (_cocoa_video_data.device_bpp/8);
+	}
+
+	UnlockPortBits ( thePort );
+
+	/* Allocate new buffer */
+	if(_cocoa_video_data.pixels != NULL)
+		free(_cocoa_video_data.pixels);
+	_cocoa_video_data.pixels = (uint8 *) malloc(newViewFrame.size.width * newViewFrame.size.height);
+	assert(_cocoa_video_data.pixels != NULL);
+
+
+	/* Tell the game that the resolution changed */
+	_cocoa_video_data.width = newViewFrame.size.width;
+	_cocoa_video_data.height = newViewFrame.size.height;
+
+	_screen.width = _cocoa_video_data.width;
+	_screen.height = _cocoa_video_data.height;
+	_screen.pitch = _cocoa_video_data.width;
+
+	GameSizeChanged();
+
+	/* Redraw screen */
+	_cocoa_video_data.num_dirty_rects = MAX_DIRTY_RECTS;
+}
+
+- (void)appDidHide:(NSNotification*)note
+{
+	_cocoa_video_data.active = false;
+//	DEBUG(driver, 1)("cocoa_v: appDidHide");
+}
+
+
+- (void)appWillUnhide:(NSNotification*)note
+{
+	QZ_SetPortAlphaOpaque ();
+
+	/* save current visible surface */
+	[ self cacheImageInRect:[ _cocoa_video_data.qdview frame ] ];
+}
+
+- (void)appDidUnhide:(NSNotification*)note
+{
+	/* restore cached image, since it may not be current, post expose event too */
+	[ self restoreCachedImage ];
+
+	_cocoa_video_data.active = true;
+//	DEBUG(driver, 1)("cocoa_v: appDidUnhide");
+}
+
+
+- (id)initWithContentRect:(NSRect)contentRect styleMask:(unsigned int)styleMask backing:(NSBackingStoreType)backingType defer:(BOOL)flag
+{
+	/* Make our window subclass receive these application notifications */
+	[ [ NSNotificationCenter defaultCenter ] addObserver:self
+	selector:@selector(appDidHide:) name:NSApplicationDidHideNotification object:NSApp ];
+
+	[ [ NSNotificationCenter defaultCenter ] addObserver:self
+	selector:@selector(appDidUnhide:) name:NSApplicationDidUnhideNotification object:NSApp ];
+
+	[ [ NSNotificationCenter defaultCenter ] addObserver:self
+	selector:@selector(appWillUnhide:) name:NSApplicationWillUnhideNotification object:NSApp ];
+
+	return [ super initWithContentRect:contentRect styleMask:styleMask backing:backingType defer:flag ];
+}
+
+@end
+
+@implementation OTTD_QuartzWindowDelegate
+- (BOOL)windowShouldClose:(id)sender
+{
+	QZ_AskQuit();
+
+	return NO;
+}
+
+- (void)windowDidBecomeKey:(NSNotification *)aNotification
+{
+	_cocoa_video_data.active = true;
+//	DEBUG(driver, 1)("cocoa_v: windowDidBecomeKey");
+}
+
+- (void)windowDidResignKey:(NSNotification *)aNotification
+{
+	_cocoa_video_data.active = false;
+//	DEBUG(driver, 1)("cocoa_v: windowDidResignKey");
+}
+
+- (void)windowDidBecomeMain:(NSNotification *)aNotification
+{
+	_cocoa_video_data.active = true;
+//	DEBUG(driver, 1)("cocoa_v: windowDidBecomeMain");
+}
+
+- (void)windowDidResignMain:(NSNotification *)aNotification
+{
+	_cocoa_video_data.active = false;
+//	DEBUG(driver, 1)("cocoa_v: windowDidResignMain");
+}
+
+@end
+
+
+static void QZ_UpdateWindowPalette(uint start, uint count)
+{
+	uint i;
+	uint32 clr32;
+	uint16 clr16;
+
+	switch(_cocoa_video_data.device_bpp)
+	{
+		case 32:
+			for (i = start; i < start + count; i++) {
+				clr32 = 0xff000000;
+				clr32|= ((uint32) _cur_palette[i].r) << 16;
+				clr32|= ((uint32) _cur_palette[i].g) << 8;
+				clr32|= (uint32) _cur_palette[i].b;
+				_cocoa_video_data.palette32[i] = clr32;
+			}
+			break;
+		case 16:
+			for (i = start; i < start + count; i++) {
+				clr16 = 0x0000;
+				clr16|= ((uint16) ((_cur_palette[i].r >> 3) & 0x1f)) << 10;
+				clr16|= ((uint16) ((_cur_palette[i].g >> 3) & 0x1f)) << 5;
+				clr16|= (uint16) ((_cur_palette[i].b >> 3) & 0x1f);
+				_cocoa_video_data.palette16[i] = clr16;
+			}
+			break;
+	}
+
+	_cocoa_video_data.num_dirty_rects = MAX_DIRTY_RECTS;
+}
+
+static inline void QZ_WindowBlitIndexedPixelsToView32(int left, int top, int right, int bottom)
+{
+	uint32 *trg;
+	uint8 *src;
+	int x, y;
+
+	for(y = top; y < bottom; y++) {
+		trg = ((uint32 *) _cocoa_video_data.realpixels) + y * _cocoa_video_data.pitch / 4 + left;
+		src = _cocoa_video_data.pixels + y * _cocoa_video_data.width + left;
+		for(x = left; x < right; x++, trg++, src++) {
+			*trg = _cocoa_video_data.palette32[*src];
+		}
+	}
+}
+
+static inline void QZ_WindowBlitIndexedPixelsToView16(int left, int top, int right, int bottom)
+{
+	uint16 *trg;
+	uint8 *src;
+	int x, y;
+
+	for(y = top; y < bottom; y++) {
+		trg = ((uint16 *) _cocoa_video_data.realpixels) + y * _cocoa_video_data.pitch / 2 + left;
+		src = _cocoa_video_data.pixels + y * _cocoa_video_data.width + left;
+		for(x = left; x < right; x++, trg++, src++) {
+			*trg = _cocoa_video_data.palette16[*src];
+		}
+	}
+}
+
+static inline void QZ_WindowBlitIndexedPixelsToView(int left, int top, int right, int bottom)
+{
+	switch(_cocoa_video_data.device_bpp)
+	{
+		case 32:
+			QZ_WindowBlitIndexedPixelsToView32(left, top, right, bottom);
+			break;
+		case 16:
+			QZ_WindowBlitIndexedPixelsToView16(left, top, right, bottom);
+			break;
+	}
+}
+
+static bool _resize_icon[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
+							  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1,
+							  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0,
+							  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0,
+							  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1,
+							  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1,
+							  0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 0,
+							  0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0,
+							  0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1,
+							  0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1,
+							  0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0,
+							  0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0,
+							  0, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1,
+							  0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1,
+							  0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0,
+							  1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0,
+};
+
+static void QZ_DrawResizeIcon(void) {
+	int xoff, yoff, x, y;
+	uint16 *trg16;
+	uint32 *trg32;
+
+	xoff = _cocoa_video_data.width - 16;
+	yoff = _cocoa_video_data.height - 16;
+
+	for(y = 0; y < 16; y++) {
+		trg16 = ((uint16 *) _cocoa_video_data.realpixels) + (yoff + y) * _cocoa_video_data.pitch / 2 + xoff;
+		trg32 = ((uint32 *) _cocoa_video_data.realpixels) + (yoff + y) * _cocoa_video_data.pitch / 4 + xoff;
+
+		for(x = 0; x < 16; x++, trg16++, trg32++) {
+			if(!_resize_icon[y * 16 + x])
+				continue;
+
+			switch(_cocoa_video_data.device_bpp)
+			{
+				case 32:
+					*trg32 = 0xff000000;
+					break;
+				case 16:
+					*trg16 = 0x0000;
+					break;
+			}
+		}
+	}
+}
+
+static void QZ_DrawWindow (void) {
+	int i;
+	RgnHandle dirty, temp;
+
+	/* Check if we need to do anything */
+	if(_cocoa_video_data.num_dirty_rects == 0 || [ _cocoa_video_data.window isMiniaturized ])
+		return;
+
+	if(_cocoa_video_data.num_dirty_rects >= MAX_DIRTY_RECTS) {
+		_cocoa_video_data.num_dirty_rects = 1;
+		_cocoa_video_data.dirty_rects[0].left = 0;
+		_cocoa_video_data.dirty_rects[0].top = 0;
+		_cocoa_video_data.dirty_rects[0].right = _cocoa_video_data.width;
+		_cocoa_video_data.dirty_rects[0].bottom = _cocoa_video_data.height;
+	}
+
+	dirty = NewRgn ();
+	temp  = NewRgn ();
+
+	SetEmptyRgn (dirty);
+
+	/* Build the region of dirty rectangles */
+	for (i = 0; i < _cocoa_video_data.num_dirty_rects; i++) {
+		QZ_WindowBlitIndexedPixelsToView(_cocoa_video_data.dirty_rects[i].left,
+											_cocoa_video_data.dirty_rects[i].top,
+											_cocoa_video_data.dirty_rects[i].right,
+											_cocoa_video_data.dirty_rects[i].bottom);
+
+		MacSetRectRgn (temp, _cocoa_video_data.dirty_rects[i].left, _cocoa_video_data.dirty_rects[i].top,
+								_cocoa_video_data.dirty_rects[i].right, _cocoa_video_data.dirty_rects[i].bottom);
+		MacUnionRgn (dirty, temp, dirty);
+	}
+
+	QZ_DrawResizeIcon();
+
+	/* Flush the dirty region */
+	QDFlushPortBuffer ( [ _cocoa_video_data.qdview qdPort ], dirty );
+	DisposeRgn (dirty);
+	DisposeRgn (temp);
+
+	_cocoa_video_data.num_dirty_rects = 0;
+}
+
+
+extern const char _openttd_revision[];
+
+static const char *QZ_SetVideoWindowed (uint width, uint height) {
+	char caption[50];
+	NSString *nsscaption;
+	unsigned int style;
+	NSRect contentRect;
+	BOOL isCustom = NO;
+
+	if(width > _cocoa_video_data.device_width)
+		width = _cocoa_video_data.device_width;
+	if(height > _cocoa_video_data.device_height)
+		height = _cocoa_video_data.device_height;
+
+	_cocoa_video_data.width = width;
+	_cocoa_video_data.height = height;
+
+	contentRect = NSMakeRect (0, 0, width, height);
+
+	/*
+			Check if we should completely destroy the previous mode
+			- If it is fullscreen
+	*/
+	if (_cocoa_video_data.isset && _cocoa_video_data.fullscreen )
+		QZ_UnsetVideoMode ();
+
+	/* Check if we should recreate the window */
+	if (_cocoa_video_data.window == nil) {
+
+		/* Set the window style */
+		style = NSTitledWindowMask;
+		style|= (NSMiniaturizableWindowMask | NSClosableWindowMask);
+		style|= NSResizableWindowMask;
+
+		/* Manually create a window, avoids having a nib file resource */
+		_cocoa_video_data.window = [ [ OTTD_QuartzWindow alloc ]
+										initWithContentRect:contentRect
+										styleMask:style
+										backing:NSBackingStoreBuffered
+										defer:NO ];
+
+		if (_cocoa_video_data.window == nil)
+			return "Could not create the Cocoa window";
+
+		snprintf(caption, sizeof(caption), "OpenTTD %s", _openttd_revision);
+		nsscaption = [ [ NSString alloc ] initWithCString:caption encoding:NSASCIIStringEncoding ];
+		[ _cocoa_video_data.window setTitle:nsscaption ];
+		[ _cocoa_video_data.window setMiniwindowTitle:nsscaption ];
+		[ nsscaption release ];
+
+		[ _cocoa_video_data.window setAcceptsMouseMovedEvents:YES ];
+		[ _cocoa_video_data.window setViewsNeedDisplay:NO ];
+
+		[ _cocoa_video_data.window setDelegate: [ [ [ OTTD_QuartzWindowDelegate alloc ] init ] autorelease ] ];
+	}
+	/* We already have a window, just change its size */
+	else {
+
+		if (!isCustom) {
+			[ _cocoa_video_data.window setContentSize:contentRect.size ];
+			[ _cocoa_video_data.qdview setFrameSize:contentRect.size ];
+		}
+	}
+
+	[ _cocoa_video_data.window center ];
+
+	/* Only recreate the view if it doesn't already exist */
+	if (_cocoa_video_data.qdview == nil) {
+
+		_cocoa_video_data.qdview = [ [ NSQuickDrawView alloc ] initWithFrame:contentRect ];
+		[ _cocoa_video_data.qdview setAutoresizingMask: NSViewWidthSizable | NSViewHeightSizable ];
+		[ [ _cocoa_video_data.window contentView ] addSubview:_cocoa_video_data.qdview ];
+		[ _cocoa_video_data.qdview release ];
+		[ _cocoa_video_data.window makeKeyAndOrderFront:nil ];
+	}
+
+	LockPortBits ( [ _cocoa_video_data.qdview qdPort ] );
+	_cocoa_video_data.realpixels = GetPixBaseAddr ( GetPortPixMap ( [ _cocoa_video_data.qdview qdPort ] ) );
+	_cocoa_video_data.pitch  = GetPixRowBytes ( GetPortPixMap ( [ _cocoa_video_data.qdview qdPort ] ) );
+	UnlockPortBits ( [ _cocoa_video_data.qdview qdPort ] );
+
+	/*
+	_cocoa_video_data.realpixels now points to the window's pixels
+	We want it to point to the *view's* pixels
+	*/
+	{
+		int vOffset = [ _cocoa_video_data.window frame ].size.height - [ _cocoa_video_data.qdview frame ].size.height - [ _cocoa_video_data.qdview frame ].origin.y;
+
+		int hOffset = [ _cocoa_video_data.qdview frame ].origin.x;
+
+		_cocoa_video_data.realpixels = (uint8 *) _cocoa_video_data.realpixels + (vOffset * _cocoa_video_data.pitch) + hOffset * (_cocoa_video_data.device_bpp / 8);
+	}
+
+	if(_cocoa_video_data.pixels != NULL)
+		free(_cocoa_video_data.pixels);
+	_cocoa_video_data.pixels = (uint8 *) malloc(width * height);
+	if(_cocoa_video_data.pixels == NULL)
+		return "Failed to allocate 8-bit buffer";
+
+	_cocoa_video_data.fullscreen = false;
+
+	return NULL;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+/******************************************************************************************
+ *                             Fullscreen mode                                            *
+ ******************************************************************************************/
+
+
+/*
+    Gamma functions to try to hide the flash from a rez switch
+    Fade the display from normal to black
+    Save gamma tables for fade back to normal
+*/
+static uint32 QZ_FadeGammaOut (OTTD_QuartzGammaTable *table) {
+
+	CGGammaValue redTable[QZ_GAMMA_TABLE_SIZE],
+		greenTable[QZ_GAMMA_TABLE_SIZE],
+		blueTable[QZ_GAMMA_TABLE_SIZE];
+
+	float percent;
+	int j;
+	unsigned int actual;
+
+	if ( (CGGetDisplayTransferByTable(_cocoa_video_data.display_id, QZ_GAMMA_TABLE_SIZE, table->red, table->green, table->blue, &actual) != CGDisplayNoErr) || actual != QZ_GAMMA_TABLE_SIZE) {
+		return 1;
+	}
+
+	memcpy (redTable, table->red, sizeof(redTable));
+	memcpy (greenTable, table->green, sizeof(greenTable));
+	memcpy (blueTable, table->blue, sizeof(greenTable));
+
+	for (percent = 1.0; percent >= 0.0; percent -= 0.01) {
+		for (j = 0; j < QZ_GAMMA_TABLE_SIZE; j++) {
+			redTable[j]   = redTable[j]   * percent;
+			greenTable[j] = greenTable[j] * percent;
+			blueTable[j]  = blueTable[j]  * percent;
+		}
+
+		if (CGSetDisplayTransferByTable(_cocoa_video_data.display_id, QZ_GAMMA_TABLE_SIZE, redTable, greenTable, blueTable) != CGDisplayNoErr) {
+				CGDisplayRestoreColorSyncSettings();
+				return 1;
+		}
+
+		CSleep (10);
+	}
+
+	return 0;
+}
+
+/*
+    Fade the display from black to normal
+    Restore previously saved gamma values
+*/
+static uint32 QZ_FadeGammaIn (OTTD_QuartzGammaTable *table) {
+
+	CGGammaValue redTable[QZ_GAMMA_TABLE_SIZE],
+	greenTable[QZ_GAMMA_TABLE_SIZE],
+	blueTable[QZ_GAMMA_TABLE_SIZE];
+
+	float percent;
+	int j;
+
+	memset (redTable, 0, sizeof(redTable));
+	memset (greenTable, 0, sizeof(greenTable));
+	memset (blueTable, 0, sizeof(greenTable));
+
+	for (percent = 0.0; percent <= 1.0; percent += 0.01) {
+		for (j = 0; j < QZ_GAMMA_TABLE_SIZE; j++) {
+			redTable[j]   = table->red[j]   * percent;
+			greenTable[j] = table->green[j] * percent;
+			blueTable[j]  = table->blue[j]  * percent;
+		}
+
+		if (CGSetDisplayTransferByTable(_cocoa_video_data.display_id, QZ_GAMMA_TABLE_SIZE, redTable, greenTable, blueTable) != CGDisplayNoErr) {
+			CGDisplayRestoreColorSyncSettings();
+			return 1;
+		}
+
+		CSleep(10);
+	}
+
+	return 0;
+}
+
+static const char *QZ_SetVideoFullScreen (int width, int height) {
+	const char *errstr = "QZ_SetVideoFullScreen error";
+	int exact_match;
+	CFNumberRef number;
+	int bpp;
+	int gamma_error;
+	OTTD_QuartzGammaTable gamma_table;
+	NSRect screen_rect;
+	CGError error;
+	NSPoint pt;
+
+	/* Destroy any previous mode */
+	if (_cocoa_video_data.isset)
+		QZ_UnsetVideoMode ();
+
+	/* See if requested mode exists */
+	_cocoa_video_data.mode = CGDisplayBestModeForParameters(_cocoa_video_data.display_id, 8, width, height, &exact_match);
+
+	/* If the mode wasn't an exact match, check if it has the right bpp, and update width and height */
+	if ( ! exact_match ) {
+		number = CFDictionaryGetValue (_cocoa_video_data.mode, kCGDisplayBitsPerPixel);
+		CFNumberGetValue (number, kCFNumberSInt32Type, &bpp);
+		if(bpp != 8) {
+			errstr = "Failed to find display resolution";
+			goto ERR_NO_MATCH;
+		}
+
+		number = CFDictionaryGetValue (_cocoa_video_data.mode, kCGDisplayWidth);
+		CFNumberGetValue (number, kCFNumberSInt32Type, &width);
+
+		number = CFDictionaryGetValue (_cocoa_video_data.mode, kCGDisplayHeight);
+		CFNumberGetValue (number, kCFNumberSInt32Type, &height);
+	}
+
+	/* Fade display to zero gamma */
+	gamma_error = QZ_FadeGammaOut (&gamma_table);
+
+	/* Put up the blanking window (a window above all other windows) */
+	error = CGDisplayCapture (_cocoa_video_data.display_id);
+
+	if ( CGDisplayNoErr != error ) {
+		errstr = "Failed capturing display";
+		goto ERR_NO_CAPTURE;
+	}
+
+	/* Do the physical switch */
+	if (CGDisplaySwitchToMode (_cocoa_video_data.display_id, _cocoa_video_data.mode) != CGDisplayNoErr) {
+		errstr = "Failed switching display resolution";
+		goto ERR_NO_SWITCH;
+	}
+
+	_cocoa_video_data.realpixels = (uint8 *) CGDisplayBaseAddress (_cocoa_video_data.display_id);
+	_cocoa_video_data.pitch  = CGDisplayBytesPerRow (_cocoa_video_data.display_id);
+
+	_cocoa_video_data.width = CGDisplayPixelsWide (_cocoa_video_data.display_id);
+	_cocoa_video_data.height = CGDisplayPixelsHigh (_cocoa_video_data.display_id);
+	_cocoa_video_data.fullscreen = true;
+
+	/* Setup double-buffer emulation */
+	_cocoa_video_data.pixels = (uint8 *) malloc(width * height);
+	if(_cocoa_video_data.pixels == NULL) {
+		errstr = "Failed to allocate memory for double buffering";
+		goto ERR_DOUBLEBUF;
+	}
+
+	if (!CGDisplayCanSetPalette (_cocoa_video_data.display_id) ) {
+		errstr = "Not an indexed display mode.";
+		goto ERR_NOT_INDEXED;
+	}
+
+	/* If we don't hide menu bar, it will get events and interrupt the program */
+	HideMenuBar ();
+
+	/* Fade the display to original gamma */
+	if (! gamma_error )
+		QZ_FadeGammaIn (&gamma_table);
+
+	/*
+	There is a bug in Cocoa where NSScreen doesn't synchronize
+	with CGDirectDisplay, so the main screen's frame is wrong.
+	As a result, coordinate translation produces incorrect results.
+	We can hack around this bug by setting the screen rect
+	ourselves. This hack should be removed if/when the bug is fixed.
+	*/
+	screen_rect = NSMakeRect(0,0,width,height);
+	[ [ NSScreen mainScreen ] setFrame:screen_rect ];
+
+	/* we're fullscreen, so flag all input states... */
+	_cocoa_video_data.active = true;
+
+
+	pt = [ NSEvent mouseLocation ];
+	pt.y = CGDisplayPixelsHigh (_cocoa_video_data.display_id) - pt.y;
+	if(QZ_MouseIsInsideView(&pt))
+		QZ_HideMouse();
+
+	return NULL;
+
+/* Since the blanking window covers *all* windows (even force quit) correct recovery is crucial */
+ERR_NOT_INDEXED:
+	free(_cocoa_video_data.pixels);
+	_cocoa_video_data.pixels = NULL;
+ERR_DOUBLEBUF:
+	CGDisplaySwitchToMode (_cocoa_video_data.display_id, _cocoa_video_data.save_mode);
+ERR_NO_SWITCH:
+	CGReleaseAllDisplays ();
+ERR_NO_CAPTURE:
+	if (!gamma_error) {
+		QZ_FadeGammaIn (&gamma_table);
+	}
+ERR_NO_MATCH:
+	return errstr;
+}
+
+
+static void QZ_UpdateFullscreenPalette (uint first_color, uint num_colors) {
+
+	CGTableCount  index;
+	CGDeviceColor color;
+
+	for (index = first_color; index < first_color+num_colors; index++) {
+		/* Clamp colors between 0.0 and 1.0 */
+		color.red   = _cur_palette[index].r / 255.0;
+		color.blue  = _cur_palette[index].b / 255.0;
+		color.green = _cur_palette[index].g / 255.0;
+
+		CGPaletteSetColorAtIndex (_cocoa_video_data.palette, color, index);
+	}
+
+	CGDisplaySetPalette (_cocoa_video_data.display_id, _cocoa_video_data.palette);
+}
+
+/* Wait for the VBL to occur (estimated since we don't have a hardware interrupt) */
+static void QZ_WaitForVerticalBlank(void)
+{
+	/* The VBL delay is based on Ian Ollmann's RezLib <iano@cco.caltech.edu> */
+	double refreshRate;
+	double linesPerSecond;
+	double target;
+	double position;
+	double adjustment;
+	CFNumberRef refreshRateCFNumber;
+
+	refreshRateCFNumber = CFDictionaryGetValue (_cocoa_video_data.mode, kCGDisplayRefreshRate);
+	if (refreshRateCFNumber == NULL)
+		return;
+
+	if (CFNumberGetValue (refreshRateCFNumber, kCFNumberDoubleType, &refreshRate) == 0)
+		return;
+
+	if ( refreshRate == 0 )
+		return;
+
+	linesPerSecond = refreshRate * _cocoa_video_data.height;
+	target = _cocoa_video_data.height;
+
+	/* Figure out the first delay so we start off about right */
+	position = CGDisplayBeamPosition (_cocoa_video_data.display_id);
+	if (position > target)
+		position = 0;
+
+	adjustment = (target - position) / linesPerSecond;
+
+	CSleep((uint32) (adjustment * 1000));
+}
+
+static void QZ_DrawScreen(void)
+{
+	uint y;
+	uint8 *src, *dst;
+
+	QZ_WaitForVerticalBlank();
+
+	for(y = 0; y < _cocoa_video_data.height; y++) {
+		src = _cocoa_video_data.pixels + y * _cocoa_video_data.width;
+		dst = ((uint8 *) _cocoa_video_data.realpixels) + y * _cocoa_video_data.pitch;
+
+		memcpy(dst, src, _cocoa_video_data.width);
+	}
+}
+
+static int QZ_ListFullscreenModes (OTTDPoint *mode_list, int max_modes) {
+	CFIndex num_modes;
+	CFIndex i;
+	int list_size = 0;
+
+	num_modes = CFArrayGetCount (_cocoa_video_data.mode_list);
+
+	/* Build list of modes with the requested bpp */
+	for (i = 0; i < num_modes && list_size < max_modes; i++) {
+		CFDictionaryRef onemode;
+		CFNumberRef     number;
+		int bpp;
+		int intvalue;
+		bool hasMode;
+		uint16 width, height;
+
+		onemode = CFArrayGetValueAtIndex (_cocoa_video_data.mode_list, i);
+		number = CFDictionaryGetValue (onemode, kCGDisplayBitsPerPixel);
+		CFNumberGetValue (number, kCFNumberSInt32Type, &bpp);
+
+		if (bpp != 8)
+			continue;
+
+		number = CFDictionaryGetValue (onemode, kCGDisplayWidth);
+		CFNumberGetValue (number, kCFNumberSInt32Type, &intvalue);
+		width = (uint16) intvalue;
+
+		number = CFDictionaryGetValue (onemode, kCGDisplayHeight);
+		CFNumberGetValue (number, kCFNumberSInt32Type, &intvalue);
+		height = (uint16) intvalue;
+
+		/* Check if mode is already in the list */
+		{
+			int i;
+			hasMode = false;
+			for (i = 0; i < list_size; i++) {
+				if (mode_list[i].x == width &&  mode_list[i].y == height) {
+					hasMode = true;
+					break;
+				}
+			}
+		}
+
+		if ( hasMode )
+			continue;
+
+		/* Add mode to the list */
+		mode_list[list_size].x = width;
+		mode_list[list_size].y = height;
+		list_size++;
+	}
+
+	/* Sort list smallest to largest */
+	{
+		int i, j;
+		for (i = 0; i < list_size; i++) {
+			for (j = 0; j < list_size-1; j++) {
+				if(mode_list[j].x > mode_list[j + 1].x || (mode_list[j].x == mode_list[j + 1].x && mode_list[j].y > mode_list[j + 1].y)) {
+					uint tmpw = mode_list[j].x;
+					uint tmph = mode_list[j].y;
+
+					mode_list[j].x = mode_list[j+1].x;
+					mode_list[j].y = mode_list[j+1].y;
+
+					mode_list[j+1].x = tmpw;
+					mode_list[j+1].y = tmph;
+				}
+			}
+		}
+	}
+
+	return list_size;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+/******************************************************************************************
+ *                             Windowed and fullscreen common code                        *
+ ******************************************************************************************/
+
+static void QZ_UpdatePalette(uint start, uint count)
+{
+	if(_cocoa_video_data.fullscreen) {
+		QZ_UpdateFullscreenPalette(start, count);
+	} else {
+		QZ_UpdateWindowPalette(start, count);
+	}
+}
+
+static void QZ_InitPalette(void)
+{
+	QZ_UpdatePalette(0, 256);
+}
+
+static void QZ_Draw(void)
+{
+	if(_cocoa_video_data.fullscreen) {
+		QZ_DrawScreen();
+	} else {
+		QZ_DrawWindow();
+	}
+}
+
+
+static const OTTDPoint _default_resolutions[] = {
+	{ 640,  480},
+	{ 800,  600},
+	{1024,  768},
+	{1152,  864},
+	{1280,  800},
+	{1280,  960},
+	{1280, 1024},
+	{1400, 1050},
+	{1600, 1200},
+	{1680, 1050},
+	{1920, 1200}
+};
+
+static void QZ_UpdateVideoModes(void)
+{
+	uint i, j, count;
+	OTTDPoint modes[32];
+	const OTTDPoint *current_modes;
+
+	if(_cocoa_video_data.fullscreen) {
+		count = QZ_ListFullscreenModes(modes, 32);
+		current_modes = modes;
+	} else {
+		count = lengthof(_default_resolutions);
+		current_modes = _default_resolutions;
+	}
+
+	for(i = 0, j = 0; j < lengthof(_resolutions) && i < count; i++) {
+		if (_cocoa_video_data.fullscreen || ((uint) current_modes[i].x <= _cocoa_video_data.device_width &&
+				  							 (uint) current_modes[i].y <= _cocoa_video_data.device_height)) {
+			_resolutions[j][0] = current_modes[i].x;
+			_resolutions[j][1] = current_modes[i].y;
+			j++;
+		}
+	}
+
+	_num_resolutions = j;
+}
+
+static void QZ_UnsetVideoMode (void) {
+	/* Release fullscreen resources */
+	if ( _cocoa_video_data.fullscreen ) {
+
+		OTTD_QuartzGammaTable gamma_table;
+		int gamma_error;
+		NSRect screen_rect;
+
+		gamma_error = QZ_FadeGammaOut (&gamma_table);
+
+		/* Restore original screen resolution/bpp */
+		CGDisplaySwitchToMode (_cocoa_video_data.display_id, _cocoa_video_data.save_mode);
+		CGReleaseAllDisplays ();
+		ShowMenuBar ();
+        /*
+		Reset the main screen's rectangle
+		See comment in QZ_SetVideoFullscreen for why we do this
+		*/
+		screen_rect = NSMakeRect(0,0,_cocoa_video_data.device_width,_cocoa_video_data.device_height);
+		[ [ NSScreen mainScreen ] setFrame:screen_rect ];
+
+		if (! gamma_error)
+			QZ_FadeGammaIn (&gamma_table);
+	}
+	/* Release window mode resources */
+	else {
+
+		[ _cocoa_video_data.window close ];
+		_cocoa_video_data.window = nil;
+		_cocoa_video_data.qdview = nil;
+	}
+
+	free(_cocoa_video_data.pixels);
+	_cocoa_video_data.pixels = NULL;
+
+	QZ_ShowMouse();
+
+	/* Signal successful teardown */
+	_cocoa_video_data.isset = false;
+}
+
+
+static const char *QZ_SetVideoMode (uint width, uint height, bool fullscreen) {
+	const char *ret;
+
+	/* Setup full screen video */
+	if ( fullscreen ) {
+		_cocoa_video_data.issetting = true;
+		ret = QZ_SetVideoFullScreen (width, height);
+		_cocoa_video_data.issetting = false;
+		if (ret != NULL)
+			return ret;
+	}
+	/* Setup windowed video */
+	else {
+		_cocoa_video_data.issetting = true;
+		ret = QZ_SetVideoWindowed (width, height);
+		_cocoa_video_data.issetting = false;
+		if (ret != NULL)
+			return ret;
+	}
+
+	/* Signal successful completion (used internally) */
+	_cocoa_video_data.isset = true;
+
+	/* Tell the game that the resolution has changed */
+	_screen.width = _cocoa_video_data.width;
+	_screen.height = _cocoa_video_data.height;
+	_screen.pitch = _cocoa_video_data.width;
+
+	QZ_UpdateVideoModes();
+	GameSizeChanged();
+
+	QZ_InitPalette();
+
+	return NULL;
+}
+
+static const char *QZ_SetVideoModeAndRestoreOnFailure (uint width, uint height, bool fullscreen)
+{
+	bool wasset = _cocoa_video_data.isset;
+	uint32 oldwidth = _cocoa_video_data.width;
+	uint32 oldheight = _cocoa_video_data.height;
+	bool oldfullscreen = _cocoa_video_data.fullscreen;
+	const char *ret;
+
+	ret = QZ_SetVideoMode(width, height, fullscreen);
+	if(ret != NULL && wasset)
+		QZ_SetVideoMode(oldwidth, oldheight, oldfullscreen);
+
+	return ret;
+}
+
+static void QZ_VideoInit (void) {
+
+	memset(&_cocoa_video_data, 0, sizeof(_cocoa_video_data));
+
+	/* Initialize the video settings; this data persists between mode switches */
+	_cocoa_video_data.display_id = kCGDirectMainDisplay;
+	_cocoa_video_data.save_mode  = CGDisplayCurrentMode    (_cocoa_video_data.display_id);
+	_cocoa_video_data.mode_list  = CGDisplayAvailableModes (_cocoa_video_data.display_id);
+	_cocoa_video_data.palette    = CGPaletteCreateDefaultColorPalette ();
+
+	/* Gather some information that is useful to know about the display */
+	/* Maybe this should be moved to QZ_SetVideoMode, in case this is changed after startup */
+	CFNumberGetValue (CFDictionaryGetValue (_cocoa_video_data.save_mode, kCGDisplayBitsPerPixel),
+					  kCFNumberSInt32Type, &_cocoa_video_data.device_bpp);
+
+	CFNumberGetValue (CFDictionaryGetValue (_cocoa_video_data.save_mode, kCGDisplayWidth),
+					  kCFNumberSInt32Type, &_cocoa_video_data.device_width);
+
+	CFNumberGetValue (CFDictionaryGetValue (_cocoa_video_data.save_mode, kCGDisplayHeight),
+					  kCFNumberSInt32Type, &_cocoa_video_data.device_height);
+
+	_cocoa_video_data.cursor_visible = true;
+
+	/* register for sleep notifications so wake from sleep generates SDL_VIDEOEXPOSE */
+//	QZ_RegisterForSleepNotifications ();
+}
+
+
+/* Convert local coordinate to window server (CoreGraphics) coordinate */
+static CGPoint QZ_PrivateLocalToCG (NSPoint *p) {
+	CGPoint cgp;
+
+	if ( ! _cocoa_video_data.fullscreen ) {
+		*p = [ _cocoa_video_data.qdview convertPoint:*p toView: nil ];
+		*p = [ _cocoa_video_data.window convertBaseToScreen:*p ];
+		p->y = _cocoa_video_data.device_height - p->y;
+	}
+
+	cgp.x = p->x;
+	cgp.y = p->y;
+
+	return cgp;
+}
+
+static void QZ_WarpCursor (int x, int y) {
+	NSPoint p;
+	CGPoint cgp;
+
+	/* Only allow warping when in foreground */
+	if ( ! [ NSApp isActive ] )
+		return;
+
+	p = NSMakePoint (x, y);
+	cgp = QZ_PrivateLocalToCG (&p);
+
+	/* this is the magic call that fixes cursor "freezing" after warp */
+	CGSetLocalEventsSuppressionInterval (0.0);
+	/* Do the actual warp */
+	CGWarpMouseCursorPosition (cgp);
+
+	/* Generate the mouse moved event */
+//	SDL_PrivateMouseMotion (0, 0, x, y);
+}
+
+void QZ_ShowMouse (void) {
+	if (!_cocoa_video_data.cursor_visible) {
+		[ NSCursor unhide ];
+		_cocoa_video_data.cursor_visible = true;
+	}
+}
+
+void QZ_HideMouse (void) {
+	if (_cocoa_video_data.cursor_visible) {
+#ifndef _DEBUG
+		[ NSCursor hide ];
+#endif
+		_cocoa_video_data.cursor_visible = false;
+	}
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+/******************************************************************************************
+ *                             OS X application creation                                  *
+ ******************************************************************************************/
+
+
+
+/* The main class of the application, the application's delegate */
+@implementation OTTDMain
+/* Called when the internal event loop has just started running */
+- (void) applicationDidFinishLaunching: (NSNotification *) note
+{
+    /* Hand off to main application code */
+	QZ_GameLoop();
+
+	/* We're done, thank you for playing */
+	[ NSApp stop:_ottd_main ];
+}
+
+/* Display the in game quit confirmation dialog */
+- (NSApplicationTerminateReply)applicationShouldTerminate:(NSApplication *) sender
+{
+//	DEBUG(driver, 1)("cocoa_v: applicationShouldTerminate");
+
+	QZ_AskQuit();
+
+	return NSTerminateCancel;		// NSTerminateLater ?
+}
+@end
+
+static void setApplicationMenu(void)
+{
+	/* warning: this code is very odd */
+	NSMenu *appleMenu;
+	NSMenuItem *menuItem;
+	NSString *title;
+	NSString *appName;
+
+	appName = @"OTTD";
+	appleMenu = [[NSMenu alloc] initWithTitle:appName];
+
+	/* Add menu items */
+	title = [@"About " stringByAppendingString:appName];
+	[appleMenu addItemWithTitle:title action:@selector(orderFrontStandardAboutPanel:) keyEquivalent:@""];
+
+	[appleMenu addItem:[NSMenuItem separatorItem]];
+
+	title = [@"Hide " stringByAppendingString:appName];
+	[appleMenu addItemWithTitle:title action:@selector(hide:) keyEquivalent:@"h"];
+
+	menuItem = (NSMenuItem *)[appleMenu addItemWithTitle:@"Hide Others" action:@selector(hideOtherApplications:) keyEquivalent:@"h"];
+	[menuItem setKeyEquivalentModifierMask:(NSAlternateKeyMask|NSCommandKeyMask)];
+
+	[appleMenu addItemWithTitle:@"Show All" action:@selector(unhideAllApplications:) keyEquivalent:@""];
+
+	[appleMenu addItem:[NSMenuItem separatorItem]];
+
+	title = [@"Quit " stringByAppendingString:appName];
+	[appleMenu addItemWithTitle:title action:@selector(terminate:) keyEquivalent:@"q"];
+
+
+	/* Put menu into the menubar */
+	menuItem = [[NSMenuItem alloc] initWithTitle:@"" action:nil keyEquivalent:@""];
+	[menuItem setSubmenu:appleMenu];
+	[[NSApp mainMenu] addItem:menuItem];
+
+	/* Tell the application object that this is now the application menu */
+	[NSApp setAppleMenu:appleMenu];
+
+	/* Finally give up our references to the objects */
+	[appleMenu release];
+	[menuItem release];
+}
+
+/* Create a window menu */
+static void setupWindowMenu(void)
+{
+	NSMenu      *windowMenu;
+	NSMenuItem  *windowMenuItem;
+	NSMenuItem  *menuItem;
+
+	windowMenu = [[NSMenu alloc] initWithTitle:@"Window"];
+
+	/* "Minimize" item */
+	menuItem = [[NSMenuItem alloc] initWithTitle:@"Minimize" action:@selector(performMiniaturize:) keyEquivalent:@"m"];
+	[windowMenu addItem:menuItem];
+	[menuItem release];
+
+	/* Put menu into the menubar */
+	windowMenuItem = [[NSMenuItem alloc] initWithTitle:@"Window" action:nil keyEquivalent:@""];
+	[windowMenuItem setSubmenu:windowMenu];
+	[[NSApp mainMenu] addItem:windowMenuItem];
+
+	/* Tell the application object that this is now the window menu */
+	[NSApp setWindowsMenu:windowMenu];
+
+	/* Finally give up our references to the objects */
+	[windowMenu release];
+	[windowMenuItem release];
+}
+
+static void setupApplication(void)
+{
+	CPSProcessSerNum PSN;
+
+	/* Ensure the application object is initialised */
+	[NSApplication sharedApplication];
+
+	/* Tell the dock about us */
+	if (!CPSGetCurrentProcess(&PSN))
+		if (!CPSEnableForegroundOperation(&PSN,0x03,0x3C,0x2C,0x1103))
+			if (!CPSSetFrontProcess(&PSN))
+				[NSApplication sharedApplication];
+
+	/* Set up the menubar */
+	[NSApp setMainMenu:[[NSMenu alloc] init]];
+	setApplicationMenu();
+	setupWindowMenu();
+
+	/* Create OTTDMain and make it the app delegate */
+	_ottd_main = [[OTTDMain alloc] init];
+	[NSApp setDelegate:_ottd_main];
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+/******************************************************************************************
+ *                             Video driver interface                                     *
+ ******************************************************************************************/
+
+static void CocoaVideoStop(void)
+{
+	DEBUG(driver, 1)("cocoa_v: CocoaVideoStop");
+
+	if(_cocoa_video_data.isset)
+		QZ_UnsetVideoMode();
+
+	[_ottd_main release];
+}
+
+static const char *CocoaVideoStart(const char * const *parm)
+{
+	const char *ret;
+
+	DEBUG(driver, 1)("cocoa_v: CocoaVideoStart");
+
+	setupApplication();
+
+	QZ_VideoInit();
+
+	ret = QZ_SetVideoMode(_cur_resolution[0], _cur_resolution[1], _fullscreen);
+	if(ret != NULL)
+		CocoaVideoStop();
+
+	return ret;
+}
+
+static void CocoaVideoMakeDirty(int left, int top, int width, int height)
+{
+	if (_cocoa_video_data.num_dirty_rects < MAX_DIRTY_RECTS) {
+		_cocoa_video_data.dirty_rects[_cocoa_video_data.num_dirty_rects].left = left;
+		_cocoa_video_data.dirty_rects[_cocoa_video_data.num_dirty_rects].top = top;
+		_cocoa_video_data.dirty_rects[_cocoa_video_data.num_dirty_rects].right = left + width;
+		_cocoa_video_data.dirty_rects[_cocoa_video_data.num_dirty_rects].bottom = top + height;
+	}
+	_cocoa_video_data.num_dirty_rects++;
+}
+
+static void CocoaVideoMainLoop(void)
+{
+	DEBUG(driver, 1)("cocoa_v: CocoaVideoMainLoop");
+
+	/* Start the main event loop */
+	[NSApp run];
+}
+
+static bool CocoaVideoChangeRes(int w, int h)
+{
+	const char *ret;
+	DEBUG(driver, 1)("cocoa_v: CocoaVideoChangeRes");
+
+	ret = QZ_SetVideoModeAndRestoreOnFailure((uint) w, (uint) h, _cocoa_video_data.fullscreen);
+	if(ret != NULL) {
+		DEBUG(driver, 1)("cocoa_v:  failed with message: %s", ret);
+	}
+
+	return ret == NULL;
+}
+
+static void CocoaVideoFullScreen(bool full_screen)
+{
+	const char *ret;
+
+	DEBUG(driver, 1)("cocoa_v: CocoaVideoFullScreen");
+
+	ret = QZ_SetVideoModeAndRestoreOnFailure(_cocoa_video_data.width, _cocoa_video_data.height, full_screen);
+	if(ret != NULL) {
+		DEBUG(driver, 1)("cocoa_v:  failed with message: %s", ret);
+	}
+
+	_fullscreen = _cocoa_video_data.fullscreen;
+}
+
+const HalVideoDriver _cocoa_video_driver = {
+	CocoaVideoStart,
+	CocoaVideoStop,
+	CocoaVideoMakeDirty,
+	CocoaVideoMainLoop,
+	CocoaVideoChangeRes,
+	CocoaVideoFullScreen,
+};
+
+
+/* This is needed since OS X applications are started with the working dir set to / when double-clicked */
+void cocoaSetWorkingDirectory(void)
+{
+	char parentdir[MAXPATHLEN];
+	int chdir_ret;
+	CFURLRef url = CFBundleCopyBundleURL(CFBundleGetMainBundle());
+	CFURLRef url2 = CFURLCreateCopyDeletingLastPathComponent(0, url);
+	if (CFURLGetFileSystemRepresentation(url2, true, (unsigned char *) parentdir, MAXPATHLEN)) {
+		chdir_ret = chdir (parentdir); /* chdir to the binary app's parent */
+		assert(chdir_ret == 0);
+	}
+	CFRelease(url);
+	CFRelease(url2);
+}
+
+/* These are called from main() to prevent a _NSAutoreleaseNoPool error when
+ * exiting before the cocoa video driver has been loaded
+ */
+void cocoaSetupAutoreleasePool(void)
+{
+	_ottd_autorelease_pool = [[NSAutoreleasePool alloc] init];
+}
+
+void cocoaReleaseAutoreleasePool(void)
+{
+	[_ottd_autorelease_pool release];
+}
+
+#endif /* WITH_COCOA */