1 files changed, 141 insertions, 206 deletions

diff --git a/src/video/cocoa/fullscreen.mm b/src/video/cocoa/fullscreen.mm
index b69c8aff8..73ebfe416 100644
--- 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 @@ struct OTTD_QuartzGammaTable {
 @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 @@ uint QZ_ListModes(OTTD_Point *modes, uint max_modes, CGDirectDisplayID display_i
 		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 @@ uint QZ_ListModes(OTTD_Point *modes, uint max_modes, CGDirectDisplayID display_i
 	}
 
 	/* 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 @@ class FullscreenSubdriver: public CocoaSubdriver {
 	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 @@ class FullscreenSubdriver: public CocoaSubdriver {
 		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) {
+		unsigned int actual;
+		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 @@ class FullscreenSubdriver: public CocoaSubdriver {
 		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 @@ class FullscreenSubdriver: public CocoaSubdriver {
 		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 @@ class FullscreenSubdriver: public CocoaSubdriver {
 		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 @@ class FullscreenSubdriver: public CocoaSubdriver {
 
 	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 @@ class FullscreenSubdriver: public CocoaSubdriver {
 		 * 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 @@ ERR_NO_MATCH:
 	{
 		/* 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 @@ public:
 		}
 
 		/* 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 @@ public:
 
 	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 @@ public:
 	 */
 	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 @@ public:
 
 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;