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

#import <Cocoa/Cocoa.h>

    12

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

    13

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

    14

#import <unistd.h>

    15

    16

/* Portions of CPS.h */

    17

typedef struct CPSProcessSerNum {

    18

	UInt32 lo;

    19

	UInt32 hi;

    20

} CPSProcessSerNum;

    21

    22

extern OSErr CPSGetCurrentProcess(CPSProcessSerNum* psn);

    23

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

    24

extern OSErr CPSSetFrontProcess(CPSProcessSerNum* psn);

    25

    26

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

    27

extern void ShowMenuBar(void);

    28

extern void HideMenuBar(void);

    29

    30

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

    31

#if (MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_4)

    32

@interface NSApplication(NSAppleMenu)

    33

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

    34

@end

    35

#endif

    36

    37

    38

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

    39

#undef ALIGN

    40

/* Defined in stdbool.h */

    41

#ifndef __cplusplus

    42

# ifndef __BEOS__

    43

#  undef bool

    44

#  undef false

    45

#  undef true

    46

# endif

    47

#endif

    48

    49

#include "../stdafx.h"

    50

#include "../openttd.h"

    51

#include "../debug.h"

    52

#include "../functions.h"

    53

#include "../gfx.h"

    54

#include "../macros.h"

    55

#include "../sdl.h"

    56

#include "../window.h"

    57

#include "../network.h"

    58

#include "../variables.h"

    59

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

    60

    61

#include "cocoa_v.h"

    62

#include "cocoa_keys.h"

    63

    64

#undef Point

    65

#undef Rect

    66

    67

    68

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

    69

@interface OTTD_QuartzWindow : NSWindow

    70

- (void)miniaturize:(id)sender;

    71

- (void)display;

    72

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

    73

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

    74

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

    75

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

    76

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

    77

@end

    78

    79

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

    80

@interface OTTD_QuartzWindowDelegate : NSObject

    81

- (BOOL)windowShouldClose:(id)sender;

    82

@end

    83

    84

@interface OTTDMain : NSObject

    85

@end

    86

    87

    88

/* Structure for rez switch gamma fades

    89

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

    90

 */

    91

#define QZ_GAMMA_TABLE_SIZE 256

    92

    93

typedef struct {

    94

	CGGammaValue red[QZ_GAMMA_TABLE_SIZE];

    95

	CGGammaValue green[QZ_GAMMA_TABLE_SIZE];

    96

	CGGammaValue blue[QZ_GAMMA_TABLE_SIZE];

    97

} OTTD_QuartzGammaTable;

    98

    99

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

   100

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

   101

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

   102

 * for the main screen).

   103

 */

   104

@interface NSScreen (NSScreenAccess)

   105

	- (void) setFrame:(NSRect)frame;

   106

@end

   107

   108

@implementation NSScreen (NSScreenAccess)

   109

- (void) setFrame:(NSRect)frame;

   110

{

   111

	_frame = frame;

   112

}

   113

@end

   114

   115

   116

static void QZ_Draw(void);

   117

static void QZ_UnsetVideoMode(void);

   118

static void QZ_UpdatePalette(uint start, uint count);

   119

static void QZ_WarpCursor(int x, int y);

   120

static void QZ_ShowMouse(void);

   121

static void QZ_HideMouse(void);

   122

static void CocoaVideoFullScreen(bool full_screen);

   123

   124

   125

static NSAutoreleasePool *_ottd_autorelease_pool;

   126

static OTTDMain *_ottd_main;

   127

   128

   129

static struct CocoaVideoData {

   130

	bool isset;

   131

	bool issetting;

   132

   133

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

   134

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

   135

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

   136

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

   137

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

   138

   139

	uint32 device_width;

   140

	uint32 device_height;

   141

	uint32 device_bpp;

   142

   143

	void *realpixels;

   144

	uint8 *pixels;

   145

	uint32 width;

   146

	uint32 height;

   147

	uint32 pitch;

   148

	bool fullscreen;

   149

   150

	unsigned int current_mods;

   151

	bool tab_is_down;

   152

