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

    43

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

    44

#include "cocoa_v.h"

    45

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

    46

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

    47

    48

#undef Rect

    49

    50

    51

class WindowQuartzSubdriver;

    52

    53

    54

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

    55

@interface OTTD_QuartzWindow : NSWindow {

    56

	WindowQuartzSubdriver *driver;

    57

}

    58

    59

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

    60

    61

- (void)miniaturize:(id)sender;

    62

- (void)display;

    63

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

    64

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

    65

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

    66

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

    67

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

    68

@end

    69

    70

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

    71

@interface OTTD_QuartzWindowDelegate : NSObject{

    72

	WindowQuartzSubdriver *driver;

    73

}

    74

    75

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

    76

    77

- (BOOL)windowShouldClose:(id)sender;

    78

@end

    79

    80

/* Subclass of NSView to fix Quartz rendering */

    81

@interface OTTD_QuartzView : NSView {

    82

	WindowQuartzSubdriver *driver;

    83

}

    84

    85

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

    86

    87

- (void)drawRect:(NSRect)rect;

    88

- (BOOL)isOpaque;

    89

@end

    90

    91

class WindowQuartzSubdriver: public CocoaSubdriver {

    92

	int device_width;

    93

	int device_height;

    94

    95

	int window_width;

    96

	int window_height;

    97

    98

	int buffer_depth;

    99

   100

	void* pixel_buffer;

   101

	void* image_buffer;

   102

   103

	OTTD_QuartzWindow *window;

   104

   105

	#define MAX_DIRTY_RECTS 100

   106

	Rect dirty_rects[MAX_DIRTY_RECTS];

   107

	int num_dirty_rects;

   108

   109

	uint32 palette[256];

   110

   111

public:

   112

	bool active;

   113

	bool setup;

   114

   115

	OTTD_QuartzView* qzview;

   116

	CGContextRef 	 cgcontext;

   117

   118

private:

   119

	void GetDeviceInfo();

   120

   121

	bool SetVideoMode(int width, int height);

   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

public:

   134

	WindowQuartzSubdriver(int bpp);

   135

	virtual ~WindowQuartzSubdriver();

   136

   137

	virtual void Draw();

   138

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

   139

	virtual void UpdatePalette(uint first_color, uint num_colors);

   140

   141

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

   142

   143

	virtual bool ChangeResolution(int w, int h);

   144

   145

	virtual bool IsFullscreen() { return false; }

   146

   147

	virtual int GetWidth() { return window_width; }

   148

	virtual int GetHeight() { return window_height; }

   149

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

   150

   151

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

   152

	virtual CGPoint PrivateLocalToCG(NSPoint* p);

   153

   154

	virtual NSPoint GetMouseLocation(NSEvent *event);

   155

	virtual bool MouseIsInsideView(NSPoint *pt);

   156

   157

	virtual bool IsActive() { return active; }

   158

   159

   160

	void SetPortAlphaOpaque();

   161

	bool WindowResized();

   162

};

   163

   164

   165

static CGColorSpaceRef QZ_GetCorrectColorSpace()

   166

{

   167

	static CGColorSpaceRef colorSpace = NULL;

   168

   169

	if (colorSpace == NULL)

   170

	{

   171

		CMProfileRef sysProfile;

   172

   173

		if (CMGetSystemProfile(&sysProfile) == noErr)

   174

		{

   175

			colorSpace = CGColorSpaceCreateWithPlatformColorSpace(sysProfile);

   176

			CMCloseProfile(sysProfile);

   177

		}

   178

   179

		assert(colorSpace != NULL);

   180

	}

   181

   182

	return colorSpace;

   183

}

   184

   185

   186

@implementation OTTD_QuartzWindow

   187

   188

- (void)setDriver:(WindowQuartzSubdriver*)drv

   189

{

   190

	driver = drv;

   191

}

   192

   193

   194

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

   195

- (void)miniaturize:(id)sender

   196

{

   197

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

   198

	driver->SetPortAlphaOpaque ();

   199

   200

	/* window is hidden now */

   201

	driver->active = false;

   202

   203

	QZ_ShowMouse();

   204

   205

	[ super miniaturize:sender ];

   206

}

   207

   208

