1

/* $Id$ */

     2

     3

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

     4

 *                             Cocoa video driver                             *

     5

 * Known things left to do:                                                   *

     6

 *  List available resolutions.                                               *

     7

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

     8

     9

#ifdef WITH_COCOA

    10

#ifdef ENABLE_COCOA_QUICKDRAW

    11

    12

#define MAC_OS_X_VERSION_MIN_REQUIRED    MAC_OS_X_VERSION_10_3

    13

#define MAC_OS_X_VERSION_MAX_ALLOWED     MAC_OS_X_VERSION_10_3

    14

#include <AvailabilityMacros.h>

    15

    16

#import <Cocoa/Cocoa.h>

    17

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

    18

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

    19

#import <unistd.h>

    20

    21

/**

    22

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

    23

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

    24

 * gdb has limitations.

    25

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

    26

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

    27

 */

    28

    29

    30

/* Defined in stdbool.h */

    31

#ifndef __cplusplus

    32

# ifndef __BEOS__

    33

#  undef bool

    34

#  undef false

    35

#  undef true

    36

# endif

    37

#endif

    38

    39

    40

#include "../../stdafx.h"

    41

#include "../../debug.h"

    42

#include "../../variables.h"

    43

#include "../../core/geometry_type.hpp"

    44

#include "cocoa_v.h"

    45

#include "../../core/math_func.hpp"

    46

#include "../../gfx_func.h"

    47

    48

#undef Rect

    49

    50

    51

class WindowQuickdrawSubdriver;

    52

    53

    54

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

    55

@interface OTTD_QuickdrawWindow : NSWindow {

    56

	WindowQuickdrawSubdriver *driver;

    57

}

    58

    59

- (void)setDriver:(WindowQuickdrawSubdriver*)drv;

    60

    61

- (void)miniaturize:(id)sender;

    62

- (void)display;

    63

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

    64

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

    65

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

    66

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

    67

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

    68

@end

    69

    70

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

    71

@interface OTTD_QuickdrawWindowDelegate : NSObject{

    72

	WindowQuickdrawSubdriver *driver;

    73

}

    74

    75

- (void)setDriver:(WindowQuickdrawSubdriver*)drv;

    76

    77

- (BOOL)windowShouldClose:(id)sender;

    78

@end

    79

    80

class WindowQuickdrawSubdriver: public CocoaSubdriver {

    81

	int device_width;

    82

	int device_height;

    83

	int device_depth;

    84

    85

	int window_width;

    86

	int window_height;

    87

	int window_pitch;

    88

    89

	int buffer_depth;

    90

    91

	void *pixel_buffer;

    92

	void *window_buffer;

    93

    94

	OTTD_QuickdrawWindow *window;

    95

    96

	#define MAX_DIRTY_RECTS 100

    97

	Rect dirty_rects[MAX_DIRTY_RECTS];

    98

	int num_dirty_rects;

    99

   100

	uint16 palette16[256];

   101

	uint32 palette32[256];

   102

   103

public:

   104

	bool active;

   105

	bool setup;

   106

   107

	NSQuickDrawView *qdview;

   108

   109

private:

   110

	void GetDeviceInfo();

   111

   112

	bool SetVideoMode(int width, int height);

   113

   114

	/**

   115

	 * This function copies 32bpp pixels from the screen buffer in 16bpp windowed mode.

   116

	 *

   117

	 * @param left The x coord for the left edge of the box to blit.

   118

	 * @param top The y coord for the top edge of the box to blit.

   119

	 * @param right The x coord for the right edge of the box to blit.

   120

	 * @param bottom The y coord for the bottom edge of the box to blit.

   121

	 */

   122

	void Blit32ToView32(int left, int top, int right, int bottom);

   123

   124

	/**

   125

	 * This function copies 8bpp pixels from the screen buffer in 32bpp windowed mode.

   126

	 *

   127

	 * @param left The x coord for the left edge of the box to blit.

   128

	 * @param top The y coord for the top edge of the box to blit.

   129

	 * @param right The x coord for the right edge of the box to blit.

   130

	 * @param bottom The y coord for the bottom edge of the box to blit.

   131

	 */

   132

	void BlitIndexedToView32(int left, int top, int right, int bottom);

   133

   134

	/**

   135

	 * This function copies 8bpp pixels from the screen buffer in 16bpp windowed mode.

   136

	 *

   137

	 * @param left The x coord for the left edge of the box to blit.

   138

	 * @param top The y coord for the top edge of the box to blit.

   139

	 * @param right The x coord for the right edge of the box to blit.

   140

	 * @param bottom The y coord for the bottom edge of the box to blit.

   141

	 */

