1

/* $Id$ */

     2

     3

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

     4

 *                             Cocoa video driver                             *

     5

 * Known things left to do:                                                   *

     6

 *  List available resolutions.                                               *

     7

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

     8

     9

#ifdef WITH_COCOA

    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 "cocoa_v.h"

    44

    45

#undef Point

    46

#undef Rect

    47

    48

    49

class WindowQuickdrawSubdriver;

    50

    51

    52

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

    53

@interface OTTD_QuickdrawWindow : NSWindow {

    54

	WindowQuickdrawSubdriver *driver;

    55

}

    56

    57

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

    58

    59

- (void)miniaturize:(id)sender;

    60

- (void)display;

    61

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

    62

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

    63

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

    64

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

    65

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

    66

@end

    67

    68

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

    69

@interface OTTD_QuickdrawWindowDelegate : NSObject{

    70

	WindowQuickdrawSubdriver *driver;

    71

}

    72

    73

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

    74

    75

- (BOOL)windowShouldClose:(id)sender;

    76

@end

    77

    78

class WindowQuickdrawSubdriver: public CocoaSubdriver {

    79

	int device_width;

    80

	int device_height;

    81

	int device_depth;

    82

    83

	int window_width;

    84

	int window_height;

    85

	int window_pitch;

    86

    87

	int buffer_depth;

    88

    89

	void *pixel_buffer;

    90

	void *window_buffer;

    91

    92

	OTTD_QuickdrawWindow *window;

    93

    94

	#define MAX_DIRTY_RECTS 100

    95

	Rect dirty_rects[MAX_DIRTY_RECTS];

    96

	int num_dirty_rects;

    97

    98

	uint16 palette16[256];

    99

	uint32 palette32[256];

   100

   101

public:

   102

	bool active;

   103

	bool setup;

   104

   105

	NSQuickDrawView *qdview;

   106

   107

private:

   108

	void GetDeviceInfo();

   109

   110

	bool SetVideoMode(int width, int height);

   111

   112

	/**

   113

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

   114

	 *

   115

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

   116

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

   117

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

   118

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

   119

	 */

   120

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

   121

   122

	/**

   123

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

   124

	 *

   125

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

   126

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

   127

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

   128

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

   129

	 */

   130

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

   131

   132

	/**

   133

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

   134

	 *

   135

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

   136

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

   137

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

   138

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

   139

	 */

   140

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

   141

   142

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

   143

	void DrawResizeIcon();

   144

   145

   146

public:

   147

	WindowQuickdrawSubdriver(int bpp);

   148

	virtual ~WindowQuickdrawSubdriver();

   149

   150

	virtual void Draw();

   151

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

   152

	virtual void UpdatePalette(uint first_color, uint num_colors);

   153

   154

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

   155

   156

	virtual bool ChangeResolution(int w, int h);

   157

   158

	virtual bool IsFullscreen() { return false; }

   159

   160

	virtual int GetWidth() { return window_width; }

   161

	virtual int GetHeight() { return window_height; }

   162

	virtual void *GetPixelBuffer() { return pixel_buffer; }

   163

   164

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

   165

	virtual CGPoint PrivateLocalToCG(NSPoint* p);

   166

   167

	virtual NSPoint GetMouseLocation(NSEvent *event);

   168

	virtual bool MouseIsInsideView(NSPoint *pt);

   169

   170

	virtual bool IsActive() { return active; }

   171

   172

   173

	void SetPortAlphaOpaque();

   174

	bool WindowResized();

   175

};

   176

   177

   178

@implementation OTTD_QuickdrawWindow

   179

   180

- (void)setDriver:(WindowQuickdrawSubdriver*)drv

   181

{

   182

	driver = drv;

   183

}

   184

   185

   186

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

   187

- (void)miniaturize:(id)sender

   188

