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 "../../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 WindowQuartzSubdriver;

    51

    52

    53

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

    54

@interface OTTD_QuartzWindow : NSWindow {

    55

	WindowQuartzSubdriver *driver;

    56

}

    57

    58

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

    71

	WindowQuartzSubdriver *driver;

    72

}

    73

    74

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

    75

    76

- (BOOL)windowShouldClose:(id)sender;

    77

@end

    78

    79

/* Subclass of NSView to fix Quartz rendering */

    80

@interface OTTD_QuartzView : NSView {

    81

	WindowQuartzSubdriver *driver;

    82

}

    83

    84

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

    85

    86

- (void)drawRect:(NSRect)rect;

    87

- (BOOL)isOpaque;

    88

@end

    89

    90

class WindowQuartzSubdriver: public CocoaSubdriver {

    91

	int device_width;

    92

	int device_height;

    93

    94

	int window_width;

    95

	int window_height;

    96

    97

	int buffer_depth;

    98

    99

	void* pixel_buffer;

   100

	void* image_buffer;

   101

   102

	OTTD_QuartzWindow *window;

   103

   104

	#define MAX_DIRTY_RECTS 100

   105

	Rect dirty_rects[MAX_DIRTY_RECTS];

   106

	int num_dirty_rects;

   107

   108

	uint32 palette[256];

   109

   110

public:

   111

	bool active;

   112

	bool setup;

   113

   114

	OTTD_QuartzView* qzview;

   115

	CGContextRef 	 cgcontext;

   116

   117

private:

   118

	void GetDeviceInfo();

   119

   120

	bool SetVideoMode(int width, int height);

   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

public:

   133

	WindowQuartzSubdriver(int bpp);

   134

	virtual ~WindowQuartzSubdriver();

   135

   136

	virtual void Draw();

   137

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

   138

	virtual void UpdatePalette(uint first_color, uint num_colors);

   139

   140

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

   141

   142

	virtual bool ChangeResolution(int w, int h);

   143

   144

	virtual bool IsFullscreen() { return false; }

   145

   146

	virtual int GetWidth() { return window_width; }

   147

	virtual int GetHeight() { return window_height; }

   148

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

   149

   150

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

   151

	virtual CGPoint PrivateLocalToCG(NSPoint* p);

   152

   153

	virtual NSPoint GetMouseLocation(NSEvent *event);

   154

	virtual bool MouseIsInsideView(NSPoint *pt);

   155

   156

	virtual bool IsActive() { return active; }

   157

   158

   159

	void SetPortAlphaOpaque();

   160

	bool WindowResized();

   161

};

   162

   163

   164

static CGColorSpaceRef QZ_GetCorrectColorSpace()

   165

{

   166

	static CGColorSpaceRef colorSpace = NULL;

   167

   168

	if (colorSpace == NULL)

   169

	{

   170

		CMProfileRef sysProfile;

   171

   172

		if (CMGetSystemProfile(&sysProfile) == noErr)

   173

		{

   174

			colorSpace = CGColorSpaceCreateWithPlatformColorSpace(sysProfile);

   175

			CMCloseProfile(sysProfile);

   176

		}

   177

   178

		assert(colorSpace != NULL);

   179

	}

   180

   181

	return colorSpace;

   182

}

   183

   184

   185

@implementation OTTD_QuartzWindow

   186

   187

- (void)setDriver:(WindowQuartzSubdriver*)drv

   188

{

   189

	driver = drv;

   190

}

   191

   192

   193

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

   194

- (void)miniaturize:(id)sender

   195

{

   196

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

   197

	driver->SetPortAlphaOpaque ();

   198

   199

	/* window is hidden now */

   200

	driver->active = false;

   201

   202

	QZ_ShowMouse();

   203

   204

	[ super miniaturize:sender ];

   205

}

   206

   207

- (void)display

   208

{

   209

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

   210

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

   211

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

   212

	 * is required, and the deminiaturize works perfectly.

   213

	 */

   214

   215

	driver->SetPortAlphaOpaque();

   216

   217

	/* save current visible surface */

   218

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

   219

   220

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

   221

	[ super display ];

   222

   223

	/* restore visible surface */

   224

	[ self restoreCachedImage ];

   225

   226

	/* window is visible again */

   227

	driver->active = true;

   228

}

   229

   230

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

   231

