Corrected tile rendering problem introduced by the change to record the drawing chang...

[hengbandforosx/hengbandosx.git] / src / main-cocoa.m

/**
 * \file main-cocoa.m
 * \brief OS X front end
 *
 * Copyright (c) 2011 Peter Ammon
 *
 * This work is free software; you can redistribute it and/or modify it
 * under the terms of either:
 *
 * a) the GNU General Public License as published by the Free Software
 *    Foundation, version 2, or
 *
 * b) the "Angband licence":
 *    This software may be copied and distributed for educational, research,
 *    and not for profit purposes provided that this copyright and statement
 *    are included in all such copies.  Other copyrights may also apply.
 */

#include "angband.h"
/* This is not included in angband.h in Hengband. */
#include "grafmode.h"

#if defined(MACH_O_COCOA)

/* Mac headers */
#include <Cocoa/Cocoa.h>
//#include <Carbon/Carbon.h> /* For keycodes */
/* Hack - keycodes to enable compiling in macOS 10.14 */
#define kVK_Return 0x24
#define kVK_Tab    0x30
#define kVK_Delete 0x33
#define kVK_Escape 0x35
#define kVK_ANSI_KeypadEnter 0x4C

static NSString * const AngbandDirectoryNameLib = @"lib";
static NSString * const AngbandDirectoryNameBase = @"Hengband";

static NSString * const AngbandMessageCatalog = @"Localizable";
static NSString * const AngbandTerminalsDefaultsKey = @"Terminals";
static NSString * const AngbandTerminalRowsDefaultsKey = @"Rows";
static NSString * const AngbandTerminalColumnsDefaultsKey = @"Columns";
static NSString * const AngbandTerminalVisibleDefaultsKey = @"Visible";
static NSString * const AngbandGraphicsDefaultsKey = @"GraphicsID";
static NSString * const AngbandFrameRateDefaultsKey = @"FramesPerSecond";
static NSString * const AngbandSoundDefaultsKey = @"AllowSound";
static NSInteger const AngbandWindowMenuItemTagBase = 1000;
static NSInteger const AngbandCommandMenuItemTagBase = 2000;

/* We can blit to a large layer or image and then scale it down during live
 * resize, which makes resizing much faster, at the cost of some image quality
 * during resizing */
#ifndef USE_LIVE_RESIZE_CACHE
# define USE_LIVE_RESIZE_CACHE 1
#endif

/* Global defines etc from Angband 3.5-dev - NRM */
#define ANGBAND_TERM_MAX 8

static bool new_game = TRUE;

#define MAX_COLORS 256
#define MSG_MAX SOUND_MAX

/* End Angband stuff - NRM */

/* Application defined event numbers */
enum
{
    AngbandEventWakeup = 1
};

/* Redeclare some 10.7 constants and methods so we can build on 10.6 */
enum
{
    Angband_NSWindowCollectionBehaviorFullScreenPrimary = 1 << 7,
    Angband_NSWindowCollectionBehaviorFullScreenAuxiliary = 1 << 8
};

@interface NSWindow (AngbandLionRedeclares)
- (void)setRestorable:(BOOL)flag;
@end

/* Delay handling of pre-emptive "quit" event */
static BOOL quit_when_ready = FALSE;

/* Set to indicate the game is over and we can quit without delay */
static Boolean game_is_finished = FALSE;

/* Our frames per second (e.g. 60). A value of 0 means unthrottled. */
static int frames_per_second;

/* Function to get the default font */
static NSFont *default_font;

@class AngbandView;

/*
 * To handle fonts where an individual glyph's bounding box can extend into
 * neighboring columns, Term_curs_cocoa(), Term_pict_cocoa(),
 * Term_text_cocoa(), and Term_wipe_cocoa() merely record what needs to be
 * done with the actual drawing happening in response to the notification to
 * flush all rows, the TERM_XTRA_FRESH case in Term_xtra_cocoa().  Can not use
 * the TERM_XTRA_FROSH notification (the per-row flush), since with a software
 * cursor, there are calls to Term_pict_cocoa(), Term_text_cocoa(), or
 * Term_wipe_cocoa() to take care of the old cursor position which are not
 * followed by a row flush.
 */
enum PendingCellChangeType {
    CELL_CHANGE_NONE = 0,
    CELL_CHANGE_WIPE,
    CELL_CHANGE_TEXT,
    CELL_CHANGE_PICT
};
struct PendingCellChange {
    /*
     * For text rendering, stores the character as a wchar_t; for tile
     * rendering, stores the column in the tile set for the source tile.
     */
    union { wchar_t w; char c; } c;
    /*
     * For text rendering, stores the color; for tile rendering, stores the
     * row in the tile set for the source tile.
     */
    TERM_COLOR a;
    /*
     * For text rendering, is one if wc is a character that takes up two
     * columns (i.e. Japanese kanji); otherwise it is zero.  For tile
     * rendering, Stores the column in the tile set for the terrain tile. */
    char tcol;
    /*
     * For tile rendering, stores the row in the tile set for the
     * terrain tile.
     */
    TERM_COLOR trow;
    enum PendingCellChangeType change_type;
};

struct PendingRowChange
{
    /*
     * These are the first and last columns, inclusive, that have been
     * modified.  xmin is greater than xmax if no changes have been made.
     */
    int xmin, xmax;
    /*
     * This points to storage for a number of elements equal to the number
     * of columns (implicitly gotten from the enclosing AngbandContext).
     */
    struct PendingCellChange* cell_changes;
};

static struct PendingRowChange* create_row_change(int ncol)
{
    struct PendingRowChange* prc =
        (struct PendingRowChange*) malloc(sizeof(struct PendingRowChange));
    struct PendingCellChange* pcc = (struct PendingCellChange*)
        malloc(ncol * sizeof(struct PendingCellChange));
    int i;

    if (prc == 0 || pcc == 0) {
        if (pcc != 0) {
            free(pcc);
        }
        if (prc != 0) {
            free(prc);
        }
        return 0;
    }

    prc->xmin = ncol;
    prc->xmax = -1;
    prc->cell_changes = pcc;
    for (i = 0; i < ncol; ++i) {
        pcc[i].change_type = CELL_CHANGE_NONE;
    }
    return prc;
}


static void destroy_row_change(struct PendingRowChange* prc)
{
    if (prc != 0) {
        if (prc->cell_changes != 0) {
            free(prc->cell_changes);
        }
        free(prc);
    }
}


struct PendingChanges
{
    /* Hold the number of rows specified at creation. */
    int nrow;
    /*
     * Hold the position set for the software cursor.  Use negative indices
     * to indicate that the cursor is not displayed.
     */
    int xcurs, ycurs;
    /* Is nonzero if the cursor should be drawn at double the tile width. */
    int bigcurs;
    /* Record whether the changes include any text, picts, or wipes. */
    int has_text, has_pict, has_wipe;
    /*
     * These are the first and last rows, inclusive, that have been
     * modified.  ymin is greater than ymax if no changes have been made.
     */
    int ymin, ymax;
    /*
     * This is an array of pointers to the changes.  The number of elements
     * is the number of rows.  An element will be a NULL pointer if no
     * modifications have been made to the row.
     */
    struct PendingRowChange** rows;
};


static struct PendingChanges* create_pending_changes(int ncol, int nrow)
{
    struct PendingChanges* pc =
        (struct PendingChanges*) malloc(sizeof(struct PendingChanges));
    struct PendingRowChange** pprc = (struct PendingRowChange**)
        malloc(nrow * sizeof(struct PendingRowChange*));
    int i;

    if (pc == 0 || pprc == 0) {
        if (pprc != 0) {
            free(pprc);
        }
        if (pc != 0) {
            free(pc);
        }
        return 0;
    }

    pc->nrow = nrow;
    pc->xcurs = -1;
    pc->ycurs = -1;
    pc->bigcurs = 0;
    pc->has_text = 0;
    pc->has_pict = 0;
    pc->has_wipe = 0;
    pc->ymin = nrow;
    pc->ymax = -1;
    pc->rows = pprc;
    for (i = 0; i < nrow; ++i) {
        pprc[i] = 0;
    }
    return pc;
}


static void destroy_pending_changes(struct PendingChanges* pc)
{
    if (pc != 0) {
        if (pc->rows != 0) {
            int i;

            for (i = 0; i < pc->nrow; ++i) {
                if (pc->rows[i] != 0) {
                    destroy_row_change(pc->rows[i]);
                }
            }
            free(pc->rows);
        }
        free(pc);
    }
}


static void clear_pending_changes(struct PendingChanges* pc)
{
    pc->xcurs = -1;
    pc->ycurs = -1;
    pc->bigcurs = 0;
    pc->has_text = 0;
    pc->has_pict = 0;
    pc->has_wipe = 0;
    pc->ymin = pc->nrow;
    pc->ymax = -1;
    if (pc->rows != 0) {
        int i;

        for (i = 0; i < pc->nrow; ++i) {
            if (pc->rows[i] != 0) {
                destroy_row_change(pc->rows[i]);
                pc->rows[i] = 0;
            }
        }
    }
}


/* Return zero if successful; otherwise return a nonzero value. */
static int resize_pending_changes(struct PendingChanges* pc, int nrow)
{
    struct PendingRowChange** pprc;
    int i;

    if (pc == 0) {
        return 1;
    }

    pprc = (struct PendingRowChange**)
        malloc(nrow * sizeof(struct PendingRowChange*));
    if (pprc == 0) {
        return 1;
    }
    for (i = 0; i < nrow; ++i) {
        pprc[i] = 0;
    }

    if (pc->rows != 0) {
        for (i = 0; i < pc->nrow; ++i) {
            if (pc->rows[i] != 0) {
                destroy_row_change(pc->rows[i]);
            }
        }
        free(pc->rows);
    }
    pc->nrow = nrow;
    pc->xcurs = -1;
    pc->ycurs = -1;
    pc->bigcurs = 0;
    pc->has_text = 0;
    pc->has_pict = 0;
    pc->has_wipe = 0;
    pc->ymin = nrow;
    pc->ymax = -1;
    pc->rows = pprc;
    return 0;
}


/* The max number of glyphs we support.  Currently this only affects
 * updateGlyphInfo() for the calculation of the tile size, fontAscender,
 * fontDescender, ncol_pre, and ncol_post (the glyphArray and glyphWidths
 * members of AngbandContext are only used in updateGlyphInfo()).  The
 * rendering in drawWChar will work for glyphs not in updateGlyphInfo()'s
 * set, and that is used for rendering Japanese characters.
 */
#define GLYPH_COUNT 256

/* An AngbandContext represents a logical Term (i.e. what Angband thinks is
 * a window). This typically maps to one NSView, but may map to more than one
 * NSView (e.g. the Test and real screen saver view). */
@interface AngbandContext : NSObject <NSWindowDelegate>
{
@public
    
    /* The Angband term */
    term *terminal;
    
    /* Column and row cont, by default 80 x 24 */
    size_t cols;
    size_t rows;
    
    /* The size of the border between the window edge and the contents */
    NSSize borderSize;
    
    /* Our array of views */
    NSMutableArray *angbandViews;
    
    /* The buffered image */
    CGLayerRef angbandLayer;

    /* The font of this context */
    NSFont *angbandViewFont;
    
    /* If this context owns a window, here it is */
    NSWindow *primaryWindow;
    
    /* "Glyph info": an array of the CGGlyphs and their widths corresponding to
         * the above font. */
    CGGlyph glyphArray[GLYPH_COUNT];
    CGFloat glyphWidths[GLYPH_COUNT];
    
    /* The size of one tile */
    NSSize tileSize;
    
    /* Font's ascender and descender */
    CGFloat fontAscender, fontDescender;
    
    /* Whether we are currently in live resize, which affects how big we render
         * our image */
    int inLiveResize;
    
    /* Last time we drew, so we can throttle drawing */
    CFAbsoluteTime lastRefreshTime;

    struct PendingChanges* changes;
    /*
     * These are the number of columns before or after, respectively, a text
     * change that may need to be redrawn.
     */
    int ncol_pre, ncol_post;

@private

    BOOL _hasSubwindowFlags;
    BOOL _windowVisibilityChecked;
}

@property (nonatomic, assign) BOOL hasSubwindowFlags;
@property (nonatomic, assign) BOOL windowVisibilityChecked;

- (void)drawRect:(NSRect)rect inView:(NSView *)view;

/* Called at initialization to set the term */
- (void)setTerm:(term *)t;

/* Called when the context is going down. */
- (void)dispose;

/* Returns the size of the image. */
- (NSSize)imageSize;

/* Return the rect for a tile at given coordinates. */
- (NSRect)rectInImageForTileAtX:(int)x Y:(int)y;

/* Draw the given wide character into the given tile rect. */
- (void)drawWChar:(wchar_t)wchar inRect:(NSRect)tile context:(CGContextRef)ctx;

/* Locks focus on the Angband image, and scales the CTM appropriately. */
- (CGContextRef)lockFocus;

/* Locks focus on the Angband image but does NOT scale the CTM. Appropriate
 * for drawing hairlines. */
- (CGContextRef)lockFocusUnscaled;

/* Unlocks focus. */
- (void)unlockFocus;

/* Returns the primary window for this angband context, creating it if
 * necessary */
- (NSWindow *)makePrimaryWindow;

/* Called to add a new Angband view */
- (void)addAngbandView:(AngbandView *)view;

/* Make the context aware that one of its views changed size */
- (void)angbandViewDidScale:(AngbandView *)view;

/* Handle becoming the main window */
- (void)windowDidBecomeMain:(NSNotification *)notification;

/* Return whether the context's primary window is ordered in or not */
- (BOOL)isOrderedIn;

/* Return whether the context's primary window is key */
- (BOOL)isMainWindow;

/* Invalidate the whole image */
- (void)setNeedsDisplay:(BOOL)val;

/* Invalidate part of the image, with the rect expressed in base coordinates */
- (void)setNeedsDisplayInBaseRect:(NSRect)rect;

/* Display (flush) our Angband views */
- (void)displayIfNeeded;

/* Resize context to size of contentRect, and optionally save size to
 * defaults */
- (void)resizeTerminalWithContentRect: (NSRect)contentRect saveToDefaults: (BOOL)saveToDefaults;

/* Change the minimum size for the window associated with the context. */
- (void)setMinimumWindowSize;

/* Called from the view to indicate that it is starting or ending live resize */
- (void)viewWillStartLiveResize:(AngbandView *)view;
- (void)viewDidEndLiveResize:(AngbandView *)view;
- (void)saveWindowVisibleToDefaults: (BOOL)windowVisible;
- (BOOL)windowVisibleUsingDefaults;

/* Class methods */

/* Begins an Angband game. This is the entry point for starting off. */
+ (void)beginGame;

/* Ends an Angband game. */
+ (void)endGame;

/* Internal method */
- (AngbandView *)activeView;

@end

/**
 * Generate a mask for the subwindow flags. The mask is just a safety check to
 * make sure that our windows show and hide as expected.  This function allows
 * for future changes to the set of flags without needed to update it here
 * (unless the underlying types change).
 */
u32b AngbandMaskForValidSubwindowFlags(void)
{
    int windowFlagBits = sizeof(*(window_flag)) * CHAR_BIT;
    int maxBits = MIN( 16, windowFlagBits );
    u32b mask = 0;

    for( int i = 0; i < maxBits; i++ )
    {
        if( window_flag_desc[i] != NULL )
        {
            mask |= (1 << i);
        }
    }

    return mask;
}

/**
 * Check for changes in the subwindow flags and update window visibility.
 * This seems to be called for every user event, so we don't
 * want to do any unnecessary hiding or showing of windows.
 */
static void AngbandUpdateWindowVisibility(void)
{
    /* Because this function is called frequently, we'll make the mask static.
         * It doesn't change between calls, as the flags themselves are hardcoded */
    static u32b validWindowFlagsMask = 0;

    if( validWindowFlagsMask == 0 )
    {
        validWindowFlagsMask = AngbandMaskForValidSubwindowFlags();
    }

    /* Loop through all of the subwindows and see if there is a change in the
         * flags. If so, show or hide the corresponding window. We don't care about
         * the flags themselves; we just want to know if any are set. */
    for( int i = 1; i < ANGBAND_TERM_MAX; i++ )
    {
        AngbandContext *angbandContext = angband_term[i]->data;

        if( angbandContext == nil )
        {
            continue;
        }

        /* This horrible mess of flags is so that we can try to maintain some
                 * user visibility preference. This should allow the user a window and
                 * have it stay closed between application launches. However, this
                 * means that when a subwindow is turned on, it will no longer appear
                 * automatically. Angband has no concept of user control over window
                 * visibility, other than the subwindow flags. */
        if( !angbandContext.windowVisibilityChecked )
        {
            if( [angbandContext windowVisibleUsingDefaults] )
            {
                [angbandContext->primaryWindow orderFront: nil];
                angbandContext.windowVisibilityChecked = YES;
            }
            else
            {
                [angbandContext->primaryWindow close];
                angbandContext.windowVisibilityChecked = NO;
            }
        }
        else
        {
            BOOL termHasSubwindowFlags = ((window_flag[i] & validWindowFlagsMask) > 0);

            if( angbandContext.hasSubwindowFlags && !termHasSubwindowFlags )
            {
                [angbandContext->primaryWindow close];
                angbandContext.hasSubwindowFlags = NO;
                [angbandContext saveWindowVisibleToDefaults: NO];
            }
            else if( !angbandContext.hasSubwindowFlags && termHasSubwindowFlags )
            {
                [angbandContext->primaryWindow orderFront: nil];
                angbandContext.hasSubwindowFlags = YES;
                [angbandContext saveWindowVisibleToDefaults: YES];
            }
        }
    }

    /* Make the main window key so that user events go to the right spot */
    AngbandContext *mainWindow = angband_term[0]->data;
    [mainWindow->primaryWindow makeKeyAndOrderFront: nil];
}