- (void)display

   209

{

   210

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

   211

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

   212

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

   213

	 * is required, and the deminiaturize works perfectly.

   214

	 */

   215

   216

	driver->SetPortAlphaOpaque();

   217

   218

	/* save current visible surface */

   219

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

   220

   221

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

   222

	[ super display ];

   223

   224

	/* restore visible surface */

   225

	[ self restoreCachedImage ];

   226

   227

	/* window is visible again */

   228

	driver->active = true;

   229

}

   230

   231

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

   232

{

   233

	[ super setFrame:frameRect display:flag ];

   234

   235

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

   236

	if (driver->setup) return;

   237

   238

	if (!driver->WindowResized())

   239

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

   240

}

   241

   242

- (void)appDidHide:(NSNotification*)note

   243

{

   244

	driver->active = false;

   245

}

   246

   247

   248

- (void)appWillUnhide:(NSNotification*)note

   249

{

   250

	driver->SetPortAlphaOpaque ();

   251

   252

	/* save current visible surface */

   253

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

   254

}

   255

   256

- (void)appDidUnhide:(NSNotification*)note

   257

{

   258

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

   259

	[ self restoreCachedImage ];

   260

   261

	driver->active = true;

   262

}

   263

   264

   265

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

   266

{

   267

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

   268

	[ [ NSNotificationCenter defaultCenter ] addObserver:self

   269

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

   270

   271

	[ [ NSNotificationCenter defaultCenter ] addObserver:self

   272

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

   273

   274

	[ [ NSNotificationCenter defaultCenter ] addObserver:self

   275

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

   276

   277

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

   278

}

   279

   280

@end

   281

   282

@implementation OTTD_QuartzWindowDelegate

   283

   284

- (void)setDriver:(WindowQuartzSubdriver*)drv

   285

{

   286

	driver = drv;

   287

}

   288

   289

- (BOOL)windowShouldClose:(id)sender

   290

{

   291

	HandleExitGameRequest();

   292

   293

	return NO;

   294

}

   295

   296

- (void)windowDidBecomeKey:(NSNotification*)aNotification

   297

{

   298

	driver->active = true;

   299

}

   300

   301

- (void)windowDidResignKey:(NSNotification*)aNotification

   302

{

   303

	driver->active = false;

   304

}

   305

   306

- (void)windowDidBecomeMain:(NSNotification*)aNotification

   307

{

   308

	driver->active = true;

   309

}

   310

   311

- (void)windowDidResignMain:(NSNotification*)aNotification

   312

{

   313

	driver->active = false;

   314

}

   315

   316

@end

   317

   318

@implementation OTTD_QuartzView

   319

   320

- (void)setDriver:(WindowQuartzSubdriver*)drv

   321

{

   322

	driver = drv;

   323

}

   324

   325

   326

- (BOOL)isOpaque

   327

{

   328

	return YES;

   329

}

   330

   331

- (void)drawRect:(NSRect)invalidRect

   332

{

   333

	CGImageRef    fullImage;

   334

	CGImageRef    clippedImage;

   335

	NSRect        rect;

   336

	const NSRect* dirtyRects;

   337

	int           dirtyRectCount;

   338

	int           n;

   339

	CGRect        clipRect;

   340

	CGRect        blitRect;

   341

	uint32        blitArea       = 0;

   342

	NSRect        frameRect      = [ self frame ];

   343

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

   344

   345

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

   346

   347

	CGContextSetShouldAntialias(viewContext, FALSE);

   348

	CGContextSetInterpolationQuality(viewContext, kCGInterpolationNone);

   349

   350

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

   351

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

   352

   353

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

   354

	fullImage = CGBitmapContextCreateImage(driver->cgcontext);

   355

   356

	/* Calculate total area we are blitting */

   357

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

   358

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

   359

 	}

   360

   361

	/*

   362

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

   363

	 * 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

   364

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

   365

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

   366

	 */

   367

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

   368

		rect = invalidRect;

   369

   370

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

   371

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

   372

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

   373

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

   374

   375

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

   376

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

   377

   378

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

   379

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

   380

   381

		/* Blit dirty part of image */

   382

		clippedImage = CGImageCreateWithImageInRect(fullImage, clipRect);

   383

		CGContextDrawImage(viewContext, blitRect, clippedImage);

   384

		CGImageRelease(clippedImage);

   385

	} else {

   386

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

   387

			rect = dirtyRects[n];

   388

   389

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

   390

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

   391

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

   392

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

   393

   394

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

   395

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

   396

   397

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

   398

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

   399

   400

			/* Blit dirty part of image */

   401

			clippedImage = CGImageCreateWithImageInRect(fullImage, clipRect);

   402

			CGContextDrawImage(viewContext, blitRect, clippedImage);

   403

			CGImageRelease(clippedImage);

   404

 		}

   405

 	}

   406

   407

	CGImageRelease(fullImage);

   408

}

   409

   410