   142

	void BlitIndexedToView16(int left, int top, int right, int bottom);

   143

   144

	inline void BlitToView(int left, int top, int right, int bottom);

   145

	void DrawResizeIcon();

   146

   147

   148

public:

   149

	WindowQuickdrawSubdriver(int bpp);

   150

	virtual ~WindowQuickdrawSubdriver();

   151

   152

	virtual void Draw();

   153

	virtual void MakeDirty(int left, int top, int width, int height);

   154

	virtual void UpdatePalette(uint first_color, uint num_colors);

   155

   156

	virtual uint ListModes(OTTD_Point* modes, uint max_modes);

   157

   158

	virtual bool ChangeResolution(int w, int h);

   159

   160

	virtual bool IsFullscreen() { return false; }

   161

   162

	virtual int GetWidth() { return window_width; }

   163

	virtual int GetHeight() { return window_height; }

   164

	virtual void *GetPixelBuffer() { return pixel_buffer; }

   165

   166

	/* Convert local coordinate to window server (CoreGraphics) coordinate */

   167

	virtual CGPoint PrivateLocalToCG(NSPoint* p);

   168

   169

	virtual NSPoint GetMouseLocation(NSEvent *event);

   170

	virtual bool MouseIsInsideView(NSPoint *pt);

   171

   172

	virtual bool IsActive() { return active; }

   173

   174

   175

	void SetPortAlphaOpaque();

   176

	bool WindowResized();

   177

};

   178

   179

   180

@implementation OTTD_QuickdrawWindow

   181

   182

- (void)setDriver:(WindowQuickdrawSubdriver*)drv

   183

{

   184

	driver = drv;

   185

}

   186

   187

   188

/* we override these methods to fix the miniaturize animation/dock icon bug */

   189

- (void)miniaturize:(id)sender

   190

{

   191

	/* make the alpha channel opaque so anim won't have holes in it */

   192

	driver->SetPortAlphaOpaque ();

   193

   194

	/* window is hidden now */

   195

	driver->active = false;

   196

   197

	QZ_ShowMouse();

   198

   199

	[ super miniaturize:sender ];

   200

}

   201

   202

- (void)display

   203

{

   204

	/* This method fires just before the window deminaturizes from the Dock.

   205

	 * We'll save the current visible surface, let the window manager redraw any

   206

	 * UI elements, and restore the surface. This way, no expose event

   207

	 * is required, and the deminiaturize works perfectly.

   208

	 */

   209

   210

	driver->SetPortAlphaOpaque();

   211

   212

	/* save current visible surface */

   213

	[ self cacheImageInRect:[ driver->qdview frame ] ];

   214

   215

	/* let the window manager redraw controls, border, etc */

   216

	[ super display ];

   217

   218

	/* restore visible surface */

   219

	[ self restoreCachedImage ];

   220

   221

	/* window is visible again */

   222

	driver->active = true;

   223

}

   224

   225

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

   226

{

   227

	[ super setFrame:frameRect display:flag ];

   228

   229

	/* Don't do anything if the window is currently being created */

   230

	if (driver->setup) return;

   231

   232

	if (!driver->WindowResized())

   233

		error("Cocoa: Failed to resize window.");

   234

}

   235

   236

- (void)appDidHide:(NSNotification*)note

   237

{

   238

	driver->active = false;

   239

}

   240

   241

   242

- (void)appWillUnhide:(NSNotification*)note

   243

{

   244

	driver->SetPortAlphaOpaque ();

   245

   246

	/* save current visible surface */

   247

	[ self cacheImageInRect:[ driver->qdview frame ] ];

   248

}

   249

   250

- (void)appDidUnhide:(NSNotification*)note

   251

{

   252

	/* restore cached image, since it may not be current, post expose event too */

   253

	[ self restoreCachedImage ];

   254

   255

	driver->active = true;

   256

}

   257

   258

   259

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

   260

{

   261

	/* Make our window subclass receive these application notifications */

   262

	[ [ NSNotificationCenter defaultCenter ] addObserver:self

   263

	selector:@selector(appDidHide:) name:NSApplicationDidHideNotification object:NSApp ];

   264

   265

	[ [ NSNotificationCenter defaultCenter ] addObserver:self

   266

	selector:@selector(appDidUnhide:) name:NSApplicationDidUnhideNotification object:NSApp ];

   267

   268

	[ [ NSNotificationCenter defaultCenter ] addObserver:self

   269

	selector:@selector(appWillUnhide:) name:NSApplicationWillUnhideNotification object:NSApp ];

   270

   271

	return [ super initWithContentRect:contentRect styleMask:styleMask backing:backingType defer:flag ];

   272

}

   273

   274