	bool emulating_right_button;

   153

   154

	bool cursor_visible;

   155

	bool active;

   156

   157

#ifdef _DEBUG

   158

	uint32 tEvent;

   159

#endif

   160

   161

	OTTD_QuartzWindow *window;

   162

	NSQuickDrawView *qdview;

   163

   164

#define MAX_DIRTY_RECTS 100

   165

	OTTDRect dirty_rects[MAX_DIRTY_RECTS];

   166

	int num_dirty_rects;

   167

   168

	uint16 palette16[256];

   169

	uint32 palette32[256];

   170

} _cocoa_video_data;

   171

   172

static bool _cocoa_video_started = false;

   173

static bool _cocoa_video_dialog = false;

   174

   175

   176

   177

   178

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

   179

 *                             Game loop and accessories                      *

   180

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

   181

   182

static uint32 GetTick(void)

   183

{

   184

	struct timeval tim;

   185

   186

	gettimeofday(&tim, NULL);

   187

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

   188

}

   189

   190

static void QZ_CheckPaletteAnim(void)

   191

{

   192

	if (_pal_last_dirty != -1) {

   193

		QZ_UpdatePalette(_pal_first_dirty, _pal_last_dirty - _pal_first_dirty + 1);

   194

		_pal_last_dirty = -1;

   195

	}

   196

}

   197

   198

   199

   200

extern void DoExitSave(void);

   201

   202

static void QZ_AskQuit(void)

   203

{

   204

	if (_game_mode == GM_MENU) { // do not ask to quit on the main screen

   205

		_exit_game = true;

   206

	} else if (_patches.autosave_on_exit) {

   207

		DoExitSave();

   208

		_exit_game = true;

   209

	} else {

   210

		AskExitGame();

   211

	}

   212

}

   213

   214

   215

   216

typedef struct VkMapping {

   217

	unsigned short vk_from;

   218

	byte map_to;

   219

} VkMapping;

   220

   221

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

   222

   223

