Mercurial > hg > openttd

--- a/src/video/cocoa/event.mm
+++ b/src/video/cocoa/event.mm
@@ -80,9 +80,8 @@
 		[ NSCursor unhide ];
 		_show_mouse = true;

-		// Hide the openttd cursor when leaving the window
-		if (_cocoa_subdriver != NULL)
-			UndrawMouseCursor();
+		/* Hide the openttd cursor when leaving the window */
+		if (_cocoa_subdriver != NULL) UndrawMouseCursor();
 		_cursor.in_window = false;
 	}
 }
@@ -90,39 +89,32 @@
 void QZ_HideMouse()
 {
 	if (_show_mouse) {
-		/*
-		 * Don't hide the cursor when compiling in debug mode.
-		 * Note: Not hiding the cursor will cause artefacts around it in 8bpp fullscreen mode.
-		 */
+		/* Don't hide the cursor when compiling in debug mode.
+		 * Note: Not hiding the cursor will cause artefacts around it in 8bpp fullscreen mode. */
 #ifndef _DEBUG
 		[ NSCursor hide ];
 #endif
 		_show_mouse = false;

-		// Show the openttd cursor again
+		/* Show the openttd cursor again */
 		_cursor.in_window = true;
 	}
 }

 static void QZ_WarpCursor(int x, int y)
 {
-	NSPoint p;
-	CGPoint cgp;
-
-	assert(_cocoa_subdriver);
+	assert(_cocoa_subdriver != NULL);

 	/* Only allow warping when in foreground */
 	if (![ NSApp isActive ]) return;

-	p = NSMakePoint(x, y);
-	cgp = _cocoa_subdriver->PrivateLocalToCG(&p);
+	NSPoint p = NSMakePoint(x, y);
+	CGPoint cgp = _cocoa_subdriver->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 */
 }


