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_QUARTZ

    11

    12

#include <AvailabilityMacros.h>

    13

    14

#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_4

    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 WindowQuartzSubdriver;

    53

    54

    55

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

    56

@interface OTTD_QuartzWindow : NSWindow {

    57

	WindowQuartzSubdriver *driver;

    58

}

    59

    60

- (void)setDriver:(WindowQuartzSubdriver*)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_QuartzWindowDelegate : NSObject{

    73

	WindowQuartzSubdriver *driver;

    74

}

    75

    76

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

    77

    78

- (BOOL)windowShouldClose:(id)sender;

    79

@end

    80

    81

/* Subclass of NSView to fix Quartz rendering */

    82

@interface OTTD_QuartzView : NSView {

    83

	WindowQuartzSubdriver *driver;

    84

}

    85

    86

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

    87

    88

- (void)drawRect:(NSRect)rect;

    89

- (BOOL)isOpaque;

    90

@end

    91

    92

class WindowQuartzSubdriver: public CocoaSubdriver {

    93

	int device_width;

    94

	int device_height;

    95

    96

	int window_width;

    97

	int window_height;

    98

    99

	int buffer_depth;

   100

   101

	void* pixel_buffer;

   102

	void* image_buffer;

   103

   104

	OTTD_QuartzWindow *window;

   105

   106

	#define MAX_DIRTY_RECTS 100

   107

	Rect dirty_rects[MAX_DIRTY_RECTS];

   108

	int num_dirty_rects;

   109

   110

	uint32 palette[256];

   111

   112

public:

   113

	bool active;

   114

	bool setup;

   115

   116

	OTTD_QuartzView* qzview;

   117

	CGContextRef 	 cgcontext;

   118

   119

private:

   120

	void GetDeviceInfo();

   121

   122

	bool SetVideoMode(int width, int height);

   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

public:

   135

	WindowQuartzSubdriver(int bpp);

   136

	virtual ~WindowQuartzSubdriver();

   137

   138

	virtual void Draw();

   139

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

   140

	virtual void UpdatePalette(uint first_color, uint num_colors);

   141

   142

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

   143

   144

	virtual bool ChangeResolution(int w, int h);

   145

   146

	virtual bool IsFullscreen() { return false; }

   147

   148

	virtual int GetWidth() { return window_width; }

   149

	virtual int GetHeight() { return window_height; }

   150

	virtual void *GetPixelBuffer() { return buffer_depth == 8 ? pixel_buffer : image_buffer; }

   151

   152

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

   153

	virtual CGPoint PrivateLocalToCG(NSPoint* p);

   154

   155

	virtual NSPoint GetMouseLocation(NSEvent *event);

   156

	virtual bool MouseIsInsideView(NSPoint *pt);

   157

   158

	virtual bool IsActive() { return active; }

   159

   160

   161

	void SetPortAlphaOpaque();

   162

	bool WindowResized();

   163

};

   164

   165

   166

static CGColorSpaceRef QZ_GetCorrectColorSpace()

   167

{

   168

	static CGColorSpaceRef colorSpace = NULL;

   169

   170

	if (colorSpace == NULL)

   171

	{

   172

		CMProfileRef sysProfile;

   173

   174

		if (CMGetSystemProfile(&sysProfile) == noErr)

   175

		{

   176

			colorSpace = CGColorSpaceCreateWithPlatformColorSpace(sysProfile);

   177

			CMCloseProfile(sysProfile);

   178

		}

   179

   180

		if (colorSpace == NULL)

   181

			error("Could not get system colour space. You might need to recalibrate your monitor.");

   182

	}

   183

   184

	return colorSpace;

   185

}

   186

   187

   188

@implementation OTTD_QuartzWindow

   189

   190

- (void)setDriver:(WindowQuartzSubdriver*)drv

   191

{

   192

	driver = drv;

   193

}

   194

   195

   196

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

   197

- (void)miniaturize:(id)sender

   198

{

   199

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

   200

	driver->SetPortAlphaOpaque ();

   201

   202

	/* window is hidden now */

   203

	driver->active = false;

   204

   205

	QZ_ShowMouse();

   206

   207

	[ super miniaturize:sender ];

   208

}

   209

   210

- (void)display

   211

{

   212

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

   213

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

   214

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

   215

	 * is required, and the deminiaturize works perfectly.

   216

	 */

   217

   218

	driver->SetPortAlphaOpaque();

   219

   220

	/* save current visible surface */

   221

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

   222

   223

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

   224

	[ super display ];

   225

   226

	/* restore visible surface */

   227

	[ self restoreCachedImage ];

   228

   229

	/* window is visible again */

   230

	driver->active = true;

   231

}

   232

   233

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

   234

