1

/* $Id$ */

     2

     3

/******************************************************************************

     4

 *                             Cocoa video driver                             *

     5

 * Known things left to do:                                                   *

     6

 *  Nothing at the moment.                                                    *

     7

 ******************************************************************************/

     8

     9

#ifdef WITH_COCOA

    10

    11

#include <AvailabilityMacros.h>

    12

#if (MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_4)

    13

/* On 10.4, we get tons of warnings that the QuickDraw functions are deprecated.

    14

 *  We know that. Don't keep bugging us about that. */

    15

#	undef AVAILABLE_MAC_OS_X_VERSION_10_0_AND_LATER_BUT_DEPRECATED_IN_MAC_OS_X_VERSION_10_4

    16

#	define AVAILABLE_MAC_OS_X_VERSION_10_0_AND_LATER_BUT_DEPRECATED_IN_MAC_OS_X_VERSION_10_4 AVAILABLE_MAC_OS_X_VERSION_10_0_AND_LATER

    17

#endif

    18

    19

#import <Cocoa/Cocoa.h>

    20

#import <sys/time.h> /* gettimeofday */

    21

#import <sys/param.h> /* for MAXPATHLEN */

    22

#import <unistd.h>

    23

    24

/**

    25

 * Important notice regarding all modifications!!!!!!!

    26

 * There are certain limitations because the file is objective C++.

    27

 * gdb has limitations.

    28

 * C++ and objective C code can't be joined in all cases (classes stuff).

    29

 * Read http://developer.apple.com/releasenotes/Cocoa/Objective-C++.html for more information.

    30

 */

    31

    32

    33

/* Portions of CPS.h */

    34

struct CPSProcessSerNum {

    35

	UInt32 lo;

    36

	UInt32 hi;

    37

};

    38

    39

extern "C" OSErr CPSGetCurrentProcess(CPSProcessSerNum* psn);

    40

extern "C" OSErr CPSEnableForegroundOperation(CPSProcessSerNum* psn, UInt32 _arg2, UInt32 _arg3, UInt32 _arg4, UInt32 _arg5);

    41

extern "C" OSErr CPSSetFrontProcess(CPSProcessSerNum* psn);

    42

    43

/* From Menus.h (according to Xcode Developer Documentation) */

    44

extern "C" void ShowMenuBar();

    45

extern "C" void HideMenuBar();

    46

    47

/* Disables a warning. This is needed since the method exists but has been dropped from the header, supposedly as of 10.4. */

    48

#if (MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_4)

    49

@interface NSApplication(NSAppleMenu)

    50

- (void)setAppleMenu:(NSMenu *)menu;

    51

@end

    52

#endif

    53

    54

    55

/* Defined in ppc/param.h or i386/param.h included from sys/param.h */

    56

#undef ALIGN

    57

/* Defined in stdbool.h */

    58

#ifndef __cplusplus

    59

# ifndef __BEOS__

    60

#  undef bool

    61

#  undef false

    62

#  undef true

    63

# endif

    64

#endif

    65

    66

    67

#include "../stdafx.h"

    68

#include "../debug.h"

    69

#include "../macros.h"

    70

#include "../os/macosx/splash.h"

    71

#include "../variables.h"

    72

#include "cocoa_v.h"

    73

#include "cocoa_keys.h"

    74

#include "../blitter/factory.hpp"

    75

#include "../fileio.h"

    76

    77

#undef Point

    78

#undef Rect

    79

    80

/* Subclass of NSWindow to fix genie effect and support resize events  */

    81

@interface OTTD_QuartzWindow : NSWindow

    82

- (void)miniaturize:(id)sender;

    83

- (void)display;

    84

- (void)setFrame:(NSRect)frameRect display:(BOOL)flag;

    85

- (void)appDidHide:(NSNotification*)note;

    86

- (void)appWillUnhide:(NSNotification*)note;

    87

- (void)appDidUnhide:(NSNotification*)note;

    88

- (id)initWithContentRect:(NSRect)contentRect styleMask:(unsigned int)styleMask backing:(NSBackingStoreType)backingType defer:(BOOL)flag;

    89

@end

    90

    91

/* Delegate for our NSWindow to send ask for quit on close */

    92

@interface OTTD_QuartzWindowDelegate : NSObject

    93

- (BOOL)windowShouldClose:(id)sender;

    94

@end

    95

    96

@interface OTTDMain : NSObject

    97

@end

    98

    99

   100

/* Structure for rez switch gamma fades

   101

 * We can hide the monitor flicker by setting the gamma tables to 0

   102

 */

   103

