diff options
Diffstat (limited to 'src/video/cocoa')
-rw-r--r-- | src/video/cocoa/cocoa_keys.h | 127 | ||||
-rw-r--r-- | src/video/cocoa/cocoa_v.h | 71 | ||||
-rw-r--r-- | src/video/cocoa/cocoa_v.mm | 416 | ||||
-rw-r--r-- | src/video/cocoa/event.mm | 700 | ||||
-rw-r--r-- | src/video/cocoa/fullscreen.mm | 617 | ||||
-rw-r--r-- | src/video/cocoa/wnd_quickdraw.mm | 816 |
6 files changed, 2747 insertions, 0 deletions
diff --git a/src/video/cocoa/cocoa_keys.h b/src/video/cocoa/cocoa_keys.h new file mode 100644 index 000000000..1e69c1425 --- /dev/null +++ b/src/video/cocoa/cocoa_keys.h @@ -0,0 +1,127 @@ +/* $Id$ */ + +#ifndef COCOA_KEYS_H +#define COCOA_KEYS_H + +/* 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 0x0A +#define QZ_BACKQUOTE2 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/src/video/cocoa/cocoa_v.h b/src/video/cocoa/cocoa_v.h new file mode 100644 index 000000000..fb53fb2ee --- /dev/null +++ b/src/video/cocoa/cocoa_v.h @@ -0,0 +1,71 @@ +/* $Id$ */ + +#ifndef VIDEO_COCOA_H +#define VIDEO_COCOA_H + +#include "../video_driver.hpp" + +class VideoDriver_Cocoa: public VideoDriver { +public: + /* virtual */ const char *Start(const char * const *param); + + /* virtual */ void Stop(); + + /* virtual */ void MakeDirty(int left, int top, int width, int height); + + /* virtual */ void MainLoop(); + + /* virtual */ bool ChangeResolution(int w, int h); + + /* virtual */ void ToggleFullscreen(bool fullscreen); +}; + +class FVideoDriver_Cocoa: public VideoDriverFactory<FVideoDriver_Cocoa> { +public: + static const int priority = 10; + /* virtual */ const char *GetName() { return "cocoa"; } + /* virtual */ const char *GetDescription() { return "Cocoa Video Driver"; } + /* virtual */ Driver *CreateInstance() { return new VideoDriver_Cocoa(); } +}; + + + +class CocoaSubdriver { +public: + virtual ~CocoaSubdriver() {} + + virtual void Draw() = 0; + virtual void MakeDirty(int left, int top, int width, int height) = 0; + virtual void UpdatePalette(uint first_color, uint num_colors) = 0; + + virtual uint ListModes(OTTDPoint* modes, uint max_modes) = 0; + + virtual bool ChangeResolution(int w, int h) = 0; + + virtual bool IsFullscreen() = 0; + virtual int GetWidth() = 0; + virtual int GetHeight() = 0; + virtual void *GetPixelBuffer() = 0; + + /* Convert local coordinate to window server (CoreGraphics) coordinate */ + virtual CGPoint PrivateLocalToCG(NSPoint* p) = 0; + + virtual NSPoint GetMouseLocation(NSEvent *event) = 0; + virtual bool MouseIsInsideView(NSPoint *pt) = 0; + + virtual bool IsActive() = 0; +}; + +extern CocoaSubdriver* _cocoa_subdriver; + +CocoaSubdriver *QZ_CreateFullscreenSubdriver(int width, int height, int bpp); +CocoaSubdriver *QZ_CreateWindowQuickdrawSubdriver(int width, int height, int bpp); + +void QZ_GameSizeChanged(); + +void QZ_GameLoop(); + +void QZ_ShowMouse(); +void QZ_HideMouse(); + +#endif /* VIDEO_COCOA_H */ diff --git a/src/video/cocoa/cocoa_v.mm b/src/video/cocoa/cocoa_v.mm new file mode 100644 index 000000000..7e09b3d7d --- /dev/null +++ b/src/video/cocoa/cocoa_v.mm @@ -0,0 +1,416 @@ +/* $Id$ */ + +/****************************************************************************** + * Cocoa video driver * + * Known things left to do: * + * Nothing at the moment. * + ******************************************************************************/ + +#ifdef WITH_COCOA + +#include <AvailabilityMacros.h> + +#import <Cocoa/Cocoa.h> +#import <sys/time.h> /* gettimeofday */ +#import <sys/param.h> /* for MAXPATHLEN */ +#import <unistd.h> + +/** + * Important notice regarding all modifications!!!!!!! + * There are certain limitations because the file is objective C++. + * gdb has limitations. + * C++ and objective C code can't be joined in all cases (classes stuff). + * Read http://developer.apple.com/releasenotes/Cocoa/Objective-C++.html for more information. + */ + + +/* Portions of CPS.h */ +struct CPSProcessSerNum { + UInt32 lo; + UInt32 hi; +}; + +extern "C" OSErr CPSGetCurrentProcess(CPSProcessSerNum* psn); +extern "C" OSErr CPSEnableForegroundOperation(CPSProcessSerNum* psn, UInt32 _arg2, UInt32 _arg3, UInt32 _arg4, UInt32 _arg5); +extern "C" OSErr CPSSetFrontProcess(CPSProcessSerNum* psn); + +/* Disables a warning. This is needed since the method exists but has been dropped from the header, supposedly as of 10.4. */ +#if (MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_4) +@interface NSApplication(NSAppleMenu) +- (void)setAppleMenu:(NSMenu *)menu; +@end +#endif + + +/* 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 "../../macros.h" +#include "../../os/macosx/splash.h" +#include "../../variables.h" +#include "../../gfx.h" +#include "cocoa_v.h" +#include "cocoa_keys.h" +#include "../../blitter/factory.hpp" +#include "../../fileio.h" + +#undef Point +#undef Rect + + +@interface OTTDMain : NSObject +@end + + +static NSAutoreleasePool *_ottd_autorelease_pool; +static OTTDMain *_ottd_main; +static bool _cocoa_video_started = false; +static bool _cocoa_video_dialog = false; + +CocoaSubdriver* _cocoa_subdriver = NULL; + + + +/* 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 +{ + + HandleExitGameRequest(); + + return NSTerminateCancel; // NSTerminateLater ? +} +@end + +static void setApplicationMenu() +{ + /* 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() +{ + 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() +{ + CPSProcessSerNum PSN; + + /* Ensure the application object is initialised */ + [NSApplication sharedApplication]; + + /* Tell the dock about us */ + if (!CPSGetCurrentProcess(&PSN) && + !CPSEnableForegroundOperation(&PSN, 0x03, 0x3C, 0x2C, 0x1103) && + !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]; +} + + +static void QZ_UpdateVideoModes() +{ + uint i, count; + OTTDPoint modes[32]; + + assert(_cocoa_subdriver != NULL); + + count = _cocoa_subdriver->ListModes(modes, lengthof(modes)); + + for (i = 0; i < count; i++) { + _resolutions[i][0] = modes[i].x; + _resolutions[i][1] = modes[i].y; + } + + _num_resolutions = count; +} + + +void QZ_GameSizeChanged() +{ + if (_cocoa_subdriver == NULL) return; + + /* Tell the game that the resolution has changed */ + _screen.width = _cocoa_subdriver->GetWidth(); + _screen.height = _cocoa_subdriver->GetHeight(); + _screen.pitch = _cocoa_subdriver->GetWidth(); + _fullscreen = _cocoa_subdriver->IsFullscreen(); + + GameSizeChanged(); +} + + +static CocoaSubdriver *QZ_CreateWindowSubdriver(int width, int height, int bpp) +{ + // For now there is only the quickdraw window mode subdriver, but a pure quartz one should be added. + return QZ_CreateWindowQuickdrawSubdriver(width, height, bpp); +} + + +static CocoaSubdriver *QZ_CreateSubdriver(int width, int height, int bpp, bool fullscreen, bool fallback) +{ + CocoaSubdriver *ret; + + ret = fullscreen ? QZ_CreateFullscreenSubdriver(width, height, bpp) : QZ_CreateWindowSubdriver(width, height, bpp); + if (ret != NULL) return ret; + + if (!fallback) return NULL; + + /* Try again in 640x480 windowed */ + DEBUG(driver, 0, "Setting video mode failed, falling back to 640x480 windowed mode."); + ret = QZ_CreateWindowSubdriver(640, 480, bpp); + if (ret != NULL) return ret; + +#ifdef _DEBUG + /* Try fullscreen too when in debug mode */ + DEBUG(driver, 0, "Setting video mode failed, falling back to 640x480 fullscreen mode."); + ret = QZ_CreateFullscreenSubdriver(640, 480, bpp); + if (ret != NULL) return ret; +#endif + + return NULL; +} + + +static FVideoDriver_Cocoa iFVideoDriver_Cocoa; + +void VideoDriver_Cocoa::Stop() +{ + if (!_cocoa_video_started) return; + + delete _cocoa_subdriver; + _cocoa_subdriver = NULL; + + [_ottd_main release]; + + _cocoa_video_started = false; +} + +const char *VideoDriver_Cocoa::Start(const char * const *parm) +{ + int width, height, bpp; + + if (_cocoa_video_started) return "Already started"; + _cocoa_video_started = true; + + setupApplication(); + + /* Don't create a window or enter fullscreen if we're just going to show a dialog. */ + if (_cocoa_video_dialog) return NULL; + + width = _cur_resolution[0]; + height = _cur_resolution[1]; + bpp = BlitterFactoryBase::GetCurrentBlitter()->GetScreenDepth(); + + _cocoa_subdriver = QZ_CreateSubdriver(width, height, bpp, _fullscreen, true); + if (_cocoa_subdriver == NULL) { + Stop(); + return "Could not create subdriver"; + } + + QZ_GameSizeChanged(); + + QZ_UpdateVideoModes(); + + return NULL; +} + +void VideoDriver_Cocoa::MakeDirty(int left, int top, int width, int height) +{ + assert(_cocoa_subdriver != NULL); + + _cocoa_subdriver->MakeDirty(left, top, width, height); +} + +void VideoDriver_Cocoa::MainLoop() +{ + /* Start the main event loop */ + [NSApp run]; +} + +bool VideoDriver_Cocoa::ChangeResolution(int w, int h) +{ + bool ret; + + assert(_cocoa_subdriver != NULL); + + ret = _cocoa_subdriver->ChangeResolution(w, h); + + QZ_GameSizeChanged(); + + QZ_UpdateVideoModes(); + + return ret; +} + +void VideoDriver_Cocoa::ToggleFullscreen(bool full_screen) +{ + bool oldfs; + + assert(_cocoa_subdriver != NULL); + + oldfs = _cocoa_subdriver->IsFullscreen(); + if (full_screen != oldfs) { + int width = _cocoa_subdriver->GetWidth(); + int height = _cocoa_subdriver->GetHeight(); + int bpp = BlitterFactoryBase::GetCurrentBlitter()->GetScreenDepth(); + + delete _cocoa_subdriver; + _cocoa_subdriver = NULL; + + _cocoa_subdriver = QZ_CreateSubdriver(width, height, bpp, full_screen, false); + if (_cocoa_subdriver == NULL) { + _cocoa_subdriver = QZ_CreateSubdriver(width, height, bpp, oldfs, true); + if (_cocoa_subdriver == NULL) error("Cocoa: Failed to create subdriver"); + } + } + + QZ_GameSizeChanged(); + + QZ_UpdateVideoModes(); +} + + +/* This is needed since sometimes assert is called before the videodriver is initialized */ +void CocoaDialog(const char* title, const char* message, const char* buttonLabel) +{ + bool wasstarted; + + _cocoa_video_dialog = true; + + wasstarted = _cocoa_video_started; + if (_video_driver == NULL) { + setupApplication(); // Setup application before showing dialog + } else if (!_cocoa_video_started && _video_driver->Start(NULL) != NULL) { + fprintf(stderr, "%s: %s\n", title, message); + return; + } + + NSRunAlertPanel([NSString stringWithCString: title], [NSString stringWithCString: message], [NSString stringWithCString: buttonLabel], nil, nil); + + if (!wasstarted && _video_driver != NULL) _video_driver->Stop(); + + _cocoa_video_dialog = false; +} + +/* This is needed since OS X application bundles do not have a + * current directory and the data files are 'somewhere' in the bundle */ +void cocoaSetApplicationBundleDir() +{ + char tmp[MAXPATHLEN]; + CFURLRef url = CFBundleCopyResourcesDirectoryURL(CFBundleGetMainBundle()); + if (CFURLGetFileSystemRepresentation(url, true, (unsigned char*)tmp, MAXPATHLEN)) { + AppendPathSeparator(tmp, lengthof(tmp)); + _searchpaths[SP_APPLICATION_BUNDLE_DIR] = strdup(tmp); + } else { + _searchpaths[SP_APPLICATION_BUNDLE_DIR] = NULL; + } + + CFRelease(url); +} + +/* These are called from main() to prevent a _NSAutoreleaseNoPool error when + * exiting before the cocoa video driver has been loaded + */ +void cocoaSetupAutoreleasePool() +{ + _ottd_autorelease_pool = [[NSAutoreleasePool alloc] init]; +} + +void cocoaReleaseAutoreleasePool() +{ + [_ottd_autorelease_pool release]; +} + +#endif /* WITH_COCOA */ diff --git a/src/video/cocoa/event.mm b/src/video/cocoa/event.mm new file mode 100644 index 000000000..9151f4002 --- /dev/null +++ b/src/video/cocoa/event.mm @@ -0,0 +1,700 @@ +/* $Id$ */ + +/****************************************************************************** + * 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> + +/** + * Important notice regarding all modifications!!!!!!! + * There are certain limitations because the file is objective C++. + * gdb has limitations. + * C++ and objective C code can't be joined in all cases (classes stuff). + * Read http://developer.apple.com/releasenotes/Cocoa/Objective-C++.html for more information. + */ + + +/* 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 "../../macros.h" +#include "../../os/macosx/splash.h" +#include "../../variables.h" +#include "../../gfx.h" +#include "cocoa_v.h" +#include "cocoa_keys.h" +#include "../../blitter/factory.hpp" +#include "../../fileio.h" + +#undef Point +#undef Rect + +/* Right Mouse Button Emulation enum */ +enum { + RMBE_COMMAND, + RMBE_CONTROL, + RMBE_OFF, +}; + + +static bool _show_mouse = true; +static unsigned int _current_mods; +static bool _tab_is_down; +static bool _emulating_right_button; +#ifdef _DEBUG +static uint32 _tEvent; +#endif + + +static uint32 GetTick() +{ + struct timeval tim; + + gettimeofday(&tim, NULL); + return tim.tv_usec / 1000 + tim.tv_sec * 1000; +} + + +void QZ_ShowMouse() +{ + if (!_show_mouse) { + [ NSCursor unhide ]; + _show_mouse = true; + + // Hide the openttd cursor when leaving the window + if (_cocoa_subdriver != NULL) + UndrawMouseCursor(); + _cursor.in_window = false; + } +} + +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. + */ +#ifndef _DEBUG + [ NSCursor hide ]; +#endif + _show_mouse = false; + + // Show the openttd cursor again + _cursor.in_window = true; + } +} + +static void QZ_WarpCursor(int x, int y) +{ + NSPoint p; + CGPoint cgp; + + assert(_cocoa_subdriver); + + /* Only allow warping when in foreground */ + if (![ NSApp isActive ]) return; + + p = NSMakePoint(x, y); + 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 */ +} + + +static void QZ_CheckPaletteAnim() +{ + if (_pal_count_dirty != 0) { + Blitter *blitter = BlitterFactoryBase::GetCurrentBlitter(); + + switch (blitter->UsePaletteAnimation()) { + case Blitter::PALETTE_ANIMATION_VIDEO_BACKEND: + _cocoa_subdriver->UpdatePalette(_pal_first_dirty, _pal_count_dirty); + break; + + case Blitter::PALETTE_ANIMATION_BLITTER: + blitter->PaletteAnimate(_pal_first_dirty, _pal_count_dirty); + break; + + case Blitter::PALETTE_ANIMATION_NONE: + break; + + default: + NOT_REACHED(); + } + _pal_count_dirty = 0; + } +} + + + +struct VkMapping { + unsigned short vk_from; + byte map_to; +}; + +#define AS(x, z) {x, z} + +static const VkMapping _vk_mapping[] = { + AS(QZ_BACKQUOTE, WKC_BACKQUOTE), // key left of '1' + AS(QZ_BACKQUOTE2, WKC_BACKQUOTE), // some keyboards have it on another scancode + + /* Pageup stuff + up/down */ + 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), + + /* Other non-letter keys */ + AS(QZ_SLASH, WKC_SLASH), + AS(QZ_SEMICOLON, WKC_SEMICOLON), + AS(QZ_EQUALS, WKC_EQUALS), + AS(QZ_LEFTBRACKET, WKC_L_BRACKET), + AS(QZ_BACKSLASH, WKC_BACKSLASH), + AS(QZ_RIGHTBRACKET, WKC_R_BRACKET), + + AS(QZ_QUOTE, WKC_SINGLEQUOTE), + AS(QZ_COMMA, WKC_COMMA), + AS(QZ_MINUS, WKC_MINUS), + AS(QZ_PERIOD, WKC_PERIOD) +}; + + +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 (_current_mods & NSShiftKeyMask) key |= WKC_SHIFT; + if (_current_mods & NSControlKeyMask) key |= (_patches.right_mouse_btn_emulation != RMBE_CONTROL ? WKC_CTRL : WKC_META); + if (_current_mods & NSAlternateKeyMask) key |= WKC_ALT; + if (_current_mods & NSCommandKeyMask) key |= (_patches.right_mouse_btn_emulation != RMBE_CONTROL ? WKC_META : WKC_CTRL); + + 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: _tab_is_down = down; break; + + case QZ_RETURN: + case QZ_f: + if (down && (_current_mods & NSCommandKeyMask)) { + _video_driver->ToggleFullscreen(!_fullscreen); + } + break; + } + + if (down) { + uint32 pressed_key = QZ_MapKey(keycode) | unicode; + HandleKeypress(pressed_key); + 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; + 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) { + unsigned int currentMask, newMask; + + currentMask = _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); + } + } + + _current_mods = newMods; +} + +static void QZ_MouseMovedEvent(int x, int y) +{ + if (_cursor.fix_at) { + int dx = x - _cursor.pos.x; + int 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; + } + HandleMouseEvents(); +} + + +static 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; + } + HandleMouseEvents(); + break; + + case 1: + if (down) { + _right_button_down = true; + _right_button_clicked = true; + } else { + _right_button_down = false; + } + HandleMouseEvents(); + break; + } +} + + + + +static bool QZ_PollEvent() +{ + NSEvent *event; + NSPoint pt; + NSString *chars; +#ifdef _DEBUG + uint32 et0, et; +#endif + + assert(_cocoa_subdriver != NULL); + +#ifdef _DEBUG + et0 = GetTick(); +#endif + event = [ NSApp nextEventMatchingMask:NSAnyEventMask + untilDate: [ NSDate distantPast ] + inMode: NSDefaultRunLoopMode dequeue:YES ]; +#ifdef _DEBUG + et = GetTick(); + _tEvent+= et - et0; +#endif + + if (event == nil) return false; + if (!_cocoa_subdriver->IsActive()) { + QZ_ShowMouse(); + [NSApp sendEvent:event]; + return true; + } + + QZ_DoUnsidedModifiers( [ event modifierFlags ] ); + + switch ([event type]) { + case NSMouseMoved: + case NSOtherMouseDragged: + case NSRightMouseDragged: + case NSLeftMouseDragged: + pt = _cocoa_subdriver->GetMouseLocation(event); + if (!_cocoa_subdriver->MouseIsInsideView(&pt) && + !_emulating_right_button) { + QZ_ShowMouse(); + [NSApp sendEvent:event]; + break; + } + + QZ_HideMouse(); + QZ_MouseMovedEvent((int)pt.x, (int)pt.y); + break; + + case NSLeftMouseDown: + { + uint32 keymask = 0; + if (_patches.right_mouse_btn_emulation == RMBE_COMMAND) keymask |= NSCommandKeyMask; + if (_patches.right_mouse_btn_emulation == RMBE_CONTROL) keymask |= NSControlKeyMask; + + pt = _cocoa_subdriver->GetMouseLocation(event); + + if (!([ event modifierFlags ] & keymask) || + !_cocoa_subdriver->MouseIsInsideView(&pt)) { + [NSApp sendEvent:event]; + } + + if (!_cocoa_subdriver->MouseIsInsideView(&pt)) { + QZ_ShowMouse(); + break; + } + + QZ_HideMouse(); + QZ_MouseMovedEvent((int)pt.x, (int)pt.y); + + /* Right mouse button emulation */ + if ([ event modifierFlags ] & keymask) { + _emulating_right_button = true; + QZ_MouseButtonEvent(1, YES); + } else { + QZ_MouseButtonEvent(0, YES); + } + break; + } + case NSLeftMouseUp: + [NSApp sendEvent:event]; + + pt = _cocoa_subdriver->GetMouseLocation(event); + if (!_cocoa_subdriver->MouseIsInsideView(&pt)) { + QZ_ShowMouse(); + break; + } + + QZ_HideMouse(); + QZ_MouseMovedEvent((int)pt.x, (int)pt.y); + + /* Right mouse button emulation */ + if (_emulating_right_button) { + _emulating_right_button = false; + QZ_MouseButtonEvent(1, NO); + } else { + QZ_MouseButtonEvent(0, NO); + } + break; + + case NSRightMouseDown: + pt = _cocoa_subdriver->GetMouseLocation(event); + if (!_cocoa_subdriver->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 = _cocoa_subdriver->GetMouseLocation(event); + if (!_cocoa_subdriver->MouseIsInsideView(&pt)) { + QZ_ShowMouse(); + [NSApp sendEvent:event]; + break; + } + + QZ_HideMouse(); + QZ_MouseMovedEvent((int)pt.x, (int)pt.y); + QZ_MouseButtonEvent(1, NO); + break; + +#if 0 + /* 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; +#endif + + 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 deltaY ] > 0.0) { /* Scroll up */ + _cursor.wheel--; + } else if ([ event deltaY ] < 0.0) { /* Scroll down */ + _cursor.wheel++; + } /* else: deltaY was 0.0 and we don't want to do anything */ + + /* Set the scroll count for scrollwheel scrolling */ + _cursor.h_wheel -= (int)([ event deltaX ]* 5 * _patches.scrollwheel_multiplier); + _cursor.v_wheel -= (int)([ event deltaY ]* 5 * _patches.scrollwheel_multiplier); + break; + + default: + [NSApp sendEvent:event]; + } + + return true; +} + + +void QZ_GameLoop() +{ + uint32 cur_ticks = GetTick(); + 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; +#endif + + _screen.dst_ptr = _cocoa_subdriver->GetPixelBuffer(); + DisplaySplashImage(); + QZ_CheckPaletteAnim(); + _cocoa_subdriver->Draw(); + CSleep(1); + + for (i = 0; i < 2; i++) GameLoop(); + + _screen.dst_ptr = _cocoa_subdriver->GetPixelBuffer(); + UpdateWindows(); + QZ_CheckPaletteAnim(); + _cocoa_subdriver->Draw(); + CSleep(1); + + for (;;) { + uint32 prev_cur_ticks = cur_ticks; // to check for wrapping + InteractiveRandom(); // randomness + + while (QZ_PollEvent()) {} + + if (_exit_game) break; + +#if defined(_DEBUG) + if (_current_mods & NSShiftKeyMask) +#else + if (_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 (cur_ticks >= next_tick || (_fast_forward && !_pause_game) || cur_ticks < prev_cur_ticks) { + _realtime_tick += cur_ticks - last_cur_ticks; + last_cur_ticks = cur_ticks; + next_tick = cur_ticks + 30; + + _ctrl_pressed = !!(_current_mods & ( _patches.right_mouse_btn_emulation != RMBE_CONTROL ? NSControlKeyMask : NSCommandKeyMask)); + _shift_pressed = !!(_current_mods & NSShiftKeyMask); + + GameLoop(); + + _screen.dst_ptr = _cocoa_subdriver->GetPixelBuffer(); + UpdateWindows(); + if (++pal_tick > 4) { + QZ_CheckPaletteAnim(); + pal_tick = 1; + } + _cocoa_subdriver->Draw(); + } else { +#ifdef _DEBUG + st0 = GetTick(); +#endif + CSleep(1); +#ifdef _DEBUG + st += GetTick() - st0; +#endif + _screen.dst_ptr = _cocoa_subdriver->GetPixelBuffer(); + DrawChatMessage(); + DrawMouseCursor(); + _cocoa_subdriver->Draw(); + } + } + +#ifdef _DEBUG + 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); + DEBUG(driver, 1, "cocoa_v: (nextEventMatchingMask total)/(game loop total) is %f%%", (double)_tEvent / (double)(et - et0) * 100); + DEBUG(driver, 1, "cocoa_v: (nextEventMatchingMask total)/(game loop without sleep total) is %f%%", (double)_tEvent / (double)(et - et0 - st) * 100); +#endif +} + +#endif /* WITH_COCOA */ diff --git a/src/video/cocoa/fullscreen.mm b/src/video/cocoa/fullscreen.mm new file mode 100644 index 000000000..c60e0c58a --- /dev/null +++ b/src/video/cocoa/fullscreen.mm @@ -0,0 +1,617 @@ +/* $Id$ */ + +/****************************************************************************** + * Cocoa video driver * + * Known things left to do: * + * Scale© the old pixel buffer to the new one when switching resolution. * + ******************************************************************************/ + +#ifdef WITH_COCOA + +#include <AvailabilityMacros.h> + +#import <Cocoa/Cocoa.h> +#import <sys/time.h> /* gettimeofday */ +#import <sys/param.h> /* for MAXPATHLEN */ +#import <unistd.h> + +/** + * Important notice regarding all modifications!!!!!!! + * There are certain limitations because the file is objective C++. + * gdb has limitations. + * C++ and objective C code can't be joined in all cases (classes stuff). + * Read http://developer.apple.com/releasenotes/Cocoa/Objective-C++.html for more information. + */ + + +/* From Menus.h (according to Xcode Developer Documentation) */ +extern "C" void ShowMenuBar(); +extern "C" void HideMenuBar(); + +/* 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 "../../macros.h" +#include "../../os/macosx/splash.h" +#include "../../variables.h" +#include "../../gfx.h" +#include "cocoa_v.h" +#include "cocoa_keys.h" +#include "../../blitter/factory.hpp" +#include "../../fileio.h" + +#undef Point +#undef Rect + + +/* 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 + +struct OTTD_QuartzGammaTable { + CGGammaValue red[QZ_GAMMA_TABLE_SIZE]; + CGGammaValue green[QZ_GAMMA_TABLE_SIZE]; + CGGammaValue blue[QZ_GAMMA_TABLE_SIZE]; +}; + +/* 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 + + +class FullscreenSubdriver: public CocoaSubdriver { + int display_width; + int display_height; + int display_depth; + int screen_pitch; + 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 */ + + #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 + * Fade the display from normal to black + * Save gamma tables for fade back to normal + */ + uint32 FadeGammaOut(OTTD_QuartzGammaTable* table) + { + 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) { + 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( + 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 + */ + uint32 FadeGammaIn(const OTTD_QuartzGammaTable* table) + { + 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++) { + 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) { + CGDisplayRestoreColorSyncSettings(); + return 1; + } + + CSleep(10); + } + + return 0; + } + + /* 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); + if (refreshRateCFNumber == NULL) return; + + if (CFNumberGetValue(refreshRateCFNumber, kCFNumberDoubleType, &refreshRate) == 0) + return; + + if (refreshRate == 0) return; + + linesPerSecond = refreshRate * display_height; + target = display_height; + + /* Figure out the first delay so we start off about right */ + position = CGDisplayBeamPosition(display_id); + if (position > target) position = 0; + + adjustment = (target - position) / linesPerSecond; + + CSleep((uint32)(adjustment * 1000)); + } + + + bool SetVideoMode(int w, int h) + { + 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 (pixel_buffer != NULL) { + free(pixel_buffer); + pixel_buffer = NULL; + } + + /* See if requested mode exists */ + cur_mode = CGDisplayBestModeForParameters(display_id, 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); + CFNumberGetValue(number, kCFNumberSInt32Type, &bpp); + if (bpp != display_depth) { + DEBUG(driver, 0, "Failed to find display resolution"); + goto ERR_NO_MATCH; + } + + number = (const __CFNumber*)CFDictionaryGetValue(cur_mode, kCGDisplayWidth); + CFNumberGetValue(number, kCFNumberSInt32Type, &w); + + number = (const __CFNumber*)CFDictionaryGetValue(cur_mode, kCGDisplayHeight); + CFNumberGetValue(number, kCFNumberSInt32Type, &h); + } + + /* Fade display to zero gamma */ + gamma_error = FadeGammaOut(&gamma_table); + + /* Put up the blanking window (a window above all other windows) */ + error = CGDisplayCapture(display_id); + + if (CGDisplayNoErr != error) { + DEBUG(driver, 0, "Failed capturing display"); + goto ERR_NO_CAPTURE; + } + + /* Do the physical switch */ + if (CGDisplaySwitchToMode(display_id, cur_mode) != CGDisplayNoErr) { + DEBUG(driver, 0, "Failed switching display resolution"); + goto ERR_NO_SWITCH; + } + + screen_buffer = CGDisplayBaseAddress(display_id); + screen_pitch = CGDisplayBytesPerRow(display_id); + + display_width = CGDisplayPixelsWide(display_id); + display_height = CGDisplayPixelsHigh(display_id); + + /* Setup double-buffer emulation */ + pixel_buffer = malloc(display_width * display_height * display_depth / 8); + if (pixel_buffer == NULL) { + DEBUG(driver, 0, "Failed to allocate memory for double buffering"); + goto ERR_DOUBLEBUF; + } + + if (display_depth == 8 && !CGDisplayCanSetPalette(display_id)) { + DEBUG(driver, 0, "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) 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, display_width, display_height); + [ [ NSScreen mainScreen ] setFrame:screen_rect ]; + + + pt = [ NSEvent mouseLocation ]; + pt.y = display_height - pt.y; + if (MouseIsInsideView(&pt)) QZ_HideMouse(); + + 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; +ERR_DOUBLEBUF: + CGDisplaySwitchToMode(display_id, save_mode); +ERR_NO_SWITCH: + CGReleaseAllDisplays(); +ERR_NO_CAPTURE: + if (!gamma_error) FadeGammaIn(&gamma_table); +ERR_NO_MATCH: + display_width = 0; + display_height = 0; + + return false; + } + + void RestoreVideoMode() + { + /* Release fullscreen resources */ + OTTD_QuartzGammaTable gamma_table; + int gamma_error; + NSRect screen_rect; + + gamma_error = FadeGammaOut(&gamma_table); + + /* Restore original screen resolution/bpp */ + CGDisplaySwitchToMode(display_id, 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)); + [ [ NSScreen mainScreen ] setFrame:screen_rect ]; + + QZ_ShowMouse(); + + /* Destroy the pixel buffer */ + if (pixel_buffer != NULL) { + free(pixel_buffer); + pixel_buffer = NULL; + } + + if (!gamma_error) FadeGammaIn(&gamma_table); + + display_width = 0; + display_height = 0; + } + +public: + FullscreenSubdriver(int bpp) + { + if (bpp != 8 && bpp != 32) { + error("Cocoa: This video driver only supports 8 and 32 bpp blitters."); + } + + /* Initialize the video settings; this data persists between mode switches */ + display_id = kCGDirectMainDisplay; + save_mode = CGDisplayCurrentMode(display_id); + + if (bpp == 8) palette = CGPaletteCreateDefaultColorPalette(); + + display_width = 0; + display_height = 0; + display_depth = bpp; + pixel_buffer = NULL; + + num_dirty_rects = MAX_DIRTY_RECTS; + } + + virtual ~FullscreenSubdriver() + { + 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; + + /* 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; + } + + 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 (; y < bottom; y++) { + memcpy(dst + y * pitch + left * bytesperpixel, src + y * width * bytesperpixel + left * bytesperpixel, length * bytesperpixel); + } + } + + 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; + } + num_dirty_rects++; + } + + virtual void UpdatePalette(uint first_color, uint num_colors) + { + CGTableCount index; + CGDeviceColor color; + + if (display_depth != 8) + return; + + 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(palette, color, index); + } + + CGDisplaySetPalette(display_id, palette); + } + + virtual uint ListModes(OTTDPoint* modes, uint max_modes) + { + CFArrayRef mode_list; + CFIndex num_modes; + CFIndex i; + uint count = 0; + + mode_list = CGDisplayAvailableModes(display_id); + 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; + uint16 width, height; + + onemode = (const __CFDictionary*)CFArrayGetValueAtIndex(mode_list, i); + number = (const __CFNumber*)CFDictionaryGetValue(onemode, kCGDisplayBitsPerPixel); + CFNumberGetValue (number, kCFNumberSInt32Type, &bpp); + + if (bpp != display_depth) continue; + + number = (const __CFNumber*)CFDictionaryGetValue(onemode, kCGDisplayWidth); + CFNumberGetValue(number, kCFNumberSInt32Type, &intvalue); + width = (uint16)intvalue; + + number = (const __CFNumber*)CFDictionaryGetValue(onemode, kCGDisplayHeight); + CFNumberGetValue(number, kCFNumberSInt32Type, &intvalue); + 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; + } + } + } + + if (hasMode) continue; + + /* Add mode to the list */ + modes[count].x = width; + modes[count].y = height; + count++; + } + + /* 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; + } + } + } + } + + return count; + } + + virtual bool ChangeResolution(int w, int h) + { + int old_width = display_width; + int old_height = display_height; + + if (SetVideoMode(w, h)) + return true; + + if (old_width != 0 && old_height != 0) + SetVideoMode(old_width, old_height); + + return false; + } + + virtual bool IsFullscreen() + { + return true; + } + + virtual int GetWidth() + { + return display_width; + } + + virtual int GetHeight() + { + return display_height; + } + + virtual void *GetPixelBuffer() + { + return pixel_buffer; + } + + /* + Convert local coordinate to window server (CoreGraphics) coordinate. + In fullscreen mode this just means copying the coords. + */ + virtual CGPoint PrivateLocalToCG(NSPoint* p) + { + CGPoint cgp; + + cgp.x = p->x; + cgp.y = p->y; + + return cgp; + } + + virtual NSPoint GetMouseLocation(NSEvent *event) + { + NSPoint pt; + + pt = [ NSEvent mouseLocation ]; + pt.y = 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; + } + + virtual bool IsActive() + { + return true; + } +}; + +CocoaSubdriver *QZ_CreateFullscreenSubdriver(int width, int height, int bpp) +{ + FullscreenSubdriver *ret; + + ret = new FullscreenSubdriver(bpp); + + if (!ret->ChangeResolution(width, height)) { + delete ret; + return NULL; + } + + return ret; +} + +#endif /* WITH_COCOA */ diff --git a/src/video/cocoa/wnd_quickdraw.mm b/src/video/cocoa/wnd_quickdraw.mm new file mode 100644 index 000000000..592c41d6e --- /dev/null +++ b/src/video/cocoa/wnd_quickdraw.mm @@ -0,0 +1,816 @@ +/* $Id$ */ + +/****************************************************************************** + * Cocoa video driver * + * Known things left to do: * + * List available resolutions. * + ******************************************************************************/ + +#ifdef WITH_COCOA + +#include <AvailabilityMacros.h> + +#import <Cocoa/Cocoa.h> +#import <sys/time.h> /* gettimeofday */ +#import <sys/param.h> /* for MAXPATHLEN */ +#import <unistd.h> + +/** + * Important notice regarding all modifications!!!!!!! + * There are certain limitations because the file is objective C++. + * gdb has limitations. + * C++ and objective C code can't be joined in all cases (classes stuff). + * Read http://developer.apple.com/releasenotes/Cocoa/Objective-C++.html for more information. + */ + + +/* 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 "../../macros.h" +#include "../../os/macosx/splash.h" +#include "../../variables.h" +#include "../../gfx.h" +#include "cocoa_v.h" +#include "cocoa_keys.h" +#include "../../blitter/factory.hpp" +#include "../../fileio.h" + +#undef Point +#undef Rect + + +class WindowQuickdrawSubdriver; + + +/* Subclass of NSWindow to fix genie effect and support resize events */ +@interface OTTD_QuartzWindow : NSWindow { + WindowQuickdrawSubdriver *driver; +} + +- (void)setDriver:(WindowQuickdrawSubdriver*)drv; + +- (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{ + WindowQuickdrawSubdriver *driver; +} + +- (void)setDriver:(WindowQuickdrawSubdriver*)drv; + +- (BOOL)windowShouldClose:(id)sender; +@end + +class WindowQuickdrawSubdriver: public CocoaSubdriver { + int device_width; + int device_height; + int device_depth; + + int window_width; + int window_height; + int window_pitch; + + int buffer_depth; + + void *pixel_buffer; + void *window_buffer; + + OTTD_QuartzWindow *window; + + #define MAX_DIRTY_RECTS 100 + Rect dirty_rects[MAX_DIRTY_RECTS]; + int num_dirty_rects; + + uint16 palette16[256]; + uint32 palette32[256]; + +public: + bool active; + bool setup; + + NSQuickDrawView *qdview; + +private: + void GetDeviceInfo(); + + bool SetVideoMode(int width, int height); + + /** + * This function copies 32bpp pixels from the screen buffer in 16bpp windowed mode. + * + * @param left The x coord for the left edge of the box to blit. + * @param top The y coord for the top edge of the box to blit. + * @param right The x coord for the right edge of the box to blit. + * @param bottom The y coord for the bottom edge of the box to blit. + */ + void Blit32ToView32(int left, int top, int right, int bottom); + + /** + * This function copies 8bpp pixels from the screen buffer in 32bpp windowed mode. + * + * @param left The x coord for the left edge of the box to blit. + * @param top The y coord for the top edge of the box to blit. + * @param right The x coord for the right edge of the box to blit. + * @param bottom The y coord for the bottom edge of the box to blit. + */ + void BlitIndexedToView32(int left, int top, int right, int bottom); + + /** + * This function copies 8bpp pixels from the screen buffer in 16bpp windowed mode. + * + * @param left The x coord for the left edge of the box to blit. + * @param top The y coord for the top edge of the box to blit. + * @param right The x coord for the right edge of the box to blit. + * @param bottom The y coord for the bottom edge of the box to blit. + */ + void BlitIndexedToView16(int left, int top, int right, int bottom); + + inline void BlitToView(int left, int top, int right, int bottom); + void DrawResizeIcon(); + + +public: + WindowQuickdrawSubdriver(int bpp); + virtual ~WindowQuickdrawSubdriver(); + + virtual void Draw(); + virtual void MakeDirty(int left, int top, int width, int height); + virtual void UpdatePalette(uint first_color, uint num_colors); + + virtual uint ListModes(OTTDPoint* modes, uint max_modes); + + virtual bool ChangeResolution(int w, int h); + + virtual bool IsFullscreen() { return false; } + + virtual int GetWidth() { return window_width; } + virtual int GetHeight() { return window_height; } + virtual void *GetPixelBuffer() { return pixel_buffer; } + + /* Convert local coordinate to window server (CoreGraphics) coordinate */ + virtual CGPoint PrivateLocalToCG(NSPoint* p); + + virtual NSPoint GetMouseLocation(NSEvent *event); + virtual bool MouseIsInsideView(NSPoint *pt); + + virtual bool IsActive() { return active; } + + + void SetPortAlphaOpaque(); + bool WindowResized(); +}; + + +@implementation OTTD_QuartzWindow + +- (void)setDriver:(WindowQuickdrawSubdriver*)drv +{ + driver = drv; +} + + +/* 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 */ + driver->SetPortAlphaOpaque (); + + /* window is hidden now */ + driver->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. + */ + + driver->SetPortAlphaOpaque(); + + /* save current visible surface */ + [ self cacheImageInRect:[ driver->qdview frame ] ]; + + /* let the window manager redraw controls, border, etc */ + [ super display ]; + + /* restore visible surface */ + [ self restoreCachedImage ]; + + /* window is visible again */ + driver->active = true; +} + +- (void)setFrame:(NSRect)frameRect display:(BOOL)flag +{ + [ super setFrame:frameRect display:flag ]; + + /* Don't do anything if the window is currently being created */ + if (driver->setup) return; + + if (!driver->WindowResized()) + error("Cocoa: Failed to resize window."); +} + +- (void)appDidHide:(NSNotification*)note +{ + driver->active = false; +} + + +- (void)appWillUnhide:(NSNotification*)note +{ + driver->SetPortAlphaOpaque (); + + /* save current visible surface */ + [ self cacheImageInRect:[ driver->qdview frame ] ]; +} + +- (void)appDidUnhide:(NSNotification*)note +{ + /* restore cached image, since it may not be current, post expose event too */ + [ self restoreCachedImage ]; + + driver->active = true; +} + + +- (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 +- (void)setDriver:(WindowQuickdrawSubdriver*)drv +{ + driver = drv; +} + +- (BOOL)windowShouldClose:(id)sender +{ + HandleExitGameRequest(); + + return NO; +} + +- (void)windowDidBecomeKey:(NSNotification*)aNotification +{ + driver->active = true; +} + +- (void)windowDidResignKey:(NSNotification*)aNotification +{ + driver->active = false; +} + +- (void)windowDidBecomeMain:(NSNotification*)aNotification +{ + driver->active = true; +} + +- (void)windowDidResignMain:(NSNotification*)aNotification +{ + driver->active = false; +} + +@end + + +static const int _resize_icon_width = 16; +static const int _resize_icon_height = 16; + +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 +}; + + + +extern const char _openttd_revision[]; + + +void WindowQuickdrawSubdriver::GetDeviceInfo() +{ + CFDictionaryRef cur_mode; + + /* Initialize the video settings; this data persists between mode switches */ + cur_mode = CGDisplayCurrentMode(kCGDirectMainDisplay); + + /* Gather some information that is useful to know about the display */ + CFNumberGetValue( + (const __CFNumber*)CFDictionaryGetValue(cur_mode, kCGDisplayBitsPerPixel), + kCFNumberSInt32Type, &device_depth + ); + + CFNumberGetValue( + (const __CFNumber*)CFDictionaryGetValue(cur_mode, kCGDisplayWidth), + kCFNumberSInt32Type, &device_width + ); + + CFNumberGetValue( + (const __CFNumber*)CFDictionaryGetValue(cur_mode, kCGDisplayHeight), + kCFNumberSInt32Type, &device_height + ); +} + +bool WindowQuickdrawSubdriver::SetVideoMode(int width, int height) +{ + char caption[50]; + NSString *nsscaption; + unsigned int style; + NSRect contentRect; + BOOL isCustom = NO; + bool ret; + + setup = true; + + GetDeviceInfo(); + + if (buffer_depth > device_depth) { + DEBUG(driver, 0, "Cannot use a blitter with a higer screen depth than the display when running in windowed mode."); + setup = false; + return false; + } + + if (width > device_width) + width = device_width; + if (height > device_height) + height = device_height; + + contentRect = NSMakeRect(0, 0, width, height); + + /* Check if we should recreate the window */ + if (window == nil) { + OTTD_QuartzWindowDelegate *delegate; + + /* Set the window style */ + style = NSTitledWindowMask; + style |= (NSMiniaturizableWindowMask | NSClosableWindowMask); + style |= NSResizableWindowMask; + + /* Manually create a window, avoids having a nib file resource */ + window = [ [ OTTD_QuartzWindow alloc ] + initWithContentRect:contentRect + styleMask:style + backing:NSBackingStoreBuffered + defer:NO ]; + + if (window == nil) { + DEBUG(driver, 0, "Could not create the Cocoa window."); + setup = false; + return false; + } + + [ window setDriver:this ]; + + snprintf(caption, sizeof(caption), "OpenTTD %s", _openttd_revision); + nsscaption = [ [ NSString alloc ] initWithCString:caption ]; + [ window setTitle:nsscaption ]; + [ window setMiniwindowTitle:nsscaption ]; + [ nsscaption release ]; + + [ window setAcceptsMouseMovedEvents:YES ]; + [ window setViewsNeedDisplay:NO ]; + + delegate = [ [ OTTD_QuartzWindowDelegate alloc ] init ]; + [ delegate setDriver:this ]; + [ window setDelegate: [ delegate autorelease ] ]; + } else { + /* We already have a window, just change its size */ + if (!isCustom) { + [ window setContentSize:contentRect.size ]; + // Ensure frame height - title bar height >= view height + contentRect.size.height = Clamp(height, 0, [ window frame ].size.height - 22 /* 22 is the height of title bar of window*/); + height = contentRect.size.height; + [ qdview setFrameSize:contentRect.size ]; + } + } + + // Update again + window_width = width; + window_height = height; + + [ window center ]; + + /* Only recreate the view if it doesn't already exist */ + if (qdview == nil) { + qdview = [ [ NSQuickDrawView alloc ] initWithFrame:contentRect ]; + if (qdview == nil) { + DEBUG(driver, 0, "Could not create the Quickdraw view."); + setup = false; + return false; + } + + [ qdview setAutoresizingMask: NSViewWidthSizable | NSViewHeightSizable ]; + [ [ window contentView ] addSubview:qdview ]; + [ qdview release ]; + [ window makeKeyAndOrderFront:nil ]; + } + + ret = WindowResized(); + + UpdatePalette(0, 256); + + setup = false; + + return ret; +} + +void WindowQuickdrawSubdriver::Blit32ToView32(int left, int top, int right, int bottom) +{ + const uint32* src = (uint32*)pixel_buffer; + uint32* dst = (uint32*)window_buffer; + uint width = window_width; + uint pitch = window_pitch / 4; + int y; + + + dst += top * pitch + left; + src += top * width + left; + + for (y = top; y < bottom; y++, dst+= pitch, src+= width) { + memcpy(dst, src, (right - left) * 4); + } +} + +void WindowQuickdrawSubdriver::BlitIndexedToView32(int left, int top, int right, int bottom) +{ + const uint32* pal = palette32; + const uint8* src = (uint8*)pixel_buffer; + uint32* dst = (uint32*)window_buffer; + uint width = window_width; + uint pitch = window_pitch / 4; + int x; + int y; + + for (y = top; y < bottom; y++) { + for (x = left; x < right; x++) { + dst[y * pitch + x] = pal[src[y * width + x]]; + } + } +} + +void WindowQuickdrawSubdriver::BlitIndexedToView16(int left, int top, int right, int bottom) +{ + const uint16* pal = palette16; + const uint8* src = (uint8*)pixel_buffer; + uint16* dst = (uint16*)window_buffer; + uint width = window_width; + uint pitch = window_pitch / 2; + int x; + int y; + + for (y = top; y < bottom; y++) { + for (x = left; x < right; x++) { + dst[y * pitch + x] = pal[src[y * width + x]]; + } + } +} + + +inline void WindowQuickdrawSubdriver::BlitToView(int left, int top, int right, int bottom) +{ + switch (device_depth) { + case 32: + switch(buffer_depth) { + case 32: + Blit32ToView32(left, top, right, bottom); + break; + case 8: + BlitIndexedToView32(left, top, right, bottom); + break; + } + break; + case 16: + BlitIndexedToView16(left, top, right, bottom); + break; + } +} + +void WindowQuickdrawSubdriver::DrawResizeIcon() +{ + int xoff = window_width - _resize_icon_width; + int yoff = window_height - _resize_icon_height; + int x; + int y; + + switch (device_depth) { + case 32: + for (y = 0; y < _resize_icon_height; y++) { + uint32* trg = (uint32*)window_buffer + (yoff + y) * window_pitch / 4 + xoff; + + for (x = 0; x < _resize_icon_width; x++, trg++) { + if (_resize_icon[y * _resize_icon_width + x]) *trg = 0xff000000; + } + } + break; + case 16: + for (y = 0; y < _resize_icon_height; y++) { + uint16* trg = (uint16*)window_buffer + (yoff + y) * window_pitch / 2 + xoff; + + for (x = 0; x < _resize_icon_width; x++, trg++) { + if (_resize_icon[y * _resize_icon_width + x]) *trg = 0x0000; + } + } + break; + } +} + + +WindowQuickdrawSubdriver::WindowQuickdrawSubdriver(int bpp) +{ + window_width = 0; + window_height = 0; + buffer_depth = bpp; + pixel_buffer = NULL; + active = false; + setup = false; + + window = nil; + qdview = nil; + + num_dirty_rects = MAX_DIRTY_RECTS; +} + +WindowQuickdrawSubdriver::~WindowQuickdrawSubdriver() +{ + QZ_ShowMouse(); + + /* Release window mode resources */ + if (window != nil) [ window close ]; + + free(pixel_buffer); +} + +void WindowQuickdrawSubdriver::Draw() +{ + int i; + RgnHandle dirty, temp; + + /* Check if we need to do anything */ + if (num_dirty_rects == 0 || + [ window isMiniaturized ]) { + return; + } + + if (num_dirty_rects >= MAX_DIRTY_RECTS) { + num_dirty_rects = 1; + dirty_rects[0].left = 0; + dirty_rects[0].top = 0; + dirty_rects[0].right = window_width; + dirty_rects[0].bottom = window_height; + } + + dirty = NewRgn(); + temp = NewRgn(); + + SetEmptyRgn(dirty); + + /* Build the region of dirty rectangles */ + for (i = 0; i < num_dirty_rects; i++) { + BlitToView( + dirty_rects[i].left, + dirty_rects[i].top, + dirty_rects[i].right, + dirty_rects[i].bottom + ); + + MacSetRectRgn( + temp, + dirty_rects[i].left, + dirty_rects[i].top, + dirty_rects[i].right, + dirty_rects[i].bottom + ); + MacUnionRgn(dirty, temp, dirty); + } + + DrawResizeIcon(); + + /* Flush the dirty region */ + QDFlushPortBuffer( (OpaqueGrafPtr*) [ qdview qdPort ], dirty); + DisposeRgn(dirty); + DisposeRgn(temp); + + num_dirty_rects = 0; +} + +void WindowQuickdrawSubdriver::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; + } + num_dirty_rects++; +} + +void WindowQuickdrawSubdriver::UpdatePalette(uint first_color, uint num_colors) +{ + uint i; + + if (buffer_depth != 8) + return; + + switch (device_depth) { + case 32: + for (i = first_color; i < first_color + num_colors; i++) { + uint32 clr32 = 0xff000000; + clr32 |= (uint32)_cur_palette[i].r << 16; + clr32 |= (uint32)_cur_palette[i].g << 8; + clr32 |= (uint32)_cur_palette[i].b; + palette32[i] = clr32; + } + break; + case 16: + for (i = first_color; i < first_color + num_colors; i++) { + uint16 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); + palette16[i] = clr16; + } + break; + } + + num_dirty_rects = MAX_DIRTY_RECTS; +} + +uint WindowQuickdrawSubdriver::ListModes(OTTDPoint* modes, uint max_modes) +{ + if (max_modes == 0) return 0; + + modes[0].x = window_width; + modes[0].y = window_height; + + return 1; +} + +bool WindowQuickdrawSubdriver::ChangeResolution(int w, int h) +{ + int old_width = window_width; + int old_height = window_height; + + if (SetVideoMode(w, h)) + return true; + + if (old_width != 0 && old_height != 0) + SetVideoMode(old_width, old_height); + + return false; +} + +/* Convert local coordinate to window server (CoreGraphics) coordinate */ +CGPoint WindowQuickdrawSubdriver::PrivateLocalToCG(NSPoint* p) +{ + CGPoint cgp; + + *p = [ qdview convertPoint:*p toView: nil ]; + *p = [ window convertBaseToScreen:*p ]; + p->y = window_height - p->y; + + cgp.x = p->x; + cgp.y = p->y; + + return cgp; +} + +NSPoint WindowQuickdrawSubdriver::GetMouseLocation(NSEvent *event) +{ + NSPoint pt; + + pt = [ event locationInWindow ]; + pt = [ qdview convertPoint:pt fromView:nil ]; + + return pt; +} + +bool WindowQuickdrawSubdriver::MouseIsInsideView(NSPoint *pt) +{ + return [ qdview mouse:*pt inRect:[ qdview bounds ] ]; +} + + +/* 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. + */ +void WindowQuickdrawSubdriver::SetPortAlphaOpaque() +{ + if (device_depth != 32) + return; + + uint32* pixels = (uint32*)window_buffer; + uint32 pitch = window_pitch / 4; + int x, y; + + for (y = 0; y < window_height; y++) + for (x = 0; x < window_width; x++) { + pixels[y * pitch + x] |= 0xFF000000; + } +} + +bool WindowQuickdrawSubdriver::WindowResized() +{ + if (window == nil || qdview == nil) return true; + + NSRect newframe = [ qdview frame ]; + CGrafPtr thePort = (OpaqueGrafPtr*) [ qdview qdPort ]; + int voff, hoff; + + LockPortBits(thePort); + window_buffer = GetPixBaseAddr(GetPortPixMap(thePort)); + window_pitch = GetPixRowBytes(GetPortPixMap(thePort)); + UnlockPortBits(thePort); + + /* _cocoa_video_data.realpixels now points to the window's pixels + * We want it to point to the *view's* pixels + */ + voff = [ window frame ].size.height - newframe.size.height - newframe.origin.y; + hoff = [ qdview frame ].origin.x; + window_buffer = (uint8*)window_buffer + (voff * window_pitch) + hoff * (device_depth / 8); + + window_width = newframe.size.width; + window_height = newframe.size.height; + + free(pixel_buffer); + pixel_buffer = malloc(window_width * window_height * buffer_depth / 8); + if (pixel_buffer == NULL) { + DEBUG(driver, 0, "Failed to allocate pixel buffer"); + return false; + } + + QZ_GameSizeChanged(); + + /* Redraw screen */ + num_dirty_rects = MAX_DIRTY_RECTS; + + return true; +} + + +CocoaSubdriver *QZ_CreateWindowQuickdrawSubdriver(int width, int height, int bpp) +{ + WindowQuickdrawSubdriver *ret; + + ret = new WindowQuickdrawSubdriver(bpp); + + if (!ret->ChangeResolution(width, height)) { + delete ret; + return NULL; + } + + return ret; +} + +#endif /* WITH_COCOA */ |