{

   235

	[ super setFrame:frameRect display:flag ];

   236

   237

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

   238

	if (driver->setup) return;

   239

   240

	if (!driver->WindowResized())

   241

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

   242

}

   243

   244

- (void)appDidHide:(NSNotification*)note

   245

{

   246

	driver->active = false;

   247

}

   248

   249

   250

- (void)appWillUnhide:(NSNotification*)note

   251

{

   252

	driver->SetPortAlphaOpaque ();

   253

   254

	/* save current visible surface */

   255

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

   256

}

   257

   258

- (void)appDidUnhide:(NSNotification*)note

   259

{

   260

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

   261

	[ self restoreCachedImage ];

   262

   263

	driver->active = true;

   264

}

   265

   266

   267

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

   268

{

   269

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

   270

	[ [ NSNotificationCenter defaultCenter ] addObserver:self

   271

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

   272

   273

	[ [ NSNotificationCenter defaultCenter ] addObserver:self

   274

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

   275

   276

	[ [ NSNotificationCenter defaultCenter ] addObserver:self

   277

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

   278

   279

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

   280

}

   281

   282

@end

   283

   284

@implementation OTTD_QuartzWindowDelegate

   285

   286

- (void)setDriver:(WindowQuartzSubdriver*)drv

   287

{

   288

	driver = drv;

   289

}

   290

   291

- (BOOL)windowShouldClose:(id)sender

   292

{

   293

	HandleExitGameRequest();

   294

   295

	return NO;

   296

}

   297

   298

- (void)windowDidBecomeKey:(NSNotification*)aNotification

   299

{

   300

	driver->active = true;

   301

}

   302

   303

- (void)windowDidResignKey:(NSNotification*)aNotification

   304

{

   305

	driver->active = false;

   306

}

   307

   308

- (void)windowDidBecomeMain:(NSNotification*)aNotification

   309

{

   310

	driver->active = true;

   311

}

   312

   313

- (void)windowDidResignMain:(NSNotification*)aNotification

   314

{

   315

	driver->active = false;

   316

}

   317

   318

@end

   319

   320

@implementation OTTD_QuartzView

   321

   322

- (void)setDriver:(WindowQuartzSubdriver*)drv

   323

{

   324

	driver = drv;

   325

}

   326

   327

   328

- (BOOL)isOpaque

   329

{

   330

	return YES;

   331

}

   332

   333

- (void)drawRect:(NSRect)invalidRect

   334

{

   335

	CGImageRef    fullImage;

   336

	CGImageRef    clippedImage;

   337

	NSRect        rect;

   338

	const NSRect* dirtyRects;

   339

	int           dirtyRectCount;

   340

	int           n;

   341

	CGRect        clipRect;

   342

	CGRect        blitRect;

   343

	uint32        blitArea       = 0;

   344

	NSRect        frameRect      = [ self frame ];

   345

	CGContextRef  viewContext    = (CGContextRef)[ [ NSGraphicsContext currentContext ] graphicsPort ];

   346

   347

	if (driver->cgcontext == NULL) return;

   348

   349

	CGContextSetShouldAntialias(viewContext, FALSE);

   350

	CGContextSetInterpolationQuality(viewContext, kCGInterpolationNone);

   351

   352

	/* The obtained 'rect' is actually a union of all dirty rects, let's ask for an explicit list of rects instead */

   353

	[ self getRectsBeingDrawn:&dirtyRects count:&dirtyRectCount ];

   354

   355

	/* We need an Image in order to do blitting, but as we don't touch the context between this call and drawing no copying will actually be done here */

   356

	fullImage = CGBitmapContextCreateImage(driver->cgcontext);

   357

   358

	/* Calculate total area we are blitting */

   359

	for (n = 0; n < dirtyRectCount; n++) {

   360

		blitArea += dirtyRects[n].size.width * dirtyRects[n].size.height;

   361

 	}

   362

   363

	/*

   364

	 * This might be completely stupid, but in my extremely subjective opinion it feels faster

   365

	 * The point is, if we're blitting less than 50% of the dirty rect union then it's still a good idea to blit each dirty

   366

	 * rect separately but if we blit more than that, it's just cheaper to blit the entire union in one pass.

   367

	 * Feel free to remove or find an even better value than 50% ... / blackis

   368

	 */

   369

	if (blitArea / (float)(invalidRect.size.width * invalidRect.size.height) > 0.5f) {

   370

		rect = invalidRect;

   371

   372

		blitRect.origin.x = rect.origin.x;

   373

		blitRect.origin.y = rect.origin.y;

   374

		blitRect.size.width = rect.size.width;

   375

		blitRect.size.height = rect.size.height;

   376

   377

		clipRect.origin.x = rect.origin.x;

   378

		clipRect.origin.y = frameRect.size.height - rect.origin.y - rect.size.height;

   379

   380

		clipRect.size.width = rect.size.width;

   381

		clipRect.size.height = rect.size.height;

   382

   383

		/* Blit dirty part of image */

   384

		clippedImage = CGImageCreateWithImageInRect(fullImage, clipRect);

   385

		CGContextDrawImage(viewContext, blitRect, clippedImage);

   386

		CGImageRelease(clippedImage);

   387

	} else {

   388

		for (n = 0; n < dirtyRectCount; n++) {

   389

			rect = dirtyRects[n];

   390

   391

			blitRect.origin.x = rect.origin.x;

   392

			blitRect.origin.y = rect.origin.y;

   393

			blitRect.size.width = rect.size.width;

   394

			blitRect.size.height = rect.size.height;

   395

   396

			clipRect.origin.x = rect.origin.x;

   397

			clipRect.origin.y = frameRect.size.height - rect.origin.y - rect.size.height;

   398

   399

			clipRect.size.width = rect.size.width;

   400

			clipRect.size.height = rect.size.height;

   401

   402

			/* Blit dirty part of image */

   403

			clippedImage = CGImageCreateWithImageInRect(fullImage, clipRect);

   404

			CGContextDrawImage(viewContext, blitRect, clippedImage);

   405

			CGImageRelease(clippedImage);

   406

 		}

   407

 	}

   408

   409

	CGImageRelease(fullImage);

   410

}

   411

   412

@end

   413

   414

   415

void WindowQuartzSubdriver::GetDeviceInfo()

   416

{

   417

	CFDictionaryRef    cur_mode;

   418

   419

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

   420

	cur_mode = CGDisplayCurrentMode(kCGDirectMainDisplay);

   421

   422

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

   423

	CFNumberGetValue(

   424

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

   425

		kCFNumberSInt32Type, &device_width

   426

	);

   427

   428

	CFNumberGetValue(

   429

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

   430

		kCFNumberSInt32Type, &device_height

   431

	);

   432

}

   433

   434

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

   435

{

   436

	char caption[50];

   437

	NSString *nsscaption;

   438

	unsigned int style;

   439

	NSRect contentRect;

   440

	BOOL isCustom = NO;

   441

	bool ret;

   442

   443

	setup = true;

   444

   445

	GetDeviceInfo();

   446

   447

	if (width > device_width)

   448

		width = device_width;

   449

	if (height > device_height)

   450

		height = device_height;

   451

   452

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

   453

   454

	/* Check if we should recreate the window */

   455

	if (window == nil) {

   456

		OTTD_QuartzWindowDelegate *delegate;

   457

   458

		/* Set the window style */

   459

		style = NSTitledWindowMask;

   460

		style |= (NSMiniaturizableWindowMask | NSClosableWindowMask);

   461

		style |= NSResizableWindowMask;

   462

   463

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

   464

		window = [ [ OTTD_QuartzWindow alloc ]

   465

						initWithContentRect: contentRect

   466

						styleMask: style

   467

						backing: NSBackingStoreBuffered

   468

						defer: NO ];

   469

   470

		if (window == nil) {

   471

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

   472

			setup = false;

   473

			return false;

   474

		}

   475

   476

		[ window setDriver:this ];

   477

   478

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

   479

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

   480

		[ window setTitle: nsscaption ];

   481

		[ window setMiniwindowTitle: nsscaption ];

   482

		[ nsscaption release ];

   483

   484

		[ window setAcceptsMouseMovedEvents: YES ];

   485

		[ window setViewsNeedDisplay: NO ];

   486

   487

		[ window useOptimizedDrawing: YES ];

   488

   489

		delegate = [ [ OTTD_QuartzWindowDelegate alloc ] init ];

   490

		[ delegate setDriver: this ];

   491

		[ window setDelegate: [ delegate autorelease ] ];

   492

	} else {

   493

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

   494

		if (!isCustom) {

   495

			[ window setContentSize: contentRect.size ];

   496

   497

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