#define QZ_GAMMA_TABLE_SIZE 256

   104

   105

struct OTTD_QuartzGammaTable {

   106

	CGGammaValue red[QZ_GAMMA_TABLE_SIZE];

   107

	CGGammaValue green[QZ_GAMMA_TABLE_SIZE];

   108

	CGGammaValue blue[QZ_GAMMA_TABLE_SIZE];

   109

};

   110

   111

/* Add methods to get at private members of NSScreen.

   112

 * Since there is a bug in Apple's screen switching code that does not update

   113

 * this variable when switching to fullscreen, we'll set it manually (but only

   114

 * for the main screen).

   115

 */

   116

@interface NSScreen (NSScreenAccess)

   117

	- (void) setFrame:(NSRect)frame;

   118

@end

   119

   120

@implementation NSScreen (NSScreenAccess)

   121

- (void) setFrame:(NSRect)frame;

   122

{

   123

	_frame = frame;

   124

}

   125

@end

   126

   127

   128

static void QZ_Draw();

   129

static void QZ_UnsetVideoMode();

   130

static void QZ_UpdatePalette(uint start, uint count);

   131

static void QZ_WarpCursor(int x, int y);

   132

static void QZ_ShowMouse();

   133

static void QZ_HideMouse();

   134

static void CocoaVideoFullScreen(bool full_screen);

   135

   136

   137

static NSAutoreleasePool *_ottd_autorelease_pool;

   138

static OTTDMain *_ottd_main;

   139

   140

   141

static struct CocoaVideoData {

   142

	bool isset;

   143

	bool issetting;

   144

   145

	CGDirectDisplayID  display_id;         /* 0 == main display (only support single display) */

   146

	CFDictionaryRef    mode;               /* current mode of the display */

   147

	CFDictionaryRef    save_mode;          /* original mode of the display */

   148

	CFArrayRef         mode_list;          /* list of available fullscreen modes */

   149

	CGDirectPaletteRef palette;            /* palette of an 8-bit display */

   150

   151

	uint32 device_width;

   152

	uint32 device_height;

   153

	uint32 device_bpp;

   154

   155

	void *realpixels;

   156

	uint8 *pixels;

   157

	uint32 width;

   158

	uint32 height;

   159

	uint32 pitch;

   160

	bool fullscreen;

   161

   162

	unsigned int current_mods;

   163

	bool tab_is_down;

   164

	bool emulating_right_button;

   165

   166

	bool cursor_visible;

   167

	bool active;

   168

   169

#ifdef _DEBUG

   170

	uint32 tEvent;

   171

#endif

   172

   173

	OTTD_QuartzWindow *window;

   174

	NSQuickDrawView *qdview;

   175

   176

#define MAX_DIRTY_RECTS 100

   177

	Rect dirty_rects[MAX_DIRTY_RECTS];

   178

	int num_dirty_rects;

   179

   180

	uint16 palette16[256];

   181

	uint32 palette32[256];

   182

} _cocoa_video_data;

   183

   184

static bool _cocoa_video_started = false;

   185

static bool _cocoa_video_dialog = false;

   186

   187

   188

   189

   190

/******************************************************************************

   191

 *                             Game loop and accessories                      *

   192

 ******************************************************************************/

   193

   194

static uint32 GetTick()

   195

{

   196

	struct timeval tim;

   197

   198

	gettimeofday(&tim, NULL);

   199

	return tim.tv_usec / 1000 + tim.tv_sec * 1000;

   200

}

   201

   202

static void QZ_CheckPaletteAnim()

   203

{

   204

	if (_pal_count_dirty != 0) {

   205

		Blitter *blitter = BlitterFactoryBase::GetCurrentBlitter();

   206

   207

		switch (blitter->UsePaletteAnimation()) {

   208

			case Blitter::PALETTE_ANIMATION_VIDEO_BACKEND:

   209

				QZ_UpdatePalette(_pal_first_dirty, _pal_count_dirty);

   210

				break;

   211

   212

			case Blitter::PALETTE_ANIMATION_BLITTER:

   213

				blitter->PaletteAnimate(_pal_first_dirty, _pal_count_dirty);

   214

				break;

   215

   216

			case Blitter::PALETTE_ANIMATION_NONE:

   217

				break;

   218

   219

			default:

   220

				NOT_REACHED();

   221

		}

   222

		_pal_count_dirty = 0;

   223

	}

   224

}

   225

   226

   227

   228

struct VkMapping {

   229

	unsigned short vk_from;