/**
 * ------------------------------------------------------------------------
 * Graphics support
 * ------------------------------------------------------------------------ */

/**
 * The tile image
 */
static CGImageRef pict_image;

/**
 * Numbers of rows and columns in a tileset,
 * calculated by the PICT/PNG loading code
 */
static int pict_cols = 0;
static int pict_rows = 0;

/**
 * Requested graphics mode (as a grafID).
 * The current mode is stored in current_graphics_mode.
 */
static int graf_mode_req = 0;

/**
 * Helper function to check the various ways that graphics can be enabled,
 * guarding against NULL
 */
static BOOL graphics_are_enabled(void)
{
    return current_graphics_mode
        && current_graphics_mode->grafID != GRAPHICS_NONE;
}

/**
 * Hack -- game in progress
 */
static Boolean game_in_progress = FALSE;


#pragma mark Prototypes
static void wakeup_event_loop(void);
static void hook_plog(const char *str);
static void hook_quit(const char * str);
static void load_prefs(void);
static void load_sounds(void);
static void init_windows(void);
static void handle_open_when_ready(void);
static void play_sound(int event);
static BOOL check_events(int wait);
static BOOL send_event(NSEvent *event);
static void record_current_savefile(void);
#ifdef JP
static wchar_t convert_two_byte_eucjp_to_utf16_native(const char *cp);
#endif

/**
 * Available values for 'wait'
 */
#define CHECK_EVENTS_DRAIN -1
#define CHECK_EVENTS_NO_WAIT    0
#define CHECK_EVENTS_WAIT 1


/**
 * Note when "open"/"new" become valid
 */
static bool initialized = FALSE;

/* Methods for getting the appropriate NSUserDefaults */
@interface NSUserDefaults (AngbandDefaults)
+ (NSUserDefaults *)angbandDefaults;
@end

@implementation NSUserDefaults (AngbandDefaults)
+ (NSUserDefaults *)angbandDefaults
{
    return [NSUserDefaults standardUserDefaults];
}
@end

/* Methods for pulling images out of the Angband bundle (which may be separate
 * from the current bundle in the case of a screensaver */
@interface NSImage (AngbandImages)
+ (NSImage *)angbandImage:(NSString *)name;
@end

/* The NSView subclass that draws our Angband image */
@interface AngbandView : NSView
{
    IBOutlet AngbandContext *angbandContext;
}

- (void)setAngbandContext:(AngbandContext *)context;
- (AngbandContext *)angbandContext;

@end

@implementation NSImage (AngbandImages)

/* Returns an image in the resource directoy of the bundle containing the
 * Angband view class. */
+ (NSImage *)angbandImage:(NSString *)name
{
    NSBundle *bundle = [NSBundle bundleForClass:[AngbandView class]];
    NSString *path = [bundle pathForImageResource:name];
    NSImage *result;
    if (path) result = [[[NSImage alloc] initByReferencingFile:path] autorelease];
    else result = nil;
    return result;
}

@end


@implementation AngbandContext

@synthesize hasSubwindowFlags=_hasSubwindowFlags;
@synthesize windowVisibilityChecked=_windowVisibilityChecked;

- (NSFont *)selectionFont
{
    return angbandViewFont;
}

- (BOOL)useLiveResizeOptimization
{
    /* If we have graphics turned off, text rendering is fast enough that we
         * don't need to use a live resize optimization. */
    return inLiveResize && graphics_are_enabled();
}

- (NSSize)baseSize
{
    /* We round the base size down. If we round it up, I believe we may end up
         * with pixels that nobody "owns" that may accumulate garbage. In general
         * rounding down is harmless, because any lost pixels may be sopped up by
         * the border. */
    return NSMakeSize(floor(cols * tileSize.width + 2 * borderSize.width), floor(rows * tileSize.height + 2 * borderSize.height));
}

/* qsort-compatible compare function for CGSizes */
static int compare_advances(const void *ap, const void *bp)
{
    const CGSize *a = ap, *b = bp;
    return (a->width > b->width) - (a->width < b->width);
}

- (void)updateGlyphInfo
{
    /* Update glyphArray and glyphWidths */
    NSFont *screenFont = [angbandViewFont screenFont];

    /* Generate a string containing each MacRoman character */
    unsigned char latinString[GLYPH_COUNT];
    size_t i;
    for (i=0; i < GLYPH_COUNT; i++) latinString[i] = (unsigned char)i;
    
    /* Turn that into unichar. Angband uses ISO Latin 1. */
    unichar unicharString[GLYPH_COUNT] = {0};
    NSString *allCharsString = [[NSString alloc] initWithBytes:latinString length:sizeof latinString encoding:NSISOLatin1StringEncoding];
    [allCharsString getCharacters:unicharString range:NSMakeRange(0, MIN(GLYPH_COUNT, [allCharsString length]))];
    [allCharsString autorelease];
    
    /* Get glyphs */
    memset(glyphArray, 0, sizeof glyphArray);
    CTFontGetGlyphsForCharacters((CTFontRef)screenFont, unicharString, glyphArray, GLYPH_COUNT);
    
    /* Get advances. Record the max advance. */
    CGSize advances[GLYPH_COUNT] = {};
    CTFontGetAdvancesForGlyphs((CTFontRef)screenFont, kCTFontHorizontalOrientation, glyphArray, advances, GLYPH_COUNT);
    for (i=0; i < GLYPH_COUNT; i++) {
        glyphWidths[i] = advances[i].width;
    }
    
    /* For good non-mono-font support, use the median advance. Start by sorting
         * all advances. */
    qsort(advances, GLYPH_COUNT, sizeof *advances, compare_advances);
    
    /* Skip over any initially empty run */
    size_t startIdx;
    for (startIdx = 0; startIdx < GLYPH_COUNT; startIdx++)
    {
        if (advances[startIdx].width > 0) break;
    }
    
    /* Pick the center to find the median */
    CGFloat medianAdvance = 0;
    if (startIdx < GLYPH_COUNT)
    {
                /* In case we have all zero advances for some reason */
        medianAdvance = advances[(startIdx + GLYPH_COUNT)/2].width;
    }
    
    /*
     * Record the ascender and descender.  Some fonts, for instance DIN
     * Condensed and Rockwell in 10.14, the ascent on '@' exceeds that
     * reported by [screenFont ascender].  Get the overall bounding box
     * for the glyphs and use that instead of the ascender and descender
     * values if the bounding box result extends farther from the baseline.
     */
    CGRect bounds = CTFontGetBoundingRectsForGlyphs((CTFontRef) screenFont, kCTFontHorizontalOrientation, glyphArray, NULL, GLYPH_COUNT);
    fontAscender = [screenFont ascender];
    if (fontAscender < bounds.origin.y + bounds.size.height) {
        fontAscender = bounds.origin.y + bounds.size.height;
    }
    fontDescender = [screenFont descender];
    if (fontDescender > bounds.origin.y) {
        fontDescender = bounds.origin.y;
    }

    /*
     * Record the tile size.  Round both values up to have tile boundaries
     * match pixel boundaries.
     */
    tileSize.width = ceil(medianAdvance);
    tileSize.height = ceil(fontAscender - fontDescender);

    /*
     * Determine whether neighboring columns need to redrawn when a character
     * changes.
     */
    CGRect boxes[GLYPH_COUNT] = {};
    CGFloat beyond_right = 0.;
    CGFloat beyond_left = 0.;
    CTFontGetBoundingRectsForGlyphs(
        (CTFontRef)screenFont,
        kCTFontHorizontalOrientation,
        glyphArray,
        boxes,
        GLYPH_COUNT);
    for (i = 0; i < GLYPH_COUNT; i++) {
        /* Account for the compression and offset used by drawWChar(). */
        CGFloat compression, offset;
        CGFloat v;

        if (glyphWidths[i] <= tileSize.width) {
            compression = 1.;
            offset = 0.5 * (tileSize.width - glyphWidths[i]);
        } else {
            compression = tileSize.width / glyphWidths[i];
            offset = 0.;
        }
        v = (offset + boxes[i].origin.x) * compression;
        if (beyond_left > v) {
            beyond_left = v;
        }
        v = (offset + boxes[i].origin.x + boxes[i].size.width) * compression;
        if (beyond_right < v) {
            beyond_right = v;
        }
    }
    ncol_pre = ceil(-beyond_left / tileSize.width);
    if (beyond_right > tileSize.width) {
        ncol_post = ceil((beyond_right - tileSize.width) / tileSize.width);
    } else {
        ncol_post = 0;
    }
}

- (void)updateImage
{
    NSSize size = NSMakeSize(1, 1);
    
    AngbandView *activeView = [self activeView];
    if (activeView)
    {
        /* If we are in live resize, draw as big as the screen, so we can scale
                 * nicely to any size. If we are not in live resize, then use the
                 * bounds of the active view. */
        NSScreen *screen;
        if ([self useLiveResizeOptimization] && (screen = [[activeView window] screen]) != NULL)
        {
            size = [screen frame].size;
        }
        else
        {
            size = [activeView bounds].size;
        }
    }

    CGLayerRelease(angbandLayer);
    
    /* Use the highest monitor scale factor on the system to work out what
     * scale to draw at - not the recommended method, but works where we
     * can't easily get the monitor the current draw is occurring on. */
    float angbandLayerScale = 1.0;
    if ([[NSScreen mainScreen] respondsToSelector:@selector(backingScaleFactor)]) {
        for (NSScreen *screen in [NSScreen screens]) {
            angbandLayerScale = fmax(angbandLayerScale, [screen backingScaleFactor]);
        }
    }

    /* Make a bitmap context as an example for our layer */
    CGColorSpaceRef cs = CGColorSpaceCreateDeviceRGB();
    CGContextRef exampleCtx = CGBitmapContextCreate(NULL, 1, 1, 8 /* bits per component */, 48 /* bytesPerRow */, cs, kCGImageAlphaNoneSkipFirst | kCGBitmapByteOrder32Host);
    CGColorSpaceRelease(cs);

    /* Create the layer at the appropriate size */
    size.width = fmax(1, ceil(size.width * angbandLayerScale));
    size.height = fmax(1, ceil(size.height * angbandLayerScale));
    angbandLayer = CGLayerCreateWithContext(exampleCtx, *(CGSize *)&size, NULL);

    CFRelease(exampleCtx);

    /* Set the new context of the layer to draw at the correct scale */
    CGContextRef ctx = CGLayerGetContext(angbandLayer);
    CGContextScaleCTM(ctx, angbandLayerScale, angbandLayerScale);

    [self lockFocus];
    [[NSColor blackColor] set];
    NSRectFill((NSRect){NSZeroPoint, [self baseSize]});
    [self unlockFocus];
}

- (void)requestRedraw
{
    if (! self->terminal) return;
    
    term *old = Term;
    
    /* Activate the term */
    Term_activate(self->terminal);
    
    /* Redraw the contents */
    Term_redraw();
    
    /* Flush the output */
    Term_fresh();
    
    /* Restore the old term */
    Term_activate(old);
}

- (void)setTerm:(term *)t
{
    terminal = t;
}

- (void)viewWillStartLiveResize:(AngbandView *)view
{
#if USE_LIVE_RESIZE_CACHE
    if (inLiveResize < INT_MAX) inLiveResize++;
    else [NSException raise:NSInternalInconsistencyException format:@"inLiveResize overflow"];
    
    if (inLiveResize == 1 && graphics_are_enabled())
    {
        [self updateImage];
        
        [self setNeedsDisplay:YES]; /* We'll need to redisplay everything anyways, so avoid creating all those little redisplay rects */
        [self requestRedraw];
    }
#endif
}

- (void)viewDidEndLiveResize:(AngbandView *)view
{
#if USE_LIVE_RESIZE_CACHE
    if (inLiveResize > 0) inLiveResize--;
    else [NSException raise:NSInternalInconsistencyException format:@"inLiveResize underflow"];
    
    if (inLiveResize == 0 && graphics_are_enabled())
    {
        [self updateImage];
        
        [self setNeedsDisplay:YES]; /* We'll need to redisplay everything anyways, so avoid creating all those little redisplay rects */
        [self requestRedraw];
    }
#endif
}

/**
 * If we're trying to limit ourselves to a certain number of frames per second,
 * then compute how long it's been since we last drew, and then wait until the
 * next frame has passed. */
- (void)throttle
{
    if (frames_per_second > 0)
    {
        CFAbsoluteTime now = CFAbsoluteTimeGetCurrent();
        CFTimeInterval timeSinceLastRefresh = now - lastRefreshTime;
        CFTimeInterval timeUntilNextRefresh = (1. / (double)frames_per_second) - timeSinceLastRefresh;
        
        if (timeUntilNextRefresh > 0)
        {
            usleep((unsigned long)(timeUntilNextRefresh * 1000000.));
        }
    }
    lastRefreshTime = CFAbsoluteTimeGetCurrent();
}

- (void)drawWChar:(wchar_t)wchar inRect:(NSRect)tile context:(CGContextRef)ctx
{
    CGFloat tileOffsetY = fontAscender;
    CGFloat tileOffsetX = 0.0;
    NSFont *screenFont = [angbandViewFont screenFont];
    UniChar unicharString[2] = {(UniChar)wchar, 0};

    /* Get glyph and advance */
    CGGlyph thisGlyphArray[1] = { 0 };
    CGSize advances[1] = { { 0, 0 } };
    CTFontGetGlyphsForCharacters((CTFontRef)screenFont, unicharString, thisGlyphArray, 1);
    CGGlyph glyph = thisGlyphArray[0];
    CTFontGetAdvancesForGlyphs((CTFontRef)screenFont, kCTFontHorizontalOrientation, thisGlyphArray, advances, 1);
    CGSize advance = advances[0];
    
    /* If our font is not monospaced, our tile width is deliberately not big
         * enough for every character. In that event, if our glyph is too wide, we
         * need to compress it horizontally. Compute the compression ratio.
         * 1.0 means no compression. */
    double compressionRatio;
    if (advance.width <= NSWidth(tile))
    {
        /* Our glyph fits, so we can just draw it, possibly with an offset */
        compressionRatio = 1.0;
        tileOffsetX = (NSWidth(tile) - advance.width)/2;
    }
    else
    {
        /* Our glyph doesn't fit, so we'll have to compress it */
        compressionRatio = NSWidth(tile) / advance.width;
        tileOffsetX = 0;
    }

    
    /* Now draw it */
    CGAffineTransform textMatrix = CGContextGetTextMatrix(ctx);
    CGFloat savedA = textMatrix.a;

    /* Set the position */
    textMatrix.tx = tile.origin.x + tileOffsetX;
    textMatrix.ty = tile.origin.y + tileOffsetY;

    /* Maybe squish it horizontally. */
    if (compressionRatio != 1.)
    {
        textMatrix.a *= compressionRatio;
    }

    textMatrix = CGAffineTransformScale( textMatrix, 1.0, -1.0 );
    CGContextSetTextMatrix(ctx, textMatrix);
    CGContextShowGlyphsAtPositions(ctx, &glyph, &CGPointZero, 1);
    
    /* Restore the text matrix if we messed with the compression ratio */
    if (compressionRatio != 1.)
    {
        textMatrix.a = savedA;
        CGContextSetTextMatrix(ctx, textMatrix);
    }

    textMatrix = CGAffineTransformScale( textMatrix, 1.0, -1.0 );
    CGContextSetTextMatrix(ctx, textMatrix);
}

/* Lock and unlock focus on our image or layer, setting up the CTM
 * appropriately. */
- (CGContextRef)lockFocusUnscaled
{
    /* Create an NSGraphicsContext representing this CGLayer */
    CGContextRef ctx = CGLayerGetContext(angbandLayer);
    NSGraphicsContext *context = [NSGraphicsContext graphicsContextWithGraphicsPort:ctx flipped:NO];
    [NSGraphicsContext saveGraphicsState];
    [NSGraphicsContext setCurrentContext:context];
    CGContextSaveGState(ctx);
    return ctx;
}

- (void)unlockFocus
{
    /* Restore the graphics state */
    CGContextRef ctx = [[NSGraphicsContext currentContext] graphicsPort];
    CGContextRestoreGState(ctx);
    [NSGraphicsContext restoreGraphicsState];
}

- (NSSize)imageSize
{
    /* Return the size of our layer */
    CGSize result = CGLayerGetSize(angbandLayer);
    return NSMakeSize(result.width, result.height);
}

- (CGContextRef)lockFocus
{
    return [self lockFocusUnscaled];
}


- (NSRect)rectInImageForTileAtX:(int)x Y:(int)y
{
    int flippedY = y;
    return NSMakeRect(x * tileSize.width + borderSize.width, flippedY * tileSize.height + borderSize.height, tileSize.width, tileSize.height);
}