{

   189

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

   190

	driver->SetPortAlphaOpaque ();

   191

   192

	/* window is hidden now */

   193

	driver->active = false;

   194

   195

	QZ_ShowMouse();

   196

   197

	[ super miniaturize:sender ];

   198

}

   199

   200

- (void)display

   201

{

   202

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

   203

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

   204

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

   205

	 * is required, and the deminiaturize works perfectly.

   206

	 */

   207

   208

	driver->SetPortAlphaOpaque();

   209

   210

	/* save current visible surface */

   211

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

   212

   213

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

   214

	[ super display ];

   215

   216

	/* restore visible surface */

   217

	[ self restoreCachedImage ];

   218

   219

	/* window is visible again */

   220

	driver->active = true;

   221

}

   222

   223

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

   224

{

   225

	[ super setFrame:frameRect display:flag ];

   226

   227

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

   228

	if (driver->setup) return;

   229

   230

	if (!driver->WindowResized())

   231

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

   232

}

   233

   234

- (void)appDidHide:(NSNotification*)note

   235

{

   236

	driver->active = false;

   237

}

   238

   239

   240

- (void)appWillUnhide:(NSNotification*)note

   241

{

   242

	driver->SetPortAlphaOpaque ();

   243

   244

	/* save current visible surface */

   245

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

   246

}

   247

   248

- (void)appDidUnhide:(NSNotification*)note

   249

{

   250

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

   251

	[ self restoreCachedImage ];

   252

   253

	driver->active = true;

   254

}

   255

   256

   257

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

   258

