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 "../../rev.h"

    43

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

    44

#include "cocoa_v.h"

    45

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

    46

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

    47

#include "../../functions.h"

    48

    49

#undef Rect

    50

    51

    52

class WindowQuickdrawSubdriver;

    53

    54

    55

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

    56

@interface OTTD_QuickdrawWindow : NSWindow {

    57

	WindowQuickdrawSubdriver *driver;

    58

}

    59

    60

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

    61

    62

- (void)miniaturize:(id)sender;

    63

- (void)display;

    64

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

    65

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

    66

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

    67

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

    68

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

    69

@end

    70

    71

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

    72

@interface OTTD_QuickdrawWindowDelegate : NSObject{

    73

	WindowQuickdrawSubdriver *driver;

    74

}

    75

    76

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

    77

    78

- (BOOL)windowShouldClose:(id)sender;

    79

@end

    80

    81

class WindowQuickdrawSubdriver: public CocoaSubdriver {

    82

	int device_width;

    83

	int device_height;

    84

	int device_depth;

    85

    86

	int window_width;

    87

	int window_height;

    88

	int window_pitch;

    89

    90

	int buffer_depth;

    91

    92

	void *pixel_buffer;

    93

	void *window_buffer;

    94

    95

	OTTD_QuickdrawWindow *window;

    96

    97

	#define MAX_DIRTY_RECTS 100

    98

	Rect dirty_rects[MAX_DIRTY_RECTS];

    99

	int num_dirty_rects;

   100

   101

	uint16 palette16[256];

   102

	uint32 palette32[256];

   103

   104

public:

   105

	bool active;

   106

	bool setup;

   107

   108

	NSQuickDrawView *qdview;

   109

   110

private:

   111

	void GetDeviceInfo();

   112

   113

	bool SetVideoMode(int width, int height);

   114

   115

	/**

   116

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

   117

	 *

   118

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

   119

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

   120

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

   121

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

   122

	 */

   123

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

   124

   125

	/**

   126

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

   127

	 *

   128

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

   129

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

   130

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

   131

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

   132

	 */

   133

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

   134

   135

	/**

   136

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

   137

	 *

   138

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

   139

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

   140

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

   141

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

   142

	 */

   143

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

   144

   145

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

   146

	void DrawResizeIcon();

   147

   148

   149

public:

   150

	WindowQuickdrawSubdriver(int bpp);

   151

	virtual ~WindowQuickdrawSubdriver();

   152

   153

	virtual void Draw();

   154

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

   155

	virtual void UpdatePalette(uint first_color, uint num_colors);

   156

   157

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

   158

   159

	virtual bool ChangeResolution(int w, int h);

   160

   161

	virtual bool IsFullscreen() { return false; }

   162

   163

	virtual int GetWidth() { return window_width; }

   164

	virtual int GetHeight() { return window_height; }

   165

	virtual void *GetPixelBuffer() { return pixel_buffer; }

   166

   167

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

   168

	virtual CGPoint PrivateLocalToCG(NSPoint* p);

   169

   170

	virtual NSPoint GetMouseLocation(NSEvent *event);

   171

	virtual bool MouseIsInsideView(NSPoint *pt);

   172

   173

	virtual bool IsActive() { return active; }

   174

   175

   176

	void SetPortAlphaOpaque();

   177

	bool WindowResized();

   178

};

   179

   180

   181

@implementation OTTD_QuickdrawWindow

   182

   183

- (void)setDriver:(WindowQuickdrawSubdriver*)drv

   184

{

   185

	driver = drv;

   186

}

   187

   188

   189

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

   190

- (void)miniaturize:(id)sender

   191

{

   192

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

   193

	driver->SetPortAlphaOpaque ();

   194

   195

	/* window is hidden now */

   196

	driver->active = false;

   197

   198

	QZ_ShowMouse();

   199

   200

	[ super miniaturize:sender ];

   201

}

   202

   203

- (void)display

   204

{

   205

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

   206

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

   207

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

   208

	 * is required, and the deminiaturize works perfectly.

   209

	 */

   210

   211

	driver->SetPortAlphaOpaque();

   212

   213

	/* save current visible surface */

   214

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

   215

   216

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

   217

	[ super display ];

   218

   219

	/* restore visible surface */

   220

	[ self restoreCachedImage ];

   221

   222

	/* window is visible again */

   223

	driver->active = true;

   224

}

   225

   226

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

   227

{

   228

	[ super setFrame:frameRect display:flag ];

   229

   230

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

   231

	if (driver->setup) return;

   232

   233

	if (!driver->WindowResized())

   234

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

   235

}

   236

   237

- (void)appDidHide:(NSNotification*)note

   238

{

   239

	driver->active = false;

   240

}

   241

   242

   243

- (void)appWillUnhide:(NSNotification*)note

   244

{

   245

	driver->SetPortAlphaOpaque ();

   246

   247

	/* save current visible surface */

   248

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

   249

}

   250

   251

- (void)appDidUnhide:(NSNotification*)note

   252

{

   253

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

   254

	[ self restoreCachedImage ];

   255

   256

	driver->active = true;

   257

}

   258

   259

   260

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

   261

