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

{

    19

	UInt32          lo;

    20

	UInt32          hi;

    21

} CPSProcessSerNum;

    22

    23

extern OSErr    CPSGetCurrentProcess( CPSProcessSerNum *psn);

    24

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

    25

extern OSErr    CPSSetFrontProcess( CPSProcessSerNum *psn);

    26

    27

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

    28

extern void ShowMenuBar(void);

    29

extern void HideMenuBar(void);

    30

    31

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

    32

#if (MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_4)

    33

@interface NSApplication(NSAppleMenu)

    34

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

    35

@end

    36

#endif

    37

    38

    39

/* Name conflict */

    40

#define Rect		OTTDRect

    41

#define Point		OTTDPoint

    42

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

    43

#undef ALIGN

    44

/* Defined in stdbool.h */

    45

#ifndef __cplusplus

    46

# ifndef __BEOS__

    47

#  undef bool

    48

#  undef false

    49

#  undef true

    50

# endif

    51

#endif

    52

    53

#include "../stdafx.h"

    54

#include "../openttd.h"

    55

#include "../debug.h"

    56

#include "../functions.h"

    57

#include "../gfx.h"

    58

#include "../macros.h"

    59

#include "../sdl.h"

    60

#include "../window.h"

    61

#include "../network.h"

    62

#include "../variables.h"

    63

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

    64

    65

#include "cocoa_v.h"

    66

    67

#undef Point

    68

#undef Rect

    69

    70

    71

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

    72

@interface OTTD_QuartzWindow : NSWindow

    73

- (void)miniaturize:(id)sender;

    74

- (void)display;

    75

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

    76

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

    77

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

    78

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

    79

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

    80

@end

    81

    82

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

    83

@interface OTTD_QuartzWindowDelegate : NSObject

    84

- (BOOL)windowShouldClose:(id)sender;

    85

@end

    86

    87

@interface OTTDMain : NSObject

    88

@end

    89

    90

    91

/*

    92

		Structure for rez switch gamma fades

    93

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

    94

*/

    95

#define QZ_GAMMA_TABLE_SIZE 256

    96

    97

typedef struct {

    98

	CGGammaValue red[QZ_GAMMA_TABLE_SIZE];

    99

	CGGammaValue green[QZ_GAMMA_TABLE_SIZE];

   100

	CGGammaValue blue[QZ_GAMMA_TABLE_SIZE];

   101

} OTTD_QuartzGammaTable;

   102

   103

/*

   104

    Add methods to get at private members of NSScreen.

   105

    Since there is a bug in Apple's screen switching code

   106

    that does not update this variable when switching

   107

    to fullscreen, we'll set it manually (but only for the

   108

    main screen).

   109

*/

   110

@interface NSScreen (NSScreenAccess)

   111

		- (void) setFrame:(NSRect)frame;

   112

@end

   113

   114

@implementation NSScreen (NSScreenAccess)

   115

- (void) setFrame:(NSRect)frame;

   116

{

   117

	_frame = frame;

   118

}

   119

@end

   120

   121

   122

static void QZ_Draw(void);

   123

static void QZ_UnsetVideoMode (void);

   124

static void QZ_UpdatePalette(uint start, uint count);

   125

static void QZ_WarpCursor (int x, int y);

   126

void QZ_ShowMouse (void);

   127

void QZ_HideMouse (void);

   128

static void CocoaVideoFullScreen(bool full_screen);

   129

   130

   131

static NSAutoreleasePool *_ottd_autorelease_pool;

   132

static OTTDMain *_ottd_main;

   133

   134

   135

static struct CocoaVideoData {

   136

	bool isset;

   137

	bool issetting;

   138

   139

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

   140

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

   141

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

   142

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

   143

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

   144

   145

	uint32 device_width;

   146

	uint32 device_height;

   147

	uint32 device_bpp;

   148

   149

	void *realpixels;

   150

	uint8 *pixels;

   151

	uint32 width;

   152

	uint32 height;

   153

	uint32 pitch;

   154

	bool fullscreen;

   155

   156

	unsigned int current_mods;

   157

	bool tab_is_down;

   158

	bool emulating_right_button;

   159

   160

	bool cursor_visible;

   161

	bool active;

   162

   163

#ifdef _DEBUG

   164

	uint32 tEvent;

