6

 *  List available resolutions.                                               *

    37

#include "../../stdafx.h"

    38

#include "../../openttd.h"

    39

#include "../../debug.h"

    40

#include "../../macros.h"

    41

#include "../../os/macosx/splash.h"

    42

#include "../../variables.h"

    43

#include "../../gfx.h"

    46

#include "../../blitter/factory.hpp"

    47

#include "../../fileio.h"

    52

    53

class WindowQuickdrawSubdriver;

    57

@interface OTTD_QuartzWindow : NSWindow {

    58

	WindowQuickdrawSubdriver *driver;

    59

}

    60

    61

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

    62

    73

@interface OTTD_QuartzWindowDelegate : NSObject{

    74

	WindowQuickdrawSubdriver *driver;

    75

}

    76

    77

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

    78

    82

class WindowQuickdrawSubdriver: public CocoaSubdriver {

    83

	int device_width;

    84

	int device_height;

    85

	int device_depth;

    87

	int window_width;

    88

	int window_height;

    89

	int window_pitch;

    91

	int buffer_depth;

    93

	void *pixel_buffer;

    94

	void *window_buffer;

    98

	#define MAX_DIRTY_RECTS 100

   105

public:

   106

	bool active;

   107

	bool setup;

   109

	NSQuickDrawView *qdview;

   111

private:

   112

	void GetDeviceInfo();

   114

	bool SetVideoMode(int width, int height);

   115

   116

	/**

   117

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

   118

	 *

   119

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

   120

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

   121

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

   122

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

   123

	 */

   124

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

   125

   126

	/**

   127

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

   128

	 *

   129

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

   130

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

   131

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

   132

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

   133

	 */

   134

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

   135

   136

	/**

   137

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

   138

	 *

   139

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

   140

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

   141

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

   142

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

   143

	 */

   144

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

   145

   146

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

   147

	void DrawResizeIcon();

   150

public:

   151

	WindowQuickdrawSubdriver(int bpp);

   152

	virtual ~WindowQuickdrawSubdriver();

   154

	virtual void Draw();

   155

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

   156

	virtual void UpdatePalette(uint first_color, uint num_colors);

   158

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

   160

	virtual bool ChangeResolution(int w, int h);

   162

	virtual bool IsFullscreen() { return false; }

   164

	virtual int GetWidth() { return window_width; }

   165

	virtual int GetHeight() { return window_height; }

   166

	virtual void *GetPixelBuffer() { return pixel_buffer; }

   167

   168

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

   169

	virtual CGPoint PrivateLocalToCG(NSPoint* p);

   170

   171

	virtual NSPoint GetMouseLocation(NSEvent *event);

   172

	virtual bool MouseIsInsideView(NSPoint *pt);

   173

   174

	virtual bool IsActive() { return active; }

   175

   176

   177

	void SetPortAlphaOpaque();

   178

	bool WindowResized();

   182

@implementation OTTD_QuartzWindow

   184

- (void)setDriver:(WindowQuickdrawSubdriver*)drv

   186

	driver = drv;

   194

	driver->SetPortAlphaOpaque ();

   197

	driver->active = false;

   212

	driver->SetPortAlphaOpaque();

   215

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

   224

	driver->active = true;

   231

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

   232

	if (driver->setup) return;

   234

	if (!driver->WindowResized())

   235

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

   240

	driver->active = false;

   246

	driver->SetPortAlphaOpaque ();

   249

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

   257

	driver->active = true;

   279

- (void)setDriver:(WindowQuickdrawSubdriver*)drv

   280

{

   281

	driver = drv;

   282

}

   283

   293

	driver->active = true;

   298

	driver->active = false;

   303

	driver->active = true;

   308

	driver->active = false;

   314

static const int _resize_icon_width  = 16;

   315

static const int _resize_icon_height = 16;

   336

   337

   338

extern const char _openttd_revision[];

   339

   340

   341

void WindowQuickdrawSubdriver::GetDeviceInfo()

   343

	CFDictionaryRef    cur_mode;

   344

   345

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

   346

	cur_mode = CGDisplayCurrentMode(kCGDirectMainDisplay);