{

   262

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

   263

	[ [ NSNotificationCenter defaultCenter ] addObserver:self

   264

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

   265

   266

	[ [ NSNotificationCenter defaultCenter ] addObserver:self

   267

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

   268

   269

	[ [ NSNotificationCenter defaultCenter ] addObserver:self

   270

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

   271

   272

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

   273

}

   274

   275

@end

   276

   277

@implementation OTTD_QuickdrawWindowDelegate

   278

- (void)setDriver:(WindowQuickdrawSubdriver*)drv

   279

{

   280

	driver = drv;

   281

}

   282

   283

- (BOOL)windowShouldClose:(id)sender

   284

{

   285

	HandleExitGameRequest();

   286

   287

	return NO;

   288

}

   289

   290

- (void)windowDidBecomeKey:(NSNotification*)aNotification

   291

{

   292

	driver->active = true;

   293

}

   294

   295

- (void)windowDidResignKey:(NSNotification*)aNotification

   296

{

   297

	driver->active = false;

   298

}

   299

   300

- (void)windowDidBecomeMain:(NSNotification*)aNotification

   301

{

   302

	driver->active = true;

   303

}

   304

   305

- (void)windowDidResignMain:(NSNotification*)aNotification

   306

{

   307

	driver->active = false;

   308

}

   309

   310

@end

   311

   312

   313

static const int _resize_icon_width  = 16;

   314

static const int _resize_icon_height = 16;

   315

   316

static bool _resize_icon[] = {

   317

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

   318

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

   319

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

   320

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

   321

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

   322

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

   323

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

   324

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

   325

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

   326

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

   327

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

   328

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

   329

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

   330

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

   331

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

   332

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

   333

};

   334

   335

   336

void WindowQuickdrawSubdriver::GetDeviceInfo()

   337

{

   338

	CFDictionaryRef    cur_mode;

   339

   340

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

   341

	cur_mode = CGDisplayCurrentMode(kCGDirectMainDisplay);

   342

   343

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

   344

	CFNumberGetValue(

   345

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

   346

		kCFNumberSInt32Type, &device_depth

   347

	);

   348

   349

	CFNumberGetValue(

   350

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

   351

		kCFNumberSInt32Type, &device_width

   352

	);

   353

   354

	CFNumberGetValue(

   355

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

   356

		kCFNumberSInt32Type, &device_height

   357

	);

   358

}

   359

   360

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

   361

{

   362

	char caption[50];

   363

	NSString *nsscaption;

   364

	unsigned int style;

   365

	NSRect contentRect;

   366

	BOOL isCustom = NO;

   367

	bool ret;

   368

   369

	setup = true;

   370

   371

	GetDeviceInfo();

   372

   373

	if (buffer_depth > device_depth) {

   374

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

   375

		setup = false;

   376

		return false;

   377

	}

   378

   379

	if (width > device_width)

   380

		width = device_width;

   381

	if (height > device_height)

   382

		height = device_height;

   383

   384

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

   385

   386

	/* Check if we should recreate the window */

   387

	if (window == nil) {

   388

		OTTD_QuickdrawWindowDelegate *delegate;

   389

   390

		/* Set the window style */

   391

		style = NSTitledWindowMask;

   392

		style |= (NSMiniaturizableWindowMask | NSClosableWindowMask);

   393

		style |= NSResizableWindowMask;

   394

   395

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

   396

		window = [ [ OTTD_QuickdrawWindow alloc ]

   397

						initWithContentRect:contentRect

   398

						styleMask:style

   399

						backing:NSBackingStoreBuffered

   400

						defer:NO ];

   401

   402

		if (window == nil) {

   403

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

   404

			setup = false;

   405

			return false;

   406

		}

   407

   408

		[ window setDriver:this ];

   409

   410

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

   411

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

   412

		[ window setTitle:nsscaption ];

   413

		[ window setMiniwindowTitle:nsscaption ];

   414

		[ nsscaption release ];

   415

   416

		[ window setAcceptsMouseMovedEvents:YES ];

   417

		[ window setViewsNeedDisplay:NO ];

   418

   419

		delegate = [ [ OTTD_QuickdrawWindowDelegate alloc ] init ];

   420

		[ delegate setDriver:this ];

   421

		[ window setDelegate: [ delegate autorelease ] ];

   422

	} else {

   423

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

   424

		if (!isCustom) {

   425

			[ window setContentSize:contentRect.size ];

   426

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

   427

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

   428

			height = contentRect.size.height;

   429

			[ qdview setFrameSize:contentRect.size ];

   430

		}

   431

	}

   432

   433

	// Update again

   434

	window_width = width;

   435

	window_height = height;

   436

   437

	[ window center ];

   438

   439

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

   440

	if (qdview == nil) {

   441

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

   442

		if (qdview == nil) {

   443

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

   444

			setup = false;

   445

			return false;

   446

		}

   447

   448

		[ qdview setAutoresizingMask: NSViewWidthSizable | NSViewHeightSizable ];

   449

		[ [ window contentView ] addSubview:qdview ];

   450

		[ qdview release ];

   451

		[ window makeKeyAndOrderFront:nil ];

   452

	}

   453

   454

	ret = WindowResized();

   455

   456

	UpdatePalette(0, 256);

   457

   458

	setup = false;

   459

   460

	return ret;

   461

}

   462

   463

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

   464

{

   465

	const uint32* src   = (uint32*)pixel_buffer;

   466

	uint32*       dst   = (uint32*)window_buffer;

   467

	uint          width = window_width;

   468

	uint          pitch = window_pitch / 4;

   469

	int y;

   470

   471

   472

	dst += top * pitch + left;

   473

	src += top * width + left;

   474

   475

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

   476

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

   477

	}

   478

}

   479

   480

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

   481

{

   482

	const uint32* pal   = palette32;

   483

	const uint8*  src   = (uint8*)pixel_buffer;

   484

	uint32*       dst   = (uint32*)window_buffer;

   485

	uint          width = window_width;

   486

	uint          pitch = window_pitch / 4;

   487

	int x;

   488

	int y;

   489

   490

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

   491

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

   492

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

   493

		}

   494

	}

   495

}

   496

   497

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

   498

{