@end

   411

   412

   413

extern const char _openttd_revision[];

   414

   415

   416

void WindowQuartzSubdriver::GetDeviceInfo()

   417

{

   418

	CFDictionaryRef    cur_mode;

   419

   420

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

   421

	cur_mode = CGDisplayCurrentMode(kCGDirectMainDisplay);

   422

   423

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

   424

	CFNumberGetValue(

   425

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

   426

		kCFNumberSInt32Type, &device_width

   427

	);

   428

   429

	CFNumberGetValue(

   430

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

   431

		kCFNumberSInt32Type, &device_height

   432

	);

   433

}

   434

   435

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

   436

{

   437

	char caption[50];

   438

	NSString *nsscaption;

   439

	unsigned int style;

   440

	NSRect contentRect;

   441

	BOOL isCustom = NO;

   442

	bool ret;

   443

   444

	setup = true;

   445

   446

	GetDeviceInfo();

   447

   448

	if (width > device_width)

   449

		width = device_width;

   450

	if (height > device_height)

   451

		height = device_height;

   452

   453

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

   454

   455

	/* Check if we should recreate the window */

   456

	if (window == nil) {

   457

		OTTD_QuartzWindowDelegate *delegate;

   458

   459

		/* Set the window style */

   460

		style = NSTitledWindowMask;

   461

		style |= (NSMiniaturizableWindowMask | NSClosableWindowMask);

   462

		style |= NSResizableWindowMask;

   463

   464

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

   465

		window = [ [ OTTD_QuartzWindow alloc ]

   466

						initWithContentRect: contentRect

   467

						styleMask: style

   468

						backing: NSBackingStoreBuffered

   469

						defer: NO ];

   470

   471

		if (window == nil) {

   472

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

   473

			setup = false;

   474

			return false;

   475

		}

   476

   477

		[ window setDriver:this ];

   478

   479

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

   480

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

   481

		[ window setTitle: nsscaption ];

   482

		[ window setMiniwindowTitle: nsscaption ];

   483

		[ nsscaption release ];

   484

   485

		[ window setAcceptsMouseMovedEvents: YES ];

   486

		[ window setViewsNeedDisplay: NO ];

   487

   488

		[ window useOptimizedDrawing: YES ];

   489

   490

		delegate = [ [ OTTD_QuartzWindowDelegate alloc ] init ];

   491

		[ delegate setDriver: this ];

   492

		[ window setDelegate: [ delegate autorelease ] ];

   493

	} else {

   494

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

   495

		if (!isCustom) {

   496

			[ window setContentSize: contentRect.size ];

   497

   498

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

   499

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

   500

   501

			if (qzview != nil) {

   502

				height = contentRect.size.height;

   503

				[ qzview setFrameSize: contentRect.size ];

   504

			}

   505

		}

   506

	}

   507

   508

	window_width = width;

   509

	window_height = height;

   510

   511

	[ window center ];

   512

   513

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

   514

	if (qzview == nil) {

   515

		qzview = [ [ OTTD_QuartzView alloc ] initWithFrame: contentRect ];

   516

		if (qzview == nil) {

   517

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

   518

			setup = false;

   519

			return false;

   520

		}

   521

   522

		[ qzview setDriver: this ];

   523

   524

		[ qzview setAutoresizingMask: NSViewWidthSizable | NSViewHeightSizable ];

   525

		[ window setContentView: qzview ];

   526

		[ qzview release ];

   527

		[ window makeKeyAndOrderFront:nil ];

   528

	}