   165

#endif

   166

   167

	OTTD_QuartzWindow *window;

   168

	NSQuickDrawView *qdview;

   169

   170

#define MAX_DIRTY_RECTS 100

   171

	OTTDRect dirty_rects[MAX_DIRTY_RECTS];

   172

	int num_dirty_rects;

   173

   174

	uint16 palette16[256];

   175

	uint32 palette32[256];

   176

} _cocoa_video_data;

   177

   178

static bool _cocoa_video_started = false;

   179

static bool _cocoa_video_dialog = false;

   180

   181

   182

   183

   184

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

   185

 *                             Game loop and accessories                                  *

   186

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

   187

   188

static uint32 GetTick(void)

   189

{

   190

	struct timeval tim;

   191

   192

	gettimeofday(&tim, NULL);

   193

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

   194

}

   195

   196

static void QZ_CheckPaletteAnim(void)

   197

{

   198

	if (_pal_last_dirty != -1) {

   199

		QZ_UpdatePalette(_pal_first_dirty, _pal_last_dirty - _pal_first_dirty + 1);

   200

		_pal_last_dirty = -1;

   201

	}

   202

}

   203

   204

   205

   206

extern void DoExitSave(void);

   207

   208

static void QZ_AskQuit(void)

   209

{

   210

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

   211

		_exit_game = true;

   212

	} else if (_patches.autosave_on_exit) {

   213

		DoExitSave();

   214

		_exit_game = true;

   215

	} else

   216

		AskExitGame();

   217

}

   218

   219

   220

   221

typedef struct VkMapping {

   222

	unsigned short vk_from;

   223

	byte map_to;

   224

} VkMapping;

   225

   226

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

   227

   228

static const VkMapping _vk_mapping[] = {

   229

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

   230

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

   231

   232

	// Pageup stuff + up/down

   233

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

   234

	AS(QZ_PAGEUP,		WKC_PAGEUP),

   235

	AS(QZ_PAGEDOWN,		WKC_PAGEDOWN),

   236

   237

	AS(QZ_UP,			WKC_UP),

   238

	AS(QZ_DOWN,			WKC_DOWN),

   239

	AS(QZ_LEFT,			WKC_LEFT),

   240

	AS(QZ_RIGHT,		WKC_RIGHT),

   241

   242

	AS(QZ_HOME,			WKC_HOME),

   243

	AS(QZ_END,			WKC_END),

   244

   245

	AS(QZ_INSERT,		WKC_INSERT),

   246

	AS(QZ_DELETE,		WKC_DELETE),

   247

   248

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

   249

	AS(QZ_a,			'A'),

   250

	AS(QZ_b,			'B'),

   251

	AS(QZ_c,			'C'),

   252

	AS(QZ_d,			'D'),

   253

	AS(QZ_e,			'E'),

   254

	AS(QZ_f,			'F'),

   255

	AS(QZ_g,			'G'),

   256

	AS(QZ_h,			'H'),

   257

	AS(QZ_i,			'I'),

   258

	AS(QZ_j,			'J'),

   259

	AS(QZ_k,			'K'),

   260

	AS(QZ_l,			'L'),

   261

	AS(QZ_m,			'M'),

   262

	AS(QZ_n,			'N'),

   263

	AS(QZ_o,			'O'),

   264

	AS(QZ_p,			'P'),

   265

	AS(QZ_q,			'Q'),

   266

	AS(QZ_r,			'R'),

   267

	AS(QZ_s,			'S'),

   268

	AS(QZ_t,			'T'),

   269

	AS(QZ_u,			'U'),

   270

	AS(QZ_v,			'V'),

   271

	AS(QZ_w,			'W'),

   272

	AS(QZ_x,			'X'),

   273

	AS(QZ_y,			'Y'),

   274

	AS(QZ_z,			'Z'),

   275

	// Same thing for digits

   276

	AS(QZ_0,			'0'),

   277

	AS(QZ_1,			'1'),

   278

	AS(QZ_2,			'2'),

   279

	AS(QZ_3,			'3'),

   280

	AS(QZ_4,			'4'),

   281

	AS(QZ_5,			'5'),

   282

	AS(QZ_6,			'6'),

   283

	AS(QZ_7,			'7'),

   284

	AS(QZ_8,			'8'),

   285

	AS(QZ_9,			'9'),

   286

   287

	AS(QZ_ESCAPE,		WKC_ESC),

   288

	AS(QZ_PAUSE,  		WKC_PAUSE),

   289

	AS(QZ_BACKSPACE,	WKC_BACKSPACE),

   290

   291

	AS(QZ_SPACE,		WKC_SPACE),

   292

	AS(QZ_RETURN,		WKC_RETURN),

   293

	AS(QZ_TAB,			WKC_TAB),

   294

   295

	// Function keys

   296

	AS(QZ_F1,			WKC_F1),

   297

	AS(QZ_F2,			WKC_F2),

   298

	AS(QZ_F3,			WKC_F3),

   299

	AS(QZ_F4,			WKC_F4),

   300

	AS(QZ_F5,			WKC_F5),

   301

	AS(QZ_F6,			WKC_F6),

   302

	AS(QZ_F7,			WKC_F7),

   303

	AS(QZ_F8,			WKC_F8),

   304

	AS(QZ_F9,			WKC_F9),

   305

	AS(QZ_F10,			WKC_F10),

   306

	AS(QZ_F11,			WKC_F11),

   307

	AS(QZ_F12,			WKC_F12),

   308

   309

	// Numeric part.

   310

	AS(QZ_KP0,				WKC_NUM_0),

   311

	AS(QZ_KP1,				WKC_NUM_1),

   312

	AS(QZ_KP2,				WKC_NUM_2),

   313

	AS(QZ_KP3,				WKC_NUM_3),

   314

	AS(QZ_KP4,				WKC_NUM_4),

   315

	AS(QZ_KP5,				WKC_NUM_5),

   316

	AS(QZ_KP6,				WKC_NUM_6),

   317

	AS(QZ_KP7,				WKC_NUM_7),

   318

	AS(QZ_KP8,				WKC_NUM_8),

   319

	AS(QZ_KP9,				WKC_NUM_9),

   320

	AS(QZ_KP_DIVIDE,		WKC_NUM_DIV),

   321

	AS(QZ_KP_MULTIPLY,		WKC_NUM_MUL),

   322

	AS(QZ_KP_MINUS,			WKC_NUM_MINUS),

   323

	AS(QZ_KP_PLUS,			WKC_NUM_PLUS),

   324

	AS(QZ_KP_ENTER,			WKC_NUM_ENTER),

   325

	AS(QZ_KP_PERIOD,		WKC_NUM_DECIMAL)

   326

};

   327

   328

   329