{

   259

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

   260

	[ [ NSNotificationCenter defaultCenter ] addObserver:self

   261

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

   262

   263

	[ [ NSNotificationCenter defaultCenter ] addObserver:self

   264

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

   265

   266

	[ [ NSNotificationCenter defaultCenter ] addObserver:self

   267

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

   268

   269

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

   270

}

   271

   272

@end

   273

   274

@implementation OTTD_QuickdrawWindowDelegate

   275

- (void)setDriver:(WindowQuickdrawSubdriver*)drv

   276

{

   277

	driver = drv;

   278

}

   279

   280

- (BOOL)windowShouldClose:(id)sender

   281

{

   282

	HandleExitGameRequest();

   283

   284

	return NO;

   285

}

   286

   287

- (void)windowDidBecomeKey:(NSNotification*)aNotification

   288

{

   289

	driver->active = true;

   290

}

   291

   292

- (void)windowDidResignKey:(NSNotification*)aNotification

   293

{

   294

	driver->active = false;

   295

}

   296

   297

- (void)windowDidBecomeMain:(NSNotification*)aNotification

   298

{

   299

	driver->active = true;

   300

}

   301

   302

- (void)windowDidResignMain:(NSNotification*)aNotification

   303

{

   304

	driver->active = false;

   305

}

   306

   307

@end

   308

   309

   310

static const int _resize_icon_width  = 16;

   311

static const int _resize_icon_height = 16;

   312

   313

static bool _resize_icon[] = {

   314

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

   315

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

   316

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

   317

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

   318

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

   319

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

   320

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

   321

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

   322

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

   323

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

   324

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

   325

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

   326

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

   327

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

   328

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

   329

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

   330

};

   331

   332

   333

   334

extern const char _openttd_revision[];

   335

   336

   337

void WindowQuickdrawSubdriver::GetDeviceInfo()

   338

{

   339

	CFDictionaryRef    cur_mode;

   340

   341

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

   342

	cur_mode = CGDisplayCurrentMode(kCGDirectMainDisplay);

   343

   344

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

   345

	CFNumberGetValue(

   346

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

   347

		kCFNumberSInt32Type, &device_depth

   348

	);

   349

   350

	CFNumberGetValue(

   351

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

   352

		kCFNumberSInt32Type, &device_width

   353

	);

   354

   355

	CFNumberGetValue(

   356

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

   357

		kCFNumberSInt32Type, &device_height

   358

	);

   359

}

   360

   361

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

   362

{

   363

	char caption[50];

   364

	NSString *nsscaption;

   365

	unsigned int style;

   366

	NSRect contentRect;

   367

	BOOL isCustom = NO;

   368

	bool ret;

   369

   370

	setup = true;

   371

   372

	GetDeviceInfo();

   373

   374

	if (buffer_depth > device_depth) {

   375

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

   376

		setup = false;

   377

		return false;

   378

	}

   379

   380

	if (width > device_width)

   381

		width = device_width;

   382

	if (height > device_height)

   383

		height = device_height;

   384

   385

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

   386

   387

	/* Check if we should recreate the window */

   388

	if (window == nil) {

   389

		OTTD_QuickdrawWindowDelegate *delegate;

   390

   391

		/* Set the window style */

   392

		style = NSTitledWindowMask;

   393

		style |= (NSMiniaturizableWindowMask | NSClosableWindowMask);

   394

		style |= NSResizableWindowMask;

   395

   396

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

   397

		window = [ [ OTTD_QuickdrawWindow alloc ]

   398

						initWithContentRect:contentRect

   399

						styleMask:style

   400

						backing:NSBackingStoreBuffered

   401

						defer:NO ];

   402

   403

		if (window == nil) {

   404

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

   405

			setup = false;

   406

			return false;

   407

		}

   408

   409

		[ window setDriver:this ];

   410

   411

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

   412

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

   413

		[ window setTitle:nsscaption ];

   414

		[ window setMiniwindowTitle:nsscaption ];

   415

		[ nsscaption release ];

   416

   417

		[ window setAcceptsMouseMovedEvents:YES ];

   418

		[ window setViewsNeedDisplay:NO ];

   419

   420

		delegate = [ [ OTTD_QuickdrawWindowDelegate alloc ] init ];

   421

		[ delegate setDriver:this ];

   422

		[ window setDelegate: [ delegate autorelease ] ];

   423

	} else {

   424

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

   425

		if (!isCustom) {

   426

			[ window setContentSize:contentRect.size ];

   427

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

   428

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

   429

			height = contentRect.size.height;

   430

			[ qdview setFrameSize:contentRect.size ];

   431

		}

   432

	}

   433

   434

	// Update again

   435

	window_width = width;

   436

	window_height = height;

   437

   438

	[ window center ];

   439

   440

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

   441

	if (qdview == nil) {

   442

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

   443

		if (qdview == nil) {

   444

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

   445

			setup = false;

   446

			return false;

   447

		}

   448

   449

		[ qdview setAutoresizingMask: NSViewWidthSizable | NSViewHeightSizable ];

   450

		[ [ window contentView ] addSubview:qdview ];

   451

		[ qdview release ];

   452

		[ window makeKeyAndOrderFront:nil ];

   453

	}

   454

   455

	ret = WindowResized();

   456

   457

	UpdatePalette(0, 256);

   458

   459

	setup = false;

   460

   461

	return ret;

   462

}

   463

   464

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

   465

{

   466

	const uint32* src   = (uint32*)pixel_buffer;

   467

	uint32*       dst   = (uint32*)window_buffer;

   468

	uint          width = window_width;

   469

	uint          pitch = window_pitch / 4;

   470

	int y;

   471

   472

   473

	dst += top * pitch + left;

   474

	src += top * width + left;

   475

   476

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

   477

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

   478

	}

   479

}

   480

   481

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

   482

{

   483

	const uint32* pal   = palette32;

   484

	const uint8*  src   = (uint8*)pixel_buffer;

   485

	uint32*       dst   = (uint32*)window_buffer;

   486

	uint          width = window_width;

   487

	uint          pitch = window_pitch / 4;

   488

	int x;

   489

	int y;

   490

   491

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

   492

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

   493

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

   494

		}

   495

	}

   496

}

   497

   498

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

   499