   230

	byte map_to;

   231

};

   232

   233

#define AS(x, z) {x, z}

   234

   235

static const VkMapping _vk_mapping[] = {

   236

	AS(QZ_BACKQUOTE,  WKC_BACKQUOTE), // key left of '1'

   237

	AS(QZ_BACKQUOTE2, WKC_BACKQUOTE), // some keyboards have it on another scancode

   238

   239

	// Pageup stuff + up/down

   240

	//AM(SDLK_PAGEUP, SDLK_PAGEDOWN, WKC_PAGEUP, WKC_PAGEDOWN),  <==== Does this include HOME/END?

   241

	AS(QZ_PAGEUP,   WKC_PAGEUP),

   242

	AS(QZ_PAGEDOWN, WKC_PAGEDOWN),

   243

   244

	AS(QZ_UP,    WKC_UP),

   245

	AS(QZ_DOWN,  WKC_DOWN),

   246

	AS(QZ_LEFT,  WKC_LEFT),

   247

	AS(QZ_RIGHT, WKC_RIGHT),

   248

   249

	AS(QZ_HOME, WKC_HOME),

   250

	AS(QZ_END,  WKC_END),

   251

   252

	AS(QZ_INSERT, WKC_INSERT),

   253

	AS(QZ_DELETE, WKC_DELETE),

   254

   255

	// Letters. QZ_[a-z] is not in numerical order so we can't use AM(...)

   256

	AS(QZ_a, 'A'),

   257

	AS(QZ_b, 'B'),

   258

	AS(QZ_c, 'C'),

   259

	AS(QZ_d, 'D'),

   260

	AS(QZ_e, 'E'),

   261

	AS(QZ_f, 'F'),

   262

	AS(QZ_g, 'G'),

   263

	AS(QZ_h, 'H'),

   264

	AS(QZ_i, 'I'),

   265

	AS(QZ_j, 'J'),

   266

	AS(QZ_k, 'K'),

   267

	AS(QZ_l, 'L'),

   268

	AS(QZ_m, 'M'),

   269

	AS(QZ_n, 'N'),

   270

	AS(QZ_o, 'O'),

   271

	AS(QZ_p, 'P'),

   272

	AS(QZ_q, 'Q'),

   273

	AS(QZ_r, 'R'),

   274

	AS(QZ_s, 'S'),

   275

	AS(QZ_t, 'T'),

   276

	AS(QZ_u, 'U'),

   277

	AS(QZ_v, 'V'),

   278

	AS(QZ_w, 'W'),

   279

	AS(QZ_x, 'X'),

   280

	AS(QZ_y, 'Y'),

   281

	AS(QZ_z, 'Z'),

   282

	// Same thing for digits

   283

	AS(QZ_0, '0'),

   284

	AS(QZ_1, '1'),

   285

	AS(QZ_2, '2'),

   286

	AS(QZ_3, '3'),

   287

	AS(QZ_4, '4'),

   288

	AS(QZ_5, '5'),

   289

	AS(QZ_6, '6'),

   290

	AS(QZ_7, '7'),

   291

	AS(QZ_8, '8'),

   292

	AS(QZ_9, '9'),

   293

   294

	AS(QZ_ESCAPE,    WKC_ESC),

   295

	AS(QZ_PAUSE,     WKC_PAUSE),

   296

	AS(QZ_BACKSPACE, WKC_BACKSPACE),

   297

   298

	AS(QZ_SPACE,  WKC_SPACE),

   299

	AS(QZ_RETURN, WKC_RETURN),

   300

	AS(QZ_TAB,    WKC_TAB),

   301

   302

	// Function keys

   303

	AS(QZ_F1,  WKC_F1),

   304

	AS(QZ_F2,  WKC_F2),

   305

	AS(QZ_F3,  WKC_F3),

   306

	AS(QZ_F4,  WKC_F4),

   307

	AS(QZ_F5,  WKC_F5),

   308

	AS(QZ_F6,  WKC_F6),

   309

	AS(QZ_F7,  WKC_F7),

   310

	AS(QZ_F8,  WKC_F8),

   311

	AS(QZ_F9,  WKC_F9),

   312

	AS(QZ_F10, WKC_F10),

   313

	AS(QZ_F11, WKC_F11),

   314

	AS(QZ_F12, WKC_F12),

   315

   316

	// Numeric part.

   317

	AS(QZ_KP0,         WKC_NUM_0),

   318

	AS(QZ_KP1,         WKC_NUM_1),

   319

	AS(QZ_KP2,         WKC_NUM_2),

   320

	AS(QZ_KP3,         WKC_NUM_3),

   321

	AS(QZ_KP4,         WKC_NUM_4),

   322

	AS(QZ_KP5,         WKC_NUM_5),

   323

	AS(QZ_KP6,         WKC_NUM_6),

   324

	AS(QZ_KP7,         WKC_NUM_7),

   325

	AS(QZ_KP8,         WKC_NUM_8),

   326

	AS(QZ_KP9,         WKC_NUM_9),

   327

	AS(QZ_KP_DIVIDE,   WKC_NUM_DIV),

   328

	AS(QZ_KP_MULTIPLY, WKC_NUM_MUL),

   329

	AS(QZ_KP_MINUS,    WKC_NUM_MINUS),

   330

	AS(QZ_KP_PLUS,     WKC_NUM_PLUS),

   331

	AS(QZ_KP_ENTER,    WKC_NUM_ENTER),

   332

	AS(QZ_KP_PERIOD,   WKC_NUM_DECIMAL)

   333

};

   334

   335

   336