- (void)setSelectionFont:(NSFont*)font adjustTerminal: (BOOL)adjustTerminal
{
    /* Record the new font */
    [font retain];
    [angbandViewFont release];
    angbandViewFont = font;
    
    /* Update our glyph info */
    [self updateGlyphInfo];

    if( adjustTerminal )
    {
        /* Adjust terminal to fit window with new font; save the new columns
                 * and rows since they could be changed */
        NSRect contentRect = [self->primaryWindow contentRectForFrameRect: [self->primaryWindow frame]];

        [self setMinimumWindowSize];
        NSSize size = self->primaryWindow.contentMinSize;
        BOOL windowNeedsResizing = NO;
        if (contentRect.size.width < size.width) {
            contentRect.size.width = size.width;
            windowNeedsResizing = YES;
        }
        if (contentRect.size.height < size.height) {
            contentRect.size.height = size.height;
            windowNeedsResizing = YES;
        }
        if (windowNeedsResizing) {
            size.width = contentRect.size.width;
            size.height = contentRect.size.height;
            [self->primaryWindow setContentSize:size];
        }
        [self resizeTerminalWithContentRect: contentRect saveToDefaults: YES];
    }

    /* Update our image */
    [self updateImage];
    
    /* Get redrawn */
    [self requestRedraw];
}

- (id)init
{
    if ((self = [super init]))
    {
        /* Default rows and cols */
        self->cols = 80;
        self->rows = 24;

        /* Default border size */
        self->borderSize = NSMakeSize(2, 2);

        /* Allocate our array of views */
        angbandViews = [[NSMutableArray alloc] init];
        
        self->changes = create_pending_changes(self->cols, self->rows);
        if (self->changes == 0) {
            NSLog(@"AngbandContext init:  out of memory for pending changes");
        }
        self->ncol_pre = 0;
        self->ncol_post = 0;

        /* Make the image. Since we have no views, it'll just be a puny 1x1 image. */
        [self updateImage];

        _windowVisibilityChecked = NO;
    }
    return self;
}

/**
 * Destroy all the receiver's stuff. This is intended to be callable more than
 * once.
 */
- (void)dispose
{
    terminal = NULL;
    
    /* Disassociate ourselves from our angbandViews */
    [angbandViews makeObjectsPerformSelector:@selector(setAngbandContext:) withObject:nil];
    [angbandViews release];
    angbandViews = nil;
    
    /* Destroy the layer/image */
    CGLayerRelease(angbandLayer);
    angbandLayer = NULL;

    /* Font */
    [angbandViewFont release];
    angbandViewFont = nil;
    
    /* Window */
    [primaryWindow setDelegate:nil];
    [primaryWindow close];
    [primaryWindow release];
    primaryWindow = nil;

    /* Pending changes */
    destroy_pending_changes(self->changes);
    self->changes = 0;
}

/* Usual Cocoa fare */
- (void)dealloc
{
    [self dispose];
    [super dealloc];
}



#pragma mark -
#pragma mark Directories and Paths Setup

/**
 * Return the path for Angband's lib directory and bail if it isn't found. The
 * lib directory should be in the bundle's resources directory, since it's
 * copied when built.
 */
+ (NSString *)libDirectoryPath
{
    NSString *bundleLibPath = [[[NSBundle mainBundle] resourcePath] stringByAppendingPathComponent: AngbandDirectoryNameLib];
    BOOL isDirectory = NO;
    BOOL libExists = [[NSFileManager defaultManager] fileExistsAtPath: bundleLibPath isDirectory: &isDirectory];

    if( !libExists || !isDirectory )
    {
        NSLog( @"[%@ %@]: can't find %@/ in bundle: isDirectory: %d libExists: %d", NSStringFromClass( [self class] ), NSStringFromSelector( _cmd ), AngbandDirectoryNameLib, isDirectory, libExists );

        NSString *msg = NSLocalizedStringWithDefaultValue(
            @"Error.MissingResources",
            AngbandMessageCatalog,
            [NSBundle mainBundle],
            @"Missing Resources",
            @"Alert text for missing resources");
        NSString *info = NSLocalizedStringWithDefaultValue(
            @"Error.MissingAngbandLib",
            AngbandMessageCatalog,
            [NSBundle mainBundle],
            @"Hengband was unable to find required resources and must quit. Please report a bug on the Angband forums.",
            @"Alert informative message for missing Angband lib/ folder");
        NSString *quit_label = NSLocalizedStringWithDefaultValue(
            @"Label.Quit", AngbandMessageCatalog, [NSBundle mainBundle],
            @"Quit", @"Quit");
        NSAlert *alert = [[NSAlert alloc] init];

        /*
         * Note that NSCriticalAlertStyle was deprecated in 10.10.  The
         * replacement is NSAlertStyleCritical.
         */
        alert.alertStyle = NSCriticalAlertStyle;
        alert.messageText = msg;
        alert.informativeText = info;
        [alert addButtonWithTitle:quit_label];
        NSModalResponse result = [alert runModal];
        [alert release];
        exit( 0 );
    }

        return bundleLibPath;
}

/**
 * Return the path for the directory where Angband should look for its standard
 * user file tree.
 */
+ (NSString *)angbandDocumentsPath
{
        NSString *documents = [NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES) lastObject];

#if defined(SAFE_DIRECTORY)
        NSString *versionedDirectory = [NSString stringWithFormat: @"%@-%s", AngbandDirectoryNameBase, VERSION_STRING];
        return [documents stringByAppendingPathComponent: versionedDirectory];
#else
        return [documents stringByAppendingPathComponent: AngbandDirectoryNameBase];
#endif
}

/**
 * Adjust directory paths as needed to correct for any differences needed by
 * Angband. \c init_file_paths() currently requires that all paths provided have
 * a trailing slash and all other platforms honor this.
 *
 * \param originalPath The directory path to adjust.
 * \return A path suitable for Angband or nil if an error occurred.
 */
static NSString *AngbandCorrectedDirectoryPath(NSString *originalPath)
{
        if ([originalPath length] == 0) {
                return nil;
        }

        if (![originalPath hasSuffix: @"/"]) {
                return [originalPath stringByAppendingString: @"/"];
        }

        return originalPath;
}

/**
 * Give Angband the base paths that should be used for the various directories
 * it needs. It will create any needed directories.
 */
+ (void)prepareFilePathsAndDirectories
{
        char libpath[PATH_MAX + 1] = "\0";
        NSString *libDirectoryPath = AngbandCorrectedDirectoryPath([self libDirectoryPath]);
        [libDirectoryPath getFileSystemRepresentation: libpath maxLength: sizeof(libpath)];

        char basepath[PATH_MAX + 1] = "\0";
        NSString *angbandDocumentsPath = AngbandCorrectedDirectoryPath([self angbandDocumentsPath]);
        [angbandDocumentsPath getFileSystemRepresentation: basepath maxLength: sizeof(basepath)];

        init_file_paths(libpath, libpath, basepath);
        create_needed_dirs();
}

#pragma mark -

#if 0
/* From the Linux mbstowcs(3) man page:
 *   If dest is NULL, n is ignored, and the conversion  proceeds  as  above,
 *   except  that  the converted wide characters are not written out to mem‐
 *   ory, and that no length limit exists.
 */
static size_t Term_mbcs_cocoa(wchar_t *dest, const char *src, int n)
{
    int i;
    int count = 0;

    /* Unicode code point to UTF-8
     *  0x0000-0x007f:   0xxxxxxx
     *  0x0080-0x07ff:   110xxxxx 10xxxxxx
     *  0x0800-0xffff:   1110xxxx 10xxxxxx 10xxxxxx
     * 0x10000-0x1fffff: 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
     * Note that UTF-16 limits Unicode to 0x10ffff. This code is not
     * endian-agnostic.
     */
    for (i = 0; i < n || dest == NULL; i++) {
        if ((src[i] & 0x80) == 0) {
            if (dest != NULL) dest[count] = src[i];
            if (src[i] == 0) break;
        } else if ((src[i] & 0xe0) == 0xc0) {
            if (dest != NULL) dest[count] = 
                            (((unsigned char)src[i] & 0x1f) << 6)| 
                            ((unsigned char)src[i+1] & 0x3f);
            i++;
        } else if ((src[i] & 0xf0) == 0xe0) {
            if (dest != NULL) dest[count] = 
                            (((unsigned char)src[i] & 0x0f) << 12) | 
                            (((unsigned char)src[i+1] & 0x3f) << 6) |
                            ((unsigned char)src[i+2] & 0x3f);
            i += 2;
        } else if ((src[i] & 0xf8) == 0xf0) {
            if (dest != NULL) dest[count] = 
                            (((unsigned char)src[i] & 0x0f) << 18) | 
                            (((unsigned char)src[i+1] & 0x3f) << 12) |
                            (((unsigned char)src[i+2] & 0x3f) << 6) |
                            ((unsigned char)src[i+3] & 0x3f);
            i += 3;
        } else {
            /* Found an invalid multibyte sequence */
            return (size_t)-1;
        }
        count++;
    }
    return count;
}
#endif

/**
 * Entry point for initializing Angband
 */
+ (void)beginGame
{
    NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
    
    /* Hooks in some "z-util.c" hooks */
    plog_aux = hook_plog;
    quit_aux = hook_quit;
    
    /* Initialize file paths */
    [self prepareFilePathsAndDirectories];

    /* Note the "system" */
    ANGBAND_SYS = "coc";

    /* Load preferences */
    load_prefs();
    
    /* Prepare the windows */
    init_windows();
    
    /* Set up game event handlers */
    /* init_display(); */
    
    /* Register the sound hook */
    /* sound_hook = play_sound; */
    
    /* Initialise game */
    init_angband();

    /* This is not incorporated into Hengband's init_angband() yet. */
    init_graphics_modes();

    /* Initialize some save file stuff */
    player_egid = getegid();
    
    /* We are now initialized */
    initialized = TRUE;
    
    /* Handle "open_when_ready" */
    handle_open_when_ready();
    
    /* Handle pending events (most notably update) and flush input */
    Term_flush();

    /* Prompt the user. */
    int message_row = (Term->hgt - 23) / 5 + 23;
    Term_erase(0, message_row, 255);
    put_str(
#ifdef JP
        "['ファイル' メニューから '新' または '開く' を選択します]",
        message_row, (Term->wid - 57) / 2
#else
        "[Choose 'New' or 'Open' from the 'File' menu]",
        message_row, (Term->wid - 45) / 2
#endif
    );
    Term_fresh();

    /*
     * Play a game -- "new_game" is set by "new", "open" or the open document
     * even handler as appropriate
     */
        
    [pool drain];
    
    while (!game_in_progress) {
        NSAutoreleasePool *splashScreenPool = [[NSAutoreleasePool alloc] init];
        NSEvent *event = [NSApp nextEventMatchingMask:NSAnyEventMask untilDate:[NSDate distantFuture] inMode:NSDefaultRunLoopMode dequeue:YES];
        if (event) [NSApp sendEvent:event];
        [splashScreenPool drain];
    }

    Term_fresh();
    play_game(new_game);

    quit(NULL);
}

+ (void)endGame
{    
    /* Hack -- Forget messages */
    msg_flag = FALSE;
    
    p_ptr->playing = FALSE;
    p_ptr->leaving = TRUE;
    quit_when_ready = TRUE;
}

- (void)addAngbandView:(AngbandView *)view
{
    if (! [angbandViews containsObject:view])
    {
        [angbandViews addObject:view];
        [self updateImage];
        [self setNeedsDisplay:YES]; /* We'll need to redisplay everything anyways, so avoid creating all those little redisplay rects */
        [self requestRedraw];
    }
}

/**
 * We have this notion of an "active" AngbandView, which is the largest - the
 * idea being that in the screen saver, when the user hits Test in System
 * Preferences, we don't want to keep driving the AngbandView in the
 * background.  Our active AngbandView is the widest - that's a hack all right.
 * Mercifully when we're just playing the game there's only one view.
 */
- (AngbandView *)activeView
{
    if ([angbandViews count] == 1)
        return [angbandViews objectAtIndex:0];
    
    AngbandView *result = nil;
    float maxWidth = 0;
    for (AngbandView *angbandView in angbandViews)
    {
        float width = [angbandView frame].size.width;
        if (width > maxWidth)
        {
            maxWidth = width;
            result = angbandView;
        }
    }
    return result;
}

- (void)angbandViewDidScale:(AngbandView *)view
{
    /* If we're live-resizing with graphics, we're using the live resize
         * optimization, so don't update the image. Otherwise do it. */
    if (! (inLiveResize && graphics_are_enabled()) && view == [self activeView])
    {
        [self updateImage];
        
        [self setNeedsDisplay:YES]; /*we'll need to redisplay everything anyways, so avoid creating all those little redisplay rects */
        [self requestRedraw];
    }
}


- (void)removeAngbandView:(AngbandView *)view
{
    if ([angbandViews containsObject:view])
    {
        [angbandViews removeObject:view];
        [self updateImage];
        [self setNeedsDisplay:YES]; /* We'll need to redisplay everything anyways, so avoid creating all those little redisplay rects */
        if ([angbandViews count]) [self requestRedraw];
    }
}


static NSMenuItem *superitem(NSMenuItem *self)
{
    NSMenu *supermenu = [[self menu] supermenu];
    int index = [supermenu indexOfItemWithSubmenu:[self menu]];
    if (index == -1) return nil;
    else return [supermenu itemAtIndex:index];
}


- (BOOL)validateMenuItem:(NSMenuItem *)menuItem
{
    int tag = [menuItem tag];
    SEL sel = [menuItem action];
    if (sel == @selector(setGraphicsMode:))
    {
        [menuItem setState: (tag == graf_mode_req)];
        return YES;
    }
    else
    {
        return YES;
    }
}

- (NSWindow *)makePrimaryWindow
{
    if (! primaryWindow)
    {
        /* This has to be done after the font is set, which it already is in
                 * term_init_cocoa() */
        CGFloat width = self->cols * tileSize.width + borderSize.width * 2.0;
        CGFloat height = self->rows * tileSize.height + borderSize.height * 2.0;
        NSRect contentRect = NSMakeRect( 0.0, 0.0, width, height );

        NSUInteger styleMask = NSTitledWindowMask | NSResizableWindowMask | NSMiniaturizableWindowMask;

        /* Make every window other than the main window closable */
        if( angband_term[0]->data != self )
        {
            styleMask |= NSClosableWindowMask;
        }

        primaryWindow = [[NSWindow alloc] initWithContentRect:contentRect styleMask: styleMask backing:NSBackingStoreBuffered defer:YES];

        /* Not to be released when closed */
        [primaryWindow setReleasedWhenClosed:NO];
        [primaryWindow setExcludedFromWindowsMenu: YES]; /* we're using custom window menu handling */

        /* Make the view */
        AngbandView *angbandView = [[AngbandView alloc] initWithFrame:contentRect];
        [angbandView setAngbandContext:self];
        [angbandViews addObject:angbandView];
        [primaryWindow setContentView:angbandView];
        [angbandView release];

        /* We are its delegate */
        [primaryWindow setDelegate:self];

        /* Update our image, since this is probably the first angband view
                 * we've gotten. */
        [self updateImage];
    }
    return primaryWindow;
}



#pragma mark View/Window Passthrough

/**
 * This is what our views call to get us to draw to the window
 */
- (void)drawRect:(NSRect)rect inView:(NSView *)view
{
    /* Take this opportunity to throttle so we don't flush faster than desired.
         */
    BOOL viewInLiveResize = [view inLiveResize];
    if (! viewInLiveResize) [self throttle];

    /* With a GLayer, use CGContextDrawLayerInRect */
    CGContextRef context = [[NSGraphicsContext currentContext] graphicsPort];
    NSRect bounds = [view bounds];
    if (viewInLiveResize) CGContextSetInterpolationQuality(context, kCGInterpolationLow);
    CGContextSetBlendMode(context, kCGBlendModeCopy);
    CGContextDrawLayerInRect(context, *(CGRect *)&bounds, angbandLayer);
    if (viewInLiveResize) CGContextSetInterpolationQuality(context, kCGInterpolationDefault);
}

- (BOOL)isOrderedIn
{
    return [[[angbandViews lastObject] window] isVisible];
}

- (BOOL)isMainWindow
{
    return [[[angbandViews lastObject] window] isMainWindow];
}

- (void)setNeedsDisplay:(BOOL)val
{
    for (NSView *angbandView in angbandViews)
    {
        [angbandView setNeedsDisplay:val];
    }
}

- (void)setNeedsDisplayInBaseRect:(NSRect)rect
{
    for (NSView *angbandView in angbandViews)
    {
        [angbandView setNeedsDisplayInRect: rect];
    }
}

- (void)displayIfNeeded
{
    [[self activeView] displayIfNeeded];
}

- (int)terminalIndex
{
        int termIndex = 0;

        for( termIndex = 0; termIndex < ANGBAND_TERM_MAX; termIndex++ )
        {
                if( angband_term[termIndex] == self->terminal )
                {
                        break;
                }
        }

        return termIndex;
}