   347

   348

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

   349

	CFNumberGetValue(

   350

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

   351

		kCFNumberSInt32Type, &device_depth

   352

	);

   353

   354

	CFNumberGetValue(

   355

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

   356

		kCFNumberSInt32Type, &device_width

   357

	);

   358

   359

	CFNumberGetValue(

   360

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

   361

		kCFNumberSInt32Type, &device_height

   362

	);

   363

}

   364

   365

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

   366

{

   367

	char caption[50];

   368

	NSString *nsscaption;

   369

	unsigned int style;

   370

	NSRect contentRect;

   371

	BOOL isCustom = NO;

   372

	bool ret;

   373

   374

	setup = true;

   375

   376

	GetDeviceInfo();

   377

   378

	if (buffer_depth > device_depth) {

   379

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

   380

		setup = false;

   381

		return false;

   382

	}

   383

   384

	if (width > device_width)

   385

		width = device_width;

   386

	if (height > device_height)

   387

		height = device_height;

   388

   389

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

   390

   391

	/* Check if we should recreate the window */

   392

	if (window == nil) {

   393

		OTTD_QuartzWindowDelegate *delegate;

   394

   395

		/* Set the window style */

   396

		style = NSTitledWindowMask;

   397

		style |= (NSMiniaturizableWindowMask | NSClosableWindowMask);

   398

		style |= NSResizableWindowMask;

   399

   400

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

   401

		window = [ [ OTTD_QuartzWindow alloc ]

   402

						initWithContentRect:contentRect

   403

						styleMask:style

   404

						backing:NSBackingStoreBuffered

   405

						defer:NO ];

   406

   407

		if (window == nil) {

   408

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

   409

			setup = false;

   410

			return false;

   411

		}

   412

   413

		[ window setDriver:this ];

   414

   415

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

   416

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

   417

		[ window setTitle:nsscaption ];

   418

		[ window setMiniwindowTitle:nsscaption ];

   419

		[ nsscaption release ];

   420

   421

		[ window setAcceptsMouseMovedEvents:YES ];

   422

		[ window setViewsNeedDisplay:NO ];

   423

   424

		delegate = [ [ OTTD_QuartzWindowDelegate alloc ] init ];

   425

		[ delegate setDriver:this ];

   426

		[ window setDelegate: [ delegate autorelease ] ];

   427

	} else {

   428

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

   429

		if (!isCustom) {

   430

			[ window setContentSize:contentRect.size ];

   431

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

   432

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

   433

			height = contentRect.size.height;

   434

			[ qdview setFrameSize:contentRect.size ];

   435

		}

   436

	}

   437

   438

	// Update again

   439

	window_width = width;

   440

	window_height = height;

   441

   442

	[ window center ];

   443

   444

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

   445

	if (qdview == nil) {

   446

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

   447

		if (qdview == nil) {

   448

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

   449

			setup = false;

   450

			return false;

   451

		}

   452

   453

		[ qdview setAutoresizingMask: NSViewWidthSizable | NSViewHeightSizable ];

   454

		[ [ window contentView ] addSubview:qdview ];

   455

		[ qdview release ];

   456

		[ window makeKeyAndOrderFront:nil ];

   457

	}

   458

   459

	ret = WindowResized();

   460

   461

	UpdatePalette(0, 256);

   462

   463

	setup = false;

   464

   465

	return ret;

   466

}

   467

   468

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

   469

{

   470

	const uint32* src   = (uint32*)pixel_buffer;

   471

	uint32*       dst   = (uint32*)window_buffer;

   472

	uint          width = window_width;

   473

	uint          pitch = window_pitch / 4;

   474

	int y;

   475

   476

   477

	dst += top * pitch + left;

   478

	src += top * width + left;

   479

   480

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

   481

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

   482

	}

   483

}

   484

   485

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

   486

{

   487

	const uint32* pal   = palette32;

   488

	const uint8*  src   = (uint8*)pixel_buffer;

   489

	uint32*       dst   = (uint32*)window_buffer;

   490

	uint          width = window_width;

   491

	uint          pitch = window_pitch / 4;

   495

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

   496

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

   497

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