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 "../../core/geometry_type.hpp"

    43

#include "cocoa_v.h"

    44

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

    45

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

    46

    47

#undef Rect

    48

    49

    50

class WindowQuickdrawSubdriver;

    51

    52

    53

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

    54

@interface OTTD_QuickdrawWindow : NSWindow {

    55

	WindowQuickdrawSubdriver *driver;

    56

}

    57

    58

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

    59

    60

- (void)miniaturize:(id)sender;

    61

- (void)display;

    62

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

    63

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

    64

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

    65

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

    66

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

    67

@end

    68

    69

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

    70

@interface OTTD_QuickdrawWindowDelegate : NSObject{

    71

	WindowQuickdrawSubdriver *driver;

    72

}

    73

    74

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

    75

    76

- (BOOL)windowShouldClose:(id)sender;

    77

@end

    78

    79

class WindowQuickdrawSubdriver: public CocoaSubdriver {

    80

	int device_width;

    81

	int device_height;

    82

	int device_depth;

    83

    84

	int window_width;

    85

	int window_height;

    86

	int window_pitch;

    87

    88

	int buffer_depth;

    89

    90

	void *pixel_buffer;

    91

	void *window_buffer;

    92

    93

	OTTD_QuickdrawWindow *window;

    94

    95

	#define MAX_DIRTY_RECTS 100

    96

	Rect dirty_rects[MAX_DIRTY_RECTS];

    97

	int num_dirty_rects;

    98

    99

	uint16 palette16[256];

   100

	uint32 palette32[256];

   101

   102

public:

   103

	bool active;

   104

	bool setup;

   105

   106

	NSQuickDrawView *qdview;

   107

   108

private:

   109

	void GetDeviceInfo();

   110

   111

	bool SetVideoMode(int width, int height);

   112

   113

	/**

   114

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

   115

	 *

   116

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

   117

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

   118

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

   119

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

   120

	 */

   121

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

   122

   123

	/**

   124

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

   125

	 *

   126

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

   127

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

   128

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

   129

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

   130

	 */

   131

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

   132

   133

	/**

   134

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

   135

	 *

   136

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

   137

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

   138

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

   139

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

   140

	 */

   141

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

   142

   143

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

   144

	void DrawResizeIcon();

   145

   146

   147

public:

   148

	WindowQuickdrawSubdriver(int bpp);

   149

	virtual ~WindowQuickdrawSubdriver();

   150

   151

	virtual void Draw();

   152

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

   153

	virtual void UpdatePalette(uint first_color, uint num_colors);

   154

   155

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

   156

   157

	virtual bool ChangeResolution(int w, int h);

   158

   159

	virtual bool IsFullscreen() { return false; }

   160

   161

	virtual int GetWidth() { return window_width; }

   162

	virtual int GetHeight() { return window_height; }

   163

	virtual void *GetPixelBuffer() { return pixel_buffer; }

   164

   165

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

   166

	virtual CGPoint PrivateLocalToCG(NSPoint* p);

   167

   168

	virtual NSPoint GetMouseLocation(NSEvent *event);

   169

	virtual bool MouseIsInsideView(NSPoint *pt);

   170

   171

	virtual bool IsActive() { return active; }

   172

   173

   174

	void SetPortAlphaOpaque();

   175

	bool WindowResized();

   176

};

   177

   178

   179

@implementation OTTD_QuickdrawWindow

   180

   181

- (void)setDriver:(WindowQuickdrawSubdriver*)drv

   182

{

   183

	driver = drv;

   184

}

   185

   186

   187

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

   188

- (void)miniaturize:(id)sender

   189

{

   190

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

   191

	driver->SetPortAlphaOpaque ();

   192

   193

	/* window is hidden now */

   194

	driver->active = false;

   195

   196

	QZ_ShowMouse();

   197

   198

	[ super miniaturize:sender ];

   199

}

   200

   201

- (void)display

   202

{

   203

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

   204

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

   205

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

   206

	 * is required, and the deminiaturize works perfectly.

   207

	 */

   208

   209

	driver->SetPortAlphaOpaque();

   210

   211

	/* save current visible surface */

   212

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

   213

   214

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

   215

	[ super display ];

   216

   217

	/* restore visible surface */

   218

	[ self restoreCachedImage ];

   219

   220

	/* window is visible again */

   221

	driver->active = true;

   222

}

   223

   224

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

   225

{

   226

	[ super setFrame:frameRect display:flag ];

   227

   228

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

   229

	if (driver->setup) return;

   230

   231

	if (!driver->WindowResized())

   232

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

   233

}

   234

   235

- (void)appDidHide:(NSNotification*)note

   236

{

   237

	driver->active = false;

   238

}

   239

   240

   241

- (void)appWillUnhide:(NSNotification*)note

   242

{

   243

	driver->SetPortAlphaOpaque ();

   244

   245

	/* save current visible surface */

   246

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

   247

}

   248

   249

- (void)appDidUnhide:(NSNotification*)note

   250

{

   251

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

   252

	[ self restoreCachedImage ];

   253

   254

	driver->active = true;

   255

}

   256

   257

   258

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

   259