- (void)resizeTerminalWithContentRect: (NSRect)contentRect saveToDefaults: (BOOL)saveToDefaults
{
    CGFloat newRows = floor( (contentRect.size.height - (borderSize.height * 2.0)) / tileSize.height );
    CGFloat newColumns = ceil( (contentRect.size.width - (borderSize.width * 2.0)) / tileSize.width );

    if (newRows < 1 || newColumns < 1) return;
    self->cols = newColumns;
    self->rows = newRows;

    if (resize_pending_changes(self->changes, self->rows) != 0) {
        destroy_pending_changes(self->changes);
        self->changes = 0;
        NSLog(@"out of memory for pending changes with resize of terminal %d",
              [self terminalIndex]);
    }

    if( saveToDefaults )
    {
        int termIndex = [self terminalIndex];
        NSArray *terminals = [[NSUserDefaults standardUserDefaults] valueForKey: AngbandTerminalsDefaultsKey];

        if( termIndex < (int)[terminals count] )
        {
            NSMutableDictionary *mutableTerm = [[NSMutableDictionary alloc] initWithDictionary: [terminals objectAtIndex: termIndex]];
            [mutableTerm setValue: [NSNumber numberWithUnsignedInt: self->cols] forKey: AngbandTerminalColumnsDefaultsKey];
            [mutableTerm setValue: [NSNumber numberWithUnsignedInt: self->rows] forKey: AngbandTerminalRowsDefaultsKey];

            NSMutableArray *mutableTerminals = [[NSMutableArray alloc] initWithArray: terminals];
            [mutableTerminals replaceObjectAtIndex: termIndex withObject: mutableTerm];

            [[NSUserDefaults standardUserDefaults] setValue: mutableTerminals forKey: AngbandTerminalsDefaultsKey];
            [mutableTerminals release];
            [mutableTerm release];
        }
        [[NSUserDefaults standardUserDefaults] synchronize];
    }

    term *old = Term;
    Term_activate( self->terminal );
    Term_resize( (int)newColumns, (int)newRows);
    Term_redraw();
    Term_activate( old );
}

- (void)setMinimumWindowSize
{
    NSSize minsize;

    if ([self terminalIndex] == 0) {
        minsize.width = 80;
        minsize.height = 24;
    } else {
        minsize.width = 1;
        minsize.height = 1;
    }
    minsize.width =
        minsize.width * self->tileSize.width + self->borderSize.width * 2.0;
    minsize.height =
        minsize.height * self->tileSize.height + self->borderSize.height * 2.0;
    [[self makePrimaryWindow] setContentMinSize:minsize];
}

- (void)saveWindowVisibleToDefaults: (BOOL)windowVisible
{
        int termIndex = [self terminalIndex];
        BOOL safeVisibility = (termIndex == 0) ? YES : windowVisible; /* Ensure main term doesn't go away because of these defaults */
        NSArray *terminals = [[NSUserDefaults standardUserDefaults] valueForKey: AngbandTerminalsDefaultsKey];

        if( termIndex < (int)[terminals count] )
        {
                NSMutableDictionary *mutableTerm = [[NSMutableDictionary alloc] initWithDictionary: [terminals objectAtIndex: termIndex]];
                [mutableTerm setValue: [NSNumber numberWithBool: safeVisibility] forKey: AngbandTerminalVisibleDefaultsKey];

                NSMutableArray *mutableTerminals = [[NSMutableArray alloc] initWithArray: terminals];
                [mutableTerminals replaceObjectAtIndex: termIndex withObject: mutableTerm];

                [[NSUserDefaults standardUserDefaults] setValue: mutableTerminals forKey: AngbandTerminalsDefaultsKey];
                [mutableTerminals release];
                [mutableTerm release];
        }
}

- (BOOL)windowVisibleUsingDefaults
{
        int termIndex = [self terminalIndex];

        if( termIndex == 0 )
        {
                return YES;
        }

        NSArray *terminals = [[NSUserDefaults standardUserDefaults] valueForKey: AngbandTerminalsDefaultsKey];
        BOOL visible = NO;

        if( termIndex < (int)[terminals count] )
        {
                NSDictionary *term = [terminals objectAtIndex: termIndex];
                NSNumber *visibleValue = [term valueForKey: AngbandTerminalVisibleDefaultsKey];

                if( visibleValue != nil )
                {
                        visible = [visibleValue boolValue];
                }
        }

        return visible;
}

#pragma mark -
#pragma mark NSWindowDelegate Methods

/*- (void)windowWillStartLiveResize: (NSNotification *)notification
{ 
}*/ 

- (void)windowDidEndLiveResize: (NSNotification *)notification
{
    NSWindow *window = [notification object];
    NSRect contentRect = [window contentRectForFrameRect: [window frame]];
    [self resizeTerminalWithContentRect: contentRect saveToDefaults: YES];
}

/*- (NSSize)windowWillResize: (NSWindow *)sender toSize: (NSSize)frameSize
{
} */

- (void)windowDidEnterFullScreen: (NSNotification *)notification
{
    NSWindow *window = [notification object];
    NSRect contentRect = [window contentRectForFrameRect: [window frame]];
    [self resizeTerminalWithContentRect: contentRect saveToDefaults: NO];
}

- (void)windowDidExitFullScreen: (NSNotification *)notification
{
    NSWindow *window = [notification object];
    NSRect contentRect = [window contentRectForFrameRect: [window frame]];
    [self resizeTerminalWithContentRect: contentRect saveToDefaults: NO];
}

- (void)windowDidBecomeMain:(NSNotification *)notification
{
    NSWindow *window = [notification object];

    if( window != self->primaryWindow )
    {
        return;
    }

    int termIndex = [self terminalIndex];
    NSMenuItem *item = [[[NSApplication sharedApplication] windowsMenu] itemWithTag: AngbandWindowMenuItemTagBase + termIndex];
    [item setState: NSOnState];

    if( [[NSFontPanel sharedFontPanel] isVisible] )
    {
        [[NSFontPanel sharedFontPanel] setPanelFont: [self selectionFont] isMultiple: NO];
    }
}

- (void)windowDidResignMain: (NSNotification *)notification
{
    NSWindow *window = [notification object];

    if( window != self->primaryWindow )
    {
        return;
    }

    int termIndex = [self terminalIndex];
    NSMenuItem *item = [[[NSApplication sharedApplication] windowsMenu] itemWithTag: AngbandWindowMenuItemTagBase + termIndex];
    [item setState: NSOffState];
}

- (void)windowWillClose: (NSNotification *)notification
{
        [self saveWindowVisibleToDefaults: NO];
}

@end


@implementation AngbandView

- (BOOL)isOpaque
{
    return YES;
}

- (BOOL)isFlipped
{
    return YES;
}

- (void)drawRect:(NSRect)rect
{
    if (! angbandContext)
    {
        /* Draw bright orange, 'cause this ain't right */
        [[NSColor orangeColor] set];
        NSRectFill([self bounds]);
    }
    else
    {
        /* Tell the Angband context to draw into us */
        [angbandContext drawRect:rect inView:self];
    }
}

- (void)setAngbandContext:(AngbandContext *)context
{
    angbandContext = context;
}

- (AngbandContext *)angbandContext
{
    return angbandContext;
}

- (void)setFrameSize:(NSSize)size
{
    BOOL changed = ! NSEqualSizes(size, [self frame].size);
    [super setFrameSize:size];
    if (changed) [angbandContext angbandViewDidScale:self];
}

- (void)viewWillStartLiveResize
{
    [angbandContext viewWillStartLiveResize:self];
}

- (void)viewDidEndLiveResize
{
    [angbandContext viewDidEndLiveResize:self];
}

@end

/**
 * Delay handling of double-clicked savefiles
 */
Boolean open_when_ready = FALSE;



/**
 * ------------------------------------------------------------------------
 * Some generic functions
 * ------------------------------------------------------------------------ */

/**
 * Sets an Angband color at a given index
 */
static void set_color_for_index(int idx)
{
    u16b rv, gv, bv;
    
    /* Extract the R,G,B data */
    rv = angband_color_table[idx][1];
    gv = angband_color_table[idx][2];
    bv = angband_color_table[idx][3];
    
    CGContextSetRGBFillColor([[NSGraphicsContext currentContext] graphicsPort], rv/255., gv/255., bv/255., 1.);
}

/**
 * Remember the current character in UserDefaults so we can select it by
 * default next time.
 */
static void record_current_savefile(void)
{
    NSString *savefileString = [[NSString stringWithCString:savefile encoding:NSMacOSRomanStringEncoding] lastPathComponent];
    if (savefileString)
    {
        NSUserDefaults *angbandDefs = [NSUserDefaults angbandDefaults];
        [angbandDefs setObject:savefileString forKey:@"SaveFile"];
        [angbandDefs synchronize];
    }
}


#ifdef JP
/**
 * Convert a two-byte EUC-JP encoded character (both *cp and (*cp + 1) are in
 * the range, 0xA1-0xFE, or *cp is 0x8E) to a utf16 value in the native byte
 * ordering.
 */
static wchar_t convert_two_byte_eucjp_to_utf16_native(const char *cp)
{
    NSString* str = [[NSString alloc] initWithBytes:cp length:2
                                      encoding:NSJapaneseEUCStringEncoding];
    wchar_t result = [str characterAtIndex:0];

    [str release];
    return result;
}
#endif /* JP */


/**
 * ------------------------------------------------------------------------
 * Support for the "z-term.c" package
 * ------------------------------------------------------------------------ */


/**
 * Initialize a new Term
 */
static void Term_init_cocoa(term *t)
{
    NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
    AngbandContext *context = [[AngbandContext alloc] init];
    
    /* Give the term a hard retain on context (for GC) */
    t->data = (void *)CFRetain(context);
    [context release];
    
    /* Handle graphics */
    t->higher_pict = !! use_graphics;
    t->always_pict = FALSE;
    
    NSDisableScreenUpdates();
    
    /* Figure out the frame autosave name based on the index of this term */
    NSString *autosaveName = nil;
    int termIdx;
    for (termIdx = 0; termIdx < ANGBAND_TERM_MAX; termIdx++)
    {
        if (angband_term[termIdx] == t)
        {
            autosaveName = [NSString stringWithFormat:@"AngbandTerm-%d", termIdx];
            break;
        }
    }

    /* Set its font. */
    NSString *fontName = [[NSUserDefaults angbandDefaults] stringForKey:[NSString stringWithFormat:@"FontName-%d", termIdx]];
    if (! fontName) fontName = [default_font fontName];

    /* Use a smaller default font for the other windows, but only if the font
         * hasn't been explicitly set */
    float fontSize = (termIdx > 0) ? 10.0 : [default_font pointSize];
    NSNumber *fontSizeNumber = [[NSUserDefaults angbandDefaults] valueForKey: [NSString stringWithFormat: @"FontSize-%d", termIdx]];

    if( fontSizeNumber != nil )
    {
        fontSize = [fontSizeNumber floatValue];
    }

    [context setSelectionFont:[NSFont fontWithName:fontName size:fontSize] adjustTerminal: NO];

    NSArray *terminalDefaults = [[NSUserDefaults standardUserDefaults] valueForKey: AngbandTerminalsDefaultsKey];
    NSInteger rows = 24;
    NSInteger columns = 80;

    if( termIdx < (int)[terminalDefaults count] )
    {
        NSDictionary *term = [terminalDefaults objectAtIndex: termIdx];
        NSInteger defaultRows = [[term valueForKey: AngbandTerminalRowsDefaultsKey] integerValue];
        NSInteger defaultColumns = [[term valueForKey: AngbandTerminalColumnsDefaultsKey] integerValue];

        if (defaultRows > 0) rows = defaultRows;
        if (defaultColumns > 0) columns = defaultColumns;
    }

    context->cols = columns;
    context->rows = rows;

    if (resize_pending_changes(context->changes, context->rows) != 0) {
        destroy_pending_changes(context->changes);
        context->changes = 0;
        NSLog(@"initializing terminal %d:  out of memory for pending changes",
              termIdx);
    }

    /* Get the window */
    NSWindow *window = [context makePrimaryWindow];
    /* Set its title and, for auxiliary terms, tentative size */
    NSString *title = [NSString stringWithCString:angband_term_name[termIdx]
#ifdef JP
                                encoding:NSJapaneseEUCStringEncoding
#else
                                encoding:NSMacOSRomanStringEncoding
#endif
    ];
    [window setTitle:title];
    [context setMinimumWindowSize];
    
    /* If this is the first term, and we support full screen (Mac OS X Lion or
         * later), then allow it to go full screen (sweet). Allow other terms to be
         * FullScreenAuxilliary, so they can at least show up. Unfortunately in
         * Lion they don't get brought to the full screen space; but they would
         * only make sense on multiple displays anyways so it's not a big loss. */
    if ([window respondsToSelector:@selector(toggleFullScreen:)])
    {
        NSWindowCollectionBehavior behavior = [window collectionBehavior];
        behavior |= (termIdx == 0 ? Angband_NSWindowCollectionBehaviorFullScreenPrimary : Angband_NSWindowCollectionBehaviorFullScreenAuxiliary);
        [window setCollectionBehavior:behavior];
    }
    
    /* No Resume support yet, though it would not be hard to add */
    if ([window respondsToSelector:@selector(setRestorable:)])
    {
        [window setRestorable:NO];
    }

        /* default window placement */ {
                static NSRect overallBoundingRect;

                if( termIdx == 0 )
                {
                        /* This is a bit of a trick to allow us to display multiple windows
                         * in the "standard default" window position in OS X: the upper
                         * center of the screen.
                         * The term sizes set in load_prefs() are based on a 5-wide by
                         * 3-high grid, with the main term being 4/5 wide by 2/3 high
                         * (hence the scaling to find */

                        /* What the containing rect would be). */
                        NSRect originalMainTermFrame = [window frame];
                        NSRect scaledFrame = originalMainTermFrame;
                        scaledFrame.size.width *= 5.0 / 4.0;
                        scaledFrame.size.height *= 3.0 / 2.0;
                        scaledFrame.size.width += 1.0; /* spacing between window columns */
                        scaledFrame.size.height += 1.0; /* spacing between window rows */
                        [window setFrame: scaledFrame  display: NO];
                        [window center];
                        overallBoundingRect = [window frame];
                        [window setFrame: originalMainTermFrame display: NO];
                }

                static NSRect mainTermBaseRect;
                NSRect windowFrame = [window frame];

                if( termIdx == 0 )
                {
                        /* The height and width adjustments were determined experimentally,
                         * so that the rest of the windows line up nicely without
                         * overlapping */
            windowFrame.size.width += 7.0;
                        windowFrame.size.height += 9.0;
                        windowFrame.origin.x = NSMinX( overallBoundingRect );
                        windowFrame.origin.y = NSMaxY( overallBoundingRect ) - NSHeight( windowFrame );
                        mainTermBaseRect = windowFrame;
                }
                else if( termIdx == 1 )
                {
                        windowFrame.origin.x = NSMinX( mainTermBaseRect );
                        windowFrame.origin.y = NSMinY( mainTermBaseRect ) - NSHeight( windowFrame ) - 1.0;
                }
                else if( termIdx == 2 )
                {
                        windowFrame.origin.x = NSMaxX( mainTermBaseRect ) + 1.0;
                        windowFrame.origin.y = NSMaxY( mainTermBaseRect ) - NSHeight( windowFrame );
                }
                else if( termIdx == 3 )
                {
                        windowFrame.origin.x = NSMaxX( mainTermBaseRect ) + 1.0;
                        windowFrame.origin.y = NSMinY( mainTermBaseRect ) - NSHeight( windowFrame ) - 1.0;
                }
                else if( termIdx == 4 )
                {
                        windowFrame.origin.x = NSMaxX( mainTermBaseRect ) + 1.0;
                        windowFrame.origin.y = NSMinY( mainTermBaseRect );
                }
                else if( termIdx == 5 )
                {
                        windowFrame.origin.x = NSMinX( mainTermBaseRect ) + NSWidth( windowFrame ) + 1.0;
                        windowFrame.origin.y = NSMinY( mainTermBaseRect ) - NSHeight( windowFrame ) - 1.0;
                }

                [window setFrame: windowFrame display: NO];
        }

        /* Override the default frame above if the user has adjusted windows in
         * the past */
        if (autosaveName) [window setFrameAutosaveName:autosaveName];

    /* Tell it about its term. Do this after we've sized it so that the sizing
         * doesn't trigger redrawing and such. */
    [context setTerm:t];
    
    /* Only order front if it's the first term. Other terms will be ordered
         * front from AngbandUpdateWindowVisibility(). This is to work around a
         * problem where Angband aggressively tells us to initialize terms that
         * don't do anything! */
    if (t == angband_term[0]) [context->primaryWindow makeKeyAndOrderFront: nil];
    
    NSEnableScreenUpdates();
    
    /* Set "mapped" flag */
    t->mapped_flag = true;
    [pool drain];
}



/**
 * Nuke an old Term
 */
static void Term_nuke_cocoa(term *t)
{
    NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
    
    AngbandContext *context = t->data;
    if (context)
    {
        /* Tell the context to get rid of its windows, etc. */
        [context dispose];
        
        /* Balance our CFRetain from when we created it */
        CFRelease(context);
        
        /* Done with it */
        t->data = NULL;
    }
    
    [pool drain];
}