@end

   275

   276

@implementation OTTD_QuickdrawWindowDelegate

   277

- (void)setDriver:(WindowQuickdrawSubdriver*)drv

   278

{

   279

	driver = drv;

   280

}

   281

   282

- (BOOL)windowShouldClose:(id)sender

   283

{

   284

	HandleExitGameRequest();

   285

   286

	return NO;

   287

}

   288

   289

- (void)windowDidBecomeKey:(NSNotification*)aNotification

   290

{

   291

	driver->active = true;

   292

}

   293

   294

- (void)windowDidResignKey:(NSNotification*)aNotification

   295

{

   296

	driver->active = false;

   297

}

   298

   299

- (void)windowDidBecomeMain:(NSNotification*)aNotification

   300

{

   301

	driver->active = true;

   302

}

   303

   304

- (void)windowDidResignMain:(NSNotification*)aNotification

   305

{

   306

	driver->active = false;

   307

}

   308

   309

@end

   310

   311

   312

static const int _resize_icon_width  = 16;

   313

static const int _resize_icon_height = 16;

   314

   315

static bool _resize_icon[] = {

   316

	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,

   317

	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1,

   318

	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0,

   319

	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0,

   320

	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1,

   321

	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1,

   322

	0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 0,

   323

	0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0,

   324

	0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1,

   325

	0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1,

   326

	0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0,

   327

	0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0,

   328

	0, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1,

   329

	0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1,

   330

	0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0,

   331

	1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0

   332

};

   333

   334

   335

   336

extern const char _openttd_revision[];

   337

   338

   339

void WindowQuickdrawSubdriver::GetDeviceInfo()

   340

{

   341

	CFDictionaryRef    cur_mode;

   342

   343

	/* Initialize the video settings; this data persists between mode switches */

   344

	cur_mode = CGDisplayCurrentMode(kCGDirectMainDisplay);

   345

   346

	/* Gather some information that is useful to know about the display */

   347

	CFNumberGetValue(

   348

		(const __CFNumber*)CFDictionaryGetValue(cur_mode, kCGDisplayBitsPerPixel),

   349

		kCFNumberSInt32Type, &device_depth

   350

	);

   351

   352

	CFNumberGetValue(

   353

		(const __CFNumber*)CFDictionaryGetValue(cur_mode, kCGDisplayWidth),

   354

		kCFNumberSInt32Type, &device_width

   355

	);

   356

   357

	CFNumberGetValue(

   358

		(const __CFNumber*)CFDictionaryGetValue(cur_mode, kCGDisplayHeight),

   359

		kCFNumberSInt32Type, &device_height

   360

	);

   361

}

   362

   363

bool WindowQuickdrawSubdriver::SetVideoMode(int width, int height)

   364