{

   260

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

   261

	[ [ NSNotificationCenter defaultCenter ] addObserver:self

   262

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

   263

   264

	[ [ NSNotificationCenter defaultCenter ] addObserver:self

   265

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

   266

   267

	[ [ NSNotificationCenter defaultCenter ] addObserver:self

   268

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

   269

   270

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

   271

}

   272

   273

@end

   274

   275

@implementation OTTD_QuickdrawWindowDelegate

   276

- (void)setDriver:(WindowQuickdrawSubdriver*)drv

   277

{

   278

	driver = drv;

   279

}

   280

   281

- (BOOL)windowShouldClose:(id)sender

   282

{

   283

	HandleExitGameRequest();

   284

   285

	return NO;

   286

}

   287

   288

- (void)windowDidBecomeKey:(NSNotification*)aNotification

   289

{

   290

	driver->active = true;

   291

}

   292

   293

- (void)windowDidResignKey:(NSNotification*)aNotification

   294

{

   295

	driver->active = false;

   296

}

   297

   298

- (void)windowDidBecomeMain:(NSNotification*)aNotification

   299

{

   300

	driver->active = true;

   301

}

   302

   303

- (void)windowDidResignMain:(NSNotification*)aNotification

   304

{

   305

	driver->active = false;

   306

}

   307

   308

@end

   309

   310

   311

static const int _resize_icon_width  = 16;

   312

static const int _resize_icon_height = 16;

   313

   314

static bool _resize_icon[] = {

   315

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

   316

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

   317

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

   318

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

   319

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

   320

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

   321

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

   322

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

   323

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

   324

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

   325

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

   326

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

   327

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

   328

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

   329

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

   330

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

   331

};

   332

   333

   334

   335

extern const char _openttd_revision[];

   336

   337

   338

void WindowQuickdrawSubdriver::GetDeviceInfo()

   339

{

   340

	CFDictionaryRef    cur_mode;

   341

   342

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

   343

	cur_mode = CGDisplayCurrentMode(kCGDirectMainDisplay);

   344

   345

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

   346

	CFNumberGetValue(

   347

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

   348

		kCFNumberSInt32Type, &device_depth

   349

	);

   350

   351

	CFNumberGetValue(

   352

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

   353

		kCFNumberSInt32Type, &device_width

   354

	);

   355

   356

	CFNumberGetValue(

   357

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

   358

		kCFNumberSInt32Type, &device_height

   359

	);

   360

}

   361

   362

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

   363

{

   364

	char caption[50];

   365

	NSString *nsscaption;

   366

	unsigned int style;

   367

	NSRect contentRect;

   368

	BOOL isCustom = NO;

   369

	bool ret;

   370

   371

	setup = true;

   372

   373

	GetDeviceInfo();

   374

   375

	if (buffer_depth > device_depth) {

   376

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

   377

		setup = false;

   378

		return false;

   379

	}

   380

   381

	if (width > device_width)

   382

		width = device_width;

   383

	if (height > device_height)

   384

		height = device_height;

   385

   386

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

   387

   388

	/* Check if we should recreate the window */

   389

	if (window == nil) {

   390

		OTTD_QuickdrawWindowDelegate *delegate;

   391

   392

		/* Set the window style */

   393

		style = NSTitledWindowMask;

   394

		style |= (NSMiniaturizableWindowMask | NSClosableWindowMask);

   395

		style |= NSResizableWindowMask;

   396

   397

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

   398

		window = [ [ OTTD_QuickdrawWindow alloc ]

   399

						initWithContentRect:contentRect

   400

						styleMask:style

   401

						backing:NSBackingStoreBuffered

   402

						defer:NO ];

   403

   404

		if (window == nil) {

   405

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

   406

			setup = false;

   407

			return false;

   408

		}

   409

   410

		[ window setDriver:this ];

   411

   412

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

   413

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

   414

		[ window setTitle:nsscaption ];

   415

		[ window setMiniwindowTitle:nsscaption ];

   416

		[ nsscaption release ];

   417

   418

		[ window setAcceptsMouseMovedEvents:YES ];

   419

		[ window setViewsNeedDisplay:NO ];

   420

   421

		delegate = [ [ OTTD_QuickdrawWindowDelegate alloc ] init ];

   422

		[ delegate setDriver:this ];

   423

		[ window setDelegate: [ delegate autorelease ] ];

   424

	} else {

   425

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

   426

		if (!isCustom) {

   427

			[ window setContentSize:contentRect.size ];

   428

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

   429

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

   430

			height = contentRect.size.height;

   431

			[ qdview setFrameSize:contentRect.size ];

   432

		}

   433

	}

   434

   435

	// Update again

   436

	window_width = width;

   437

	window_height = height;

   438

   439

	[ window center ];

   440

   441

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

   442

	if (qdview == nil) {

   443

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

   444

		if (qdview == nil) {

   445

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

   446

			setup = false;

   447

			return false;

   448

		}

   449

   450

		[ qdview setAutoresizingMask: NSViewWidthSizable | NSViewHeightSizable ];

   451

		[ [ window contentView ] addSubview:qdview ];

   452

		[ qdview release ];

   453

		[ window makeKeyAndOrderFront:nil ];

   454

	}

   455

   456

	ret = WindowResized();

   457

   458

	UpdatePalette(0, 256);

   459

   460

	setup = false;

   461

   462

	return ret;

   463

}

   464

   465

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

   466

{

   467

	const uint32* src   = (uint32*)pixel_buffer;

   468

	uint32*       dst   = (uint32*)window_buffer;

   469

	uint          width = window_width;

   470

	uint          pitch = window_pitch / 4;

   471

	int y;

   472

   473

   474

	dst += top * pitch + left;

   475

	src += top * width + left;

   476

   477

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

   478

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

   479

	}

   480

}

   481

   482

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

   483

{

   484

	const uint32* pal   = palette32;

   485

	const uint8*  src   = (uint8*)pixel_buffer;

   486

	uint32*       dst   = (uint32*)window_buffer;

   487

	uint          width = window_width;

   488

	uint          pitch = window_pitch / 4;

   489

	int x;

   490

	int y;

   491

   492

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

   493

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

   494

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

   495

		}

   496

	}

   497

}

   498