/**
 * Returns the CGImageRef corresponding to an image with the given name in the
 * resource directory, transferring ownership to the caller
 */
static CGImageRef create_angband_image(NSString *path)
{
    CGImageRef decodedImage = NULL, result = NULL;
    
    /* Try using ImageIO to load the image */
    if (path)
    {
        NSURL *url = [[NSURL alloc] initFileURLWithPath:path isDirectory:NO];
        if (url)
        {
            NSDictionary *options = [[NSDictionary alloc] initWithObjectsAndKeys:(id)kCFBooleanTrue, kCGImageSourceShouldCache, nil];
            CGImageSourceRef source = CGImageSourceCreateWithURL((CFURLRef)url, (CFDictionaryRef)options);
            if (source)
            {
                /* We really want the largest image, but in practice there's
                                 * only going to be one */
                decodedImage = CGImageSourceCreateImageAtIndex(source, 0, (CFDictionaryRef)options);
                CFRelease(source);
            }
            [options release];
            [url release];
        }
    }
    
    /* Draw the sucker to defeat ImageIO's weird desire to cache and decode on
         * demand. Our images aren't that big! */
    if (decodedImage)
    {
        size_t width = CGImageGetWidth(decodedImage), height = CGImageGetHeight(decodedImage);
        
        /* Compute our own bitmap info */
        CGBitmapInfo imageBitmapInfo = CGImageGetBitmapInfo(decodedImage);
        CGBitmapInfo contextBitmapInfo = kCGBitmapByteOrderDefault;
        
        switch (imageBitmapInfo & kCGBitmapAlphaInfoMask) {
            case kCGImageAlphaNone:
            case kCGImageAlphaNoneSkipLast:
            case kCGImageAlphaNoneSkipFirst:
                /* No alpha */
                contextBitmapInfo |= kCGImageAlphaNone;
                break;
            default:
                /* Some alpha, use premultiplied last which is most efficient. */
                contextBitmapInfo |= kCGImageAlphaPremultipliedLast;
                break;
        }

        /* Draw the source image flipped, since the view is flipped */
        CGContextRef ctx = CGBitmapContextCreate(NULL, width, height, CGImageGetBitsPerComponent(decodedImage), CGImageGetBytesPerRow(decodedImage), CGImageGetColorSpace(decodedImage), contextBitmapInfo);
        CGContextSetBlendMode(ctx, kCGBlendModeCopy);
        CGContextTranslateCTM(ctx, 0.0, height);
        CGContextScaleCTM(ctx, 1.0, -1.0);
        CGContextDrawImage(ctx, CGRectMake(0, 0, width, height), decodedImage);
        result = CGBitmapContextCreateImage(ctx);

        /* Done with these things */
        CFRelease(ctx);
        CGImageRelease(decodedImage);
    }
    return result;
}

/**
 * React to changes
 */
static errr Term_xtra_cocoa_react(void)
{
    /* Don't actually switch graphics until the game is running */
    if (!initialized || !game_in_progress) return (-1);

    NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
    AngbandContext *angbandContext = Term->data;

    /* Handle graphics */
    int expected_graf_mode = (current_graphics_mode) ?
        current_graphics_mode->grafID : GRAPHICS_NONE;
    if (graf_mode_req != expected_graf_mode)
    {
        graphics_mode *new_mode;
        if (graf_mode_req != GRAPHICS_NONE) {
            new_mode = get_graphics_mode(graf_mode_req);
        } else {
            new_mode = NULL;
        }
        
        /* Get rid of the old image. CGImageRelease is NULL-safe. */
        CGImageRelease(pict_image);
        pict_image = NULL;
        
        /* Try creating the image if we want one */
        if (new_mode != NULL)
        {
            NSString *img_path = [NSString stringWithFormat:@"%s/%s", new_mode->path, new_mode->file];
            pict_image = create_angband_image(img_path);

            /* If we failed to create the image, set the new desired mode to
                         * NULL */
            if (! pict_image)
                new_mode = NULL;
        }
        
        /* Record what we did */
        use_graphics = new_mode ? new_mode->grafID : 0;
        ANGBAND_GRAF = (new_mode ? new_mode->graf : "ascii");
        current_graphics_mode = new_mode;
        
        /* Enable or disable higher picts. Note: this should be done for all
                 * terms. */
        angbandContext->terminal->higher_pict = !! use_graphics;
        
        if (pict_image && current_graphics_mode)
        {
            /* Compute the row and column count via the image height and width.
                         */
            pict_rows = (int)(CGImageGetHeight(pict_image) / current_graphics_mode->cell_height);
            pict_cols = (int)(CGImageGetWidth(pict_image) / current_graphics_mode->cell_width);
        }
        else
        {
            pict_rows = 0;
            pict_cols = 0;
        }
        
        /* Reset visuals */
        if (initialized && game_in_progress)
        {
            reset_visuals();
        }
    }
    [pool drain];
    
    /* Success */
    return (0);
}


/**
 * Draws one tile as a helper function for Term_xtra_cocoa_fresh().
 */
static void draw_image_tile(
    NSGraphicsContext* nsContext,
    CGContextRef cgContext,
    CGImageRef image,
    NSRect srcRect,
    NSRect dstRect,
    NSCompositingOperation op)
{
    /* Flip the source rect since the source image is flipped */
    CGAffineTransform flip = CGAffineTransformIdentity;
    flip = CGAffineTransformTranslate(flip, 0.0, CGImageGetHeight(image));
    flip = CGAffineTransformScale(flip, 1.0, -1.0);
    CGRect flippedSourceRect =
        CGRectApplyAffineTransform(NSRectToCGRect(srcRect), flip);

    /*
     * When we use high-quality resampling to draw a tile, pixels from outside
     * the tile may bleed in, causing graphics artifacts. Work around that.
     */
    CGImageRef subimage =
        CGImageCreateWithImageInRect(image, flippedSourceRect);
    [nsContext setCompositingOperation:op];
    CGContextDrawImage(cgContext, NSRectToCGRect(dstRect), subimage);
    CGImageRelease(subimage);
}


/**
 * This is a helper function for Term_xtra_cocoa_fresh():  look before a block
 * of text on a row to see if the bounds for rendering and clipping need to be
 * extended.
 */
static void query_before_text(
    struct PendingRowChange* prc, int iy, int npre, int* pclip, int* prend)
{
    int start = *prend;
    int i = start - 1;

    while (1) {
        if (i < 0 || i < start - npre) {
            break;
        }

        if (prc->cell_changes[i].change_type == CELL_CHANGE_PICT) {
            /*
             * The cell has been rendered with a tile.  Do not want to modify
             * its contents so the clipping and rendering region can not be
             * extended.
             */
            break;
        } else if (prc->cell_changes[i].change_type == CELL_CHANGE_NONE) {
            /* It has not changed so inquire what it is. */
            TERM_COLOR a[2];
            char c[2];

            Term_what(i, iy, a + 1, c + 1);
            if (use_graphics && (a[1] & 0x80) && (c[1] & 0x80)) {
                /*
                 * It is an unchanged location rendered with a tile.  Do not
                 * want to modify its contents so the clipping and rendering
                 * region can not be extended.
                 */
                break;
            }
            /*
             * It is unchanged text.  A character from the changed region
             * may have extended into it so render it to clear that.
             */
#ifdef JP
            /* Check to see if it is the second part of a kanji character. */
            if (i > 0) {
                Term_what(i - 1, iy, a, c);
                if (iskanji(c)) {
                    prc->cell_changes[i - 1].c.w =
                        convert_two_byte_eucjp_to_utf16_native(c);
                    prc->cell_changes[i - 1].a = a[0];
                    prc->cell_changes[i - 1].tcol = 1;
                    prc->cell_changes[i].c.w = 0;
                    prc->cell_changes[i].a = a[0];
                    prc->cell_changes[i].tcol = 0;
                    *pclip = i - 1;
                    *prend = i - 1;
                    --i;
                } else {
                    prc->cell_changes[i].c.w = c[1];
                    prc->cell_changes[i].a = a[1];
                    prc->cell_changes[i].tcol = 0;
                    *pclip = i;
                    *prend = i;
                }
            } else {
                prc->cell_changes[i].c.w = c[1];
                prc->cell_changes[i].a = a[1];
                prc->cell_changes[i].tcol = 0;
                *pclip = i;
                *prend = i;
            }
#else
            prc->cell_changes[i].c.w = c[1];
            prc->cell_changes[i].a = a[1];
            prc->cell_changes[i].tcol = 0;
            *pclip = i;
            *prend = i;
#endif
            --i;
        } else {
            /*
             * The cell has been wiped or had changed text rendered.  Do
             * not need to render.  Can extend the clipping rectangle into it.
             */
            *pclip = i;
            --i;
        }
    }
}


/**
 * This is a helper function for Term_xtra_cocoa_fresh():  look after a block
 * of text on a row to see if the bounds for rendering and clipping need to be
 * extended.
 */
static void query_after_text(
    struct PendingRowChange* prc,
    int iy,
    int ncol,
    int npost,
    int* pclip,
    int* prend)
{
    int end = *prend;
    int i = end + 1;

    while (1) {
        /*
         * Be willing to consolidate this block with the one after it.  This
         * logic should be sufficient to avoid redraws of the region between
         * changed blocks of text if angbandContext->ncol_pre is zero or one.
         * For larger values of ncol_pre, would need to do something more to
         * avoid extra redraws.
         */
        if (i >= ncol ||
            (i > end + npost &&
             prc->cell_changes[i].change_type != CELL_CHANGE_TEXT &&
             prc->cell_changes[i].change_type != CELL_CHANGE_WIPE)) {
            break;
        }

        if (prc->cell_changes[i].change_type == CELL_CHANGE_PICT) {
            /*
             * The cell has been rendered with a tile.  Do not want to modify
             * its contents so the clipping and rendering region can not be
             * extended.
             */
            break;
        } else if (prc->cell_changes[i].change_type == CELL_CHANGE_NONE) {
            /* It has not changed so inquire what it is. */
            TERM_COLOR a[2];
            char c[2];

            Term_what(i, iy, a, c);
            if (use_graphics && (a[0] & 0x80) && (c[0] & 0x80)) {
                /*
                 * It is an unchanged location rendered with a tile.  Do not
                 * want to modify its contents so the clipping and rendering
                 * region can not be extended.
                 */
                break;
            }
            /*
             * It is unchanged text.  A character from the changed region
             * may have extended into it so render it to clear that.
             */
#ifdef JP
            /* Check to see if it is the first part of a kanji character. */
            if (i < ncol - 1) {
                Term_what(i + 1, iy, a + 1, c + 1);
                if (iskanji(c)) {
                    prc->cell_changes[i].c.w =
                        convert_two_byte_eucjp_to_utf16_native(c);
                    prc->cell_changes[i].a = a[0];
                    prc->cell_changes[i].tcol = 1;
                    prc->cell_changes[i + 1].c.w = 0;
                    prc->cell_changes[i + 1].a = a[0];
                    prc->cell_changes[i + 1].tcol = 0;
                    *pclip = i + 1;
                    *prend = i + 1;
                    ++i;
                } else {
                    prc->cell_changes[i].c.w = c[0];
                    prc->cell_changes[i].a = a[0];
                    prc->cell_changes[i].tcol = 0;
                    *pclip = i;
                    *prend = i;
                }
            } else {
                prc->cell_changes[i].c.w = c[0];
                prc->cell_changes[i].a = a[0];
                prc->cell_changes[i].tcol = 0;
                *pclip = i;
                *prend = i;
            }
#else
            prc->cell_changes[i].c.w = c[0];
            prc->cell_changes[i].a = a[0];
            prc->cell_changes[i].tcol = 0;
            *pclip = i;
            *prend = i;
#endif
            ++i;
        } else {
            /*
             * Have come to another region of changed text or another region
             * to wipe.  Combine the regions to minimize redraws.
             */
            *pclip = i;
            *prend = i;
            end = i;
            ++i;
        }
    }
}


/**
 * Draw the pending changes saved in angbandContext->changes.
 */
static void Term_xtra_cocoa_fresh(AngbandContext* angbandContext)
{
    int graf_width, graf_height, alphablend;

    if (angbandContext->changes->has_pict) {
        graf_width = current_graphics_mode->cell_width;
        graf_height = current_graphics_mode->cell_height;
        /*
         * Transparency effect. We really want to check
         * current_graphics_mode->alphablend, but as of this writing
         * that's  never set, so we do something lame.
         */
        /* alphablend = current_graphics_mode->alphablend */
        alphablend = (graf_width > 8 || graf_height > 8);
    } else {
        graf_width = 0;
        graf_height = 0;
        alphablend = 0;
    }

    CGContextRef ctx = [angbandContext lockFocus];

    if (angbandContext->changes->has_text ||
        angbandContext->changes->has_wipe) {
        NSFont *selectionFont = [[angbandContext selectionFont] screenFont];
        [selectionFont set];
    }

    int iy;
    for (iy = angbandContext->changes->ymin;
         iy <= angbandContext->changes->ymax;
         ++iy) {
        struct PendingRowChange* prc = angbandContext->changes->rows[iy];
        int ix;

        /* Skip untouched rows. */
        if (prc == 0) {
            continue;
        }

        ix = prc->xmin;
        while (1) {
            int jx;

            if (ix > prc->xmax) {
                break;
            }

            switch (prc->cell_changes[ix].change_type) {
            case CELL_CHANGE_NONE:
                ++ix;
                break;

            case CELL_CHANGE_PICT:
                {
                    /*
                     * Because changes are made to the compositing mode, save
                     * the incoming value.
                     */
                    NSGraphicsContext *nsContext =
                        [NSGraphicsContext currentContext];
                    NSCompositingOperation op = nsContext.compositingOperation;

                    jx = ix;
                    while (jx <= prc->xmax &&
                           prc->cell_changes[jx].change_type
                           == CELL_CHANGE_PICT) {
                        NSRect destinationRect =
                            [angbandContext rectInImageForTileAtX:jx Y:iy];
                        NSRect sourceRect, terrainRect;

                        sourceRect.origin.x = graf_width *
                            prc->cell_changes[jx].c.c;
                        sourceRect.origin.y = graf_height *
                            prc->cell_changes[jx].a;
                        sourceRect.size.width = graf_width;
                        sourceRect.size.height = graf_height;
                        terrainRect.origin.x = graf_width *
                            prc->cell_changes[jx].tcol;
                        terrainRect.origin.y = graf_height *
                            prc->cell_changes[jx].trow;
                        terrainRect.size.width = graf_width;
                        terrainRect.size.height = graf_height;
                        if (alphablend) {
                            draw_image_tile(
                                nsContext,
                                ctx,
                                pict_image,
                                terrainRect,
                                destinationRect,
                                NSCompositeCopy);
                            draw_image_tile(
                                nsContext,
                                ctx,
                                pict_image,
                                sourceRect,
                                destinationRect,
                                NSCompositeSourceOver);
                        } else {
                            draw_image_tile(
                                nsContext,
                                ctx,
                                pict_image,
                                sourceRect,
                                destinationRect,
                                NSCompositeCopy);
                        }
                        ++jx;
                    }

                    [nsContext setCompositingOperation:op];

                    NSRect rect =
                        [angbandContext rectInImageForTileAtX:ix Y:iy];
                    rect.size.width =
                        angbandContext->tileSize.width * (jx - ix);
                    [angbandContext setNeedsDisplayInBaseRect:rect];
                }
                ix = jx;
                break;

            case CELL_CHANGE_WIPE:
            case CELL_CHANGE_TEXT:
                /*
                 * For a wiped region, treat it as if it had text (the only
                 * loss if it was not is some extra work rendering
                 * neighboring unchanged text).
                 */
                jx = ix + 1;
                while (jx < angbandContext->cols &&
                       (prc->cell_changes[jx].change_type
                        == CELL_CHANGE_TEXT
                        || prc->cell_changes[jx].change_type
                        == CELL_CHANGE_WIPE)) {
                    ++jx;
                }
                {
                    int isclip = ix;
                    int ieclip = jx - 1;
                    int isrend = ix;
                    int ierend = jx - 1;
                    int set_color = 1;
                    TERM_COLOR alast = 0;
                    NSRect r;
                    int k;

                    query_before_text(
                        prc, iy, angbandContext->ncol_pre, &isclip, &isrend);
                    query_after_text(
                        prc,
                        iy,
                        angbandContext->cols,
                        angbandContext->ncol_post,
                        &ieclip,
                        &ierend
                    );
                    ix = ierend + 1;

                    /* Save the state since the clipping will be modified. */
                    CGContextSaveGState(ctx);

                    /* Clear the area where rendering will be done. */
                    r = [angbandContext rectInImageForTileAtX:isrend Y:iy];
                    r.size.width = angbandContext->tileSize.width *
                        (ierend - isrend + 1);
                    [[NSColor blackColor] set];
                    NSRectFill(r);

                    /*
                     * Clear the current path so it does not affect clipping.
                     * Then set the clipping rectangle.  Using
                     * CGContextSetTextDrawingMode() to include clipping does
                     * not appear to be necessary on 10.14 and is actually
                     * detrimental:  when displaying more than one character,
                     * only the first is visible.
                     */
                    CGContextBeginPath(ctx);
                    r = [angbandContext rectInImageForTileAtX:isclip Y:iy];
                    r.size.width = angbandContext->tileSize.width *
                        (ieclip - isclip + 1);
                    CGContextClipToRect(ctx, r);

                    /* Render. */
                    k = isrend;
                    while (k <= ierend) {
                        NSRect rectToDraw;

                        if (prc->cell_changes[k].change_type
                            == CELL_CHANGE_WIPE) {
                            /* Skip over since no rendering is necessary. */
                            ++k;
                            continue;
                        }

                        if (set_color || alast != prc->cell_changes[k].a) {
                            set_color = 0;
                            alast = prc->cell_changes[k].a;
                            set_color_for_index(alast % MAX_COLORS);
                        }

                        rectToDraw =
                            [angbandContext rectInImageForTileAtX:k Y:iy];
                        if (prc->cell_changes[k].tcol) {
                            rectToDraw.size.width *= 2.0;
                            [angbandContext drawWChar:prc->cell_changes[k].c.w
                                            inRect:rectToDraw context:ctx];
                            k += 2;
                        } else {
                            [angbandContext drawWChar:prc->cell_changes[k].c.w
                                            inRect:rectToDraw context:ctx];
                            ++k;
                        }
                    }

                    /*
                     * Inform the context that the area in the clipping
                     * rectangle needs to be redisplayed.
                     */
                    [angbandContext setNeedsDisplayInBaseRect:r];

                    CGContextRestoreGState(ctx);
                }
                break;
            }
        }
    }

    if (angbandContext->changes->xcurs >= 0 &&
        angbandContext->changes->ycurs >= 0) {
        NSRect rect = [angbandContext
                          rectInImageForTileAtX:angbandContext->changes->xcurs
                          Y:angbandContext->changes->ycurs];

        if (angbandContext->changes->bigcurs) {
            rect.size.width += angbandContext->tileSize.width;
        }
        [[NSColor yellowColor] set];
        NSFrameRectWithWidth(rect, 1);
        /* Invalidate that rect */
        [angbandContext setNeedsDisplayInBaseRect:rect];
    }

    [angbandContext unlockFocus];
}


