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

    50

#include "../stdafx.h"

    51

#include "../debug.h"

    52

#include "../macros.h"

    53

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

    54

#include "cocoa_v.h"

    55

#include "cocoa_keys.h"

    56

    57

#undef Point

    58

#undef Rect

    59

    60

    61

    62

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

    63

@interface OTTD_QuartzWindow : NSWindow

    64

- (void)miniaturize:(id)sender;

    65

- (void)display;

    66

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

    67

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

    68

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

    69

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

    70

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

    71

@end

    72

    73

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

    74

@interface OTTD_QuartzWindowDelegate : NSObject

    75

- (BOOL)windowShouldClose:(id)sender;

    76

@end

    77

    78

@interface OTTDMain : NSObject

    79

@end

    80

    81

    82

/* Structure for rez switch gamma fades

    83

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

    84

 */

    85

#define QZ_GAMMA_TABLE_SIZE 256

    86

    87

typedef struct {

    88

	CGGammaValue red[QZ_GAMMA_TABLE_SIZE];

    89

	CGGammaValue green[QZ_GAMMA_TABLE_SIZE];

    90

	CGGammaValue blue[QZ_GAMMA_TABLE_SIZE];

    91

} OTTD_QuartzGammaTable;

    92

    93

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

    94

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

    95

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

    96

 * for the main screen).

    97

 */

    98

@interface NSScreen (NSScreenAccess)

    99

	- (void) setFrame:(NSRect)frame;

   100

@end

   101

   102

@implementation NSScreen (NSScreenAccess)

   103

- (void) setFrame:(NSRect)frame;

   104

{

   105

	_frame = frame;

   106

}

   107

@end

   108

   109

   110

static void QZ_Draw(void);

   111

static void QZ_UnsetVideoMode(void);

   112

static void QZ_UpdatePalette(uint start, uint count);

   113

static void QZ_WarpCursor(int x, int y);

   114

static void QZ_ShowMouse(void);

   115

static void QZ_HideMouse(void);

   116

static void CocoaVideoFullScreen(bool full_screen);

   117

   118

   119

static NSAutoreleasePool *_ottd_autorelease_pool;

   120

static OTTDMain *_ottd_main;

   121

   122

   123

static struct CocoaVideoData {

   124

	bool isset;

   125

	bool issetting;

   126

   127

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

   128

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

   129

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

   130

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

   131

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

   132

   133

	uint32 device_width;

   134

	uint32 device_height;

   135

	uint32 device_bpp;

   136

   137

	void *realpixels;

   138

	uint8 *pixels;

   139

	uint32 width;

   140

	uint32 height;

   141

	uint32 pitch;

   142

	bool fullscreen;

   143

   144

	unsigned int current_mods;

   145

	bool tab_is_down;

   146

	bool emulating_right_button;

   147

   148

	bool cursor_visible;

   149

	bool active;

   150

   151

#ifdef _DEBUG

   152

	uint32 tEvent;

   153

#endif

   154

   155

	OTTD_QuartzWindow *window;

   156

	NSQuickDrawView *qdview;

   157

   158

#define MAX_DIRTY_RECTS 100

   159

	Rect dirty_rects[MAX_DIRTY_RECTS];

   160

	int num_dirty_rects;

   161

   162

	uint16 palette16[256];

   163

	uint32 palette32[256];

   164

} _cocoa_video_data;

   165

   166

static bool _cocoa_video_started = false;

   167

static bool _cocoa_video_dialog = false;

   168

   169

   170

   171

   172

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

   173

 *                             Game loop and accessories                      *

   174

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

   175

   176

static uint32 GetTick(void)

   177

{

   178

	struct timeval tim;

   179

   180

	gettimeofday(&tim, NULL);

   181

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

   182

}

   183

   184

static void QZ_CheckPaletteAnim(void)

   185

{

   186

	if (_pal_last_dirty != -1) {

   187

		QZ_UpdatePalette(_pal_first_dirty, _pal_last_dirty - _pal_first_dirty + 1);

   188

		_pal_last_dirty = -1;

   189

	}

   190

}

   191

   192

   193

   194

typedef struct VkMapping {

   195

	unsigned short vk_from;

   196

	byte map_to;

   197

} VkMapping;

   198

   199

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

   200

   201