@@ -274,10 +266,9 @@

 static uint32 QZ_MapKey(unsigned short sym)
 {
-	const VkMapping *map;
 	uint32 key = 0;

-	for (map = _vk_mapping; map != endof(_vk_mapping); ++map) {
+	for (const VkMapping *map = _vk_mapping; map != endof(_vk_mapping); ++map) {
 		if (sym == map->vk_from) {
 			key = map->map_to;
 			break;
@@ -323,23 +314,20 @@
 {
 	const int mapping[] = { QZ_CAPSLOCK, QZ_LSHIFT, QZ_LCTRL, QZ_LALT, QZ_LMETA };

-	int i;
-	unsigned int bit;
-
 	if (_current_mods == newMods) return;

 	/* Iterate through the bits, testing each against the current modifiers */
-	for (i = 0, bit = NSAlphaShiftKeyMask; bit <= NSCommandKeyMask; bit <<= 1, ++i) {
+	for (unsigned int i = 0, bit = NSAlphaShiftKeyMask; bit <= NSCommandKeyMask; bit <<= 1, ++i) {
 		unsigned int currentMask, newMask;

 		currentMask = _current_mods & bit;
 		newMask     = newMods & bit;

-		if (currentMask && currentMask != newMask) { /* modifier up event */
+		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 */
+		} 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);
@@ -402,44 +390,37 @@

 static bool QZ_PollEvent()
 {
-	NSEvent *event;
-	NSPoint pt;
-	NSString *chars;
-#ifdef _DEBUG
-	uint32 et0, et;
-#endif
-
 	assert(_cocoa_subdriver != NULL);

 #ifdef _DEBUG
-	et0 = GetTick();
+	uint32 et0 = GetTick();
 #endif
-	event = [ NSApp nextEventMatchingMask:NSAnyEventMask
-			untilDate: [ NSDate distantPast ]
-			inMode: NSDefaultRunLoopMode dequeue:YES ];
+	NSEvent *event = [ NSApp nextEventMatchingMask:NSAnyEventMask
+				untilDate:[ NSDate distantPast ]
+				inMode:NSDefaultRunLoopMode dequeue:YES ];
 #ifdef _DEBUG
-	et = GetTick();
-	_tEvent+= et - et0;
+	_tEvent += GetTick() - et0;
 #endif

 	if (event == nil) return false;
 	if (!_cocoa_subdriver->IsActive()) {
 		QZ_ShowMouse();
-		[NSApp sendEvent:event];
+		[ NSApp sendEvent:event ];
 		return true;
 	}

 	QZ_DoUnsidedModifiers( [ event modifierFlags ] );

-	switch ([event type]) {
+	NSString *chars;
+	NSPoint  pt;
+	switch ([ event type ]) {
 		case NSMouseMoved:
 		case NSOtherMouseDragged:
 		case NSLeftMouseDragged:
 			pt = _cocoa_subdriver->GetMouseLocation(event);
-			if (!_cocoa_subdriver->MouseIsInsideView(&pt) &&
-					!_emulating_right_button) {
+			if (!_cocoa_subdriver->MouseIsInsideView(&pt) && !_emulating_right_button) {
 				QZ_ShowMouse();
-				[NSApp sendEvent:event];
+				[ NSApp sendEvent:event ];
 				break;
 			}

@@ -461,9 +442,8 @@

 			pt = _cocoa_subdriver->GetMouseLocation(event);

-			if (!([ event modifierFlags ] & keymask) ||
-					!_cocoa_subdriver->MouseIsInsideView(&pt)) {
-				[NSApp sendEvent:event];
+			if (!([ event modifierFlags ] & keymask) || !_cocoa_subdriver->MouseIsInsideView(&pt)) {
+				[ NSApp sendEvent:event ];
 			}

 			if (!_cocoa_subdriver->MouseIsInsideView(&pt)) {
@@ -484,7 +464,7 @@
 			break;
 		}
 		case NSLeftMouseUp:
-			[NSApp sendEvent:event];
+			[ NSApp sendEvent:event ];

 			pt = _cocoa_subdriver->GetMouseLocation(event);
 			if (!_cocoa_subdriver->MouseIsInsideView(&pt)) {
@@ -508,7 +488,7 @@
 			pt = _cocoa_subdriver->GetMouseLocation(event);
 			if (!_cocoa_subdriver->MouseIsInsideView(&pt)) {
 				QZ_ShowMouse();
-				[NSApp sendEvent:event];
+				[ NSApp sendEvent:event ];
 				break;
 			}

@@ -521,7 +501,7 @@
 			pt = _cocoa_subdriver->GetMouseLocation(event);
 			if (!_cocoa_subdriver->MouseIsInsideView(&pt)) {
 				QZ_ShowMouse();
-				[NSApp sendEvent:event];
+				[ NSApp sendEvent:event ];
 				break;
 			}

@@ -536,7 +516,7 @@
 			pt = QZ_GetMouseLocation(event);
 			if (!QZ_MouseIsInsideView(&pt)) {
 				QZ_ShowMouse();
-				[NSApp sendEvent:event];
+				[ NSApp sendEvent:event ];
 				break;
 			}

@@ -549,7 +529,7 @@
 			pt = QZ_GetMouseLocation(event);
 			if (!QZ_MouseIsInsideView(&pt)) {
 				QZ_ShowMouse();
-				[NSApp sendEvent:event];
+				[ NSApp sendEvent:event ];
 				break;
 			}

@@ -561,34 +541,34 @@

 		case NSKeyDown:
 			/* Quit, hide and minimize */
-			switch ([event keyCode]) {
+			switch ([ event keyCode ]) {
 				case QZ_q:
 				case QZ_h:
 				case QZ_m:
 					if ([ event modifierFlags ] & NSCommandKeyMask) {
-						[NSApp sendEvent:event];
+						[ NSApp sendEvent:event ];
 					}
 					break;
 			}

 			chars = [ event characters ];
-			QZ_KeyEvent([event keyCode], [ chars length ] ? [ chars characterAtIndex:0 ] : 0, YES);
+			QZ_KeyEvent([ event keyCode ], [ chars length ] ? [ chars characterAtIndex:0 ] : 0, YES);
 			break;

 		case NSKeyUp:
 			/* Quit, hide and minimize */
-			switch ([event keyCode]) {
+			switch ([ event keyCode ]) {
 				case QZ_q:
 				case QZ_h:
 				case QZ_m:
 					if ([ event modifierFlags ] & NSCommandKeyMask) {
-						[NSApp sendEvent:event];
+						[ NSApp sendEvent:event ];
 					}
 					break;
 			}

 			chars = [ event characters ];
-			QZ_KeyEvent([event keyCode], [ chars length ] ? [ chars characterAtIndex:0 ] : 0, NO);
+			QZ_KeyEvent([ event keyCode ], [ chars length ] ? [ chars characterAtIndex:0 ] : 0, NO);
 			break;

 		case NSScrollWheel:
@@ -604,7 +584,7 @@
 			break;

 		default:
-			[NSApp sendEvent:event];
+			[ NSApp sendEvent:event ];
 	}

 	return true;
@@ -617,14 +597,10 @@
 	uint32 last_cur_ticks = cur_ticks;
 	uint32 next_tick = cur_ticks + 30;
 	uint32 pal_tick = 0;
-#ifdef _DEBUG
-	uint32 et0, et, st0, st;
-#endif
-	int i;

 #ifdef _DEBUG
-	et0 = GetTick();
-	st = 0;
+	uint32 et0 = GetTick();
+	uint32 st = 0;
 #endif

 	_screen.dst_ptr = _cocoa_subdriver->GetPixelBuffer();
@@ -633,7 +609,7 @@
 	_cocoa_subdriver->Draw();
 	CSleep(1);

-	for (i = 0; i < 2; i++) GameLoop();
+	for (int i = 0; i < 2; i++) GameLoop();

 	_screen.dst_ptr = _cocoa_subdriver->GetPixelBuffer();
 	UpdateWindows();
@@ -684,7 +660,7 @@
 			_cocoa_subdriver->Draw();
 		} else {
 #ifdef _DEBUG
-			st0 = GetTick();
+			uint32 st0 = GetTick();
 #endif
 			CSleep(1);
 #ifdef _DEBUG
@@ -698,7 +674,7 @@
 	}

 #ifdef _DEBUG
-	et = GetTick();
+	uint32 et = GetTick();

 	DEBUG(driver, 1, "cocoa_v: nextEventMatchingMask took %i ms total", _tEvent);
 	DEBUG(driver, 1, "cocoa_v: game loop took %i ms total (%i ms without sleep)", et - et0, et - et0 - st);
--- a/src/video/cocoa/fullscreen.mm
+++ b/src/video/cocoa/fullscreen.mm
@@ -25,6 +25,7 @@

 #include "../../debug.h"
 #include "../../core/geometry_type.hpp"
+#include "../../core/sort_func.hpp"
 #include "cocoa_v.h"
 #include "../../gfx_func.h"

@@ -73,29 +74,29 @@
 @end


+static int CDECL ModeSorter(const OTTD_Point *p1, const OTTD_Point *p2)
+{
+	if (p1->x < p2->x) return -1;
+	if (p1->x > p2->x) return +1;
+	if (p1->y < p2->y) return -1;
+	if (p1->y > p2->y) return +1;
+	return 0;
+}

 uint QZ_ListModes(OTTD_Point *modes, uint max_modes, CGDirectDisplayID display_id, int display_depth)
 {
-	CFArrayRef mode_list;
-	CFIndex num_modes;
-	CFIndex i;
-	uint count = 0;
-
-	mode_list  = CGDisplayAvailableModes(display_id);
-	num_modes = CFArrayGetCount(mode_list);
+	CFArrayRef mode_list  = CGDisplayAvailableModes(display_id);
+	CFIndex    num_modes = CFArrayGetCount(mode_list);

 	/* Build list of modes with the requested bpp */
-	for (i = 0; i < num_modes && count < max_modes; i++) {
-		CFDictionaryRef onemode;
-		CFNumberRef     number;
-		int bpp;
-		int intvalue;
-		bool hasMode;
+	uint count = 0;
+	for (CFIndex i = 0; i < num_modes && count < max_modes; i++) {
+		int intvalue, bpp;
 		uint16 width, height;

-		onemode = (const __CFDictionary*)CFArrayGetValueAtIndex(mode_list, i);
-		number = (const __CFNumber*)CFDictionaryGetValue(onemode, kCGDisplayBitsPerPixel);
-		CFNumberGetValue (number, kCFNumberSInt32Type, &bpp);
+		CFDictionaryRef onemode = (const __CFDictionary*)CFArrayGetValueAtIndex(mode_list, i);
+		CFNumberRef number = (const __CFNumber*)CFDictionaryGetValue(onemode, kCGDisplayBitsPerPixel);
+		CFNumberGetValue(number, kCFNumberSInt32Type, &bpp);

 		if (bpp != display_depth) continue;

@@ -108,14 +109,11 @@
 		height = (uint16)intvalue;

 		/* Check if mode is already in the list */
-		{
-			uint i;
-			hasMode = false;
-			for (i = 0; i < count; i++) {
-				if (modes[i].x == width &&  modes[i].y == height) {
-					hasMode = true;
-					break;
-				}
+		bool hasMode = false;
+		for (uint i = 0; i < count; i++) {
+			if (modes[i].x == width &&  modes[i].y == height) {
+				hasMode = true;
+				break;
 			}
 		}

@@ -128,37 +126,19 @@
 	}

 	/* Sort list smallest to largest */
-	{
-		uint i, j;
-		for (i = 0; i < count; i++) {
-			for (j = 0; j < count-1; j++) {
-				if (modes[j].x > modes[j + 1].x || (
-					modes[j].x == modes[j + 1].x &&
-					modes[j].y >  modes[j + 1].y
-					)) {
-					uint tmpw = modes[j].x;
-					uint tmph = modes[j].y;
-
-					modes[j].x = modes[j + 1].x;
-					modes[j].y = modes[j + 1].y;
-
-					modes[j + 1].x = tmpw;
-					modes[j + 1].y = tmph;
-				}
-			}
-		}
-	}
+	QSortT(modes, count, &ModeSorter);

 	return count;
 }

-/* Small function to test if the main display can display 8 bpp in fullscreen */
+/** Small function to test if the main display can display 8 bpp in fullscreen */
 bool QZ_CanDisplay8bpp()
 {
 	OTTD_Point p;

-	/* We want to know if 8 bpp is possible in fullscreen and not anything about resolutions.
-	 * Because of this we want to fill a list of 1 resolution of 8 bpp on display 0 (main) and return if we found one. */
+	/* We want to know if 8 bpp is possible in fullscreen and not anything about
+	 * resolutions. Because of this we want to fill a list of 1 resolution of 8 bpp
+	 * on display 0 (main) and return if we found one. */
 	return QZ_ListModes(&p, 1, 0, 8);
 }

@@ -170,17 +150,17 @@
 	void              *screen_buffer;
 	void              *pixel_buffer;

-	CGDirectDisplayID  display_id;         /* 0 == main display (only support single display) */
-	CFDictionaryRef    cur_mode;           /* current mode of the display */
-	CFDictionaryRef    save_mode;          /* original mode of the display */
-	CGDirectPaletteRef palette;            /* palette of an 8-bit display */
+	CGDirectDisplayID  display_id;         ///< 0 == main display (only support single display)
+	CFDictionaryRef    cur_mode;           ///< current mode of the display
+	CFDictionaryRef    save_mode;          ///< original mode of the display
+	CGDirectPaletteRef palette;            ///< palette of an 8-bit display

 	#define MAX_DIRTY_RECTS 100
 	Rect dirty_rects[MAX_DIRTY_RECTS];
 	int num_dirty_rects;


-	/* Gamma functions to try to hide the flash from a rez switch
+	/* Gamma functions to try to hide the flash from a res switch
 	 * Fade the display from normal to black
 	 * Save gamma tables for fade back to normal
 	 */
@@ -189,15 +169,10 @@
 		CGGammaValue redTable[QZ_GAMMA_TABLE_SIZE];
 		CGGammaValue greenTable[QZ_GAMMA_TABLE_SIZE];
 		CGGammaValue blueTable[QZ_GAMMA_TABLE_SIZE];
-		float percent;
-		int j;
+
 		unsigned int actual;
-
-		if (CGGetDisplayTransferByTable(
-					display_id, QZ_GAMMA_TABLE_SIZE,
-					table->red, table->green, table->blue, &actual
-				) != CGDisplayNoErr ||
-				actual != QZ_GAMMA_TABLE_SIZE) {
+		if (CGGetDisplayTransferByTable(this->display_id, QZ_GAMMA_TABLE_SIZE, table->red, table->green, table->blue, &actual) != CGDisplayNoErr
+				|| actual != QZ_GAMMA_TABLE_SIZE) {
 			return 1;
 		}

@@ -205,17 +180,14 @@
 		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++) {
+		for (float percent = 1.0; percent >= 0.0; percent -= 0.01) {
+			for (int 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(
-						display_id, QZ_GAMMA_TABLE_SIZE,
-						redTable, greenTable, blueTable
-					) != CGDisplayNoErr) {
+			if (CGSetDisplayTransferByTable(this->display_id, QZ_GAMMA_TABLE_SIZE, redTable, greenTable, blueTable) != CGDisplayNoErr) {
 				CGDisplayRestoreColorSyncSettings();
 				return 1;
 			}
@@ -234,24 +206,19 @@
 		CGGammaValue redTable[QZ_GAMMA_TABLE_SIZE];
 		CGGammaValue greenTable[QZ_GAMMA_TABLE_SIZE];
 		CGGammaValue 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++) {
+		for (float percent = 0.0; percent <= 1.0; percent += 0.01) {
+			for (int 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(
-						display_id, QZ_GAMMA_TABLE_SIZE,
-						redTable, greenTable, blueTable
-					) != CGDisplayNoErr) {
+			if (CGSetDisplayTransferByTable(this->display_id, QZ_GAMMA_TABLE_SIZE, redTable, greenTable, blueTable) != CGDisplayNoErr) {
 				CGDisplayRestoreColorSyncSettings();
 				return 1;
 			}
@@ -262,33 +229,27 @@
 		return 0;
 	}

-	/* Wait for the VBL to occur (estimated since we don't have a hardware interrupt) */
+	/** Wait for the VBL to occur (estimated since we don't have a hardware interrupt) */
 	void WaitForVerticalBlank()
 	{
 		/* 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 = (const __CFNumber*)CFDictionaryGetValue(cur_mode, kCGDisplayRefreshRate);
+		CFNumberRef refreshRateCFNumber = (const __CFNumber*)CFDictionaryGetValue(this->cur_mode, kCGDisplayRefreshRate);
 		if (refreshRateCFNumber == NULL) return;

-		if (CFNumberGetValue(refreshRateCFNumber, kCFNumberDoubleType, &refreshRate) == 0)
-			return;
+		double refreshRate;
+		if (CFNumberGetValue(refreshRateCFNumber, kCFNumberDoubleType, &refreshRate) == 0) return;

 		if (refreshRate == 0) return;

-		linesPerSecond = refreshRate * display_height;
-		target = display_height;
+		double linesPerSecond = refreshRate * this->display_height;
+		double target = this->display_height;

 		/* Figure out the first delay so we start off about right */
-		position = CGDisplayBeamPosition(display_id);
+		double position = CGDisplayBeamPosition(this->display_id);
 		if (position > target) position = 0;

-		adjustment = (target - position) / linesPerSecond;
+		double adjustment = (target - position) / linesPerSecond;

 		CSleep((uint32)(adjustment * 1000));
 	}
@@ -296,71 +257,63 @@

 	bool SetVideoMode(int w, int h)
 	{
-		boolean_t 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 (pixel_buffer != NULL) {
-			free(pixel_buffer);
-			pixel_buffer = NULL;
+		if (this->pixel_buffer != NULL) {
+			free(this->pixel_buffer);
+			this->pixel_buffer = NULL;
 		}

 		/* See if requested mode exists */
-		cur_mode = CGDisplayBestModeForParameters(display_id, display_depth, w, h, &exact_match);
+		boolean_t exact_match;
+		this->cur_mode = CGDisplayBestModeForParameters(this->display_id, this->display_depth, w, h, &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 = (const __CFNumber*) CFDictionaryGetValue(cur_mode, kCGDisplayBitsPerPixel);
+			int bpp;
+			CFNumberRef number = (const __CFNumber*) CFDictionaryGetValue(this->cur_mode, kCGDisplayBitsPerPixel);
 			CFNumberGetValue(number, kCFNumberSInt32Type, &bpp);
-			if (bpp != display_depth) {
+			if (bpp != this->display_depth) {
 				DEBUG(driver, 0, "Failed to find display resolution");
 				goto ERR_NO_MATCH;
 			}

-			number = (const __CFNumber*)CFDictionaryGetValue(cur_mode, kCGDisplayWidth);
+			number = (const __CFNumber*)CFDictionaryGetValue(this->cur_mode, kCGDisplayWidth);
 			CFNumberGetValue(number, kCFNumberSInt32Type, &w);

-			number = (const __CFNumber*)CFDictionaryGetValue(cur_mode, kCGDisplayHeight);
+			number = (const __CFNumber*)CFDictionaryGetValue(this->cur_mode, kCGDisplayHeight);
 			CFNumberGetValue(number, kCFNumberSInt32Type, &h);
 		}

 		/* Fade display to zero gamma */
-		gamma_error = FadeGammaOut(&gamma_table);
+		OTTD_QuartzGammaTable gamma_table;
+		int gamma_error = this->FadeGammaOut(&gamma_table);

 		/* Put up the blanking window (a window above all other windows) */
-		error = CGDisplayCapture(display_id);
-
-		if (CGDisplayNoErr != error) {
+		if (CGDisplayCapture(this->display_id) != CGDisplayNoErr ) {
 			DEBUG(driver, 0, "Failed capturing display");
 			goto ERR_NO_CAPTURE;
 		}

 		/* Do the physical switch */
-		if (CGDisplaySwitchToMode(display_id, cur_mode) != CGDisplayNoErr) {
+		if (CGDisplaySwitchToMode(this->display_id, this->cur_mode) != CGDisplayNoErr) {
 			DEBUG(driver, 0, "Failed switching display resolution");
 			goto ERR_NO_SWITCH;
 		}

-		screen_buffer = CGDisplayBaseAddress(display_id);
-		screen_pitch  = CGDisplayBytesPerRow(display_id);
+		this->screen_buffer = CGDisplayBaseAddress(this->display_id);
+		this->screen_pitch  = CGDisplayBytesPerRow(this->display_id);

-		display_width = CGDisplayPixelsWide(display_id);
-		display_height = CGDisplayPixelsHigh(display_id);
+		this->display_width = CGDisplayPixelsWide(this->display_id);
+		this->display_height = CGDisplayPixelsHigh(this->display_id);

 		/* Setup double-buffer emulation */
-		pixel_buffer = malloc(display_width * display_height * display_depth / 8);
-		if (pixel_buffer == NULL) {
+		this->pixel_buffer = malloc(this->display_width * this->display_height * this->display_depth / 8);
+		if (this->pixel_buffer == NULL) {
 			DEBUG(driver, 0, "Failed to allocate memory for double buffering");
 			goto ERR_DOUBLEBUF;
 		}

-		if (display_depth == 8 && !CGDisplayCanSetPalette(display_id)) {
+		if (this->display_depth == 8 && !CGDisplayCanSetPalette(this->display_id)) {
 			DEBUG(driver, 0, "Not an indexed display mode.");
 			goto ERR_NOT_INDEXED;
 		}
@@ -377,31 +330,31 @@
 		 * 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, display_width, display_height);
+		NSRect screen_rect = NSMakeRect(0, 0, this->display_width, this->display_height);
 		[ [ NSScreen mainScreen ] setFrame:screen_rect ];


-		pt = [ NSEvent mouseLocation ];
-		pt.y = display_height - pt.y;
-		if (MouseIsInsideView(&pt)) QZ_HideMouse();
+		NSPoint pt = [ NSEvent mouseLocation ];
+		pt.y = this->display_height - pt.y;
+		if (this->MouseIsInsideView(&pt)) QZ_HideMouse();

-		UpdatePalette(0, 256);
+		this->UpdatePalette(0, 256);

 		return true;

 		/* Since the blanking window covers *all* windows (even force quit) correct recovery is crucial */
 ERR_NOT_INDEXED:
-		free(pixel_buffer);
-		pixel_buffer = NULL;
+		free(this->pixel_buffer);
+		this->pixel_buffer = NULL;
 ERR_DOUBLEBUF:
-		CGDisplaySwitchToMode(display_id, save_mode);
+		CGDisplaySwitchToMode(this->display_id, this->save_mode);
 ERR_NO_SWITCH:
 		CGReleaseAllDisplays();
 ERR_NO_CAPTURE:
-		if (!gamma_error) FadeGammaIn(&gamma_table);
+		if (!gamma_error) this->FadeGammaIn(&gamma_table);
 ERR_NO_MATCH:
-		display_width = 0;
-		display_height = 0;
+		this->display_width = 0;
+		this->display_height = 0;

 		return false;
 	}
@@ -410,33 +363,30 @@
 	{
 		/* Release fullscreen resources */
 		OTTD_QuartzGammaTable gamma_table;
-		int gamma_error;
-		NSRect screen_rect;
-
-		gamma_error = FadeGammaOut(&gamma_table);
+		int gamma_error = this->FadeGammaOut(&gamma_table);

 		/* Restore original screen resolution/bpp */
-		CGDisplaySwitchToMode(display_id, save_mode);
+		CGDisplaySwitchToMode(this->display_id, this->save_mode);
 		CGReleaseAllDisplays();
 		ShowMenuBar();
+
 		/* Reset the main screen's rectangle
-		 * See comment in SetVideoMode for why we do this
-		 */
-		screen_rect = NSMakeRect(0, 0, CGDisplayPixelsWide(display_id), CGDisplayPixelsHigh(display_id));
+		 * See comment in SetVideoMode for why we do this */
+		NSRect screen_rect = NSMakeRect(0, 0, CGDisplayPixelsWide(this->display_id), CGDisplayPixelsHigh(this->display_id));
 		[ [ NSScreen mainScreen ] setFrame:screen_rect ];

 		QZ_ShowMouse();

 		/* Destroy the pixel buffer */
-		if (pixel_buffer != NULL) {
-			free(pixel_buffer);
-			pixel_buffer = NULL;
+		if (this->pixel_buffer != NULL) {
+			free(this->pixel_buffer);
+			this->pixel_buffer = NULL;
 		}

-		if (!gamma_error) FadeGammaIn(&gamma_table);
+		if (!gamma_error) this->FadeGammaIn(&gamma_table);

-		display_width = 0;
-		display_height = 0;
+		this->display_width = 0;
+		this->display_height = 0;
 	}

 public:
@@ -447,107 +397,101 @@
 		}

 		/* Initialize the video settings; this data persists between mode switches */
-		display_id = kCGDirectMainDisplay;
-		save_mode  = CGDisplayCurrentMode(display_id);
+		this->display_id = kCGDirectMainDisplay;
+		this->save_mode  = CGDisplayCurrentMode(this->display_id);

-		if (bpp == 8) palette = CGPaletteCreateDefaultColorPalette();
+		if (bpp == 8) this->palette = CGPaletteCreateDefaultColorPalette();

-		display_width  = 0;
-		display_height = 0;
-		display_depth  = bpp;
-		pixel_buffer   = NULL;
+		this->display_width  = 0;
+		this->display_height = 0;
+		this->display_depth  = bpp;
+		this->pixel_buffer   = NULL;

-		num_dirty_rects = MAX_DIRTY_RECTS;
+		this->num_dirty_rects = MAX_DIRTY_RECTS;
 	}

 	virtual ~FullscreenSubdriver()
 	{
-		RestoreVideoMode();
+		this->RestoreVideoMode();
 	}

 	virtual void Draw()
 	{
-		const uint8 *src   = (uint8*) pixel_buffer;
-		uint8 *dst         = (uint8*) screen_buffer;
-		uint pitch         = screen_pitch;
-		uint width         = display_width;
-		uint num_dirty     = num_dirty_rects;
-		uint bytesperpixel = display_depth / 8;
-		uint i;
+		const uint8 *src   = (uint8 *)this->pixel_buffer;
+		uint8 *dst         = (uint8 *)this->screen_buffer;
+		uint pitch         = this->screen_pitch;
+		uint width         = this->display_width;
+		uint num_dirty     = this->num_dirty_rects;
+		uint bytesperpixel = this->display_depth / 8;

 		/* Check if we need to do anything */
 		if (num_dirty == 0) return;

 		if (num_dirty >= MAX_DIRTY_RECTS) {
 			num_dirty = 1;
-			dirty_rects[0].left   = 0;
-			dirty_rects[0].top    = 0;
-			dirty_rects[0].right  = display_width;
-			dirty_rects[0].bottom = display_height;
+			this->dirty_rects[0].left   = 0;
+			this->dirty_rects[0].top    = 0;
+			this->dirty_rects[0].right  = this->display_width;
+			this->dirty_rects[0].bottom = this->display_height;
 		}

 		WaitForVerticalBlank();
 		/* Build the region of dirty rectangles */
-		for (i = 0; i < num_dirty; i++) {
-			uint y      = dirty_rects[i].top;
-			uint left   = dirty_rects[i].left;
-			uint length = dirty_rects[i].right - left;
-			uint bottom = dirty_rects[i].bottom;
+		for (uint i = 0; i < num_dirty; i++) {
+			uint y      = this->dirty_rects[i].top;
+			uint left   = this->dirty_rects[i].left;
+			uint length = this->dirty_rects[i].right - left;
+			uint bottom = this->dirty_rects[i].bottom;

 			for (; y < bottom; y++) {
 				memcpy(dst + y * pitch + left * bytesperpixel, src + y * width * bytesperpixel + left * bytesperpixel, length * bytesperpixel);
 			}
 		}

-		num_dirty_rects = 0;
+		this->num_dirty_rects = 0;
 	}

 	virtual void MakeDirty(int left, int top, int width, int height)
 	{
-		if (num_dirty_rects < MAX_DIRTY_RECTS) {
-			dirty_rects[num_dirty_rects].left = left;
-			dirty_rects[num_dirty_rects].top = top;
-			dirty_rects[num_dirty_rects].right = left + width;
-			dirty_rects[num_dirty_rects].bottom = top + height;
+		if (this->num_dirty_rects < MAX_DIRTY_RECTS) {
+			this->dirty_rects[this->num_dirty_rects].left = left;
+			this->dirty_rects[this->num_dirty_rects].top = top;
+			this->dirty_rects[this->num_dirty_rects].right = left + width;
+			this->dirty_rects[this->num_dirty_rects].bottom = top + height;
 		}
-		num_dirty_rects++;
+		this->num_dirty_rects++;
 	}

 	virtual void UpdatePalette(uint first_color, uint num_colors)
 	{
-		CGTableCount  index;
-		CGDeviceColor color;
+		if (this->display_depth != 8) return;

-		if (display_depth != 8)
-			return;
-
-		for (index = first_color; index < first_color+num_colors; index++) {
+		for (CGTableCount index = first_color; index < first_color + num_colors; index++) {
 			/* Clamp colors between 0.0 and 1.0 */
+			CGDeviceColor color;
 			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(palette, color, index);
+			CGPaletteSetColorAtIndex(this->palette, color, index);
 		}

-		CGDisplaySetPalette(display_id, palette);
+		CGDisplaySetPalette(this->display_id, this->palette);
 	}

 	virtual uint ListModes(OTTD_Point *modes, uint max_modes)
 	{
-		return QZ_ListModes(modes, max_modes, display_id, display_depth);
+		return QZ_ListModes(modes, max_modes, this->display_id, this->display_depth);
 	}

 	virtual bool ChangeResolution(int w, int h)
 	{
-		int old_width  = display_width;
-		int old_height = display_height;
+		int old_width  = this->display_width;
+		int old_height = this->display_height;

-		if (SetVideoMode(w, h))
-			return true;
+		if (SetVideoMode(w, h)) return true;

-		if (old_width != 0 && old_height != 0)
-			SetVideoMode(old_width, old_height);
+		if (old_width != 0 && old_height != 0) SetVideoMode(old_width, old_height);

 		return false;
 	}
@@ -559,17 +503,17 @@

 	virtual int GetWidth()
 	{
-		return display_width;
+		return this->display_width;
 	}

 	virtual int GetHeight()
 	{
-		return display_height;
+		return this->display_height;
 	}

 	virtual void *GetPixelBuffer()
 	{
-		return pixel_buffer;
+		return this->pixel_buffer;
 	}

 	/*
@@ -578,27 +522,20 @@
 	 */
 	virtual CGPoint PrivateLocalToCG(NSPoint *p)
 	{
-		CGPoint cgp;
-
-		cgp.x = p->x;
-		cgp.y = p->y;
-
-		return cgp;
+		return CGPointMake(p->x, p->y);
 	}

 	virtual NSPoint GetMouseLocation(NSEvent *event)
 	{
-		NSPoint pt;
-
-		pt = [ NSEvent mouseLocation ];
-		pt.y = display_height - pt.y;
+		NSPoint pt = [ NSEvent mouseLocation ];
+		pt.y = this->display_height - pt.y;

 		return pt;
 	}

 	virtual bool MouseIsInsideView(NSPoint *pt)
 	{
-		return pt->x >= 0 && pt->y >= 0 && pt->x < display_width && pt->y < display_height;
+		return pt->x >= 0 && pt->y >= 0 && pt->x < this->display_width && pt->y < this->display_height;
 	}

 	virtual bool IsActive()
@@ -609,9 +546,7 @@

 CocoaSubdriver *QZ_CreateFullscreenSubdriver(int width, int height, int bpp)
 {
-	FullscreenSubdriver *ret;
-
-	ret = new FullscreenSubdriver(bpp);
+	FullscreenSubdriver *ret = new FullscreenSubdriver(bpp);

 	if (!ret->ChangeResolution(width, height)) {
 		delete ret;