/**
 * Do a "special thing"
 */
static errr Term_xtra_cocoa(int n, int v)
{
    NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
    AngbandContext* angbandContext = Term->data;
    
    errr result = 0;
    
    /* Analyze */
    switch (n)
    {
                /* Make a noise */
        case TERM_XTRA_NOISE:
        {
            NSBeep();
            
            /* Success */
            break;
        }

        /*  Make a sound */
        case TERM_XTRA_SOUND:
            play_sound(v);
            break;

            /* Process random events */
        case TERM_XTRA_BORED:
        {
            /* Show or hide cocoa windows based on the subwindow flags set by
                         * the user */
            AngbandUpdateWindowVisibility();

            /* Process an event */
            (void)check_events(CHECK_EVENTS_NO_WAIT);
            
            /* Success */
            break;
        }
            
                /* Process pending events */
        case TERM_XTRA_EVENT:
        {
            /* Process an event */
            (void)check_events(v);
            
            /* Success */
            break;
        }
            
                /* Flush all pending events (if any) */
        case TERM_XTRA_FLUSH:
        {
            /* Hack -- flush all events */
            while (check_events(CHECK_EVENTS_DRAIN)) /* loop */;
            
            /* Success */
            break;
        }
            
                /* Hack -- Change the "soft level" */
        case TERM_XTRA_LEVEL:
        {
            /* Here we could activate (if requested), but I don't think Angband
                         * should be telling us our window order (the user should decide
                         * that), so do nothing. */            
            break;
        }
            
                /* Clear the screen */
        case TERM_XTRA_CLEAR:
        {        
            [angbandContext lockFocus];
            [[NSColor blackColor] set];
            NSRect imageRect = {NSZeroPoint, [angbandContext imageSize]};
            NSRectFillUsingOperation(imageRect, NSCompositeCopy);
            [angbandContext unlockFocus];
            [angbandContext setNeedsDisplay:YES];
            /* Success */
            break;
        }
            
                /* React to changes */
        case TERM_XTRA_REACT:
        {
            /* React to changes */
            return (Term_xtra_cocoa_react());
        }
            
                /* Delay (milliseconds) */
        case TERM_XTRA_DELAY:
        {
            /* If needed */
            if (v > 0)
            {
                
                double seconds = v / 1000.;
                NSDate* date = [NSDate dateWithTimeIntervalSinceNow:seconds];
                do
                {
                    NSEvent* event;
                    do
                    {
                        event = [NSApp nextEventMatchingMask:-1 untilDate:date inMode:NSDefaultRunLoopMode dequeue:YES];
                        if (event) send_event(event);
                    } while (event);
                } while ([date timeIntervalSinceNow] >= 0);
                
            }
            
            /* Success */
            break;
        }
            
        case TERM_XTRA_FRESH:
            /* Draw the pending changes. */
            if (angbandContext->changes != 0) {
                Term_xtra_cocoa_fresh(angbandContext);
                clear_pending_changes(angbandContext->changes);
            }
            break;
            
        default:
            /* Oops */
            result = 1;
            break;
    }
    
    [pool drain];
    
    /* Oops */
    return result;
}

static errr Term_curs_cocoa(int x, int y)
{
    AngbandContext *angbandContext = Term->data;

    if (angbandContext->changes == 0) {
        /* Bail out; there was an earlier memory allocation failure. */
        return 1;
    }
    angbandContext->changes->xcurs = x;
    angbandContext->changes->ycurs = y;
    angbandContext->changes->bigcurs = 0;

    /* Success */
    return 0;
}

/**
 * Draw a cursor that's two tiles wide.  For Japanese, that's used when
 * the cursor points at a kanji character, irregardless of whether operating
 * in big tile mode.
 */
static errr Term_bigcurs_cocoa(int x, int y)
{
    AngbandContext *angbandContext = Term->data;

    if (angbandContext->changes == 0) {
        /* Bail out; there was an earlier memory allocation failure. */
        return 1;
    }
    angbandContext->changes->xcurs = x;
    angbandContext->changes->ycurs = y;
    angbandContext->changes->bigcurs = 1;

    /* Success */
    return 0;
}

/**
 * Low level graphics (Assumes valid input)
 *
 * Erase "n" characters starting at (x,y)
 */
static errr Term_wipe_cocoa(int x, int y, int n)
{
    AngbandContext *angbandContext = Term->data;
    struct PendingCellChange *pc;

    if (angbandContext->changes == 0) {
        /* Bail out; there was an earlier memory allocation failure. */
        return 1;
    }
    if (angbandContext->changes->rows[y] == 0) {
        angbandContext->changes->rows[y] =
            create_row_change(angbandContext->cols);
        if (angbandContext->changes->rows[y] == 0) {
            NSLog(@"failed to allocate changes for row %d", y);
            return 1;
        }
        if (angbandContext->changes->ymin > y) {
            angbandContext->changes->ymin = y;
        }
        if (angbandContext->changes->ymax < y) {
            angbandContext->changes->ymax = y;
        }
    }

    angbandContext->changes->has_wipe = 1;
    if (angbandContext->changes->rows[y]->xmin > x) {
        angbandContext->changes->rows[y]->xmin = x;
    }
    if (angbandContext->changes->rows[y]->xmax < x + n - 1) {
        angbandContext->changes->rows[y]->xmax = x + n - 1;
    }
    for (pc = angbandContext->changes->rows[y]->cell_changes + x;
         pc != angbandContext->changes->rows[y]->cell_changes + x + n;
         ++pc) {
        pc->change_type = CELL_CHANGE_WIPE;
    }
    
    /* Success */
    return (0);
}

static errr Term_pict_cocoa(int x, int y, int n, TERM_COLOR *ap,
                            const char *cp, const TERM_COLOR *tap,
                            const char *tcp)
{
    
    /* Paranoia: Bail if we don't have a current graphics mode */
    if (! current_graphics_mode) return -1;
    
    AngbandContext* angbandContext = Term->data;
    int any_change = 0;
    struct PendingCellChange *pc;

    if (angbandContext->changes == 0) {
        /* Bail out; there was an earlier memory allocation failure. */
        return 1;
    }
    if (angbandContext->changes->rows[y] == 0) {
        angbandContext->changes->rows[y] =
            create_row_change(angbandContext->cols);
        if (angbandContext->changes->rows[y] == 0) {
            NSLog(@"failed to allocate changes for row %d", y);
            return 1;
        }
        if (angbandContext->changes->ymin > y) {
            angbandContext->changes->ymin = y;
        }
        if (angbandContext->changes->ymax < y) {
            angbandContext->changes->ymax = y;
        }
    }

    if (angbandContext->changes->rows[y]->xmin > x) {
        angbandContext->changes->rows[y]->xmin = x;
    }
    if (angbandContext->changes->rows[y]->xmax < x + n - 1) {
        angbandContext->changes->rows[y]->xmax = x + n - 1;
    }
    for (pc = angbandContext->changes->rows[y]->cell_changes + x;
         pc != angbandContext->changes->rows[y]->cell_changes + x + n;
         ++pc) {
        TERM_COLOR a = *ap++;
        char c = *cp++;
        TERM_COLOR ta = *tap++;
        char tc = *tcp++;

        if (use_graphics && (a & 0x80) && (c & 0x80)) {
            pc->c.c = ((byte)c & 0x7F) % pict_cols;
            pc->a = ((byte)a & 0x7F) % pict_rows;
            pc->tcol = ((byte)tc & 0x7F) % pict_cols;
            pc->trow = ((byte)ta & 0x7F) % pict_rows;
            pc->change_type = CELL_CHANGE_PICT;
            any_change = 1;
        }
    }
    if (any_change) {
        angbandContext->changes->has_pict = 1;
    }
    
    /* Success */
    return (0);
}

/**
 * Low level graphics.  Assumes valid input.
 *
 * Draw several ("n") chars, with an attr, at a given location.
 */
static errr Term_text_cocoa(int x, int y, int n, byte_hack a, concptr cp)
{
    AngbandContext* angbandContext = Term->data;
    struct PendingCellChange *pc;

    if (angbandContext->changes == 0) {
        /* Bail out; there was an earlier memory allocation failure. */
        return 1;
    }
    if (angbandContext->changes->rows[y] == 0) {
        angbandContext->changes->rows[y] =
            create_row_change(angbandContext->cols);
        if (angbandContext->changes->rows[y] == 0) {
            NSLog(@"failed to allocate changes for row %d", y);
            return 1;
        }
        if (angbandContext->changes->ymin > y) {
            angbandContext->changes->ymin = y;
        }
        if (angbandContext->changes->ymax < y) {
            angbandContext->changes->ymax = y;
        }
    }

    angbandContext->changes->has_text = 1;
    if (angbandContext->changes->rows[y]->xmin > x) {
        angbandContext->changes->rows[y]->xmin = x;
    }
    if (angbandContext->changes->rows[y]->xmax < x + n - 1) {
        angbandContext->changes->rows[y]->xmax = x + n - 1;
    }
    pc = angbandContext->changes->rows[y]->cell_changes + x;
    while (pc != angbandContext->changes->rows[y]->cell_changes + x + n) {
#ifdef JP
        if (iskanji(*cp)) {
            if (pc + 1 ==
                angbandContext->changes->rows[y]->cell_changes + x + n) {
                /*
                 * The second byte of the character is past the end.  Ignore
                 * the character.
                 */
                break;
            } else {
                pc->c.w = convert_two_byte_eucjp_to_utf16_native(cp);
                pc->a = a;
                pc->tcol = 1;
                pc->change_type = CELL_CHANGE_TEXT;
                ++pc;
                /*
                 * Fill in a dummy value since the previous character will take
                 * up two columns.
                 */
                pc->c.w = 0;
                pc->a = a;
                pc->tcol = 0;
                pc->change_type = CELL_CHANGE_TEXT;
                ++pc;
                cp += 2;
            }
        } else {
            pc->c.w = *cp;
            pc->a = a;
            pc->tcol = 0;
            pc->change_type = CELL_CHANGE_TEXT;
            ++pc;
            ++cp;
        }
#else
        pc->c.w = *cp;
        pc->a = a;
        pc->tcol = 0;
        pc->change_type = CELL_CHANGE_TEXT;
        ++pc;
        ++cp;
#endif
    }
    
    /* Success */
    return (0);
}

/**
 * Post a nonsense event so that our event loop wakes up
 */
static void wakeup_event_loop(void)
{
    /* Big hack - send a nonsense event to make us update */
    NSEvent *event = [NSEvent otherEventWithType:NSApplicationDefined location:NSZeroPoint modifierFlags:0 timestamp:0 windowNumber:0 context:NULL subtype:AngbandEventWakeup data1:0 data2:0];
    [NSApp postEvent:event atStart:NO];
}


/**
 * Create and initialize window number "i"
 */
static term *term_data_link(int i)
{
    NSArray *terminalDefaults = [[NSUserDefaults standardUserDefaults] valueForKey: AngbandTerminalsDefaultsKey];
    NSInteger rows = 24;
    NSInteger columns = 80;

    if( i < (int)[terminalDefaults count] )
    {
        NSDictionary *term = [terminalDefaults objectAtIndex: i];
        rows = [[term valueForKey: AngbandTerminalRowsDefaultsKey] integerValue];
        columns = [[term valueForKey: AngbandTerminalColumnsDefaultsKey] integerValue];
    }

    /* Allocate */
    term *newterm = ZNEW(term);

    /* Initialize the term */
    term_init(newterm, columns, rows, 256 /* keypresses, for some reason? */);
    
    /* Differentiate between BS/^h, Tab/^i, etc. */
    /* newterm->complex_input = TRUE; */

    /* Use a "software" cursor */
    newterm->soft_cursor = TRUE;
    
    /* Disable the per-row flush notifications since they are not used. */
    newterm->never_frosh = TRUE;

    /* Erase with "white space" */
    newterm->attr_blank = TERM_WHITE;
    newterm->char_blank = ' ';
    
    /* Prepare the init/nuke hooks */
    newterm->init_hook = Term_init_cocoa;
    newterm->nuke_hook = Term_nuke_cocoa;
    
    /* Prepare the function hooks */
    newterm->xtra_hook = Term_xtra_cocoa;
    newterm->wipe_hook = Term_wipe_cocoa;
    newterm->curs_hook = Term_curs_cocoa;
    newterm->bigcurs_hook = Term_bigcurs_cocoa;
    newterm->text_hook = Term_text_cocoa;
    newterm->pict_hook = Term_pict_cocoa;
    /* newterm->mbcs_hook = Term_mbcs_cocoa; */
    
    /* Global pointer */
    angband_term[i] = newterm;
    
    return newterm;
}

/**
 * Load preferences from preferences file for current host+current user+
 * current application.
 */
static void load_prefs()
{
    NSUserDefaults *defs = [NSUserDefaults angbandDefaults];
    
    /* Make some default defaults */
    NSMutableArray *defaultTerms = [[NSMutableArray alloc] init];

    /* The following default rows/cols were determined experimentally by first
         * finding the ideal window/font size combinations. But because of awful
         * temporal coupling in Term_init_cocoa(), it's impossible to set up the
         * defaults there, so we do it this way. */
    for( NSUInteger i = 0; i < ANGBAND_TERM_MAX; i++ )
    {
                int columns, rows;
                BOOL visible = YES;

                switch( i )
                {
                        case 0:
                                columns = 129;
                                rows = 32;
                                break;
                        case 1:
                                columns = 84;
                                rows = 20;
                                break;
                        case 2:
                                columns = 42;
                                rows = 24;
                                break;
                        case 3:
                                columns = 42;
                                rows = 20;
                                break;
                        case 4:
                                columns = 42;
                                rows = 16;
                                break;
                        case 5:
                                columns = 84;
                                rows = 20;
                                break;
                        default:
                                columns = 80;
                                rows = 24;
                                visible = NO;
                                break;
                }

                NSDictionary *standardTerm = [NSDictionary dictionaryWithObjectsAndKeys:
                                                                          [NSNumber numberWithInt: rows], AngbandTerminalRowsDefaultsKey,
                                                                          [NSNumber numberWithInt: columns], AngbandTerminalColumnsDefaultsKey,
                                                                          [NSNumber numberWithBool: visible], AngbandTerminalVisibleDefaultsKey,
                                                                          nil];
        [defaultTerms addObject: standardTerm];
    }

    NSDictionary *defaults = [[NSDictionary alloc] initWithObjectsAndKeys:
#ifdef JP
                              @"Osaka", @"FontName",
#else
                              @"Menlo", @"FontName",
#endif
                              [NSNumber numberWithFloat:13.f], @"FontSize",
                              [NSNumber numberWithInt:60], AngbandFrameRateDefaultsKey,
                              [NSNumber numberWithBool:YES], AngbandSoundDefaultsKey,
                              [NSNumber numberWithInt:GRAPHICS_NONE], AngbandGraphicsDefaultsKey,
                              defaultTerms, AngbandTerminalsDefaultsKey,
                              nil];
    [defs registerDefaults:defaults];
    [defaults release];
    [defaultTerms release];
    
    /* Preferred graphics mode */
    graf_mode_req = [defs integerForKey:AngbandGraphicsDefaultsKey];
    
    /* Use sounds; set the Angband global */
    use_sound = ([defs boolForKey:AngbandSoundDefaultsKey] == YES) ? TRUE : FALSE;
    
    /* fps */
    frames_per_second = [defs integerForKey:AngbandFrameRateDefaultsKey];
    
    /* Font */
    default_font = [[NSFont fontWithName:[defs valueForKey:@"FontName-0"] size:[defs floatForKey:@"FontSize-0"]] retain];
    if (! default_font) default_font = [[NSFont fontWithName:@"Menlo" size:13.] retain];
}