static uint32 QZ_MapKey(unsigned short sym)

   337

{

   338

	const VkMapping *map;

   339

	uint32 key = 0;

   340

   341

	for (map = _vk_mapping; map != endof(_vk_mapping); ++map) {

   342

		if (sym == map->vk_from) {

   343

			key = map->map_to;

   344

			break;

   345

		}

   346

	}

   347

   348

	if (_cocoa_video_data.current_mods & NSShiftKeyMask)     key |= WKC_SHIFT;

   349

	if (_cocoa_video_data.current_mods & NSControlKeyMask)   key |= WKC_CTRL;

   350

	if (_cocoa_video_data.current_mods & NSAlternateKeyMask) key |= WKC_ALT;

   351

	if (_cocoa_video_data.current_mods & NSCommandKeyMask)   key |= WKC_META;

   352

   353

	return key << 16;

   354

}

   355

   356

static void QZ_KeyEvent(unsigned short keycode, unsigned short unicode, BOOL down)

   357

{

   358

	switch (keycode) {

   359

		case QZ_UP:    SB(_dirkeys, 1, 1, down); break;

   360

		case QZ_DOWN:  SB(_dirkeys, 3, 1, down); break;

   361

		case QZ_LEFT:  SB(_dirkeys, 0, 1, down); break;

   362

		case QZ_RIGHT: SB(_dirkeys, 2, 1, down); break;

   363

   364

		case QZ_TAB: _cocoa_video_data.tab_is_down = down; break;

   365

   366

		case QZ_RETURN:

   367

		case QZ_f:

   368

			if (down && (_cocoa_video_data.current_mods & NSCommandKeyMask)) {

   369

				CocoaVideoFullScreen(!_fullscreen);

   370

			}

   371

			break;

   372

	}

   373

   374

	if (down) {

   375

		uint32 pressed_key = QZ_MapKey(keycode) | unicode;

   376

		HandleKeypress(pressed_key);

   377

		DEBUG(driver, 2, "cocoa_v: QZ_KeyEvent: %x (%x), down, mapping: %x", keycode, unicode, pressed_key);

   378

	} else {

   379

		DEBUG(driver, 2, "cocoa_v: QZ_KeyEvent: %x (%x), up", keycode, unicode);

   380

	}

   381

}

   382

   383

static void QZ_DoUnsidedModifiers(unsigned int newMods)

   384

{

   385

	const int mapping[] = { QZ_CAPSLOCK, QZ_LSHIFT, QZ_LCTRL, QZ_LALT, QZ_LMETA };

   386

   387

	int i;

   388

	unsigned int bit;

   389

   390

	if (_cocoa_video_data.current_mods == newMods) return;

   391

   392

	/* Iterate through the bits, testing each against the current modifiers */

   393

	for (i = 0, bit = NSAlphaShiftKeyMask; bit <= NSCommandKeyMask; bit <<= 1, ++i) {

   394

		unsigned int currentMask, newMask;

   395

   396

		currentMask = _cocoa_video_data.current_mods & bit;

   397

		newMask     = newMods & bit;

   398

   399

		if (currentMask && currentMask != newMask) { /* modifier up event */

   400

			/* If this was Caps Lock, we need some additional voodoo to make SDL happy (is this needed in ottd?) */

   401

			if (bit == NSAlphaShiftKeyMask) QZ_KeyEvent(mapping[i], 0, YES);

   402

			QZ_KeyEvent(mapping[i], 0, NO);

   403

		} else if (newMask && currentMask != newMask) { /* modifier down event */

   404

			QZ_KeyEvent(mapping[i], 0, YES);

   405

			/* If this was Caps Lock, we need some additional voodoo to make SDL happy (is this needed in ottd?) */

   406

			if (bit == NSAlphaShiftKeyMask) QZ_KeyEvent(mapping[i], 0, NO);

   407

		}

   408

	}

   409

   410

	_cocoa_video_data.current_mods = newMods;

   411

}

   412

   413