static const VkMapping _vk_mapping[] = {

   224

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

   225

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

   226

   227

	// Pageup stuff + up/down

   228

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

   229

	AS(QZ_PAGEUP,   WKC_PAGEUP),

   230

	AS(QZ_PAGEDOWN, WKC_PAGEDOWN),

   231

   232

	AS(QZ_UP,    WKC_UP),

   233

	AS(QZ_DOWN,  WKC_DOWN),

   234

	AS(QZ_LEFT,  WKC_LEFT),

   235

	AS(QZ_RIGHT, WKC_RIGHT),

   236

   237

	AS(QZ_HOME, WKC_HOME),

   238

	AS(QZ_END,  WKC_END),

   239

   240

	AS(QZ_INSERT, WKC_INSERT),

   241

	AS(QZ_DELETE, WKC_DELETE),

   242

   243

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

   244

	AS(QZ_a, 'A'),

   245

	AS(QZ_b, 'B'),

   246

	AS(QZ_c, 'C'),

   247

	AS(QZ_d, 'D'),

   248

	AS(QZ_e, 'E'),

   249

	AS(QZ_f, 'F'),

   250

	AS(QZ_g, 'G'),

   251

	AS(QZ_h, 'H'),

   252

	AS(QZ_i, 'I'),

   253

	AS(QZ_j, 'J'),

   254

	AS(QZ_k, 'K'),

   255

	AS(QZ_l, 'L'),

   256

	AS(QZ_m, 'M'),

   257

	AS(QZ_n, 'N'),

   258

	AS(QZ_o, 'O'),

   259

	AS(QZ_p, 'P'),

   260

	AS(QZ_q, 'Q'),

   261

	AS(QZ_r, 'R'),

   262

	AS(QZ_s, 'S'),

   263

	AS(QZ_t, 'T'),

   264

	AS(QZ_u, 'U'),

   265

	AS(QZ_v, 'V'),

   266

	AS(QZ_w, 'W'),

   267

	AS(QZ_x, 'X'),

   268

	AS(QZ_y, 'Y'),

   269

	AS(QZ_z, 'Z'),

   270

	// Same thing for digits

   271

	AS(QZ_0, '0'),

   272

	AS(QZ_1, '1'),

   273

	AS(QZ_2, '2'),

   274

	AS(QZ_3, '3'),

   275

	AS(QZ_4, '4'),

   276

	AS(QZ_5, '5'),

   277

	AS(QZ_6, '6'),

   278

	AS(QZ_7, '7'),

   279

	AS(QZ_8, '8'),

   280

	AS(QZ_9, '9'),

   281

   282

	AS(QZ_ESCAPE,    WKC_ESC),

   283

	AS(QZ_PAUSE,     WKC_PAUSE),

   284

	AS(QZ_BACKSPACE, WKC_BACKSPACE),

   285

   286

	AS(QZ_SPACE,  WKC_SPACE),

   287

	AS(QZ_RETURN, WKC_RETURN),

   288

	AS(QZ_TAB,    WKC_TAB),

   289

   290

	// Function keys

   291

	AS(QZ_F1,  WKC_F1),

   292

	AS(QZ_F2,  WKC_F2),

   293

	AS(QZ_F3,  WKC_F3),

   294

	AS(QZ_F4,  WKC_F4),

   295

	AS(QZ_F5,  WKC_F5),

   296

	AS(QZ_F6,  WKC_F6),

   297

	AS(QZ_F7,  WKC_F7),

   298

	AS(QZ_F8,  WKC_F8),

   299

	AS(QZ_F9,  WKC_F9),

   300

	AS(QZ_F10, WKC_F10),

   301

	AS(QZ_F11, WKC_F11),

   302

	AS(QZ_F12, WKC_F12),

   303

   304

	// Numeric part.

   305

	AS(QZ_KP0,         WKC_NUM_0),

   306

	AS(QZ_KP1,         WKC_NUM_1),

   307

	AS(QZ_KP2,         WKC_NUM_2),

   308

	AS(QZ_KP3,         WKC_NUM_3),

   309

	AS(QZ_KP4,         WKC_NUM_4),

   310

	AS(QZ_KP5,         WKC_NUM_5),

   311

	AS(QZ_KP6,         WKC_NUM_6),

   312

	AS(QZ_KP7,         WKC_NUM_7),

   313

	AS(QZ_KP8,         WKC_NUM_8),

   314

	AS(QZ_KP9,         WKC_NUM_9),

   315

	AS(QZ_KP_DIVIDE,   WKC_NUM_DIV),

   316

	AS(QZ_KP_MULTIPLY, WKC_NUM_MUL),

   317

	AS(QZ_KP_MINUS,    WKC_NUM_MINUS),

   318

	AS(QZ_KP_PLUS,     WKC_NUM_PLUS),

   319

	AS(QZ_KP_ENTER,    WKC_NUM_ENTER),

   320

	AS(QZ_KP_PERIOD,   WKC_NUM_DECIMAL)

   321

};

   322

   323

   324

static uint32 QZ_MapKey(unsigned short sym)

   325

{

   326

	const VkMapping *map;

   327

	uint32 key = 0;

   328

   329

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

   330

		if (sym == map->vk_from) {

   331

			key = map->map_to;

   332

			break;

   333

		}

   334

	}

   335

   336

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

   337

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

   338

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

   339

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

   340

   341

	return key << 16;

   342

}

   343

   344

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

   345

{

   346

	switch (keycode) {

   347

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

   348

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

   349

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

   350

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

   351

   352

		case QZ_TAB: _cocoa_video_data.tab_is_down = down; break;

   353

   354

		case QZ_RETURN:

   355

		case QZ_f:

   356

			if (down && (

   357

						(_cocoa_video_data.current_mods & NSControlKeyMask) ||

   358

						(_cocoa_video_data.current_mods & NSCommandKeyMask)

   359

					)) {

   360

				CocoaVideoFullScreen(!_fullscreen);

   361

			}

   362

			break;

   363

	}

   364

   365

	if (down) {

   366

		_pressed_key = QZ_MapKey(keycode) | unicode;

   367

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

   368

	} else {

   369

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

   370

	}

   371

}

   372

   373