/**
 * Arbitary limit on number of possible samples per event
 */
#define MAX_SAMPLES            16

/**
 * Struct representing all data for a set of event samples
 */
typedef struct
{
        int num;        /* Number of available samples for this event */
        NSSound *sound[MAX_SAMPLES];
} sound_sample_list;

/**
 * Array of event sound structs
 */
static sound_sample_list samples[MSG_MAX];


/**
 * Load sound effects based on sound.cfg within the xtra/sound directory;
 * bridge to Cocoa to use NSSound for simple loading and playback, avoiding
 * I/O latency by cacheing all sounds at the start.  Inherits full sound
 * format support from Quicktime base/plugins.
 * pelpel favoured a plist-based parser for the future but .cfg support
 * improves cross-platform compatibility.
 */
static void load_sounds(void)
{
        char sound_dir[1024];
        char path[1024];
        char buffer[2048];
        FILE *fff;
    
        /* Build the "sound" path */
        path_build(sound_dir, sizeof(sound_dir), ANGBAND_DIR_XTRA, "sound");
    
        /* Find and open the config file */
        path_build(path, sizeof(path), sound_dir, "sound.cfg");
        fff = my_fopen(path, "r");
    
        /* Handle errors */
        if (!fff)
        {
                NSLog(@"The sound configuration file could not be opened.");
                return;
        }
        
        /* Instantiate an autorelease pool for use by NSSound */
        NSAutoreleasePool *autorelease_pool;
        autorelease_pool = [[NSAutoreleasePool alloc] init];
    
    /* Use a dictionary to unique sounds, so we can share NSSounds across
         * multiple events */
    NSMutableDictionary *sound_dict = [NSMutableDictionary dictionary];
    
        /*
         * This loop may take a while depending on the count and size of samples
         * to load.
         */
    
        /* Parse the file */
        /* Lines are always of the form "name = sample [sample ...]" */
        while (my_fgets(fff, buffer, sizeof(buffer)) == 0)
        {
                char *msg_name;
                char *cfg_sample_list;
                char *search;
                char *cur_token;
                char *next_token;
                int event;
        
                /* Skip anything not beginning with an alphabetic character */
                if (!buffer[0] || !isalpha((unsigned char)buffer[0])) continue;
        
                /* Split the line into two: message name, and the rest */
                search = strchr(buffer, ' ');
                cfg_sample_list = strchr(search + 1, ' ');
                if (!search) continue;
                if (!cfg_sample_list) continue;
        
                /* Set the message name, and terminate at first space */
                msg_name = buffer;
                search[0] = '\0';
        
                /* Make sure this is a valid event name */
                for (event = MSG_MAX - 1; event >= 0; event--)
                {
                        if (strcmp(msg_name, angband_sound_name[event]) == 0)
                                break;
                }
                if (event < 0) continue;
        
                /* Advance the sample list pointer so it's at the beginning of text */
                cfg_sample_list++;
                if (!cfg_sample_list[0]) continue;
        
                /* Terminate the current token */
                cur_token = cfg_sample_list;
                search = strchr(cur_token, ' ');
                if (search)
                {
                        search[0] = '\0';
                        next_token = search + 1;
                }
                else
                {
                        next_token = NULL;
                }
        
                /*
                 * Now we find all the sample names and add them one by one
                 */
                while (cur_token)
                {
                        int num = samples[event].num;
            
                        /* Don't allow too many samples */
                        if (num >= MAX_SAMPLES) break;
            
            NSString *token_string = [NSString stringWithUTF8String:cur_token];
            NSSound *sound = [sound_dict objectForKey:token_string];
            
            if (! sound)
            {
                struct stat stb;

                /* We have to load the sound. Build the path to the sample */
                path_build(path, sizeof(path), sound_dir, cur_token);
                if (stat(path, &stb) == 0)
                {
                    
                    /* Load the sound into memory */
                    sound = [[[NSSound alloc] initWithContentsOfFile:[NSString stringWithUTF8String:path] byReference:YES] autorelease];
                    if (sound) [sound_dict setObject:sound forKey:token_string];
                }
            }
            
            /* Store it if we loaded it */
            if (sound)
            {
                samples[event].sound[num] = [sound retain];
                
                /* Imcrement the sample count */
                samples[event].num++;
            }
            
            
                        /* Figure out next token */
                        cur_token = next_token;
                        if (next_token)
                        {
                                /* Try to find a space */
                                search = strchr(cur_token, ' ');
                
                                /* If we can find one, terminate, and set new "next" */
                                if (search)
                                {
                                        search[0] = '\0';
                                        next_token = search + 1;
                                }
                                else
                                {
                                        /* Otherwise prevent infinite looping */
                                        next_token = NULL;
                                }
                        }
                }
        }
    
        /* Release the autorelease pool */
        [autorelease_pool release];
    
        /* Close the file */
        my_fclose(fff);
}

/**
 * Play sound effects asynchronously.  Select a sound from any available
 * for the required event, and bridge to Cocoa to play it.
 */
static void play_sound(int event)
{    
        /* Paranoia */
        if (event < 0 || event >= MSG_MAX) return;
    
    /* Load sounds just-in-time (once) */
    static BOOL loaded = NO;
    if (!loaded) {
        loaded = YES;
        load_sounds();
    }
    
    /* Check there are samples for this event */
    if (!samples[event].num) return;
    
    /* Instantiate an autorelease pool for use by NSSound */
    NSAutoreleasePool *autorelease_pool;
    autorelease_pool = [[NSAutoreleasePool alloc] init];
    
    /* Choose a random event */
    int s = randint0(samples[event].num);
    
    /* Stop the sound if it's currently playing */
    if ([samples[event].sound[s] isPlaying])
        [samples[event].sound[s] stop];
    
    /* Play the sound */
    [samples[event].sound[s] play];
    
    /* Release the autorelease pool */
    [autorelease_pool drain];
}

/*
 * 
 */
static void init_windows(void)
{
    /* Create the main window */
    term *primary = term_data_link(0);
    
    /* Prepare to create any additional windows */
    int i;
    for (i=1; i < ANGBAND_TERM_MAX; i++) {
        term_data_link(i);
    }
    
    /* Activate the primary term */
    Term_activate(primary);
}

/**
 * Handle the "open_when_ready" flag
 */
static void handle_open_when_ready(void)
{
    /* Check the flag XXX XXX XXX make a function for this */
    if (open_when_ready && initialized && !game_in_progress)
    {
        /* Forget */
        open_when_ready = FALSE;
        
        /* Game is in progress */
        game_in_progress = TRUE;
        
        /* Wait for a keypress */
        pause_line(Term->hgt - 1);
    }
}


/**
 * Handle quit_when_ready, by Peter Ammon,
 * slightly modified to check inkey_flag.
 */
static void quit_calmly(void)
{
    /* Quit immediately if game's not started */
    if (!game_in_progress || !character_generated) quit(NULL);

    /* Save the game and Quit (if it's safe) */
    if (inkey_flag)
    {
        /* Hack -- Forget messages and term */
        msg_flag = FALSE;
                Term->mapped_flag = FALSE;

        /* Save the game */
        do_cmd_save_game(FALSE);
        record_current_savefile();

        /* Quit */
        quit(NULL);
    }

    /* Wait until inkey_flag is set */
}



/**
 * Returns YES if we contain an AngbandView (and hence should direct our events
 * to Angband)
 */
static BOOL contains_angband_view(NSView *view)
{
    if ([view isKindOfClass:[AngbandView class]]) return YES;
    for (NSView *subview in [view subviews]) {
        if (contains_angband_view(subview)) return YES;
    }
    return NO;
}


/**
 * Queue mouse presses if they occur in the map section of the main window.
 */
static void AngbandHandleEventMouseDown( NSEvent *event )
{
#if 0
        AngbandContext *angbandContext = [[[event window] contentView] angbandContext];
        AngbandContext *mainAngbandContext = angband_term[0]->data;

        if (mainAngbandContext->primaryWindow && [[event window] windowNumber] == [mainAngbandContext->primaryWindow windowNumber])
        {
                int cols, rows, x, y;
                Term_get_size(&cols, &rows);
                NSSize tileSize = angbandContext->tileSize;
                NSSize border = angbandContext->borderSize;
                NSPoint windowPoint = [event locationInWindow];

                /* Adjust for border; add border height because window origin is at
                 * bottom */
                windowPoint = NSMakePoint( windowPoint.x - border.width, windowPoint.y + border.height );

                NSPoint p = [[[event window] contentView] convertPoint: windowPoint fromView: nil];
                x = floor( p.x / tileSize.width );
                y = floor( p.y / tileSize.height );

                /* Being safe about this, since xcode doesn't seem to like the
                 * bool_hack stuff */
                BOOL displayingMapInterface = ((int)inkey_flag != 0);

                /* Sidebar plus border == thirteen characters; top row is reserved. */
                /* Coordinates run from (0,0) to (cols-1, rows-1). */
                BOOL mouseInMapSection = (x > 13 && x <= cols - 1 && y > 0  && y <= rows - 2);

                /* If we are displaying a menu, allow clicks anywhere; if we are
                 * displaying the main game interface, only allow clicks in the map
                 * section */
                if (!displayingMapInterface || (displayingMapInterface && mouseInMapSection))
                {
                        /* [event buttonNumber] will return 0 for left click,
                         * 1 for right click, but this is safer */
                        int button = ([event type] == NSLeftMouseDown) ? 1 : 2;

#ifdef KC_MOD_ALT
                        NSUInteger eventModifiers = [event modifierFlags];
                        byte angbandModifiers = 0;
                        angbandModifiers |= (eventModifiers & NSShiftKeyMask) ? KC_MOD_SHIFT : 0;
                        angbandModifiers |= (eventModifiers & NSControlKeyMask) ? KC_MOD_CONTROL : 0;
                        angbandModifiers |= (eventModifiers & NSAlternateKeyMask) ? KC_MOD_ALT : 0;
                        button |= (angbandModifiers & 0x0F) << 4; /* encode modifiers in the button number (see Term_mousepress()) */
#endif

                        Term_mousepress(x, y, button);
                }
        }
#endif
    /* Pass click through to permit focus change, resize, etc. */
    [NSApp sendEvent:event];
}



/**
 * Encodes an NSEvent Angband-style, or forwards it along.  Returns YES if the
 * event was sent to Angband, NO if Cocoa (or nothing) handled it */
static BOOL send_event(NSEvent *event)
{

    /* If the receiving window is not an Angband window, then do nothing */
    if (! contains_angband_view([[event window] contentView]))
    {
        [NSApp sendEvent:event];
        return NO;
    }

    /* Analyze the event */
    switch ([event type])
    {
        case NSKeyDown:
        {
            /* Try performing a key equivalent */
            if ([[NSApp mainMenu] performKeyEquivalent:event]) break;
            
            unsigned modifiers = [event modifierFlags];
            
            /* Send all NSCommandKeyMasks through */
            if (modifiers & NSCommandKeyMask)
            {
                [NSApp sendEvent:event];
                break;
            }
            
            if (! [[event characters] length]) break;
            
            
            /* Extract some modifiers */
            int mc = !! (modifiers & NSControlKeyMask);
            int ms = !! (modifiers & NSShiftKeyMask);
            int mo = !! (modifiers & NSAlternateKeyMask);
            int kp = !! (modifiers & NSNumericPadKeyMask);
            
            
            /* Get the Angband char corresponding to this unichar */
            unichar c = [[event characters] characterAtIndex:0];
            char ch;
            /*
             * Have anything from the numeric keypad generate a macro
             * trigger so that shift or control modifiers can be passed.
             */
            if (c <= 0x7F && !kp)
            {
                ch = (char) c;
            }
            else {
                /*
                 * The rest of Hengband uses Angband 2.7's or so key handling:
                 * so for the rest do something like the encoding that
                 * main-win.c does:  send a macro trigger with the Unicode
                 * value encoded into printable ASCII characters.
                 */
                ch = '\0';
            }
            
            /* override special keys */
            switch([event keyCode]) {
                case kVK_Return: ch = '\r'; break;
                case kVK_Escape: ch = 27; break;
                case kVK_Tab: ch = '\t'; break;
                case kVK_Delete: ch = '\b'; break;
                case kVK_ANSI_KeypadEnter: ch = '\r'; kp = TRUE; break;
            }

            /* Hide the mouse pointer */
            [NSCursor setHiddenUntilMouseMoves:YES];
            
            /* Enqueue it */
            if (ch != '\0')
            {
                Term_keypress(ch);
            }
            else
            {
                /*
                 * Could use the hexsym global but some characters overlap with
                 * those used to indicate modifiers.
                 */
                const char encoded[16] = {
                    '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b',
                    'c', 'd', 'e', 'f'
                };

                /* Begin the macro trigger. */
                Term_keypress(31);

                /* Send the modifiers. */
                if (mc) Term_keypress('C');
                if (ms) Term_keypress('S');
                if (mo) Term_keypress('O');
                if (kp) Term_keypress('K');

                do {
                    Term_keypress(encoded[c & 0xF]);
                    c >>= 4;
                } while (c > 0);

                /* End the macro trigger. */
                Term_keypress(13);
            }
            
            break;
        }
            
        case NSLeftMouseDown:
                case NSRightMouseDown:
                        AngbandHandleEventMouseDown(event);
            break;

        case NSApplicationDefined:
        {
            if ([event subtype] == AngbandEventWakeup)
            {
                return YES;
            }
            break;
        }
            
        default:
            [NSApp sendEvent:event];
            return YES;
    }
    return YES;
}

/**
 * Check for Events, return TRUE if we process any
 */
static BOOL check_events(int wait)
{ 
    
    NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
    
    /* Handles the quit_when_ready flag */
    if (quit_when_ready) quit_calmly();
    
    NSDate* endDate;
    if (wait == CHECK_EVENTS_WAIT) endDate = [NSDate distantFuture];
    else endDate = [NSDate distantPast];
    
    NSEvent* event;
    for (;;) {
        if (quit_when_ready)
        {
            /* send escape events until we quit */
            Term_keypress(0x1B);
            [pool drain];
            return false;
        }
        else {
            event = [NSApp nextEventMatchingMask:-1 untilDate:endDate inMode:NSDefaultRunLoopMode dequeue:YES];
            if (! event)
            {
                [pool drain];
                return FALSE;
            }
            if (send_event(event)) break;
        }
    }
    
    [pool drain];
    
    /* Something happened */
    return YES;
    
}

/**
 * Hook to tell the user something important
 */
static void hook_plog(const char * str)
{
    if (str)
    {
        NSString *msg = NSLocalizedStringWithDefaultValue(
            @"Warning", AngbandMessageCatalog, [NSBundle mainBundle],
            @"Warning", @"Alert text for generic warning");
        NSString *info = [NSString stringWithCString:str
#ifdef JP
                                   encoding:NSJapaneseEUCStringEncoding
#else
                                   encoding:NSMacOSRomanStringEncoding
#endif
        ];
        NSAlert *alert = [[NSAlert alloc] init];

        alert.messageText = msg;
        alert.informativeText = info;
        NSModalResponse result = [alert runModal];
        [alert release];
    }
}


/**
 * Hook to tell the user something, and then quit
 */
static void hook_quit(const char * str)
{
    plog(str);
    exit(0);
}

/**
 * ------------------------------------------------------------------------
 * Main program
 * ------------------------------------------------------------------------ */

@interface AngbandAppDelegate : NSObject {
    IBOutlet NSMenu *terminalsMenu;
    NSMenu *_graphicsMenu;
    NSMenu *_commandMenu;
    NSDictionary *_commandMenuTagMap;
}

@property (nonatomic, retain) IBOutlet NSMenu *graphicsMenu;
@property (nonatomic, retain) IBOutlet NSMenu *commandMenu;
@property (nonatomic, retain) NSDictionary *commandMenuTagMap;

- (IBAction)newGame:sender;
- (IBAction)openGame:sender;

- (IBAction)editFont:sender;
- (IBAction)setGraphicsMode:(NSMenuItem *)sender;
- (IBAction)toggleSound:(NSMenuItem *)sender;

- (IBAction)setRefreshRate:(NSMenuItem *)menuItem;
- (IBAction)selectWindow: (id)sender;

@end

@implementation AngbandAppDelegate

@synthesize graphicsMenu=_graphicsMenu;
@synthesize commandMenu=_commandMenu;
@synthesize commandMenuTagMap=_commandMenuTagMap;

- (IBAction)newGame:sender
{
    /* Game is in progress */
    game_in_progress = TRUE;
    new_game = TRUE;
}