static void QZ_MouseMovedEvent(int x, int y)

   414

{

   415

	if (_cursor.fix_at) {

   416

		int dx = x - _cursor.pos.x;

   417

		int dy = y - _cursor.pos.y;

   418

   419

		if (dx != 0 || dy != 0) {

   420

			_cursor.delta.x += dx;

   421

			_cursor.delta.y += dy;

   422

   423

			QZ_WarpCursor(_cursor.pos.x, _cursor.pos.y);

   424

		}

   425

	} else {

   426

		_cursor.delta.x = x - _cursor.pos.x;

   427

		_cursor.delta.y = y - _cursor.pos.y;

   428

		_cursor.pos.x = x;

   429

		_cursor.pos.y = y;

   430

		_cursor.dirty = true;

   431

	}

   432

	HandleMouseEvents();

   433

}

   434

   435

   436

static void QZ_MouseButtonEvent(int button, BOOL down)

   437

{

   438

	switch (button) {

   439

		case 0:

   440

			if (down) {

   441

				_left_button_down = true;

   442

			} else {

   443

				_left_button_down = false;

   444

				_left_button_clicked = false;

   445

			}

   446

			HandleMouseEvents();

   447

			break;

   448

   449

		case 1:

   450

			if (down) {

   451

				_right_button_down = true;

   452

				_right_button_clicked = true;

   453

			} else {

   454

				_right_button_down = false;

   455

			}

   456

			HandleMouseEvents();

   457

			break;

   458

	}

   459

}

   460

   461

   462

static inline NSPoint QZ_GetMouseLocation(NSEvent *event)

   463

{

   464

	NSPoint pt;

   465

   466

	if (_cocoa_video_data.fullscreen) {

   467

		pt = [ NSEvent mouseLocation ];

   468

		pt.y = _cocoa_video_data.height - pt.y;

   469

	} else {

   470

		pt = [event locationInWindow];

   471

		pt = [_cocoa_video_data.qdview convertPoint:pt fromView:nil];

   472

	}

   473

   474

	return pt;

   475

}

   476

   477

static bool QZ_MouseIsInsideView(NSPoint *pt)

   478

{

   479

	if (_cocoa_video_data.fullscreen) {

   480

		return pt->x >= 0 && pt->y >= 0 && pt->x < _cocoa_video_data.width && pt->y < _cocoa_video_data.height;

   481

	} else {

   482

		return [ _cocoa_video_data.qdview mouse:*pt inRect:[ _cocoa_video_data.qdview bounds ] ];

   483

	}

   484

}

   485

   486

   487

static bool QZ_PollEvent()

   488

{

   489

	NSEvent *event;

   490

	NSPoint pt;

   491

	NSString *chars;

   492

#ifdef _DEBUG

   493

	uint32 et0, et;

   494

#endif

   495

   496

#ifdef _DEBUG

   497

	et0 = GetTick();

   498

#endif

   499

	event = [ NSApp nextEventMatchingMask:NSAnyEventMask

   500

			untilDate: [ NSDate distantPast ]

   501

			inMode: NSDefaultRunLoopMode dequeue:YES ];

   502

#ifdef _DEBUG

   503

	et = GetTick();

   504

	_cocoa_video_data.tEvent+= et - et0;

   505

#endif

   506

   507

	if (event == nil) return false;

   508

	if (!_cocoa_video_data.active) {

   509

		QZ_ShowMouse();

   510

		[NSApp sendEvent:event];

   511

		return true;

   512

	}

   513

   514

	QZ_DoUnsidedModifiers( [ event modifierFlags ] );

   515

   516

	switch ([event type]) {

   517

		case NSMouseMoved:

   518

		case NSOtherMouseDragged:

   519

		case NSRightMouseDragged:

   520

		case NSLeftMouseDragged:

   521

			pt = QZ_GetMouseLocation(event);

   522

			if (!QZ_MouseIsInsideView(&pt) &&

   523

					!_cocoa_video_data.emulating_right_button) {

   524

				QZ_ShowMouse();