{

   232

	[ super setFrame:frameRect display:flag ];

   233

   234

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

   235

	if (driver->setup) return;

   236

   237

	if (!driver->WindowResized())

   238

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

   239

}

   240

   241

- (void)appDidHide:(NSNotification*)note

   242

{

   243

	driver->active = false;

   244

}

   245

   246

   247

- (void)appWillUnhide:(NSNotification*)note

   248

{

   249

	driver->SetPortAlphaOpaque ();

   250

   251

	/* save current visible surface */

   252

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

   253

}

   254

   255

- (void)appDidUnhide:(NSNotification*)note

   256

{

   257

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

   258

	[ self restoreCachedImage ];

   259

   260

	driver->active = true;

   261

}

   262

   263

   264

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

   265

{

   266

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

   267

	[ [ NSNotificationCenter defaultCenter ] addObserver:self

   268

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

   269

   270

	[ [ NSNotificationCenter defaultCenter ] addObserver:self

   271

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

   272

   273

	[ [ NSNotificationCenter defaultCenter ] addObserver:self

   274

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

   275

   276

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

   277

}

   278

   279

@end

   280

   281

@implementation OTTD_QuartzWindowDelegate

   282

   283

- (void)setDriver:(WindowQuartzSubdriver*)drv

   284

{

   285

	driver = drv;

   286

}

   287

   288

- (BOOL)windowShouldClose:(id)sender

   289

{

   290

	HandleExitGameRequest();

   291

   292

	return NO;

   293

}

   294

   295

- (void)windowDidBecomeKey:(NSNotification*)aNotification

   296

{

   297

	driver->active = true;

   298

}

   299

   300

- (void)windowDidResignKey:(NSNotification*)aNotification

   301

{

   302

	driver->active = false;

   303

}

   304

   305

- (void)windowDidBecomeMain:(NSNotification*)aNotification

   306

{

   307

	driver->active = true;

   308

}

   309

   310

- (void)windowDidResignMain:(NSNotification*)aNotification

   311

{

   312

	driver->active = false;

   313

}

   314

   315

@end

   316

   317

@implementation OTTD_QuartzView

   318

   319

- (void)setDriver:(WindowQuartzSubdriver*)drv

   320

{

   321

	driver = drv;

   322

}

   323

   324

   325

- (BOOL)isOpaque

   326

{

   327

	return YES;

   328

}

   329

   330

- (void)drawRect:(NSRect)invalidRect

   331

{

   332

	CGImageRef    fullImage;

   333

	CGImageRef    clippedImage;

   334

	NSRect        rect;

   335

	const NSRect* dirtyRects;

   336

	int           dirtyRectCount;

   337

	int           n;

   338

	CGRect        clipRect;

   339

	CGRect        blitRect;

   340

	uint32        blitArea       = 0;

   341

	NSRect        frameRect      = [ self frame ];

   342

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

   343

   344

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

   345

   346

	CGContextSetShouldAntialias(viewContext, FALSE);

   347

	CGContextSetInterpolationQuality(viewContext, kCGInterpolationNone);

   348

   349

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

   350

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

   351

   352

	/* 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 */

   353

	fullImage = CGBitmapContextCreateImage(driver->cgcontext);

   354

   355

	/* Calculate total area we are blitting */

   356

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

   357

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

   358

 	}

   359

   360

	/*

   361

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

   362

	 * 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

   363

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

   364

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

   365

	 */

   366

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

   367

		rect = invalidRect;

   368

   369

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

   370

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

   371

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

   372

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

   373

   374

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

   375

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

   376

   377

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

   378

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

   379

   380

		/* Blit dirty part of image */

   381

		clippedImage = CGImageCreateWithImageInRect(fullImage, clipRect);

   382

		CGContextDrawImage(viewContext, blitRect, clippedImage);

   383

		CGImageRelease(clippedImage);

   384

	} else {

   385

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

   386

			rect = dirtyRects[n];

   387

   388

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

   389

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

   390

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

   391

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

   392

   393

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

   394

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

   395

   396

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

   397

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

   398

   399

			/* Blit dirty part of image */

   400

			clippedImage = CGImageCreateWithImageInRect(fullImage, clipRect);

   401

			CGContextDrawImage(viewContext, blitRect, clippedImage);

   402

			CGImageRelease(clippedImage);

   403

 		}

   404

 	}

   405

   406

	CGImageRelease(fullImage);

   407

}

   408

   409

@end

   410

   411

   412

extern const char _openttd_revision[];

   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