static uint32 QZ_MapKey(unsigned short sym)

   330

{

   331

	const VkMapping *map;

   332

	uint32 key = 0;

   333

   334

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

   335

		if(sym == map->vk_from) {

   336

			key = map->map_to;

   337

			break;

   338

		}

   339

	}

   340

   341

	if(_cocoa_video_data.current_mods & NSShiftKeyMask)

   342

		key|= WKC_SHIFT;

   343

	if(_cocoa_video_data.current_mods & NSControlKeyMask)

   344

		key|= WKC_CTRL;

   345

	if(_cocoa_video_data.current_mods & NSAlternateKeyMask)

   346

		key|= WKC_ALT;

   347

	if(_cocoa_video_data.current_mods & NSCommandKeyMask)

   348

		key|= WKC_META;

   349

   350

	return key << 16;

   351

}

   352

   353

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

   354

{

   355

	switch(keycode)

   356

	{

   357

		case QZ_UP:

   358

			SB(_dirkeys, 1, 1, down);

   359

			break;

   360

		case QZ_DOWN:

   361

			SB(_dirkeys, 3, 1, down);

   362

			break;

   363

		case QZ_LEFT:

   364

			SB(_dirkeys, 0, 1, down);

   365

			break;

   366

		case QZ_RIGHT:

   367

			SB(_dirkeys, 2, 1, down);

   368

			break;

   369

		case QZ_TAB:

   370

			_cocoa_video_data.tab_is_down = down;

   371

			break;

   372

		case QZ_RETURN:

   373

		case QZ_f:

   374

			if(down && ((_cocoa_video_data.current_mods & NSControlKeyMask) || (_cocoa_video_data.current_mods & NSCommandKeyMask)))

   375

				CocoaVideoFullScreen(!_fullscreen);

   376

   377

	}

   378

   379

	if(down) {

   380

		_pressed_key = QZ_MapKey(keycode) | unicode;

   381

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

   382

	} else {

   383

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

   384

	}

   385

}

   386

   387