static const VkMapping _vk_mapping[] = {

   202

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

   203

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

   204

   205

	// Pageup stuff + up/down

   206

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

   207

	AS(QZ_PAGEUP,   WKC_PAGEUP),

   208

	AS(QZ_PAGEDOWN, WKC_PAGEDOWN),

   209

   210

	AS(QZ_UP,    WKC_UP),

   211

	AS(QZ_DOWN,  WKC_DOWN),

   212

	AS(QZ_LEFT,  WKC_LEFT),

   213

	AS(QZ_RIGHT, WKC_RIGHT),

   214

   215

	AS(QZ_HOME, WKC_HOME),

   216

	AS(QZ_END,  WKC_END),

   217

   218

	AS(QZ_INSERT, WKC_INSERT),

   219

	AS(QZ_DELETE, WKC_DELETE),

   220

   221

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

   222

	AS(QZ_a, 'A'),

   223

	AS(QZ_b, 'B'),

   224

	AS(QZ_c, 'C'),

   225

	AS(QZ_d, 'D'),

   226

	AS(QZ_e, 'E'),

   227

	AS(QZ_f, 'F'),

   228

	AS(QZ_g, 'G'),

   229

	AS(QZ_h, 'H'),

   230

	AS(QZ_i, 'I'),

   231

	AS(QZ_j, 'J'),

   232

	AS(QZ_k, 'K'),

   233

	AS(QZ_l, 'L'),

   234

	AS(QZ_m, 'M'),

   235

	AS(QZ_n, 'N'),

   236

	AS(QZ_o, 'O'),

   237

	AS(QZ_p, 'P'),

   238

	AS(QZ_q, 'Q'),

   239

	AS(QZ_r, 'R'),

   240

	AS(QZ_s, 'S'),

   241

	AS(QZ_t, 'T'),

   242

	AS(QZ_u, 'U'),

   243

	AS(QZ_v, 'V'),

   244

	AS(QZ_w, 'W'),

   245

	AS(QZ_x, 'X'),

   246

	AS(QZ_y, 'Y'),

   247

	AS(QZ_z, 'Z'),

   248

	// Same thing for digits

   249

	AS(QZ_0, '0'),

   250

	AS(QZ_1, '1'),

   251

	AS(QZ_2, '2'),

   252

	AS(QZ_3, '3'),

   253

	AS(QZ_4, '4'),

   254

	AS(QZ_5, '5'),

   255

	AS(QZ_6, '6'),

   256

	AS(QZ_7, '7'),

   257

	AS(QZ_8, '8'),

   258

	AS(QZ_9, '9'),

   259

   260

	AS(QZ_ESCAPE,    WKC_ESC),

   261

	AS(QZ_PAUSE,     WKC_PAUSE),

   262

	AS(QZ_BACKSPACE, WKC_BACKSPACE),

   263

   264

	AS(QZ_SPACE,  WKC_SPACE),

   265

	AS(QZ_RETURN, WKC_RETURN),

   266

	AS(QZ_TAB,    WKC_TAB),

   267

   268

	// Function keys

   269

	AS(QZ_F1,  WKC_F1),

   270

	AS(QZ_F2,  WKC_F2),

   271

	AS(QZ_F3,  WKC_F3),

   272

	AS(QZ_F4,  WKC_F4),

   273

	AS(QZ_F5,  WKC_F5),

   274

	AS(QZ_F6,  WKC_F6),

   275

	AS(QZ_F7,  WKC_F7),

   276

	AS(QZ_F8,  WKC_F8),

   277

	AS(QZ_F9,  WKC_F9),

   278

	AS(QZ_F10, WKC_F10),

   279

	AS(QZ_F11, WKC_F11),

   280

	AS(QZ_F12, WKC_F12),

   281

   282

	// Numeric part.

   283

	AS(QZ_KP0,         WKC_NUM_0),

   284

	AS(QZ_KP1,         WKC_NUM_1),

   285

	AS(QZ_KP2,         WKC_NUM_2),

   286

	AS(QZ_KP3,         WKC_NUM_3),

   287

	AS(QZ_KP4,         WKC_NUM_4),

   288

	AS(QZ_KP5,         WKC_NUM_5),

   289

	AS(QZ_KP6,         WKC_NUM_6),

   290

	AS(QZ_KP7,         WKC_NUM_7),

   291

	AS(QZ_KP8,         WKC_NUM_8),

   292

	AS(QZ_KP9,         WKC_NUM_9),

   293

	AS(QZ_KP_DIVIDE,   WKC_NUM_DIV),

   294

	AS(QZ_KP_MULTIPLY, WKC_NUM_MUL),

   295

	AS(QZ_KP_MINUS,    WKC_NUM_MINUS),

   296

	AS(QZ_KP_PLUS,     WKC_NUM_PLUS),

   297

	AS(QZ_KP_ENTER,    WKC_NUM_ENTER),

   298

	AS(QZ_KP_PERIOD,   WKC_NUM_DECIMAL)

   299

};

   300

   301

   302

static uint32 QZ_MapKey(unsigned short sym)

   303

{

   304

	const VkMapping *map;

   305

	uint32 key = 0;

   306

   307

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

   308

		if (sym == map->vk_from) {

   309

			key = map->map_to;

   310

			break;

   311

		}

   312

	}

   313

   314

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

   315

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

   316

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

   317

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

   318

   319

	return key << 16;

   320

}

   321

   322

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

   323