{

   365

	char caption[50];

   366

	NSString *nsscaption;

   367

	unsigned int style;

   368

	NSRect contentRect;

   369

	BOOL isCustom = NO;

   370

	bool ret;

   371

   372

	setup = true;

   373

   374

	GetDeviceInfo();

   375

   376

	if (buffer_depth > device_depth) {

   377

		DEBUG(driver, 0, "Cannot use a blitter with a higer screen depth than the display when running in windowed mode.");

   378

		setup = false;

   379

		return false;

   380

	}

   381

   382

	if (width > device_width)

   383

		width = device_width;

   384

	if (height > device_height)

   385

		height = device_height;

   386

   387

	contentRect = NSMakeRect(0, 0, width, height);

   388

   389

	/* Check if we should recreate the window */

   390

	if (window == nil) {

   391

		OTTD_QuickdrawWindowDelegate *delegate;

   392

   393

		/* Set the window style */

   394

		style = NSTitledWindowMask;

   395

		style |= (NSMiniaturizableWindowMask | NSClosableWindowMask);

   396

		style |= NSResizableWindowMask;

   397

   398

		/* Manually create a window, avoids having a nib file resource */

   399

		window = [ [ OTTD_QuickdrawWindow alloc ]

   400

						initWithContentRect:contentRect

   401

						styleMask:style

   402

						backing:NSBackingStoreBuffered

   403

						defer:NO ];

   404

   405

		if (window == nil) {

   406

			DEBUG(driver, 0, "Could not create the Cocoa window.");

   407

			setup = false;

   408

			return false;

   409

		}

   410

   411

		[ window setDriver:this ];

   412

   413

		snprintf(caption, sizeof(caption), "OpenTTD %s", _openttd_revision);

   414

		nsscaption = [ [ NSString alloc ] initWithCString:caption ];

   415

		[ window setTitle:nsscaption ];

   416

		[ window setMiniwindowTitle:nsscaption ];

   417

		[ nsscaption release ];

   418

   419

		[ window setAcceptsMouseMovedEvents:YES ];

   420

		[ window setViewsNeedDisplay:NO ];

   421

   422

		delegate = [ [ OTTD_QuickdrawWindowDelegate alloc ] init ];

   423

		[ delegate setDriver:this ];

   424

		[ window setDelegate: [ delegate autorelease ] ];

   425

	} else {

   426

		/* We already have a window, just change its size */

   427

		if (!isCustom) {

   428

			[ window setContentSize:contentRect.size ];

   429

			// Ensure frame height - title bar height >= view height

   430

			contentRect.size.height = Clamp(height, 0, [ window frame ].size.height - 22 /* 22 is the height of title bar of window*/);

   431

			height = contentRect.size.height;

   432

			[ qdview setFrameSize:contentRect.size ];

   433

		}

   434

	}

   435

   436

	// Update again

   437

	window_width = width;

   438

	window_height = height;

   439

   440

	[ window center ];

   441

   442

	/* Only recreate the view if it doesn't already exist */

   443

	if (qdview == nil) {

   444

		qdview = [ [ NSQuickDrawView alloc ] initWithFrame:contentRect ];

   445

		if (qdview == nil) {

   446

			DEBUG(driver, 0, "Could not create the Quickdraw view.");

   447

			setup = false;

   448

			return false;

   449

		}

   450

   451

		[ qdview setAutoresizingMask: NSViewWidthSizable | NSViewHeightSizable ];

   452

		[ [ window contentView ] addSubview:qdview ];

   453

		[ qdview release ];

   454

		[ window makeKeyAndOrderFront:nil ];

   455

	}

   456

   457

	ret = WindowResized();

   458

   459

	UpdatePalette(0, 256);

   460

   461

	setup = false;

   462

   463

	return ret;

   464

}

   465

   466

void WindowQuickdrawSubdriver::Blit32ToView32(int left, int top, int right, int bottom)

   467

{

   468

	const uint32* src   = (uint32*)pixel_buffer;

   469

	uint32*       dst   = (uint32*)window_buffer;

   470

	uint          width = window_width;

   471

	uint          pitch = window_pitch / 4;

   472

	int y;

   473

   474

   475

	dst += top * pitch + left;

   476

	src += top * width + left;

   477

   478

	for (y = top; y < bottom; y++, dst+= pitch, src+= width) {

   479

		memcpy(dst, src, (right - left) * 4);

   480

	}

   481

}

   482

   483

void WindowQuickdrawSubdriver::BlitIndexedToView32(int left, int top, int right, int bottom)

   484

{

   485

	const uint32* pal   = palette32;

   486

	const uint8*  src   = (uint8*)pixel_buffer;

   487

	uint32*       dst   = (uint32*)window_buffer;

   488

	uint          width = window_width;

   489

	uint          pitch = window_pitch / 4;

   490

	int x;

   491

	int y;

   492

   493

	for (y = top; y < bottom; y++) {

   494

		for (x = left; x < right; x++) {

   495

			dst[y * pitch + x] = pal[src[y * width + x]];

   496

		}

   497

	}

   498

}

   499

   500

void WindowQuickdrawSubdriver::BlitIndexedToView16(int left, int top, int right, int bottom)

   501

{

   502

	const uint16* pal   = palette16;

   503

	const uint8*  src   = (uint8*)pixel_buffer;

   504

	uint16*       dst   = (uint16*)window_buffer;

   505

	uint          width = window_width;

   506

	uint          pitch = window_pitch / 2;

   507

	int x;

   508

	int y;

   509

   510

	for (y = top; y < bottom; y++) {

   511

		for (x = left; x < right; x++) {

   512

			dst[y * pitch + x] = pal[src[y * width + x]];

   513

		}

   514

	}

   515

}

   516

   517

   518

inline void WindowQuickdrawSubdriver::BlitToView(int left, int top, int right, int bottom)

   519

{

   520

	switch (device_depth) {

   521

		case 32:

   522

			switch(buffer_depth) {

   523

				case 32:

   524

					Blit32ToView32(left, top, right, bottom);

   525

					break;

   526

				case 8:

   527

					BlitIndexedToView32(left, top, right, bottom);