static void QZ_DoUnsidedModifiers(unsigned int newMods)

   374

{

   375

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

   376

   377

	int i;

   378

	int bit;

   379

   380

	if (_cocoa_video_data.current_mods == newMods) return;

   381

   382

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

   383

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

   384

		unsigned int currentMask, newMask;

   385

   386

		currentMask = _cocoa_video_data.current_mods & bit;

   387

		newMask     = newMods & bit;

   388

   389

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

   390

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

   391

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

   392

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

   393

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

   394

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

   395

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

   396

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

   397

		}

   398

	}

   399

   400

	_cocoa_video_data.current_mods = newMods;

   401

}

   402

   403

static void QZ_MouseMovedEvent(int x, int y)

   404

{

   405

	if (_cursor.fix_at) {

   406

		int dx = x - _cursor.pos.x;

   407

		int dy = y - _cursor.pos.y;

   408

   409

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

   410

			_cursor.delta.x += dx;

   411

			_cursor.delta.y += dy;

   412

   413

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

   414

		}

   415

	} else {

   416

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

   417

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

   418

		_cursor.pos.x = x;

   419

		_cursor.pos.y = y;

   420

		_cursor.dirty = true;

   421

	}

   422

}

   423

   424

void QZ_MouseButtonEvent(int button, BOOL down)

   425

{

   426

	switch (button) {

   427

		case 0:

   428

			if (down) {

   429

				_left_button_down = true;

   430

			} else {

   431

				_left_button_down = false;

   432

				_left_button_clicked = false;

   433

			}

   434

			break;

   435

   436

		case 1:

   437

			if (down) {

   438

				_right_button_down = true;

   439

				_right_button_clicked = true;

   440

			} else {

   441

				_right_button_down = false;

   442

			}

   443

			break;

   444

	}

   445

}

   446

   447

   448

static inline NSPoint QZ_GetMouseLocation(NSEvent *event)

   449

{

   450

	NSPoint pt;

   451

   452

	if (_cocoa_video_data.fullscreen) {

   453

		pt = [ NSEvent mouseLocation ];

   454

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

   455

	} else {

   456

		pt = [event locationInWindow];

   457

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

   458

	}

   459

   460

	return pt;

   461

}

   462

   463

static bool QZ_MouseIsInsideView(NSPoint *pt)

   464

{

   465

	if (_cocoa_video_data.fullscreen) {

   466

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

   467

	} else {

   468

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

   469

	}

   470

}

   471

   472

   473

static bool QZ_PollEvent(void)

   474

{

   475

	NSEvent *event;

   476

	NSPoint pt;

   477

	NSString *chars;

   478

#ifdef _DEBUG

   479

	uint32 et0, et;

   480

#endif

   481

   482

#ifdef _DEBUG

   483

	et0 = GetTick();

   484

#endif

   485

	event = [ NSApp nextEventMatchingMask:NSAnyEventMask

   486

			untilDate: [ NSDate distantPast ]

   487

			inMode: NSDefaultRunLoopMode dequeue:YES ];

   488

#ifdef _DEBUG

   489

	et = GetTick();

   490

	_cocoa_video_data.tEvent+= et - et0;

   491

#endif

   492

   493

	if (event == nil) return false;

   494

	if (!_cocoa_video_data.active) {

   495

		QZ_ShowMouse();

   496

		[NSApp sendEvent:event];

   497

		return true;

   498

	}

   499

   500

	QZ_DoUnsidedModifiers( [ event modifierFlags ] );

   501

   502

	switch ([event type]) {

   503

		case NSMouseMoved:

   504

		case NSOtherMouseDragged:

   505

		case NSRightMouseDragged:

   506

		case NSLeftMouseDragged:

   507

			pt = QZ_GetMouseLocation(event);

   508

			if (!QZ_MouseIsInsideView(&pt) &&

   509

					!_cocoa_video_data.emulating_right_button) {

   510

				QZ_ShowMouse();

   511

				[NSApp sendEvent:event];

   512

				break;