static void QZ_DoUnsidedModifiers (unsigned int newMods) {

   388

   389

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

   390

   391

	int i;

   392

	int bit;

   393

   394

	if (_cocoa_video_data.current_mods == newMods)

   395

		return;

   396

   397

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

   398

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

   399

		unsigned int currentMask, newMask;

   400

   401

		currentMask = _cocoa_video_data.current_mods & bit;

   402

		newMask     = newMods & bit;

   403

   404

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

   405

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

   406

			if (bit == NSAlphaShiftKeyMask)

   407

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

   408

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

   409

		}

   410

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

   411

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

   412

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

   413

			if (bit == NSAlphaShiftKeyMask)

   414

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

   415

		}

   416

	}

   417

   418

	_cocoa_video_data.current_mods = newMods;

   419

}

   420

   421

static void QZ_MouseMovedEvent(int x, int y)

   422

{

   423

	int dx, dy;

   424

   425

	if (_cursor.fix_at) {

   426

		dx = x - _cursor.pos.x;

   427

		dy = y - _cursor.pos.y;

   428

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

   429

			_cursor.delta.x += dx;

   430

			_cursor.delta.y += dy;

   431

   432

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

   433

		}

   434

	} else {

   435

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

   436

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

   437

		_cursor.pos.x = x;

   438

		_cursor.pos.y = y;

   439

		_cursor.dirty = true;

   440

	}

   441

}

   442

   443

void QZ_MouseButtonEvent( int button, BOOL down )

   444

{

   445

	switch(button) {

   446

		case 0:

   447

			if(down) {

   448

				_left_button_down = true;

   449

			} else {

   450

				_left_button_down = false;

   451

				_left_button_clicked = false;

   452

			}

   453

			break;

   454

		case 1:

   455

			if(down) {

   456

				_right_button_down = true;

   457

				_right_button_clicked = true;

   458

			} else {

   459

				_right_button_down = false;

   460

			}

   461

			break;

   462

	}

   463

}

   464

   465

   466

static inline NSPoint QZ_GetMouseLocation(NSEvent *event)

   467

{

   468

	NSPoint pt;

   469

   470

	if(_cocoa_video_data.fullscreen) {

   471

		pt = [ NSEvent mouseLocation ];

   472

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

   473

	} else {

   474

		pt = [event locationInWindow];

   475

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

   476

	}

   477

   478

	return pt;

   479

}

   480

   481

static bool QZ_MouseIsInsideView(NSPoint *pt)

   482

{

   483

	if(_cocoa_video_data.fullscreen)

   484

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

   485

	else

   486

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

   487

}

   488

   489

   490

static bool QZ_PollEvent(void)

   491

{

   492

	NSEvent *event;

   493

	NSPoint pt;

   494

	NSString *chars;

   495

#ifdef _DEBUG

   496

	uint32 et0, et;

   497

#endif

   498

   499

#ifdef _DEBUG

   500

	et0 = GetTick();

   501

#endif

   502

	event = [ NSApp nextEventMatchingMask:NSAnyEventMask

   503

			untilDate: [ NSDate distantPast ]

   504

			inMode: NSDefaultRunLoopMode dequeue:YES ];

   505

#ifdef _DEBUG

   506

	et = GetTick();

   507

	_cocoa_video_data.tEvent+= et - et0;

   508

#endif

   509

   510

	if(event == nil)

   511

		return false;

   512

	if(!_cocoa_video_data.active) {

   513

		QZ_ShowMouse();

   514

		[NSApp sendEvent:event];

   515

		return true;

   516

	}

   517

   518

	QZ_DoUnsidedModifiers( [ event modifierFlags ] );

   519

   520

	switch ([event type]) {

   521

		case NSMouseMoved:

   522

		case NSOtherMouseDragged:

   523

		case NSRightMouseDragged:

   524

		case NSLeftMouseDragged:

   525

			pt = QZ_GetMouseLocation(event);

   526

			if(!QZ_MouseIsInsideView(&pt) && !_cocoa_video_data.emulating_right_button) {

   527

				QZ_ShowMouse();

   528

				[NSApp sendEvent:event];