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"

    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

typedef struct VkMapping {

   201

	unsigned short vk_from;

   202

	byte map_to;

   203

} VkMapping;

   204

   205

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

   206

   207

static const VkMapping _vk_mapping[] = {

   208

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

   209

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

   210

   211

	// Pageup stuff + up/down

   212

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

   213

	AS(QZ_PAGEUP,   WKC_PAGEUP),

   214

	AS(QZ_PAGEDOWN, WKC_PAGEDOWN),

   215

   216

	AS(QZ_UP,    WKC_UP),

   217

	AS(QZ_DOWN,  WKC_DOWN),

   218

	AS(QZ_LEFT,  WKC_LEFT),

   219

	AS(QZ_RIGHT, WKC_RIGHT),

   220

   221

	AS(QZ_HOME, WKC_HOME),

   222

	AS(QZ_END,  WKC_END),

   223

   224

	AS(QZ_INSERT, WKC_INSERT),

   225

	AS(QZ_DELETE, WKC_DELETE),

   226

   227

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

   228

	AS(QZ_a, 'A'),

   229

	AS(QZ_b, 'B'),

   230

	AS(QZ_c, 'C'),

   231

	AS(QZ_d, 'D'),

   232

	AS(QZ_e, 'E'),

   233

	AS(QZ_f, 'F'),

   234

	AS(QZ_g, 'G'),

   235

	AS(QZ_h, 'H'),

   236

	AS(QZ_i, 'I'),

   237

	AS(QZ_j, 'J'),

   238

	AS(QZ_k, 'K'),

   239

	AS(QZ_l, 'L'),

   240

	AS(QZ_m, 'M'),

   241

	AS(QZ_n, 'N'),

   242

	AS(QZ_o, 'O'),

   243

	AS(QZ_p, 'P'),

   244

	AS(QZ_q, 'Q'),

   245

	AS(QZ_r, 'R'),

   246

	AS(QZ_s, 'S'),

   247

	AS(QZ_t, 'T'),

   248

	AS(QZ_u, 'U'),

   249

	AS(QZ_v, 'V'),

   250

	AS(QZ_w, 'W'),

   251

	AS(QZ_x, 'X'),

   252

	AS(QZ_y, 'Y'),

   253

	AS(QZ_z, 'Z'),

   254

	// Same thing for digits

   255

	AS(QZ_0, '0'),

   256

	AS(QZ_1, '1'),

   257

	AS(QZ_2, '2'),

   258

	AS(QZ_3, '3'),

   259

	AS(QZ_4, '4'),

   260

	AS(QZ_5, '5'),

   261

	AS(QZ_6, '6'),

   262

	AS(QZ_7, '7'),

   263

	AS(QZ_8, '8'),

   264

	AS(QZ_9, '9'),

   265

   266

	AS(QZ_ESCAPE,    WKC_ESC),

   267

	AS(QZ_PAUSE,     WKC_PAUSE),

   268

	AS(QZ_BACKSPACE, WKC_BACKSPACE),

   269

   270

	AS(QZ_SPACE,  WKC_SPACE),

   271

	AS(QZ_RETURN, WKC_RETURN),

   272

	AS(QZ_TAB,    WKC_TAB),

   273

   274

	// Function keys

   275

	AS(QZ_F1,  WKC_F1),

   276

	AS(QZ_F2,  WKC_F2),

   277

	AS(QZ_F3,  WKC_F3),

   278

	AS(QZ_F4,  WKC_F4),

   279

	AS(QZ_F5,  WKC_F5),

   280

	AS(QZ_F6,  WKC_F6),

   281

	AS(QZ_F7,  WKC_F7),

   282

	AS(QZ_F8,  WKC_F8),

   283

	AS(QZ_F9,  WKC_F9),

   284

	AS(QZ_F10, WKC_F10),

   285

	AS(QZ_F11, WKC_F11),

   286

	AS(QZ_F12, WKC_F12),

   287

   288

	// Numeric part.

   289

	AS(QZ_KP0,         WKC_NUM_0),

   290

	AS(QZ_KP1,         WKC_NUM_1),

   291

	AS(QZ_KP2,         WKC_NUM_2),

   292

	AS(QZ_KP3,         WKC_NUM_3),

   293

	AS(QZ_KP4,         WKC_NUM_4),

   294

	AS(QZ_KP5,         WKC_NUM_5),

   295

	AS(QZ_KP6,         WKC_NUM_6),

   296

	AS(QZ_KP7,         WKC_NUM_7),

   297

	AS(QZ_KP8,         WKC_NUM_8),

   298

	AS(QZ_KP9,         WKC_NUM_9),

   299

	AS(QZ_KP_DIVIDE,   WKC_NUM_DIV),

   300

	AS(QZ_KP_MULTIPLY, WKC_NUM_MUL),

   301

	AS(QZ_KP_MINUS,    WKC_NUM_MINUS),

   302

	AS(QZ_KP_PLUS,     WKC_NUM_PLUS),

   303

	AS(QZ_KP_ENTER,    WKC_NUM_ENTER),

   304

	AS(QZ_KP_PERIOD,   WKC_NUM_DECIMAL)

   305

};

   306

   307

   308

static uint32 QZ_MapKey(unsigned short sym)

   309

{

   310

	const VkMapping *map;

   311

	uint32 key = 0;

   312

   313

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

   314

		if (sym == map->vk_from) {

   315

			key = map->map_to;

   316

			break;

   317

		}

   318

	}

   319

   320

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

   321

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

   322

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

   323

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

   324

   325

	return key << 16;

   326

}

   327

   328

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

   329