{

   324

	switch (keycode) {

   325

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

   326

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

   327

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

   328

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

   329

   330

		case QZ_TAB: _cocoa_video_data.tab_is_down = down; break;

   331

   332

		case QZ_RETURN:

   333

		case QZ_f:

   334

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

   335

				CocoaVideoFullScreen(!_fullscreen);

   336

			}

   337

			break;

   338

	}

   339

   340

	if (down) {

   341

		uint32 pressed_key = QZ_MapKey(keycode) | unicode;

   342

		HandleKeypress(pressed_key);

   343

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

   344

	} else {

   345

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

   346

	}

   347

}

   348

   349

static void QZ_DoUnsidedModifiers(unsigned int newMods)

   350

{

   351

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

   352

   353

	int i;

   354

	int bit;

   355

   356

	if (_cocoa_video_data.current_mods == newMods) return;

   357

   358

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

   359

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

   360

		unsigned int currentMask, newMask;

   361

   362

		currentMask = _cocoa_video_data.current_mods & bit;

   363

		newMask     = newMods & bit;

   364

   365

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

   366

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

   367

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

   368

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

   369

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

   370

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

   371

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

   372

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

   373

		}

   374

	}

   375

   376

	_cocoa_video_data.current_mods = newMods;

   377

}

   378

   379

static void QZ_MouseMovedEvent(int x, int y)

   380

{

   381

	if (_cursor.fix_at) {

   382

		int dx = x - _cursor.pos.x;

   383

		int dy = y - _cursor.pos.y;

   384

   385

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

   386

			_cursor.delta.x += dx;

   387

			_cursor.delta.y += dy;

   388

   389

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

   390

		}

   391

	} else {

   392

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

   393

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

   394

		_cursor.pos.x = x;

   395

		_cursor.pos.y = y;

   396

		_cursor.dirty = true;

   397

	}

   398

	HandleMouseEvents();

   399

}

   400

   401

   402

static void QZ_MouseButtonEvent(int button, BOOL down)

   403

{

   404

	switch (button) {

   405

		case 0:

   406

			if (down) {

   407

				_left_button_down = true;

   408

			} else {

   409

				_left_button_down = false;

   410

				_left_button_clicked = false;

   411

			}

   412

			HandleMouseEvents();

   413

			break;

   414

   415

		case 1:

   416

			if (down) {

   417

				_right_button_down = true;

   418

				_right_button_clicked = true;

   419

			} else {

   420

				_right_button_down = false;

   421

			}

   422

			HandleMouseEvents();

   423

			break;

   424

	}

   425

}

   426

   427

   428

static inline NSPoint QZ_GetMouseLocation(NSEvent *event)

   429

{

   430

	NSPoint pt;

   431

   432

	if (_cocoa_video_data.fullscreen) {

   433

		pt = [ NSEvent mouseLocation ];

   434

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

   435

	} else {

   436

		pt = [event locationInWindow];

   437

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

   438

	}

   439

   440

	return pt;

   441

}

   442

   443

static bool QZ_MouseIsInsideView(NSPoint *pt)

   444

{

   445

	if (_cocoa_video_data.fullscreen) {

   446

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

   447

	} else {

   448

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

   449

	}

   450

}

   451

   452

   453

static bool QZ_PollEvent(void)

   454

{

   455

	NSEvent *event;

   456

	NSPoint pt;

   457

	NSString *chars;

   458

#ifdef _DEBUG

   459

	uint32 et0, et;

   460

#endif

   461

   462

#ifdef _DEBUG

   463

	et0 = GetTick();

   464

#endif

   465

	event = [ NSApp nextEventMatchingMask:NSAnyEventMask

   466

			untilDate: [ NSDate distantPast ]

   467

			inMode: NSDefaultRunLoopMode dequeue:YES ];

   468

#ifdef _DEBUG

   469

	et = GetTick();

   470

	_cocoa_video_data.tEvent+= et - et0;

   471

#endif

   472

   473

	if (event == nil) return false;

   474

	if (!_cocoa_video_data.active) {

   475

		QZ_ShowMouse();

   476

		[NSApp sendEvent:event];

   477

		return true;

   478

	}

   479

   480

	QZ_DoUnsidedModifiers( [ event modifierFlags ] );

   481

   482

	switch ([event type]) {

   483

		case NSMouseMoved:

   484

		case NSOtherMouseDragged:

   485

		case NSRightMouseDragged:

   486

		case NSLeftMouseDragged:

   487

			pt = QZ_GetMouseLocation(event);

   488

			if (!QZ_MouseIsInsideView(&pt) &&

   489

					!_cocoa_video_data.emulating_right_button) {

   490

				QZ_ShowMouse();

   491

				[NSApp sendEvent:event];

   492

				break;

   493

			}

   494

   495

			QZ_HideMouse();

   496

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

   497

			break;

   498

   499

		case NSLeftMouseDown:

   500

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

   501

					!QZ_MouseIsInsideView(&pt)) {

   502

				[NSApp sendEvent:event];

   503

			}

   504

   505

			pt = QZ_GetMouseLocation(event);

   506

			if (!QZ_MouseIsInsideView(&pt)) {

   507

				QZ_ShowMouse();

   508

				break;

   509

			}

   510