summaryrefslogtreecommitdiff
path: root/src/video/cocoa/fullscreen.mm
diff options
context:
space:
mode:
Diffstat (limited to 'src/video/cocoa/fullscreen.mm')
-rw-r--r--src/video/cocoa/fullscreen.mm347
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;