{

   330

	switch (keycode) {

   331

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

   332

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

   333

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

   334

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

   335

   336

		case QZ_TAB: _cocoa_video_data.tab_is_down = down; break;

   337

   338

		case QZ_RETURN:

   339

		case QZ_f:

   340

			if (down && (

   341

						(_cocoa_video_data.current_mods & NSControlKeyMask) ||

   342

						(_cocoa_video_data.current_mods & NSCommandKeyMask)

   343

					)) {

   344

				CocoaVideoFullScreen(!_fullscreen);

   345

			}

   346

			break;

   347

	}

   348

   349

	if (down) {

   350

		uint32 pressed_key = QZ_MapKey(keycode) | unicode;

   351

		HandleKeypress(pressed_key);

   352

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

   353

	} else {

   354

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

   355

	}

   356

}

   357

   358

static void QZ_DoUnsidedModifiers(unsigned int newMods)

   359

{

   360

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

   361

   362

	int i;

   363

	int bit;

   364

   365

	if (_cocoa_video_data.current_mods == newMods) return;

   366

   367

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

   368

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

   369

		unsigned int currentMask, newMask;

   370

   371

		currentMask = _cocoa_video_data.current_mods & bit;

   372

		newMask     = newMods & bit;

   373

   374

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

   375

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

   376

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

   377

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

   378

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

   379

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

   380

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

   381

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

   382

		}

   383

	}

   384

   385

	_cocoa_video_data.current_mods = newMods;

   386

}

   387

   388

static void QZ_MouseMovedEvent(int x, int y)

   389

{

   390

	if (_cursor.fix_at) {

   391

		int dx = x - _cursor.pos.x;

   392

		int dy = y - _cursor.pos.y;

   393

   394

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

   395

			_cursor.delta.x += dx;

   396

			_cursor.delta.y += dy;

   397

   398

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

   399

		}

   400

	} else {

   401

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

   402

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

   403

		_cursor.pos.x = x;

   404

		_cursor.pos.y = y;

   405

		_cursor.dirty = true;

   406

	}

   407

	HandleMouseEvents();

   408

}

   409

   410

   411

static void QZ_MouseButtonEvent(int button, BOOL down)

   412

{

   413

	switch (button) {

   414

		case 0:

   415

			if (down) {

   416

				_left_button_down = true;

   417

			} else {

   418

				_left_button_down = false;

   419

				_left_button_clicked = false;

   420

			}

   421

			HandleMouseEvents();

   422

			break;

   423

   424

		case 1:

   425

			if (down) {

   426

				_right_button_down = true;

   427

				_right_button_clicked = true;

   428

			} else {

   429

				_right_button_down = false;

   430

			}

   431

			HandleMouseEvents();

   432

			break;

   433

	}

   434

}

   435

   436

   437

static inline NSPoint QZ_GetMouseLocation(NSEvent *event)

   438

{

   439

	NSPoint pt;

   440

   441

	if (_cocoa_video_data.fullscreen) {

   442

		pt = [ NSEvent mouseLocation ];

   443

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

   444

	} else {

   445

		pt = [event locationInWindow];

   446

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

   447

	}

   448

   449

	return pt;

   450

}

   451

   452

static bool QZ_MouseIsInsideView(NSPoint *pt)

   453

{

   454

	if (_cocoa_video_data.fullscreen) {

   455

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

   456

	} else {

   457

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

   458

	}

   459

}

   460

   461

   462

static bool QZ_PollEvent(void)

   463

{

   464

	NSEvent *event;

   465

	NSPoint pt;

   466

	NSString *chars;

   467

#ifdef _DEBUG

   468

	uint32 et0, et;

   469

#endif

   470

   471

#ifdef _DEBUG

   472

	et0 = GetTick();

   473

#endif

   474

	event = [ NSApp nextEventMatchingMask:NSAnyEventMask

   475

			untilDate: [ NSDate distantPast ]

   476

			inMode: NSDefaultRunLoopMode dequeue:YES ];

   477

#ifdef _DEBUG

   478

	et = GetTick();

   479

	_cocoa_video_data.tEvent+= et - et0;

   480

#endif

   481

   482

	if (event == nil) return false;

   483

	if (!_cocoa_video_data.active) {

   484

		QZ_ShowMouse();

   485

		[NSApp sendEvent:event];

   486

		return true;

   487

	}

   488

   489

	QZ_DoUnsidedModifiers( [ event modifierFlags ] );

   490

   491

	switch ([event type]) {

   492

		case NSMouseMoved:

   493

		case NSOtherMouseDragged:

   494

		case NSRightMouseDragged:

   495

		case NSLeftMouseDragged:

   496

			pt = QZ_GetMouseLocation(event);

   497

			if (!QZ_MouseIsInsideView(&pt) &&

   498

					!_cocoa_video_data.emulating_right_button) {

   499

				QZ_ShowMouse();

   500

				[NSApp sendEvent:event];

   501

				break;

   502

			}

   503

   504

			QZ_HideMouse();

   505

			QZ_MouseMovedEvent((int)pt.x, (int)pt.y);

   506

			break;

   507

   508

		case NSLeftMouseDown:

   509

			if (!([ event modifierFlags ] & NSCommandKeyMask) ||

   510

					!QZ_MouseIsInsideView(&pt)) {

   511