- (IBAction)editFont:sender
{
    NSFontPanel *panel = [NSFontPanel sharedFontPanel];
    NSFont *termFont = default_font;

    int i;
    for (i=0; i < ANGBAND_TERM_MAX; i++) {
        if ([(id)angband_term[i]->data isMainWindow]) {
            termFont = [(id)angband_term[i]->data selectionFont];
            break;
        }
    }
    
    [panel setPanelFont:termFont isMultiple:NO];
    [panel orderFront:self];
}

/**
 * Implent NSObject's changeFont() method to receive a notification about the
 * changed font.  Note that, as of 10.14, changeFont() is deprecated in
 * NSObject - it will be removed at some point and the application delegate
 * will have to be declared as implementing the NSFontChanging protocol.
 */
- (void)changeFont:(id)sender
{
    int mainTerm;
    for (mainTerm=0; mainTerm < ANGBAND_TERM_MAX; mainTerm++) {
        if ([(id)angband_term[mainTerm]->data isMainWindow]) {
            break;
        }
    }

    /* Bug #1709: Only change font for angband windows */
    if (mainTerm == ANGBAND_TERM_MAX) return;
    
    NSFont *oldFont = default_font;
    NSFont *newFont = [sender convertFont:oldFont];
    if (! newFont) return; /*paranoia */
    
    /* Store as the default font if we changed the first term */
    if (mainTerm == 0) {
        [newFont retain];
        [default_font release];
        default_font = newFont;
    }
    
    /* Record it in the preferences */
    NSUserDefaults *defs = [NSUserDefaults angbandDefaults];
    [defs setValue:[newFont fontName] 
        forKey:[NSString stringWithFormat:@"FontName-%d", mainTerm]];
    [defs setFloat:[newFont pointSize]
        forKey:[NSString stringWithFormat:@"FontSize-%d", mainTerm]];
    [defs synchronize];
    
    NSDisableScreenUpdates();
    
    /* Update window */
    AngbandContext *angbandContext = angband_term[mainTerm]->data;
    [(id)angbandContext setSelectionFont:newFont adjustTerminal: YES];
    
    NSEnableScreenUpdates();
}

- (IBAction)openGame:sender
{
    NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init];
    BOOL selectedSomething = NO;
    int panelResult;
    
    /* Get where we think the save files are */
    NSURL *startingDirectoryURL = [NSURL fileURLWithPath:[NSString stringWithCString:ANGBAND_DIR_SAVE encoding:NSASCIIStringEncoding] isDirectory:YES];
    
    /* Set up an open panel */
    NSOpenPanel* panel = [NSOpenPanel openPanel];
    [panel setCanChooseFiles:YES];
    [panel setCanChooseDirectories:NO];
    [panel setResolvesAliases:YES];
    [panel setAllowsMultipleSelection:NO];
    [panel setTreatsFilePackagesAsDirectories:YES];
    [panel setDirectoryURL:startingDirectoryURL];
    
    /* Run it */
    panelResult = [panel runModal];
    if (panelResult == NSOKButton)
    {
        NSArray* fileURLs = [panel URLs];
        if ([fileURLs count] > 0 && [[fileURLs objectAtIndex:0] isFileURL])
        {
            NSURL* savefileURL = (NSURL *)[fileURLs objectAtIndex:0];
            /* The path property doesn't do the right thing except for
             * URLs with the file scheme. We had getFileSystemRepresentation
             * here before, but that wasn't introduced until OS X 10.9. */
            selectedSomething = [[savefileURL path] getCString:savefile 
                maxLength:sizeof savefile encoding:NSMacOSRomanStringEncoding];
        }
    }
    
    if (selectedSomething)
    {
        /* Remember this so we can select it by default next time */
        record_current_savefile();
        
        /* Game is in progress */
        game_in_progress = TRUE;
        new_game = FALSE;
    }
    
    [pool drain];
}

- (IBAction)saveGame:sender
{
    /* Hack -- Forget messages */
    msg_flag = FALSE;
    
    /* Save the game */
    do_cmd_save_game(FALSE);
    
    /* Record the current save file so we can select it by default next time.
         * It's a little sketchy that this only happens when we save through the
         * menu; ideally game-triggered saves would trigger it too. */
    record_current_savefile();
}

/**
 * Implement NSObject's validateMenuItem() method to override enabling or
 * disabling a menu item.  Note that, as of 10.14, validateMenuItem() is
 * deprecated in NSObject - it will be removed at some point and  the
 * application delegate will have to be declared as implementing the
 * NSMenuItemValidation protocol.
 */
- (BOOL)validateMenuItem:(NSMenuItem *)menuItem
{
    SEL sel = [menuItem action];
    NSInteger tag = [menuItem tag];

    if( tag >= AngbandWindowMenuItemTagBase && tag < AngbandWindowMenuItemTagBase + ANGBAND_TERM_MAX )
    {
        if( tag == AngbandWindowMenuItemTagBase )
        {
            /* The main window should always be available and visible */
            return YES;
        }
        else
        {
            /*
             * Another window is only usable after Term_init_cocoa() has
             * been called for it.  For Angband if window_flag[i] is nonzero
             * then that has happened for window i.  For Hengband, that is
             * not the case so also test angband_term[i]->data.
             */
            NSInteger subwindowNumber = tag - AngbandWindowMenuItemTagBase;
            return (angband_term[subwindowNumber]->data != 0
                    && window_flag[subwindowNumber] > 0);
        }

        return NO;
    }

    if (sel == @selector(newGame:))
    {
        return ! game_in_progress;
    }
    else if (sel == @selector(editFont:))
    {
        return YES;
    }
    else if (sel == @selector(openGame:))
    {
        return ! game_in_progress;
    }
    else if (sel == @selector(setRefreshRate:) && [superitem(menuItem) tag] == 150)
    {
        NSInteger fps = [[NSUserDefaults standardUserDefaults] integerForKey:AngbandFrameRateDefaultsKey];
        [menuItem setState: ([menuItem tag] == fps)];
        return YES;
    }
    else if( sel == @selector(setGraphicsMode:) )
    {
        NSInteger requestedGraphicsMode = [[NSUserDefaults standardUserDefaults] integerForKey:AngbandGraphicsDefaultsKey];
        [menuItem setState: (tag == requestedGraphicsMode)];
        return YES;
    }
    else if( sel == @selector(toggleSound:) )
    {
        BOOL is_on = [[NSUserDefaults standardUserDefaults]
                         boolForKey:AngbandSoundDefaultsKey];

        [menuItem setState: ((is_on) ? NSOnState : NSOffState)];
        return YES;
    }
    else if( sel == @selector(sendAngbandCommand:) )
    {
        /* we only want to be able to send commands during an active game */
        return !!game_in_progress;
    }
    else return YES;
}


- (IBAction)setRefreshRate:(NSMenuItem *)menuItem
{
    frames_per_second = [menuItem tag];
    [[NSUserDefaults angbandDefaults] setInteger:frames_per_second forKey:AngbandFrameRateDefaultsKey];
}

- (IBAction)selectWindow: (id)sender
{
    NSInteger subwindowNumber = [(NSMenuItem *)sender tag] - AngbandWindowMenuItemTagBase;
    AngbandContext *context = angband_term[subwindowNumber]->data;
    [context->primaryWindow makeKeyAndOrderFront: self];
        [context saveWindowVisibleToDefaults: YES];
}

- (void)prepareWindowsMenu
{
    /* Get the window menu with default items and add a separator and item for
         * the main window */
    NSMenu *windowsMenu = [[NSApplication sharedApplication] windowsMenu];
    [windowsMenu addItem: [NSMenuItem separatorItem]];

    NSString *title1 = [NSString stringWithCString:angband_term_name[0]
#ifdef JP
                                encoding:NSJapaneseEUCStringEncoding
#else
                                encoding:NSMacOSRomanStringEncoding
#endif
    ];
    NSMenuItem *angbandItem = [[NSMenuItem alloc] initWithTitle:title1 action: @selector(selectWindow:) keyEquivalent: @"0"];
    [angbandItem setTarget: self];
    [angbandItem setTag: AngbandWindowMenuItemTagBase];
    [windowsMenu addItem: angbandItem];
    [angbandItem release];

    /* Add items for the additional term windows */
    for( NSInteger i = 1; i < ANGBAND_TERM_MAX; i++ )
    {
        NSString *title = [NSString stringWithCString:angband_term_name[i]
#ifdef JP
                                    encoding:NSJapaneseEUCStringEncoding
#else
                                    encoding:NSMacOSRomanStringEncoding
#endif
        ];
        NSString *keyEquivalent = [NSString stringWithFormat: @"%ld", (long)i];
        NSMenuItem *windowItem = [[NSMenuItem alloc] initWithTitle: title action: @selector(selectWindow:) keyEquivalent: keyEquivalent];
        [windowItem setTarget: self];
        [windowItem setTag: AngbandWindowMenuItemTagBase + i];
        [windowsMenu addItem: windowItem];
        [windowItem release];
    }
}

- (IBAction)setGraphicsMode:(NSMenuItem *)sender
{
    /* We stashed the graphics mode ID in the menu item's tag */
    graf_mode_req = [sender tag];

    /* Stash it in UserDefaults */
    [[NSUserDefaults angbandDefaults] setInteger:graf_mode_req forKey:AngbandGraphicsDefaultsKey];
    [[NSUserDefaults angbandDefaults] synchronize];
    
    if (game_in_progress)
    {
        /* Hack -- Force redraw */
        do_cmd_redraw();
        
        /* Wake up the event loop so it notices the change */
        wakeup_event_loop();
    }
}

- (IBAction) toggleSound: (NSMenuItem *) sender
{
    BOOL is_on = (sender.state == NSOnState);

    /* Toggle the state and update the Angband global and preferences. */
    sender.state = (is_on) ? NSOffState : NSOnState;
    use_sound = (is_on) ? FALSE : TRUE;
    [[NSUserDefaults angbandDefaults] setBool:(! is_on)
                                      forKey:AngbandSoundDefaultsKey];
}

/**
 *  Send a command to Angband via a menu item. This places the appropriate key
 * down events into the queue so that it seems like the user pressed them
 * (instead of trying to use the term directly).
 */
- (void)sendAngbandCommand: (id)sender
{
    NSMenuItem *menuItem = (NSMenuItem *)sender;
    NSString *command = [self.commandMenuTagMap objectForKey: [NSNumber numberWithInteger: [menuItem tag]]];
    NSInteger windowNumber = [((AngbandContext *)angband_term[0]->data)->primaryWindow windowNumber];

    /* Send a \ to bypass keymaps */
    NSEvent *escape = [NSEvent keyEventWithType: NSKeyDown
                                       location: NSZeroPoint
                                  modifierFlags: 0
                                      timestamp: 0.0
                                   windowNumber: windowNumber
                                        context: nil
                                     characters: @"\\"
                    charactersIgnoringModifiers: @"\\"
                                      isARepeat: NO
                                        keyCode: 0];
    [[NSApplication sharedApplication] postEvent: escape atStart: NO];

    /* Send the actual command (from the original command set) */
    NSEvent *keyDown = [NSEvent keyEventWithType: NSKeyDown
                                        location: NSZeroPoint
                                   modifierFlags: 0
                                       timestamp: 0.0
                                    windowNumber: windowNumber
                                         context: nil
                                      characters: command
                     charactersIgnoringModifiers: command
                                       isARepeat: NO
                                         keyCode: 0];
    [[NSApplication sharedApplication] postEvent: keyDown atStart: NO];
}

/**
 *  Set up the command menu dynamically, based on CommandMenu.plist.
 */
- (void)prepareCommandMenu
{
    NSString *commandMenuPath = [[NSBundle mainBundle] pathForResource: @"CommandMenu" ofType: @"plist"];
    NSArray *commandMenuItems = [[NSArray alloc] initWithContentsOfFile: commandMenuPath];
    NSMutableDictionary *angbandCommands = [[NSMutableDictionary alloc] init];
    NSString *tblname = @"CommandMenu";
    NSInteger tagOffset = 0;

    for( NSDictionary *item in commandMenuItems )
    {
        BOOL useShiftModifier = [[item valueForKey: @"ShiftModifier"] boolValue];
        BOOL useOptionModifier = [[item valueForKey: @"OptionModifier"] boolValue];
        NSUInteger keyModifiers = NSCommandKeyMask;
        keyModifiers |= (useShiftModifier) ? NSShiftKeyMask : 0;
        keyModifiers |= (useOptionModifier) ? NSAlternateKeyMask : 0;

        NSString *lookup = [item valueForKey: @"Title"];
        NSString *title = NSLocalizedStringWithDefaultValue(
            lookup, tblname, [NSBundle mainBundle], lookup, @"");
        NSString *key = [item valueForKey: @"KeyEquivalent"];
        NSMenuItem *menuItem = [[NSMenuItem alloc] initWithTitle: title action: @selector(sendAngbandCommand:) keyEquivalent: key];
        [menuItem setTarget: self];
        [menuItem setKeyEquivalentModifierMask: keyModifiers];
        [menuItem setTag: AngbandCommandMenuItemTagBase + tagOffset];
        [self.commandMenu addItem: menuItem];
        [menuItem release];

        NSString *angbandCommand = [item valueForKey: @"AngbandCommand"];
        [angbandCommands setObject: angbandCommand forKey: [NSNumber numberWithInteger: [menuItem tag]]];
        tagOffset++;
    }

    [commandMenuItems release];

    NSDictionary *safeCommands = [[NSDictionary alloc] initWithDictionary: angbandCommands];
    self.commandMenuTagMap = safeCommands;
    [safeCommands release];
    [angbandCommands release];
}

- (void)awakeFromNib
{
    [super awakeFromNib];

    [self prepareWindowsMenu];
    [self prepareCommandMenu];
}

- (void)applicationDidFinishLaunching:sender
{
    [AngbandContext beginGame];
    
    /* Once beginGame finished, the game is over - that's how Angband works,
         * and we should quit */
    game_is_finished = TRUE;
    [NSApp terminate:self];
}

- (NSApplicationTerminateReply)applicationShouldTerminate:(NSApplication *)sender
{
    if (p_ptr->playing == FALSE || game_is_finished == TRUE)
    {
        return NSTerminateNow;
    }
    else if (! inkey_flag)
    {
        /* For compatibility with other ports, do not quit in this case */
        return NSTerminateCancel;
    }
    else
    {
        /* Stop playing */
        /* player->upkeep->playing = FALSE; */

        /* Post an escape event so that we can return from our get-key-event
                 * function */
        wakeup_event_loop();
        quit_when_ready = true;
        /* Must return Cancel, not Later, because we need to get out of the
                 * run loop and back to Angband's loop */
        return NSTerminateCancel;
    }
}

/**
 * Dynamically build the Graphics menu
 */
- (void)menuNeedsUpdate:(NSMenu *)menu {
    
    /* Only the graphics menu is dynamic */
    if (! [menu isEqual:self.graphicsMenu])
        return;
    
    /* If it's non-empty, then we've already built it. Currently graphics modes
         * won't change once created; if they ever can we can remove this check.
     * Note that the check mark does change, but that's handled in
         * validateMenuItem: instead of menuNeedsUpdate: */
    if ([menu numberOfItems] > 0)
        return;
    
    /* This is the action for all these menu items */
    SEL action = @selector(setGraphicsMode:);
    
    /* Add an initial Classic ASCII menu item */
    NSString *tblname = @"GraphicsMenu";
    NSString *key = @"Classic ASCII";
    NSString *title = NSLocalizedStringWithDefaultValue(
        key, tblname, [NSBundle mainBundle], key, @"");
    NSMenuItem *classicItem = [menu addItemWithTitle:title action:action keyEquivalent:@""];
    [classicItem setTag:GRAPHICS_NONE];
    
    /* Walk through the list of graphics modes */
    if (graphics_modes) {
        NSInteger i;

        for (i=0; graphics_modes[i].pNext; i++)
        {
            const graphics_mode *graf = &graphics_modes[i];

            if (graf->grafID == GRAPHICS_NONE) {
                continue;
            }
            /* Make the title. NSMenuItem throws on a nil title, so ensure it's
                   * not nil. */
            key = [[NSString alloc] initWithUTF8String:graf->menuname];
            title = NSLocalizedStringWithDefaultValue(
                key, tblname, [NSBundle mainBundle], key, @"");
        
            /* Make the item */
            NSMenuItem *item = [menu addItemWithTitle:title action:action keyEquivalent:@""];
            [key release];
            [item setTag:graf->grafID];
        }
    }
}

/**
 * Delegate method that gets called if we're asked to open a file.
 */
- (BOOL)application:(NSApplication *)sender openFiles:(NSArray *)filenames
{
    /* Can't open a file once we've started */
    if (game_in_progress) return NO;
    
    /* We can only open one file. Use the last one. */
    NSString *file = [filenames lastObject];
    if (! file) return NO;
    
    /* Put it in savefile */
    if (! [file getFileSystemRepresentation:savefile maxLength:sizeof savefile])
                return NO;
    
    game_in_progress = TRUE;
    new_game = FALSE;

    /* Wake us up in case this arrives while we're sitting at the Welcome
         * screen! */
    wakeup_event_loop();
    
    return YES;
}

@end

int main(int argc, char* argv[])
{
    NSApplicationMain(argc, (void*)argv);
    return (0);
}

#endif /* MACINTOSH || MACH_O_COCOA */