3 * \brief OS X front end
5 * Copyright (c) 2011 Peter Ammon
7 * This work is free software; you can redistribute it and/or modify it
8 * under the terms of either:
10 * a) the GNU General Public License as published by the Free Software
11 * Foundation, version 2, or
13 * b) the "Angband licence":
14 * This software may be copied and distributed for educational, research,
15 * and not for profit purposes provided that this copyright and statement
16 * are included in all such copies. Other copyrights may also apply.
20 /* This is not included in angband.h in Hengband. */
23 #if defined(MACH_O_COCOA)
26 #include <Cocoa/Cocoa.h>
27 //#include <Carbon/Carbon.h> /* For keycodes */
28 /* Hack - keycodes to enable compiling in macOS 10.14 */
29 #define kVK_Return 0x24
31 #define kVK_Delete 0x33
32 #define kVK_Escape 0x35
33 #define kVK_ANSI_KeypadEnter 0x4C
35 static NSString * const AngbandDirectoryNameLib = @"lib";
36 static NSString * const AngbandDirectoryNameBase = @"Hengband";
38 static NSString * const AngbandMessageCatalog = @"Localizable";
39 static NSString * const AngbandTerminalsDefaultsKey = @"Terminals";
40 static NSString * const AngbandTerminalRowsDefaultsKey = @"Rows";
41 static NSString * const AngbandTerminalColumnsDefaultsKey = @"Columns";
42 static NSString * const AngbandTerminalVisibleDefaultsKey = @"Visible";
43 static NSString * const AngbandGraphicsDefaultsKey = @"GraphicsID";
44 static NSString * const AngbandFrameRateDefaultsKey = @"FramesPerSecond";
45 static NSString * const AngbandSoundDefaultsKey = @"AllowSound";
46 static NSInteger const AngbandWindowMenuItemTagBase = 1000;
47 static NSInteger const AngbandCommandMenuItemTagBase = 2000;
49 /* We can blit to a large layer or image and then scale it down during live
50 * resize, which makes resizing much faster, at the cost of some image quality
52 #ifndef USE_LIVE_RESIZE_CACHE
53 # define USE_LIVE_RESIZE_CACHE 1
56 /* Global defines etc from Angband 3.5-dev - NRM */
57 #define ANGBAND_TERM_MAX 8
59 static bool new_game = TRUE;
61 #define MAX_COLORS 256
62 #define MSG_MAX SOUND_MAX
64 /* End Angband stuff - NRM */
66 /* Application defined event numbers */
69 AngbandEventWakeup = 1
72 /* Redeclare some 10.7 constants and methods so we can build on 10.6 */
75 Angband_NSWindowCollectionBehaviorFullScreenPrimary = 1 << 7,
76 Angband_NSWindowCollectionBehaviorFullScreenAuxiliary = 1 << 8
79 @interface NSWindow (AngbandLionRedeclares)
80 - (void)setRestorable:(BOOL)flag;
83 /* Delay handling of pre-emptive "quit" event */
84 static BOOL quit_when_ready = FALSE;
86 /* Set to indicate the game is over and we can quit without delay */
87 static Boolean game_is_finished = FALSE;
89 /* Our frames per second (e.g. 60). A value of 0 means unthrottled. */
90 static int frames_per_second;
92 /* Function to get the default font */
93 static NSFont *default_font;
98 * To handle fonts where an individual glyph's bounding box can extend into
99 * neighboring columns, Term_curs_cocoa(), Term_pict_cocoa(),
100 * Term_text_cocoa(), and Term_wipe_cocoa() merely record what needs to be
101 * done with the actual drawing happening in response to the notification to
102 * flush all rows, the TERM_XTRA_FRESH case in Term_xtra_cocoa(). Can not use
103 * the TERM_XTRA_FROSH notification (the per-row flush), since with a software
104 * cursor, there are calls to Term_pict_cocoa(), Term_text_cocoa(), or
105 * Term_wipe_cocoa() to take care of the old cursor position which are not
106 * followed by a row flush.
108 enum PendingCellChangeType {
109 CELL_CHANGE_NONE = 0,
114 struct PendingCellChange {
116 * For text rendering, stores the character as a wchar_t; for tile
117 * rendering, stores the column in the tile set for the source tile.
119 union { wchar_t w; char c; } c;
121 * For text rendering, stores the color; for tile rendering, stores the
122 * row in the tile set for the source tile.
126 * For text rendering, is one if wc is a character that takes up two
127 * columns (i.e. Japanese kanji); otherwise it is zero. For tile
128 * rendering, Stores the column in the tile set for the terrain tile. */
131 * For tile rendering, stores the row in the tile set for the
135 enum PendingCellChangeType change_type;
138 struct PendingRowChange
141 * These are the first and last columns, inclusive, that have been
142 * modified. xmin is greater than xmax if no changes have been made.
146 * This points to storage for a number of elements equal to the number
147 * of columns (implicitly gotten from the enclosing AngbandContext).
149 struct PendingCellChange* cell_changes;
152 static struct PendingRowChange* create_row_change(int ncol)
154 struct PendingRowChange* prc =
155 (struct PendingRowChange*) malloc(sizeof(struct PendingRowChange));
156 struct PendingCellChange* pcc = (struct PendingCellChange*)
157 malloc(ncol * sizeof(struct PendingCellChange));
160 if (prc == 0 || pcc == 0) {
172 prc->cell_changes = pcc;
173 for (i = 0; i < ncol; ++i) {
174 pcc[i].change_type = CELL_CHANGE_NONE;
180 static void destroy_row_change(struct PendingRowChange* prc)
183 if (prc->cell_changes != 0) {
184 free(prc->cell_changes);
191 struct PendingChanges
193 /* Hold the number of rows specified at creation. */
196 * Hold the position set for the software cursor. Use negative indices
197 * to indicate that the cursor is not displayed.
200 /* Is nonzero if the cursor should be drawn at double the tile width. */
202 /* Record whether the changes include any text, picts, or wipes. */
203 int has_text, has_pict, has_wipe;
205 * These are the first and last rows, inclusive, that have been
206 * modified. ymin is greater than ymax if no changes have been made.
210 * This is an array of pointers to the changes. The number of elements
211 * is the number of rows. An element will be a NULL pointer if no
212 * modifications have been made to the row.
214 struct PendingRowChange** rows;
218 static struct PendingChanges* create_pending_changes(int ncol, int nrow)
220 struct PendingChanges* pc =
221 (struct PendingChanges*) malloc(sizeof(struct PendingChanges));
222 struct PendingRowChange** pprc = (struct PendingRowChange**)
223 malloc(nrow * sizeof(struct PendingRowChange*));
226 if (pc == 0 || pprc == 0) {
246 for (i = 0; i < nrow; ++i) {
253 static void destroy_pending_changes(struct PendingChanges* pc)
259 for (i = 0; i < pc->nrow; ++i) {
260 if (pc->rows[i] != 0) {
261 destroy_row_change(pc->rows[i]);
271 static void clear_pending_changes(struct PendingChanges* pc)
284 for (i = 0; i < pc->nrow; ++i) {
285 if (pc->rows[i] != 0) {
286 destroy_row_change(pc->rows[i]);
294 /* Return zero if successful; otherwise return a nonzero value. */
295 static int resize_pending_changes(struct PendingChanges* pc, int nrow)
297 struct PendingRowChange** pprc;
304 pprc = (struct PendingRowChange**)
305 malloc(nrow * sizeof(struct PendingRowChange*));
309 for (i = 0; i < nrow; ++i) {
314 for (i = 0; i < pc->nrow; ++i) {
315 if (pc->rows[i] != 0) {
316 destroy_row_change(pc->rows[i]);
335 /* The max number of glyphs we support. Currently this only affects
336 * updateGlyphInfo() for the calculation of the tile size, fontAscender,
337 * fontDescender, ncol_pre, and ncol_post (the glyphArray and glyphWidths
338 * members of AngbandContext are only used in updateGlyphInfo()). The
339 * rendering in drawWChar will work for glyphs not in updateGlyphInfo()'s
340 * set, and that is used for rendering Japanese characters.
342 #define GLYPH_COUNT 256
344 /* An AngbandContext represents a logical Term (i.e. what Angband thinks is
345 * a window). This typically maps to one NSView, but may map to more than one
346 * NSView (e.g. the Test and real screen saver view). */
347 @interface AngbandContext : NSObject <NSWindowDelegate>
351 /* The Angband term */
354 /* Column and row cont, by default 80 x 24 */
358 /* The size of the border between the window edge and the contents */
361 /* Our array of views */
362 NSMutableArray *angbandViews;
364 /* The buffered image */
365 CGLayerRef angbandLayer;
367 /* The font of this context */
368 NSFont *angbandViewFont;
370 /* If this context owns a window, here it is */
371 NSWindow *primaryWindow;
373 /* "Glyph info": an array of the CGGlyphs and their widths corresponding to
375 CGGlyph glyphArray[GLYPH_COUNT];
376 CGFloat glyphWidths[GLYPH_COUNT];
378 /* The size of one tile */
381 /* Font's ascender and descender */
382 CGFloat fontAscender, fontDescender;
384 /* Whether we are currently in live resize, which affects how big we render
388 /* Last time we drew, so we can throttle drawing */
389 CFAbsoluteTime lastRefreshTime;
391 struct PendingChanges* changes;
393 * These are the number of columns before or after, respectively, a text
394 * change that may need to be redrawn.
396 int ncol_pre, ncol_post;
398 /* Flags whether or not a fullscreen transition is in progress. */
399 BOOL in_fullscreen_transition;
403 BOOL _hasSubwindowFlags;
404 BOOL _windowVisibilityChecked;
407 @property (nonatomic, assign) BOOL hasSubwindowFlags;
408 @property (nonatomic, assign) BOOL windowVisibilityChecked;
410 - (void)drawRect:(NSRect)rect inView:(NSView *)view;
412 /* Called at initialization to set the term */
413 - (void)setTerm:(term *)t;
415 /* Called when the context is going down. */
418 /* Returns the size of the image. */
421 /* Return the rect for a tile at given coordinates. */
422 - (NSRect)rectInImageForTileAtX:(int)x Y:(int)y;
424 /* Draw the given wide character into the given tile rect. */
425 - (void)drawWChar:(wchar_t)wchar inRect:(NSRect)tile context:(CGContextRef)ctx;
427 /* Locks focus on the Angband image, and scales the CTM appropriately. */
428 - (CGContextRef)lockFocus;
430 /* Locks focus on the Angband image but does NOT scale the CTM. Appropriate
431 * for drawing hairlines. */
432 - (CGContextRef)lockFocusUnscaled;
437 /* Returns the primary window for this angband context, creating it if
439 - (NSWindow *)makePrimaryWindow;
441 /* Called to add a new Angband view */
442 - (void)addAngbandView:(AngbandView *)view;
444 /* Make the context aware that one of its views changed size */
445 - (void)angbandViewDidScale:(AngbandView *)view;
447 /* Handle becoming the main window */
448 - (void)windowDidBecomeMain:(NSNotification *)notification;
450 /* Return whether the context's primary window is ordered in or not */
453 /* Return whether the context's primary window is key */
454 - (BOOL)isMainWindow;
456 /* Invalidate the whole image */
457 - (void)setNeedsDisplay:(BOOL)val;
459 /* Invalidate part of the image, with the rect expressed in base coordinates */
460 - (void)setNeedsDisplayInBaseRect:(NSRect)rect;
462 /* Display (flush) our Angband views */
463 - (void)displayIfNeeded;
465 /* Resize context to size of contentRect, and optionally save size to
467 - (void)resizeTerminalWithContentRect: (NSRect)contentRect saveToDefaults: (BOOL)saveToDefaults;
469 /* Change the minimum size for the window associated with the context. */
470 - (void)setMinimumWindowSize;
472 /* Called from the view to indicate that it is starting or ending live resize */
473 - (void)viewWillStartLiveResize:(AngbandView *)view;
474 - (void)viewDidEndLiveResize:(AngbandView *)view;
475 - (void)saveWindowVisibleToDefaults: (BOOL)windowVisible;
476 - (BOOL)windowVisibleUsingDefaults;
480 /* Begins an Angband game. This is the entry point for starting off. */
483 /* Ends an Angband game. */
486 /* Internal method */
487 - (AngbandView *)activeView;
492 * Generate a mask for the subwindow flags. The mask is just a safety check to
493 * make sure that our windows show and hide as expected. This function allows
494 * for future changes to the set of flags without needed to update it here
495 * (unless the underlying types change).
497 u32b AngbandMaskForValidSubwindowFlags(void)
499 int windowFlagBits = sizeof(*(window_flag)) * CHAR_BIT;
500 int maxBits = MIN( 16, windowFlagBits );
503 for( int i = 0; i < maxBits; i++ )
505 if( window_flag_desc[i] != NULL )
515 * Check for changes in the subwindow flags and update window visibility.
516 * This seems to be called for every user event, so we don't
517 * want to do any unnecessary hiding or showing of windows.
519 static void AngbandUpdateWindowVisibility(void)
521 /* Because this function is called frequently, we'll make the mask static.
522 * It doesn't change between calls, as the flags themselves are hardcoded */
523 static u32b validWindowFlagsMask = 0;
525 if( validWindowFlagsMask == 0 )
527 validWindowFlagsMask = AngbandMaskForValidSubwindowFlags();
530 /* Loop through all of the subwindows and see if there is a change in the
531 * flags. If so, show or hide the corresponding window. We don't care about
532 * the flags themselves; we just want to know if any are set. */
533 for( int i = 1; i < ANGBAND_TERM_MAX; i++ )
535 AngbandContext *angbandContext = angband_term[i]->data;
537 if( angbandContext == nil )
542 /* This horrible mess of flags is so that we can try to maintain some
543 * user visibility preference. This should allow the user a window and
544 * have it stay closed between application launches. However, this
545 * means that when a subwindow is turned on, it will no longer appear
546 * automatically. Angband has no concept of user control over window
547 * visibility, other than the subwindow flags. */
548 if( !angbandContext.windowVisibilityChecked )
550 if( [angbandContext windowVisibleUsingDefaults] )
552 [angbandContext->primaryWindow orderFront: nil];
553 angbandContext.windowVisibilityChecked = YES;
557 [angbandContext->primaryWindow close];
558 angbandContext.windowVisibilityChecked = NO;
563 BOOL termHasSubwindowFlags = ((window_flag[i] & validWindowFlagsMask) > 0);
565 if( angbandContext.hasSubwindowFlags && !termHasSubwindowFlags )
567 [angbandContext->primaryWindow close];
568 angbandContext.hasSubwindowFlags = NO;
569 [angbandContext saveWindowVisibleToDefaults: NO];
571 else if( !angbandContext.hasSubwindowFlags && termHasSubwindowFlags )
573 [angbandContext->primaryWindow orderFront: nil];
574 angbandContext.hasSubwindowFlags = YES;
575 [angbandContext saveWindowVisibleToDefaults: YES];
580 /* Make the main window key so that user events go to the right spot */
581 AngbandContext *mainWindow = angband_term[0]->data;
582 [mainWindow->primaryWindow makeKeyAndOrderFront: nil];
586 * ------------------------------------------------------------------------
588 * ------------------------------------------------------------------------ */
593 static CGImageRef pict_image;
596 * Numbers of rows and columns in a tileset,
597 * calculated by the PICT/PNG loading code
599 static int pict_cols = 0;
600 static int pict_rows = 0;
603 * Requested graphics mode (as a grafID).
604 * The current mode is stored in current_graphics_mode.
606 static int graf_mode_req = 0;
609 * Helper function to check the various ways that graphics can be enabled,
610 * guarding against NULL
612 static BOOL graphics_are_enabled(void)
614 return current_graphics_mode
615 && current_graphics_mode->grafID != GRAPHICS_NONE;
619 * Hack -- game in progress
621 static Boolean game_in_progress = FALSE;
624 #pragma mark Prototypes
625 static void wakeup_event_loop(void);
626 static void hook_plog(const char *str);
627 static void hook_quit(const char * str);
628 static void load_prefs(void);
629 static void load_sounds(void);
630 static void init_windows(void);
631 static void handle_open_when_ready(void);
632 static void play_sound(int event);
633 static BOOL check_events(int wait);
634 static BOOL send_event(NSEvent *event);
635 static void record_current_savefile(void);
637 static wchar_t convert_two_byte_eucjp_to_utf16_native(const char *cp);
641 * Available values for 'wait'
643 #define CHECK_EVENTS_DRAIN -1
644 #define CHECK_EVENTS_NO_WAIT 0
645 #define CHECK_EVENTS_WAIT 1
649 * Note when "open"/"new" become valid
651 static bool initialized = FALSE;
653 /* Methods for getting the appropriate NSUserDefaults */
654 @interface NSUserDefaults (AngbandDefaults)
655 + (NSUserDefaults *)angbandDefaults;
658 @implementation NSUserDefaults (AngbandDefaults)
659 + (NSUserDefaults *)angbandDefaults
661 return [NSUserDefaults standardUserDefaults];
665 /* Methods for pulling images out of the Angband bundle (which may be separate
666 * from the current bundle in the case of a screensaver */
667 @interface NSImage (AngbandImages)
668 + (NSImage *)angbandImage:(NSString *)name;
671 /* The NSView subclass that draws our Angband image */
672 @interface AngbandView : NSView
674 IBOutlet AngbandContext *angbandContext;
677 - (void)setAngbandContext:(AngbandContext *)context;
678 - (AngbandContext *)angbandContext;
682 @implementation NSImage (AngbandImages)
684 /* Returns an image in the resource directoy of the bundle containing the
685 * Angband view class. */
686 + (NSImage *)angbandImage:(NSString *)name
688 NSBundle *bundle = [NSBundle bundleForClass:[AngbandView class]];
689 NSString *path = [bundle pathForImageResource:name];
691 if (path) result = [[[NSImage alloc] initByReferencingFile:path] autorelease];
699 @implementation AngbandContext
701 @synthesize hasSubwindowFlags=_hasSubwindowFlags;
702 @synthesize windowVisibilityChecked=_windowVisibilityChecked;
704 - (NSFont *)selectionFont
706 return angbandViewFont;
709 - (BOOL)useLiveResizeOptimization
711 /* If we have graphics turned off, text rendering is fast enough that we
712 * don't need to use a live resize optimization. */
713 return inLiveResize && graphics_are_enabled();
718 /* We round the base size down. If we round it up, I believe we may end up
719 * with pixels that nobody "owns" that may accumulate garbage. In general
720 * rounding down is harmless, because any lost pixels may be sopped up by
722 return NSMakeSize(floor(cols * tileSize.width + 2 * borderSize.width), floor(rows * tileSize.height + 2 * borderSize.height));
725 /* qsort-compatible compare function for CGSizes */
726 static int compare_advances(const void *ap, const void *bp)
728 const CGSize *a = ap, *b = bp;
729 return (a->width > b->width) - (a->width < b->width);
732 - (void)updateGlyphInfo
734 /* Update glyphArray and glyphWidths */
735 NSFont *screenFont = [angbandViewFont screenFont];
737 /* Generate a string containing each MacRoman character */
738 unsigned char latinString[GLYPH_COUNT];
740 for (i=0; i < GLYPH_COUNT; i++) latinString[i] = (unsigned char)i;
742 /* Turn that into unichar. Angband uses ISO Latin 1. */
743 unichar unicharString[GLYPH_COUNT] = {0};
744 NSString *allCharsString = [[NSString alloc] initWithBytes:latinString length:sizeof latinString encoding:NSISOLatin1StringEncoding];
745 [allCharsString getCharacters:unicharString range:NSMakeRange(0, MIN(GLYPH_COUNT, [allCharsString length]))];
746 [allCharsString autorelease];
749 memset(glyphArray, 0, sizeof glyphArray);
750 CTFontGetGlyphsForCharacters((CTFontRef)screenFont, unicharString, glyphArray, GLYPH_COUNT);
752 /* Get advances. Record the max advance. */
753 CGSize advances[GLYPH_COUNT] = {};
754 CTFontGetAdvancesForGlyphs((CTFontRef)screenFont, kCTFontHorizontalOrientation, glyphArray, advances, GLYPH_COUNT);
755 for (i=0; i < GLYPH_COUNT; i++) {
756 glyphWidths[i] = advances[i].width;
759 /* For good non-mono-font support, use the median advance. Start by sorting
761 qsort(advances, GLYPH_COUNT, sizeof *advances, compare_advances);
763 /* Skip over any initially empty run */
765 for (startIdx = 0; startIdx < GLYPH_COUNT; startIdx++)
767 if (advances[startIdx].width > 0) break;
770 /* Pick the center to find the median */
771 CGFloat medianAdvance = 0;
772 if (startIdx < GLYPH_COUNT)
774 /* In case we have all zero advances for some reason */
775 medianAdvance = advances[(startIdx + GLYPH_COUNT)/2].width;
779 * Record the ascender and descender. Some fonts, for instance DIN
780 * Condensed and Rockwell in 10.14, the ascent on '@' exceeds that
781 * reported by [screenFont ascender]. Get the overall bounding box
782 * for the glyphs and use that instead of the ascender and descender
783 * values if the bounding box result extends farther from the baseline.
785 CGRect bounds = CTFontGetBoundingRectsForGlyphs((CTFontRef) screenFont, kCTFontHorizontalOrientation, glyphArray, NULL, GLYPH_COUNT);
786 fontAscender = [screenFont ascender];
787 if (fontAscender < bounds.origin.y + bounds.size.height) {
788 fontAscender = bounds.origin.y + bounds.size.height;
790 fontDescender = [screenFont descender];
791 if (fontDescender > bounds.origin.y) {
792 fontDescender = bounds.origin.y;
796 * Record the tile size. Round both values up to have tile boundaries
797 * match pixel boundaries.
799 tileSize.width = ceil(medianAdvance);
800 tileSize.height = ceil(fontAscender - fontDescender);
803 * Determine whether neighboring columns need to redrawn when a character
806 CGRect boxes[GLYPH_COUNT] = {};
807 CGFloat beyond_right = 0.;
808 CGFloat beyond_left = 0.;
809 CTFontGetBoundingRectsForGlyphs(
810 (CTFontRef)screenFont,
811 kCTFontHorizontalOrientation,
815 for (i = 0; i < GLYPH_COUNT; i++) {
816 /* Account for the compression and offset used by drawWChar(). */
817 CGFloat compression, offset;
820 if (glyphWidths[i] <= tileSize.width) {
822 offset = 0.5 * (tileSize.width - glyphWidths[i]);
824 compression = tileSize.width / glyphWidths[i];
827 v = (offset + boxes[i].origin.x) * compression;
828 if (beyond_left > v) {
831 v = (offset + boxes[i].origin.x + boxes[i].size.width) * compression;
832 if (beyond_right < v) {
836 ncol_pre = ceil(-beyond_left / tileSize.width);
837 if (beyond_right > tileSize.width) {
838 ncol_post = ceil((beyond_right - tileSize.width) / tileSize.width);
846 NSSize size = NSMakeSize(1, 1);
848 AngbandView *activeView = [self activeView];
851 /* If we are in live resize, draw as big as the screen, so we can scale
852 * nicely to any size. If we are not in live resize, then use the
853 * bounds of the active view. */
855 if ([self useLiveResizeOptimization] && (screen = [[activeView window] screen]) != NULL)
857 size = [screen frame].size;
861 size = [activeView bounds].size;
865 CGLayerRelease(angbandLayer);
867 /* Use the highest monitor scale factor on the system to work out what
868 * scale to draw at - not the recommended method, but works where we
869 * can't easily get the monitor the current draw is occurring on. */
870 float angbandLayerScale = 1.0;
871 if ([[NSScreen mainScreen] respondsToSelector:@selector(backingScaleFactor)]) {
872 for (NSScreen *screen in [NSScreen screens]) {
873 angbandLayerScale = fmax(angbandLayerScale, [screen backingScaleFactor]);
877 /* Make a bitmap context as an example for our layer */
878 CGColorSpaceRef cs = CGColorSpaceCreateDeviceRGB();
879 CGContextRef exampleCtx = CGBitmapContextCreate(NULL, 1, 1, 8 /* bits per component */, 48 /* bytesPerRow */, cs, kCGImageAlphaNoneSkipFirst | kCGBitmapByteOrder32Host);
880 CGColorSpaceRelease(cs);
882 /* Create the layer at the appropriate size */
883 size.width = fmax(1, ceil(size.width * angbandLayerScale));
884 size.height = fmax(1, ceil(size.height * angbandLayerScale));
885 angbandLayer = CGLayerCreateWithContext(exampleCtx, *(CGSize *)&size, NULL);
887 CFRelease(exampleCtx);
889 /* Set the new context of the layer to draw at the correct scale */
890 CGContextRef ctx = CGLayerGetContext(angbandLayer);
891 CGContextScaleCTM(ctx, angbandLayerScale, angbandLayerScale);
894 [[NSColor blackColor] set];
895 NSRectFill((NSRect){NSZeroPoint, [self baseSize]});
899 - (void)requestRedraw
901 if (! self->terminal) return;
905 /* Activate the term */
906 Term_activate(self->terminal);
908 /* Redraw the contents */
911 /* Flush the output */
914 /* Restore the old term */
918 - (void)setTerm:(term *)t
923 - (void)viewWillStartLiveResize:(AngbandView *)view
925 #if USE_LIVE_RESIZE_CACHE
926 if (inLiveResize < INT_MAX) inLiveResize++;
927 else [NSException raise:NSInternalInconsistencyException format:@"inLiveResize overflow"];
929 if (inLiveResize == 1 && graphics_are_enabled())
933 [self setNeedsDisplay:YES]; /* We'll need to redisplay everything anyways, so avoid creating all those little redisplay rects */
934 [self requestRedraw];
939 - (void)viewDidEndLiveResize:(AngbandView *)view
941 #if USE_LIVE_RESIZE_CACHE
942 if (inLiveResize > 0) inLiveResize--;
943 else [NSException raise:NSInternalInconsistencyException format:@"inLiveResize underflow"];
945 if (inLiveResize == 0 && graphics_are_enabled())
949 [self setNeedsDisplay:YES]; /* We'll need to redisplay everything anyways, so avoid creating all those little redisplay rects */
950 [self requestRedraw];
956 * If we're trying to limit ourselves to a certain number of frames per second,
957 * then compute how long it's been since we last drew, and then wait until the
958 * next frame has passed. */
961 if (frames_per_second > 0)
963 CFAbsoluteTime now = CFAbsoluteTimeGetCurrent();
964 CFTimeInterval timeSinceLastRefresh = now - lastRefreshTime;
965 CFTimeInterval timeUntilNextRefresh = (1. / (double)frames_per_second) - timeSinceLastRefresh;
967 if (timeUntilNextRefresh > 0)
969 usleep((unsigned long)(timeUntilNextRefresh * 1000000.));
972 lastRefreshTime = CFAbsoluteTimeGetCurrent();
975 - (void)drawWChar:(wchar_t)wchar inRect:(NSRect)tile context:(CGContextRef)ctx
977 CGFloat tileOffsetY = fontAscender;
978 CGFloat tileOffsetX = 0.0;
979 NSFont *screenFont = [angbandViewFont screenFont];
980 UniChar unicharString[2] = {(UniChar)wchar, 0};
982 /* Get glyph and advance */
983 CGGlyph thisGlyphArray[1] = { 0 };
984 CGSize advances[1] = { { 0, 0 } };
985 CTFontGetGlyphsForCharacters((CTFontRef)screenFont, unicharString, thisGlyphArray, 1);
986 CGGlyph glyph = thisGlyphArray[0];
987 CTFontGetAdvancesForGlyphs((CTFontRef)screenFont, kCTFontHorizontalOrientation, thisGlyphArray, advances, 1);
988 CGSize advance = advances[0];
990 /* If our font is not monospaced, our tile width is deliberately not big
991 * enough for every character. In that event, if our glyph is too wide, we
992 * need to compress it horizontally. Compute the compression ratio.
993 * 1.0 means no compression. */
994 double compressionRatio;
995 if (advance.width <= NSWidth(tile))
997 /* Our glyph fits, so we can just draw it, possibly with an offset */
998 compressionRatio = 1.0;
999 tileOffsetX = (NSWidth(tile) - advance.width)/2;
1003 /* Our glyph doesn't fit, so we'll have to compress it */
1004 compressionRatio = NSWidth(tile) / advance.width;
1010 CGAffineTransform textMatrix = CGContextGetTextMatrix(ctx);
1011 CGFloat savedA = textMatrix.a;
1013 /* Set the position */
1014 textMatrix.tx = tile.origin.x + tileOffsetX;
1015 textMatrix.ty = tile.origin.y + tileOffsetY;
1017 /* Maybe squish it horizontally. */
1018 if (compressionRatio != 1.)
1020 textMatrix.a *= compressionRatio;
1023 textMatrix = CGAffineTransformScale( textMatrix, 1.0, -1.0 );
1024 CGContextSetTextMatrix(ctx, textMatrix);
1025 CGContextShowGlyphsAtPositions(ctx, &glyph, &CGPointZero, 1);
1027 /* Restore the text matrix if we messed with the compression ratio */
1028 if (compressionRatio != 1.)
1030 textMatrix.a = savedA;
1031 CGContextSetTextMatrix(ctx, textMatrix);
1034 textMatrix = CGAffineTransformScale( textMatrix, 1.0, -1.0 );
1035 CGContextSetTextMatrix(ctx, textMatrix);
1038 /* Lock and unlock focus on our image or layer, setting up the CTM
1040 - (CGContextRef)lockFocusUnscaled
1042 /* Create an NSGraphicsContext representing this CGLayer */
1043 CGContextRef ctx = CGLayerGetContext(angbandLayer);
1044 NSGraphicsContext *context = [NSGraphicsContext graphicsContextWithGraphicsPort:ctx flipped:NO];
1045 [NSGraphicsContext saveGraphicsState];
1046 [NSGraphicsContext setCurrentContext:context];
1047 CGContextSaveGState(ctx);
1053 /* Restore the graphics state */
1054 CGContextRef ctx = [[NSGraphicsContext currentContext] graphicsPort];
1055 CGContextRestoreGState(ctx);
1056 [NSGraphicsContext restoreGraphicsState];
1061 /* Return the size of our layer */
1062 CGSize result = CGLayerGetSize(angbandLayer);
1063 return NSMakeSize(result.width, result.height);
1066 - (CGContextRef)lockFocus
1068 return [self lockFocusUnscaled];
1072 - (NSRect)rectInImageForTileAtX:(int)x Y:(int)y
1075 return NSMakeRect(x * tileSize.width + borderSize.width, flippedY * tileSize.height + borderSize.height, tileSize.width, tileSize.height);
1078 - (void)setSelectionFont:(NSFont*)font adjustTerminal: (BOOL)adjustTerminal
1080 /* Record the new font */
1082 [angbandViewFont release];
1083 angbandViewFont = font;
1085 /* Update our glyph info */
1086 [self updateGlyphInfo];
1088 if( adjustTerminal )
1090 /* Adjust terminal to fit window with new font; save the new columns
1091 * and rows since they could be changed */
1092 NSRect contentRect = [self->primaryWindow contentRectForFrameRect: [self->primaryWindow frame]];
1094 [self setMinimumWindowSize];
1095 NSSize size = self->primaryWindow.contentMinSize;
1096 BOOL windowNeedsResizing = NO;
1097 if (contentRect.size.width < size.width) {
1098 contentRect.size.width = size.width;
1099 windowNeedsResizing = YES;
1101 if (contentRect.size.height < size.height) {
1102 contentRect.size.height = size.height;
1103 windowNeedsResizing = YES;
1105 if (windowNeedsResizing) {
1106 size.width = contentRect.size.width;
1107 size.height = contentRect.size.height;
1108 [self->primaryWindow setContentSize:size];
1110 [self resizeTerminalWithContentRect: contentRect saveToDefaults: YES];
1113 /* Update our image */
1117 [self requestRedraw];
1122 if ((self = [super init]))
1124 /* Default rows and cols */
1128 /* Default border size */
1129 self->borderSize = NSMakeSize(2, 2);
1131 /* Allocate our array of views */
1132 angbandViews = [[NSMutableArray alloc] init];
1134 self->changes = create_pending_changes(self->cols, self->rows);
1135 if (self->changes == 0) {
1136 NSLog(@"AngbandContext init: out of memory for pending changes");
1139 self->ncol_post = 0;
1141 self->in_fullscreen_transition = NO;
1143 /* Make the image. Since we have no views, it'll just be a puny 1x1 image. */
1146 _windowVisibilityChecked = NO;
1152 * Destroy all the receiver's stuff. This is intended to be callable more than
1159 /* Disassociate ourselves from our angbandViews */
1160 [angbandViews makeObjectsPerformSelector:@selector(setAngbandContext:) withObject:nil];
1161 [angbandViews release];
1164 /* Destroy the layer/image */
1165 CGLayerRelease(angbandLayer);
1166 angbandLayer = NULL;
1169 [angbandViewFont release];
1170 angbandViewFont = nil;
1173 [primaryWindow setDelegate:nil];
1174 [primaryWindow close];
1175 [primaryWindow release];
1176 primaryWindow = nil;
1178 /* Pending changes */
1179 destroy_pending_changes(self->changes);
1183 /* Usual Cocoa fare */
1193 #pragma mark Directories and Paths Setup
1196 * Return the path for Angband's lib directory and bail if it isn't found. The
1197 * lib directory should be in the bundle's resources directory, since it's
1198 * copied when built.
1200 + (NSString *)libDirectoryPath
1202 NSString *bundleLibPath = [[[NSBundle mainBundle] resourcePath] stringByAppendingPathComponent: AngbandDirectoryNameLib];
1203 BOOL isDirectory = NO;
1204 BOOL libExists = [[NSFileManager defaultManager] fileExistsAtPath: bundleLibPath isDirectory: &isDirectory];
1206 if( !libExists || !isDirectory )
1208 NSLog( @"[%@ %@]: can't find %@/ in bundle: isDirectory: %d libExists: %d", NSStringFromClass( [self class] ), NSStringFromSelector( _cmd ), AngbandDirectoryNameLib, isDirectory, libExists );
1210 NSString *msg = NSLocalizedStringWithDefaultValue(
1211 @"Error.MissingResources",
1212 AngbandMessageCatalog,
1213 [NSBundle mainBundle],
1214 @"Missing Resources",
1215 @"Alert text for missing resources");
1216 NSString *info = NSLocalizedStringWithDefaultValue(
1217 @"Error.MissingAngbandLib",
1218 AngbandMessageCatalog,
1219 [NSBundle mainBundle],
1220 @"Hengband was unable to find required resources and must quit. Please report a bug on the Angband forums.",
1221 @"Alert informative message for missing Angband lib/ folder");
1222 NSString *quit_label = NSLocalizedStringWithDefaultValue(
1223 @"Label.Quit", AngbandMessageCatalog, [NSBundle mainBundle],
1225 NSAlert *alert = [[NSAlert alloc] init];
1228 * Note that NSCriticalAlertStyle was deprecated in 10.10. The
1229 * replacement is NSAlertStyleCritical.
1231 alert.alertStyle = NSCriticalAlertStyle;
1232 alert.messageText = msg;
1233 alert.informativeText = info;
1234 [alert addButtonWithTitle:quit_label];
1235 NSModalResponse result = [alert runModal];
1240 return bundleLibPath;
1244 * Return the path for the directory where Angband should look for its standard
1247 + (NSString *)angbandDocumentsPath
1249 NSString *documents = [NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES) lastObject];
1251 #if defined(SAFE_DIRECTORY)
1252 NSString *versionedDirectory = [NSString stringWithFormat: @"%@-%s", AngbandDirectoryNameBase, VERSION_STRING];
1253 return [documents stringByAppendingPathComponent: versionedDirectory];
1255 return [documents stringByAppendingPathComponent: AngbandDirectoryNameBase];
1260 * Adjust directory paths as needed to correct for any differences needed by
1261 * Angband. \c init_file_paths() currently requires that all paths provided have
1262 * a trailing slash and all other platforms honor this.
1264 * \param originalPath The directory path to adjust.
1265 * \return A path suitable for Angband or nil if an error occurred.
1267 static NSString *AngbandCorrectedDirectoryPath(NSString *originalPath)
1269 if ([originalPath length] == 0) {
1273 if (![originalPath hasSuffix: @"/"]) {
1274 return [originalPath stringByAppendingString: @"/"];
1277 return originalPath;
1281 * Give Angband the base paths that should be used for the various directories
1282 * it needs. It will create any needed directories.
1284 + (void)prepareFilePathsAndDirectories
1286 char libpath[PATH_MAX + 1] = "\0";
1287 NSString *libDirectoryPath = AngbandCorrectedDirectoryPath([self libDirectoryPath]);
1288 [libDirectoryPath getFileSystemRepresentation: libpath maxLength: sizeof(libpath)];
1290 char basepath[PATH_MAX + 1] = "\0";
1291 NSString *angbandDocumentsPath = AngbandCorrectedDirectoryPath([self angbandDocumentsPath]);
1292 [angbandDocumentsPath getFileSystemRepresentation: basepath maxLength: sizeof(basepath)];
1294 init_file_paths(libpath, libpath, basepath);
1295 create_needed_dirs();
1301 /* From the Linux mbstowcs(3) man page:
1302 * If dest is NULL, n is ignored, and the conversion proceeds as above,
1303 * except that the converted wide characters are not written out to mem‐
1304 * ory, and that no length limit exists.
1306 static size_t Term_mbcs_cocoa(wchar_t *dest, const char *src, int n)
1311 /* Unicode code point to UTF-8
1312 * 0x0000-0x007f: 0xxxxxxx
1313 * 0x0080-0x07ff: 110xxxxx 10xxxxxx
1314 * 0x0800-0xffff: 1110xxxx 10xxxxxx 10xxxxxx
1315 * 0x10000-0x1fffff: 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
1316 * Note that UTF-16 limits Unicode to 0x10ffff. This code is not
1319 for (i = 0; i < n || dest == NULL; i++) {
1320 if ((src[i] & 0x80) == 0) {
1321 if (dest != NULL) dest[count] = src[i];
1322 if (src[i] == 0) break;
1323 } else if ((src[i] & 0xe0) == 0xc0) {
1324 if (dest != NULL) dest[count] =
1325 (((unsigned char)src[i] & 0x1f) << 6)|
1326 ((unsigned char)src[i+1] & 0x3f);
1328 } else if ((src[i] & 0xf0) == 0xe0) {
1329 if (dest != NULL) dest[count] =
1330 (((unsigned char)src[i] & 0x0f) << 12) |
1331 (((unsigned char)src[i+1] & 0x3f) << 6) |
1332 ((unsigned char)src[i+2] & 0x3f);
1334 } else if ((src[i] & 0xf8) == 0xf0) {
1335 if (dest != NULL) dest[count] =
1336 (((unsigned char)src[i] & 0x0f) << 18) |
1337 (((unsigned char)src[i+1] & 0x3f) << 12) |
1338 (((unsigned char)src[i+2] & 0x3f) << 6) |
1339 ((unsigned char)src[i+3] & 0x3f);
1342 /* Found an invalid multibyte sequence */
1352 * Entry point for initializing Angband
1356 NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
1358 /* Hooks in some "z-util.c" hooks */
1359 plog_aux = hook_plog;
1360 quit_aux = hook_quit;
1362 /* Initialize file paths */
1363 [self prepareFilePathsAndDirectories];
1365 /* Note the "system" */
1366 ANGBAND_SYS = "coc";
1368 /* Load preferences */
1371 /* Prepare the windows */
1374 /* Set up game event handlers */
1375 /* init_display(); */
1377 /* Register the sound hook */
1378 /* sound_hook = play_sound; */
1380 /* Initialise game */
1383 /* This is not incorporated into Hengband's init_angband() yet. */
1384 init_graphics_modes();
1386 /* Initialize some save file stuff */
1387 player_egid = getegid();
1389 /* We are now initialized */
1392 /* Handle "open_when_ready" */
1393 handle_open_when_ready();
1395 /* Handle pending events (most notably update) and flush input */
1398 /* Prompt the user. */
1399 int message_row = (Term->hgt - 23) / 5 + 23;
1400 Term_erase(0, message_row, 255);
1403 "['ファイル' メニューから '新' または '開く' を選択します]",
1404 message_row, (Term->wid - 57) / 2
1406 "[Choose 'New' or 'Open' from the 'File' menu]",
1407 message_row, (Term->wid - 45) / 2
1413 * Play a game -- "new_game" is set by "new", "open" or the open document
1414 * even handler as appropriate
1419 while (!game_in_progress) {
1420 NSAutoreleasePool *splashScreenPool = [[NSAutoreleasePool alloc] init];
1421 NSEvent *event = [NSApp nextEventMatchingMask:NSAnyEventMask untilDate:[NSDate distantFuture] inMode:NSDefaultRunLoopMode dequeue:YES];
1422 if (event) [NSApp sendEvent:event];
1423 [splashScreenPool drain];
1427 play_game(new_game);
1434 /* Hack -- Forget messages */
1437 p_ptr->playing = FALSE;
1438 p_ptr->leaving = TRUE;
1439 quit_when_ready = TRUE;
1442 - (void)addAngbandView:(AngbandView *)view
1444 if (! [angbandViews containsObject:view])
1446 [angbandViews addObject:view];
1448 [self setNeedsDisplay:YES]; /* We'll need to redisplay everything anyways, so avoid creating all those little redisplay rects */
1449 [self requestRedraw];
1454 * We have this notion of an "active" AngbandView, which is the largest - the
1455 * idea being that in the screen saver, when the user hits Test in System
1456 * Preferences, we don't want to keep driving the AngbandView in the
1457 * background. Our active AngbandView is the widest - that's a hack all right.
1458 * Mercifully when we're just playing the game there's only one view.
1460 - (AngbandView *)activeView
1462 if ([angbandViews count] == 1)
1463 return [angbandViews objectAtIndex:0];
1465 AngbandView *result = nil;
1467 for (AngbandView *angbandView in angbandViews)
1469 float width = [angbandView frame].size.width;
1470 if (width > maxWidth)
1473 result = angbandView;
1479 - (void)angbandViewDidScale:(AngbandView *)view
1481 /* If we're live-resizing with graphics, we're using the live resize
1482 * optimization, so don't update the image. Otherwise do it. */
1483 if (! (inLiveResize && graphics_are_enabled()) && view == [self activeView])
1487 [self setNeedsDisplay:YES]; /*we'll need to redisplay everything anyways, so avoid creating all those little redisplay rects */
1488 [self requestRedraw];
1493 - (void)removeAngbandView:(AngbandView *)view
1495 if ([angbandViews containsObject:view])
1497 [angbandViews removeObject:view];
1499 [self setNeedsDisplay:YES]; /* We'll need to redisplay everything anyways, so avoid creating all those little redisplay rects */
1500 if ([angbandViews count]) [self requestRedraw];
1505 static NSMenuItem *superitem(NSMenuItem *self)
1507 NSMenu *supermenu = [[self menu] supermenu];
1508 int index = [supermenu indexOfItemWithSubmenu:[self menu]];
1509 if (index == -1) return nil;
1510 else return [supermenu itemAtIndex:index];
1514 - (BOOL)validateMenuItem:(NSMenuItem *)menuItem
1516 int tag = [menuItem tag];
1517 SEL sel = [menuItem action];
1518 if (sel == @selector(setGraphicsMode:))
1520 [menuItem setState: (tag == graf_mode_req)];
1529 - (NSWindow *)makePrimaryWindow
1531 if (! primaryWindow)
1533 /* This has to be done after the font is set, which it already is in
1534 * term_init_cocoa() */
1535 CGFloat width = self->cols * tileSize.width + borderSize.width * 2.0;
1536 CGFloat height = self->rows * tileSize.height + borderSize.height * 2.0;
1537 NSRect contentRect = NSMakeRect( 0.0, 0.0, width, height );
1539 NSUInteger styleMask = NSTitledWindowMask | NSResizableWindowMask | NSMiniaturizableWindowMask;
1541 /* Make every window other than the main window closable */
1542 if( angband_term[0]->data != self )
1544 styleMask |= NSClosableWindowMask;
1547 primaryWindow = [[NSWindow alloc] initWithContentRect:contentRect styleMask: styleMask backing:NSBackingStoreBuffered defer:YES];
1549 /* Not to be released when closed */
1550 [primaryWindow setReleasedWhenClosed:NO];
1551 [primaryWindow setExcludedFromWindowsMenu: YES]; /* we're using custom window menu handling */
1554 AngbandView *angbandView = [[AngbandView alloc] initWithFrame:contentRect];
1555 [angbandView setAngbandContext:self];
1556 [angbandViews addObject:angbandView];
1557 [primaryWindow setContentView:angbandView];
1558 [angbandView release];
1560 /* We are its delegate */
1561 [primaryWindow setDelegate:self];
1563 /* Update our image, since this is probably the first angband view
1567 return primaryWindow;
1572 #pragma mark View/Window Passthrough
1575 * This is what our views call to get us to draw to the window
1577 - (void)drawRect:(NSRect)rect inView:(NSView *)view
1579 /* Take this opportunity to throttle so we don't flush faster than desired.
1581 BOOL viewInLiveResize = [view inLiveResize];
1582 if (! viewInLiveResize) [self throttle];
1584 /* With a GLayer, use CGContextDrawLayerInRect */
1585 CGContextRef context = [[NSGraphicsContext currentContext] graphicsPort];
1586 NSRect bounds = [view bounds];
1587 if (viewInLiveResize) CGContextSetInterpolationQuality(context, kCGInterpolationLow);
1588 CGContextSetBlendMode(context, kCGBlendModeCopy);
1589 CGContextDrawLayerInRect(context, *(CGRect *)&bounds, angbandLayer);
1590 if (viewInLiveResize) CGContextSetInterpolationQuality(context, kCGInterpolationDefault);
1595 return [[[angbandViews lastObject] window] isVisible];
1598 - (BOOL)isMainWindow
1600 return [[[angbandViews lastObject] window] isMainWindow];
1603 - (void)setNeedsDisplay:(BOOL)val
1605 for (NSView *angbandView in angbandViews)
1607 [angbandView setNeedsDisplay:val];
1611 - (void)setNeedsDisplayInBaseRect:(NSRect)rect
1613 for (NSView *angbandView in angbandViews)
1615 [angbandView setNeedsDisplayInRect: rect];
1619 - (void)displayIfNeeded
1621 [[self activeView] displayIfNeeded];
1624 - (int)terminalIndex
1628 for( termIndex = 0; termIndex < ANGBAND_TERM_MAX; termIndex++ )
1630 if( angband_term[termIndex] == self->terminal )
1639 - (void)resizeTerminalWithContentRect: (NSRect)contentRect saveToDefaults: (BOOL)saveToDefaults
1641 CGFloat newRows = floor( (contentRect.size.height - (borderSize.height * 2.0)) / tileSize.height );
1642 CGFloat newColumns = ceil( (contentRect.size.width - (borderSize.width * 2.0)) / tileSize.width );
1644 if (newRows < 1 || newColumns < 1) return;
1645 self->cols = newColumns;
1646 self->rows = newRows;
1648 if (resize_pending_changes(self->changes, self->rows) != 0) {
1649 destroy_pending_changes(self->changes);
1651 NSLog(@"out of memory for pending changes with resize of terminal %d",
1652 [self terminalIndex]);
1655 if( saveToDefaults )
1657 int termIndex = [self terminalIndex];
1658 NSArray *terminals = [[NSUserDefaults standardUserDefaults] valueForKey: AngbandTerminalsDefaultsKey];
1660 if( termIndex < (int)[terminals count] )
1662 NSMutableDictionary *mutableTerm = [[NSMutableDictionary alloc] initWithDictionary: [terminals objectAtIndex: termIndex]];
1663 [mutableTerm setValue: [NSNumber numberWithUnsignedInt: self->cols] forKey: AngbandTerminalColumnsDefaultsKey];
1664 [mutableTerm setValue: [NSNumber numberWithUnsignedInt: self->rows] forKey: AngbandTerminalRowsDefaultsKey];
1666 NSMutableArray *mutableTerminals = [[NSMutableArray alloc] initWithArray: terminals];
1667 [mutableTerminals replaceObjectAtIndex: termIndex withObject: mutableTerm];
1669 [[NSUserDefaults standardUserDefaults] setValue: mutableTerminals forKey: AngbandTerminalsDefaultsKey];
1670 [mutableTerminals release];
1671 [mutableTerm release];
1673 [[NSUserDefaults standardUserDefaults] synchronize];
1677 Term_activate( self->terminal );
1678 Term_resize( (int)newColumns, (int)newRows);
1680 Term_activate( old );
1683 - (void)setMinimumWindowSize
1687 if ([self terminalIndex] == 0) {
1689 minsize.height = 24;
1695 minsize.width * self->tileSize.width + self->borderSize.width * 2.0;
1697 minsize.height * self->tileSize.height + self->borderSize.height * 2.0;
1698 [[self makePrimaryWindow] setContentMinSize:minsize];
1701 - (void)saveWindowVisibleToDefaults: (BOOL)windowVisible
1703 int termIndex = [self terminalIndex];
1704 BOOL safeVisibility = (termIndex == 0) ? YES : windowVisible; /* Ensure main term doesn't go away because of these defaults */
1705 NSArray *terminals = [[NSUserDefaults standardUserDefaults] valueForKey: AngbandTerminalsDefaultsKey];
1707 if( termIndex < (int)[terminals count] )
1709 NSMutableDictionary *mutableTerm = [[NSMutableDictionary alloc] initWithDictionary: [terminals objectAtIndex: termIndex]];
1710 [mutableTerm setValue: [NSNumber numberWithBool: safeVisibility] forKey: AngbandTerminalVisibleDefaultsKey];
1712 NSMutableArray *mutableTerminals = [[NSMutableArray alloc] initWithArray: terminals];
1713 [mutableTerminals replaceObjectAtIndex: termIndex withObject: mutableTerm];
1715 [[NSUserDefaults standardUserDefaults] setValue: mutableTerminals forKey: AngbandTerminalsDefaultsKey];
1716 [mutableTerminals release];
1717 [mutableTerm release];
1721 - (BOOL)windowVisibleUsingDefaults
1723 int termIndex = [self terminalIndex];
1725 if( termIndex == 0 )
1730 NSArray *terminals = [[NSUserDefaults standardUserDefaults] valueForKey: AngbandTerminalsDefaultsKey];
1733 if( termIndex < (int)[terminals count] )
1735 NSDictionary *term = [terminals objectAtIndex: termIndex];
1736 NSNumber *visibleValue = [term valueForKey: AngbandTerminalVisibleDefaultsKey];
1738 if( visibleValue != nil )
1740 visible = [visibleValue boolValue];
1748 #pragma mark NSWindowDelegate Methods
1750 /*- (void)windowWillStartLiveResize: (NSNotification *)notification
1754 - (void)windowDidEndLiveResize: (NSNotification *)notification
1756 NSWindow *window = [notification object];
1757 NSRect contentRect = [window contentRectForFrameRect: [window frame]];
1758 [self resizeTerminalWithContentRect: contentRect saveToDefaults: !(self->in_fullscreen_transition)];
1761 /*- (NSSize)windowWillResize: (NSWindow *)sender toSize: (NSSize)frameSize
1765 - (void)windowWillEnterFullScreen: (NSNotification *)notification
1767 self->in_fullscreen_transition = YES;
1770 - (void)windowDidEnterFullScreen: (NSNotification *)notification
1772 NSWindow *window = [notification object];
1773 NSRect contentRect = [window contentRectForFrameRect: [window frame]];
1774 self->in_fullscreen_transition = NO;
1775 [self resizeTerminalWithContentRect: contentRect saveToDefaults: NO];
1778 - (void)windowWillExitFullScreen: (NSNotification *)notification
1780 self->in_fullscreen_transition = YES;
1783 - (void)windowDidExitFullScreen: (NSNotification *)notification
1785 NSWindow *window = [notification object];
1786 NSRect contentRect = [window contentRectForFrameRect: [window frame]];
1787 self->in_fullscreen_transition = NO;
1788 [self resizeTerminalWithContentRect: contentRect saveToDefaults: NO];
1791 - (void)windowDidBecomeMain:(NSNotification *)notification
1793 NSWindow *window = [notification object];
1795 if( window != self->primaryWindow )
1800 int termIndex = [self terminalIndex];
1801 NSMenuItem *item = [[[NSApplication sharedApplication] windowsMenu] itemWithTag: AngbandWindowMenuItemTagBase + termIndex];
1802 [item setState: NSOnState];
1804 if( [[NSFontPanel sharedFontPanel] isVisible] )
1806 [[NSFontPanel sharedFontPanel] setPanelFont: [self selectionFont] isMultiple: NO];
1810 - (void)windowDidResignMain: (NSNotification *)notification
1812 NSWindow *window = [notification object];
1814 if( window != self->primaryWindow )
1819 int termIndex = [self terminalIndex];
1820 NSMenuItem *item = [[[NSApplication sharedApplication] windowsMenu] itemWithTag: AngbandWindowMenuItemTagBase + termIndex];
1821 [item setState: NSOffState];
1824 - (void)windowWillClose: (NSNotification *)notification
1826 [self saveWindowVisibleToDefaults: NO];
1832 @implementation AngbandView
1844 - (void)drawRect:(NSRect)rect
1846 if (! angbandContext)
1848 /* Draw bright orange, 'cause this ain't right */
1849 [[NSColor orangeColor] set];
1850 NSRectFill([self bounds]);
1854 /* Tell the Angband context to draw into us */
1855 [angbandContext drawRect:rect inView:self];
1859 - (void)setAngbandContext:(AngbandContext *)context
1861 angbandContext = context;
1864 - (AngbandContext *)angbandContext
1866 return angbandContext;
1869 - (void)setFrameSize:(NSSize)size
1871 BOOL changed = ! NSEqualSizes(size, [self frame].size);
1872 [super setFrameSize:size];
1873 if (changed) [angbandContext angbandViewDidScale:self];
1876 - (void)viewWillStartLiveResize
1878 [angbandContext viewWillStartLiveResize:self];
1881 - (void)viewDidEndLiveResize
1883 [angbandContext viewDidEndLiveResize:self];
1889 * Delay handling of double-clicked savefiles
1891 Boolean open_when_ready = FALSE;
1896 * ------------------------------------------------------------------------
1897 * Some generic functions
1898 * ------------------------------------------------------------------------ */
1901 * Sets an Angband color at a given index
1903 static void set_color_for_index(int idx)
1907 /* Extract the R,G,B data */
1908 rv = angband_color_table[idx][1];
1909 gv = angband_color_table[idx][2];
1910 bv = angband_color_table[idx][3];
1912 CGContextSetRGBFillColor([[NSGraphicsContext currentContext] graphicsPort], rv/255., gv/255., bv/255., 1.);
1916 * Remember the current character in UserDefaults so we can select it by
1917 * default next time.
1919 static void record_current_savefile(void)
1921 NSString *savefileString = [[NSString stringWithCString:savefile encoding:NSMacOSRomanStringEncoding] lastPathComponent];
1924 NSUserDefaults *angbandDefs = [NSUserDefaults angbandDefaults];
1925 [angbandDefs setObject:savefileString forKey:@"SaveFile"];
1926 [angbandDefs synchronize];
1933 * Convert a two-byte EUC-JP encoded character (both *cp and (*cp + 1) are in
1934 * the range, 0xA1-0xFE, or *cp is 0x8E) to a utf16 value in the native byte
1937 static wchar_t convert_two_byte_eucjp_to_utf16_native(const char *cp)
1939 NSString* str = [[NSString alloc] initWithBytes:cp length:2
1940 encoding:NSJapaneseEUCStringEncoding];
1941 wchar_t result = [str characterAtIndex:0];
1950 * ------------------------------------------------------------------------
1951 * Support for the "z-term.c" package
1952 * ------------------------------------------------------------------------ */
1956 * Initialize a new Term
1958 static void Term_init_cocoa(term *t)
1960 NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
1961 AngbandContext *context = [[AngbandContext alloc] init];
1963 /* Give the term a hard retain on context (for GC) */
1964 t->data = (void *)CFRetain(context);
1967 /* Handle graphics */
1968 t->higher_pict = !! use_graphics;
1969 t->always_pict = FALSE;
1971 NSDisableScreenUpdates();
1973 /* Figure out the frame autosave name based on the index of this term */
1974 NSString *autosaveName = nil;
1976 for (termIdx = 0; termIdx < ANGBAND_TERM_MAX; termIdx++)
1978 if (angband_term[termIdx] == t)
1980 autosaveName = [NSString stringWithFormat:@"AngbandTerm-%d", termIdx];
1986 NSString *fontName = [[NSUserDefaults angbandDefaults] stringForKey:[NSString stringWithFormat:@"FontName-%d", termIdx]];
1987 if (! fontName) fontName = [default_font fontName];
1989 /* Use a smaller default font for the other windows, but only if the font
1990 * hasn't been explicitly set */
1991 float fontSize = (termIdx > 0) ? 10.0 : [default_font pointSize];
1992 NSNumber *fontSizeNumber = [[NSUserDefaults angbandDefaults] valueForKey: [NSString stringWithFormat: @"FontSize-%d", termIdx]];
1994 if( fontSizeNumber != nil )
1996 fontSize = [fontSizeNumber floatValue];
1999 [context setSelectionFont:[NSFont fontWithName:fontName size:fontSize] adjustTerminal: NO];
2001 NSArray *terminalDefaults = [[NSUserDefaults standardUserDefaults] valueForKey: AngbandTerminalsDefaultsKey];
2002 NSInteger rows = 24;
2003 NSInteger columns = 80;
2005 if( termIdx < (int)[terminalDefaults count] )
2007 NSDictionary *term = [terminalDefaults objectAtIndex: termIdx];
2008 NSInteger defaultRows = [[term valueForKey: AngbandTerminalRowsDefaultsKey] integerValue];
2009 NSInteger defaultColumns = [[term valueForKey: AngbandTerminalColumnsDefaultsKey] integerValue];
2011 if (defaultRows > 0) rows = defaultRows;
2012 if (defaultColumns > 0) columns = defaultColumns;
2015 context->cols = columns;
2016 context->rows = rows;
2018 if (resize_pending_changes(context->changes, context->rows) != 0) {
2019 destroy_pending_changes(context->changes);
2020 context->changes = 0;
2021 NSLog(@"initializing terminal %d: out of memory for pending changes",
2025 /* Get the window */
2026 NSWindow *window = [context makePrimaryWindow];
2027 /* Set its title and, for auxiliary terms, tentative size */
2028 NSString *title = [NSString stringWithCString:angband_term_name[termIdx]
2030 encoding:NSJapaneseEUCStringEncoding
2032 encoding:NSMacOSRomanStringEncoding
2035 [window setTitle:title];
2036 [context setMinimumWindowSize];
2038 /* If this is the first term, and we support full screen (Mac OS X Lion or
2039 * later), then allow it to go full screen (sweet). Allow other terms to be
2040 * FullScreenAuxilliary, so they can at least show up. Unfortunately in
2041 * Lion they don't get brought to the full screen space; but they would
2042 * only make sense on multiple displays anyways so it's not a big loss. */
2043 if ([window respondsToSelector:@selector(toggleFullScreen:)])
2045 NSWindowCollectionBehavior behavior = [window collectionBehavior];
2046 behavior |= (termIdx == 0 ? Angband_NSWindowCollectionBehaviorFullScreenPrimary : Angband_NSWindowCollectionBehaviorFullScreenAuxiliary);
2047 [window setCollectionBehavior:behavior];
2050 /* No Resume support yet, though it would not be hard to add */
2051 if ([window respondsToSelector:@selector(setRestorable:)])
2053 [window setRestorable:NO];
2056 /* default window placement */ {
2057 static NSRect overallBoundingRect;
2061 /* This is a bit of a trick to allow us to display multiple windows
2062 * in the "standard default" window position in OS X: the upper
2063 * center of the screen.
2064 * The term sizes set in load_prefs() are based on a 5-wide by
2065 * 3-high grid, with the main term being 4/5 wide by 2/3 high
2066 * (hence the scaling to find */
2068 /* What the containing rect would be). */
2069 NSRect originalMainTermFrame = [window frame];
2070 NSRect scaledFrame = originalMainTermFrame;
2071 scaledFrame.size.width *= 5.0 / 4.0;
2072 scaledFrame.size.height *= 3.0 / 2.0;
2073 scaledFrame.size.width += 1.0; /* spacing between window columns */
2074 scaledFrame.size.height += 1.0; /* spacing between window rows */
2075 [window setFrame: scaledFrame display: NO];
2077 overallBoundingRect = [window frame];
2078 [window setFrame: originalMainTermFrame display: NO];
2081 static NSRect mainTermBaseRect;
2082 NSRect windowFrame = [window frame];
2086 /* The height and width adjustments were determined experimentally,
2087 * so that the rest of the windows line up nicely without
2089 windowFrame.size.width += 7.0;
2090 windowFrame.size.height += 9.0;
2091 windowFrame.origin.x = NSMinX( overallBoundingRect );
2092 windowFrame.origin.y = NSMaxY( overallBoundingRect ) - NSHeight( windowFrame );
2093 mainTermBaseRect = windowFrame;
2095 else if( termIdx == 1 )
2097 windowFrame.origin.x = NSMinX( mainTermBaseRect );
2098 windowFrame.origin.y = NSMinY( mainTermBaseRect ) - NSHeight( windowFrame ) - 1.0;
2100 else if( termIdx == 2 )
2102 windowFrame.origin.x = NSMaxX( mainTermBaseRect ) + 1.0;
2103 windowFrame.origin.y = NSMaxY( mainTermBaseRect ) - NSHeight( windowFrame );
2105 else if( termIdx == 3 )
2107 windowFrame.origin.x = NSMaxX( mainTermBaseRect ) + 1.0;
2108 windowFrame.origin.y = NSMinY( mainTermBaseRect ) - NSHeight( windowFrame ) - 1.0;
2110 else if( termIdx == 4 )
2112 windowFrame.origin.x = NSMaxX( mainTermBaseRect ) + 1.0;
2113 windowFrame.origin.y = NSMinY( mainTermBaseRect );
2115 else if( termIdx == 5 )
2117 windowFrame.origin.x = NSMinX( mainTermBaseRect ) + NSWidth( windowFrame ) + 1.0;
2118 windowFrame.origin.y = NSMinY( mainTermBaseRect ) - NSHeight( windowFrame ) - 1.0;
2121 [window setFrame: windowFrame display: NO];
2124 /* Override the default frame above if the user has adjusted windows in
2126 if (autosaveName) [window setFrameAutosaveName:autosaveName];
2128 /* Tell it about its term. Do this after we've sized it so that the sizing
2129 * doesn't trigger redrawing and such. */
2130 [context setTerm:t];
2132 /* Only order front if it's the first term. Other terms will be ordered
2133 * front from AngbandUpdateWindowVisibility(). This is to work around a
2134 * problem where Angband aggressively tells us to initialize terms that
2135 * don't do anything! */
2136 if (t == angband_term[0]) [context->primaryWindow makeKeyAndOrderFront: nil];
2138 NSEnableScreenUpdates();
2140 /* Set "mapped" flag */
2141 t->mapped_flag = true;
2150 static void Term_nuke_cocoa(term *t)
2152 NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
2154 AngbandContext *context = t->data;
2157 /* Tell the context to get rid of its windows, etc. */
2160 /* Balance our CFRetain from when we created it */
2171 * Returns the CGImageRef corresponding to an image with the given name in the
2172 * resource directory, transferring ownership to the caller
2174 static CGImageRef create_angband_image(NSString *path)
2176 CGImageRef decodedImage = NULL, result = NULL;
2178 /* Try using ImageIO to load the image */
2181 NSURL *url = [[NSURL alloc] initFileURLWithPath:path isDirectory:NO];
2184 NSDictionary *options = [[NSDictionary alloc] initWithObjectsAndKeys:(id)kCFBooleanTrue, kCGImageSourceShouldCache, nil];
2185 CGImageSourceRef source = CGImageSourceCreateWithURL((CFURLRef)url, (CFDictionaryRef)options);
2188 /* We really want the largest image, but in practice there's
2189 * only going to be one */
2190 decodedImage = CGImageSourceCreateImageAtIndex(source, 0, (CFDictionaryRef)options);
2198 /* Draw the sucker to defeat ImageIO's weird desire to cache and decode on
2199 * demand. Our images aren't that big! */
2202 size_t width = CGImageGetWidth(decodedImage), height = CGImageGetHeight(decodedImage);
2204 /* Compute our own bitmap info */
2205 CGBitmapInfo imageBitmapInfo = CGImageGetBitmapInfo(decodedImage);
2206 CGBitmapInfo contextBitmapInfo = kCGBitmapByteOrderDefault;
2208 switch (imageBitmapInfo & kCGBitmapAlphaInfoMask) {
2209 case kCGImageAlphaNone:
2210 case kCGImageAlphaNoneSkipLast:
2211 case kCGImageAlphaNoneSkipFirst:
2213 contextBitmapInfo |= kCGImageAlphaNone;
2216 /* Some alpha, use premultiplied last which is most efficient. */
2217 contextBitmapInfo |= kCGImageAlphaPremultipliedLast;
2221 /* Draw the source image flipped, since the view is flipped */
2222 CGContextRef ctx = CGBitmapContextCreate(NULL, width, height, CGImageGetBitsPerComponent(decodedImage), CGImageGetBytesPerRow(decodedImage), CGImageGetColorSpace(decodedImage), contextBitmapInfo);
2223 CGContextSetBlendMode(ctx, kCGBlendModeCopy);
2224 CGContextTranslateCTM(ctx, 0.0, height);
2225 CGContextScaleCTM(ctx, 1.0, -1.0);
2226 CGContextDrawImage(ctx, CGRectMake(0, 0, width, height), decodedImage);
2227 result = CGBitmapContextCreateImage(ctx);
2229 /* Done with these things */
2231 CGImageRelease(decodedImage);
2239 static errr Term_xtra_cocoa_react(void)
2241 /* Don't actually switch graphics until the game is running */
2242 if (!initialized || !game_in_progress) return (-1);
2244 NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
2245 AngbandContext *angbandContext = Term->data;
2247 /* Handle graphics */
2248 int expected_graf_mode = (current_graphics_mode) ?
2249 current_graphics_mode->grafID : GRAPHICS_NONE;
2250 if (graf_mode_req != expected_graf_mode)
2252 graphics_mode *new_mode;
2253 if (graf_mode_req != GRAPHICS_NONE) {
2254 new_mode = get_graphics_mode(graf_mode_req);
2259 /* Get rid of the old image. CGImageRelease is NULL-safe. */
2260 CGImageRelease(pict_image);
2263 /* Try creating the image if we want one */
2264 if (new_mode != NULL)
2266 NSString *img_path = [NSString stringWithFormat:@"%s/%s", new_mode->path, new_mode->file];
2267 pict_image = create_angband_image(img_path);
2269 /* If we failed to create the image, set the new desired mode to
2275 /* Record what we did */
2276 use_graphics = new_mode ? new_mode->grafID : 0;
2277 ANGBAND_GRAF = (new_mode ? new_mode->graf : "ascii");
2278 current_graphics_mode = new_mode;
2280 /* Enable or disable higher picts. Note: this should be done for all
2282 angbandContext->terminal->higher_pict = !! use_graphics;
2284 if (pict_image && current_graphics_mode)
2286 /* Compute the row and column count via the image height and width.
2288 pict_rows = (int)(CGImageGetHeight(pict_image) / current_graphics_mode->cell_height);
2289 pict_cols = (int)(CGImageGetWidth(pict_image) / current_graphics_mode->cell_width);
2298 if (initialized && game_in_progress)
2311 * Draws one tile as a helper function for Term_xtra_cocoa_fresh().
2313 static void draw_image_tile(
2314 NSGraphicsContext* nsContext,
2315 CGContextRef cgContext,
2319 NSCompositingOperation op)
2321 /* Flip the source rect since the source image is flipped */
2322 CGAffineTransform flip = CGAffineTransformIdentity;
2323 flip = CGAffineTransformTranslate(flip, 0.0, CGImageGetHeight(image));
2324 flip = CGAffineTransformScale(flip, 1.0, -1.0);
2325 CGRect flippedSourceRect =
2326 CGRectApplyAffineTransform(NSRectToCGRect(srcRect), flip);
2329 * When we use high-quality resampling to draw a tile, pixels from outside
2330 * the tile may bleed in, causing graphics artifacts. Work around that.
2332 CGImageRef subimage =
2333 CGImageCreateWithImageInRect(image, flippedSourceRect);
2334 [nsContext setCompositingOperation:op];
2335 CGContextDrawImage(cgContext, NSRectToCGRect(dstRect), subimage);
2336 CGImageRelease(subimage);
2341 * This is a helper function for Term_xtra_cocoa_fresh(): look before a block
2342 * of text on a row to see if the bounds for rendering and clipping need to be
2345 static void query_before_text(
2346 struct PendingRowChange* prc, int iy, int npre, int* pclip, int* prend)
2352 if (i < 0 || i < start - npre) {
2356 if (prc->cell_changes[i].change_type == CELL_CHANGE_PICT) {
2358 * The cell has been rendered with a tile. Do not want to modify
2359 * its contents so the clipping and rendering region can not be
2363 } else if (prc->cell_changes[i].change_type == CELL_CHANGE_NONE) {
2364 /* It has not changed so inquire what it is. */
2368 Term_what(i, iy, a + 1, c + 1);
2369 if (use_graphics && (a[1] & 0x80) && (c[1] & 0x80)) {
2371 * It is an unchanged location rendered with a tile. Do not
2372 * want to modify its contents so the clipping and rendering
2373 * region can not be extended.
2378 * It is unchanged text. A character from the changed region
2379 * may have extended into it so render it to clear that.
2382 /* Check to see if it is the second part of a kanji character. */
2384 Term_what(i - 1, iy, a, c);
2386 prc->cell_changes[i - 1].c.w =
2387 convert_two_byte_eucjp_to_utf16_native(c);
2388 prc->cell_changes[i - 1].a = a[0];
2389 prc->cell_changes[i - 1].tcol = 1;
2390 prc->cell_changes[i].c.w = 0;
2391 prc->cell_changes[i].a = a[0];
2392 prc->cell_changes[i].tcol = 0;
2397 prc->cell_changes[i].c.w = c[1];
2398 prc->cell_changes[i].a = a[1];
2399 prc->cell_changes[i].tcol = 0;
2404 prc->cell_changes[i].c.w = c[1];
2405 prc->cell_changes[i].a = a[1];
2406 prc->cell_changes[i].tcol = 0;
2411 prc->cell_changes[i].c.w = c[1];
2412 prc->cell_changes[i].a = a[1];
2413 prc->cell_changes[i].tcol = 0;
2420 * The cell has been wiped or had changed text rendered. Do
2421 * not need to render. Can extend the clipping rectangle into it.
2431 * This is a helper function for Term_xtra_cocoa_fresh(): look after a block
2432 * of text on a row to see if the bounds for rendering and clipping need to be
2435 static void query_after_text(
2436 struct PendingRowChange* prc,
2448 * Be willing to consolidate this block with the one after it. This
2449 * logic should be sufficient to avoid redraws of the region between
2450 * changed blocks of text if angbandContext->ncol_pre is zero or one.
2451 * For larger values of ncol_pre, would need to do something more to
2452 * avoid extra redraws.
2456 prc->cell_changes[i].change_type != CELL_CHANGE_TEXT &&
2457 prc->cell_changes[i].change_type != CELL_CHANGE_WIPE)) {
2461 if (prc->cell_changes[i].change_type == CELL_CHANGE_PICT) {
2463 * The cell has been rendered with a tile. Do not want to modify
2464 * its contents so the clipping and rendering region can not be
2468 } else if (prc->cell_changes[i].change_type == CELL_CHANGE_NONE) {
2469 /* It has not changed so inquire what it is. */
2473 Term_what(i, iy, a, c);
2474 if (use_graphics && (a[0] & 0x80) && (c[0] & 0x80)) {
2476 * It is an unchanged location rendered with a tile. Do not
2477 * want to modify its contents so the clipping and rendering
2478 * region can not be extended.
2483 * It is unchanged text. A character from the changed region
2484 * may have extended into it so render it to clear that.
2487 /* Check to see if it is the first part of a kanji character. */
2489 Term_what(i + 1, iy, a + 1, c + 1);
2491 prc->cell_changes[i].c.w =
2492 convert_two_byte_eucjp_to_utf16_native(c);
2493 prc->cell_changes[i].a = a[0];
2494 prc->cell_changes[i].tcol = 1;
2495 prc->cell_changes[i + 1].c.w = 0;
2496 prc->cell_changes[i + 1].a = a[0];
2497 prc->cell_changes[i + 1].tcol = 0;
2502 prc->cell_changes[i].c.w = c[0];
2503 prc->cell_changes[i].a = a[0];
2504 prc->cell_changes[i].tcol = 0;
2509 prc->cell_changes[i].c.w = c[0];
2510 prc->cell_changes[i].a = a[0];
2511 prc->cell_changes[i].tcol = 0;
2516 prc->cell_changes[i].c.w = c[0];
2517 prc->cell_changes[i].a = a[0];
2518 prc->cell_changes[i].tcol = 0;
2525 * Have come to another region of changed text or another region
2526 * to wipe. Combine the regions to minimize redraws.
2538 * Draw the pending changes saved in angbandContext->changes.
2540 static void Term_xtra_cocoa_fresh(AngbandContext* angbandContext)
2542 int graf_width, graf_height, alphablend;
2544 if (angbandContext->changes->has_pict) {
2545 graf_width = current_graphics_mode->cell_width;
2546 graf_height = current_graphics_mode->cell_height;
2548 * Transparency effect. We really want to check
2549 * current_graphics_mode->alphablend, but as of this writing
2550 * that's never set, so we do something lame.
2552 /* alphablend = current_graphics_mode->alphablend */
2553 alphablend = (graf_width > 8 || graf_height > 8);
2560 CGContextRef ctx = [angbandContext lockFocus];
2562 if (angbandContext->changes->has_text ||
2563 angbandContext->changes->has_wipe) {
2564 NSFont *selectionFont = [[angbandContext selectionFont] screenFont];
2565 [selectionFont set];
2569 for (iy = angbandContext->changes->ymin;
2570 iy <= angbandContext->changes->ymax;
2572 struct PendingRowChange* prc = angbandContext->changes->rows[iy];
2575 /* Skip untouched rows. */
2584 if (ix > prc->xmax) {
2588 switch (prc->cell_changes[ix].change_type) {
2589 case CELL_CHANGE_NONE:
2593 case CELL_CHANGE_PICT:
2596 * Because changes are made to the compositing mode, save
2597 * the incoming value.
2599 NSGraphicsContext *nsContext =
2600 [NSGraphicsContext currentContext];
2601 NSCompositingOperation op = nsContext.compositingOperation;
2604 while (jx <= prc->xmax &&
2605 prc->cell_changes[jx].change_type
2606 == CELL_CHANGE_PICT) {
2607 NSRect destinationRect =
2608 [angbandContext rectInImageForTileAtX:jx Y:iy];
2609 NSRect sourceRect, terrainRect;
2611 sourceRect.origin.x = graf_width *
2612 prc->cell_changes[jx].c.c;
2613 sourceRect.origin.y = graf_height *
2614 prc->cell_changes[jx].a;
2615 sourceRect.size.width = graf_width;
2616 sourceRect.size.height = graf_height;
2617 terrainRect.origin.x = graf_width *
2618 prc->cell_changes[jx].tcol;
2619 terrainRect.origin.y = graf_height *
2620 prc->cell_changes[jx].trow;
2621 terrainRect.size.width = graf_width;
2622 terrainRect.size.height = graf_height;
2632 * Skip drawing the foreground if it is the same
2633 * as the background.
2635 if (sourceRect.origin.x != terrainRect.origin.x ||
2636 sourceRect.origin.y != terrainRect.origin.y) {
2643 NSCompositeSourceOver);
2657 [nsContext setCompositingOperation:op];
2660 [angbandContext rectInImageForTileAtX:ix Y:iy];
2662 angbandContext->tileSize.width * (jx - ix);
2663 [angbandContext setNeedsDisplayInBaseRect:rect];
2668 case CELL_CHANGE_WIPE:
2669 case CELL_CHANGE_TEXT:
2671 * For a wiped region, treat it as if it had text (the only
2672 * loss if it was not is some extra work rendering
2673 * neighboring unchanged text).
2676 while (jx < angbandContext->cols &&
2677 (prc->cell_changes[jx].change_type
2679 || prc->cell_changes[jx].change_type
2680 == CELL_CHANGE_WIPE)) {
2685 int ieclip = jx - 1;
2687 int ierend = jx - 1;
2689 TERM_COLOR alast = 0;
2694 prc, iy, angbandContext->ncol_pre, &isclip, &isrend);
2698 angbandContext->cols,
2699 angbandContext->ncol_post,
2705 /* Save the state since the clipping will be modified. */
2706 CGContextSaveGState(ctx);
2708 /* Clear the area where rendering will be done. */
2709 r = [angbandContext rectInImageForTileAtX:isrend Y:iy];
2710 r.size.width = angbandContext->tileSize.width *
2711 (ierend - isrend + 1);
2712 [[NSColor blackColor] set];
2716 * Clear the current path so it does not affect clipping.
2717 * Then set the clipping rectangle. Using
2718 * CGContextSetTextDrawingMode() to include clipping does
2719 * not appear to be necessary on 10.14 and is actually
2720 * detrimental: when displaying more than one character,
2721 * only the first is visible.
2723 CGContextBeginPath(ctx);
2724 r = [angbandContext rectInImageForTileAtX:isclip Y:iy];
2725 r.size.width = angbandContext->tileSize.width *
2726 (ieclip - isclip + 1);
2727 CGContextClipToRect(ctx, r);
2731 while (k <= ierend) {
2734 if (prc->cell_changes[k].change_type
2735 == CELL_CHANGE_WIPE) {
2736 /* Skip over since no rendering is necessary. */
2741 if (set_color || alast != prc->cell_changes[k].a) {
2743 alast = prc->cell_changes[k].a;
2744 set_color_for_index(alast % MAX_COLORS);
2748 [angbandContext rectInImageForTileAtX:k Y:iy];
2749 if (prc->cell_changes[k].tcol) {
2750 rectToDraw.size.width *= 2.0;
2751 [angbandContext drawWChar:prc->cell_changes[k].c.w
2752 inRect:rectToDraw context:ctx];
2755 [angbandContext drawWChar:prc->cell_changes[k].c.w
2756 inRect:rectToDraw context:ctx];
2762 * Inform the context that the area in the clipping
2763 * rectangle needs to be redisplayed.
2765 [angbandContext setNeedsDisplayInBaseRect:r];
2767 CGContextRestoreGState(ctx);
2774 if (angbandContext->changes->xcurs >= 0 &&
2775 angbandContext->changes->ycurs >= 0) {
2776 NSRect rect = [angbandContext
2777 rectInImageForTileAtX:angbandContext->changes->xcurs
2778 Y:angbandContext->changes->ycurs];
2780 if (angbandContext->changes->bigcurs) {
2781 rect.size.width += angbandContext->tileSize.width;
2783 [[NSColor yellowColor] set];
2784 NSFrameRectWithWidth(rect, 1);
2785 /* Invalidate that rect */
2786 [angbandContext setNeedsDisplayInBaseRect:rect];
2789 [angbandContext unlockFocus];
2794 * Do a "special thing"
2796 static errr Term_xtra_cocoa(int n, int v)
2798 NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
2799 AngbandContext* angbandContext = Term->data;
2807 case TERM_XTRA_NOISE:
2816 case TERM_XTRA_SOUND:
2820 /* Process random events */
2821 case TERM_XTRA_BORED:
2823 /* Show or hide cocoa windows based on the subwindow flags set by
2825 AngbandUpdateWindowVisibility();
2827 /* Process an event */
2828 (void)check_events(CHECK_EVENTS_NO_WAIT);
2834 /* Process pending events */
2835 case TERM_XTRA_EVENT:
2837 /* Process an event */
2838 (void)check_events(v);
2844 /* Flush all pending events (if any) */
2845 case TERM_XTRA_FLUSH:
2847 /* Hack -- flush all events */
2848 while (check_events(CHECK_EVENTS_DRAIN)) /* loop */;
2854 /* Hack -- Change the "soft level" */
2855 case TERM_XTRA_LEVEL:
2857 /* Here we could activate (if requested), but I don't think Angband
2858 * should be telling us our window order (the user should decide
2859 * that), so do nothing. */
2863 /* Clear the screen */
2864 case TERM_XTRA_CLEAR:
2866 [angbandContext lockFocus];
2867 [[NSColor blackColor] set];
2868 NSRect imageRect = {NSZeroPoint, [angbandContext imageSize]};
2869 NSRectFillUsingOperation(imageRect, NSCompositeCopy);
2870 [angbandContext unlockFocus];
2871 [angbandContext setNeedsDisplay:YES];
2876 /* React to changes */
2877 case TERM_XTRA_REACT:
2879 /* React to changes */
2880 return (Term_xtra_cocoa_react());
2883 /* Delay (milliseconds) */
2884 case TERM_XTRA_DELAY:
2890 double seconds = v / 1000.;
2891 NSDate* date = [NSDate dateWithTimeIntervalSinceNow:seconds];
2897 event = [NSApp nextEventMatchingMask:-1 untilDate:date inMode:NSDefaultRunLoopMode dequeue:YES];
2898 if (event) send_event(event);
2900 } while ([date timeIntervalSinceNow] >= 0);
2908 case TERM_XTRA_FRESH:
2909 /* Draw the pending changes. */
2910 if (angbandContext->changes != 0) {
2911 Term_xtra_cocoa_fresh(angbandContext);
2912 clear_pending_changes(angbandContext->changes);
2928 static errr Term_curs_cocoa(int x, int y)
2930 AngbandContext *angbandContext = Term->data;
2932 if (angbandContext->changes == 0) {
2933 /* Bail out; there was an earlier memory allocation failure. */
2936 angbandContext->changes->xcurs = x;
2937 angbandContext->changes->ycurs = y;
2938 angbandContext->changes->bigcurs = 0;
2945 * Draw a cursor that's two tiles wide. For Japanese, that's used when
2946 * the cursor points at a kanji character, irregardless of whether operating
2949 static errr Term_bigcurs_cocoa(int x, int y)
2951 AngbandContext *angbandContext = Term->data;
2953 if (angbandContext->changes == 0) {
2954 /* Bail out; there was an earlier memory allocation failure. */
2957 angbandContext->changes->xcurs = x;
2958 angbandContext->changes->ycurs = y;
2959 angbandContext->changes->bigcurs = 1;
2966 * Low level graphics (Assumes valid input)
2968 * Erase "n" characters starting at (x,y)
2970 static errr Term_wipe_cocoa(int x, int y, int n)
2972 AngbandContext *angbandContext = Term->data;
2973 struct PendingCellChange *pc;
2975 if (angbandContext->changes == 0) {
2976 /* Bail out; there was an earlier memory allocation failure. */
2979 if (angbandContext->changes->rows[y] == 0) {
2980 angbandContext->changes->rows[y] =
2981 create_row_change(angbandContext->cols);
2982 if (angbandContext->changes->rows[y] == 0) {
2983 NSLog(@"failed to allocate changes for row %d", y);
2986 if (angbandContext->changes->ymin > y) {
2987 angbandContext->changes->ymin = y;
2989 if (angbandContext->changes->ymax < y) {
2990 angbandContext->changes->ymax = y;
2994 angbandContext->changes->has_wipe = 1;
2995 if (angbandContext->changes->rows[y]->xmin > x) {
2996 angbandContext->changes->rows[y]->xmin = x;
2998 if (angbandContext->changes->rows[y]->xmax < x + n - 1) {
2999 angbandContext->changes->rows[y]->xmax = x + n - 1;
3001 for (pc = angbandContext->changes->rows[y]->cell_changes + x;
3002 pc != angbandContext->changes->rows[y]->cell_changes + x + n;
3004 pc->change_type = CELL_CHANGE_WIPE;
3011 static errr Term_pict_cocoa(int x, int y, int n, TERM_COLOR *ap,
3012 const char *cp, const TERM_COLOR *tap,
3016 /* Paranoia: Bail if we don't have a current graphics mode */
3017 if (! current_graphics_mode) return -1;
3019 AngbandContext* angbandContext = Term->data;
3021 struct PendingCellChange *pc;
3023 if (angbandContext->changes == 0) {
3024 /* Bail out; there was an earlier memory allocation failure. */
3027 if (angbandContext->changes->rows[y] == 0) {
3028 angbandContext->changes->rows[y] =
3029 create_row_change(angbandContext->cols);
3030 if (angbandContext->changes->rows[y] == 0) {
3031 NSLog(@"failed to allocate changes for row %d", y);
3034 if (angbandContext->changes->ymin > y) {
3035 angbandContext->changes->ymin = y;
3037 if (angbandContext->changes->ymax < y) {
3038 angbandContext->changes->ymax = y;
3042 if (angbandContext->changes->rows[y]->xmin > x) {
3043 angbandContext->changes->rows[y]->xmin = x;
3045 if (angbandContext->changes->rows[y]->xmax < x + n - 1) {
3046 angbandContext->changes->rows[y]->xmax = x + n - 1;
3048 for (pc = angbandContext->changes->rows[y]->cell_changes + x;
3049 pc != angbandContext->changes->rows[y]->cell_changes + x + n;
3051 TERM_COLOR a = *ap++;
3053 TERM_COLOR ta = *tap++;
3056 if (use_graphics && (a & 0x80) && (c & 0x80)) {
3057 pc->c.c = ((byte)c & 0x7F) % pict_cols;
3058 pc->a = ((byte)a & 0x7F) % pict_rows;
3059 pc->tcol = ((byte)tc & 0x7F) % pict_cols;
3060 pc->trow = ((byte)ta & 0x7F) % pict_rows;
3061 pc->change_type = CELL_CHANGE_PICT;
3066 angbandContext->changes->has_pict = 1;
3074 * Low level graphics. Assumes valid input.
3076 * Draw several ("n") chars, with an attr, at a given location.
3078 static errr Term_text_cocoa(int x, int y, int n, byte_hack a, concptr cp)
3080 AngbandContext* angbandContext = Term->data;
3081 struct PendingCellChange *pc;
3083 if (angbandContext->changes == 0) {
3084 /* Bail out; there was an earlier memory allocation failure. */
3087 if (angbandContext->changes->rows[y] == 0) {
3088 angbandContext->changes->rows[y] =
3089 create_row_change(angbandContext->cols);
3090 if (angbandContext->changes->rows[y] == 0) {
3091 NSLog(@"failed to allocate changes for row %d", y);
3094 if (angbandContext->changes->ymin > y) {
3095 angbandContext->changes->ymin = y;
3097 if (angbandContext->changes->ymax < y) {
3098 angbandContext->changes->ymax = y;
3102 angbandContext->changes->has_text = 1;
3103 if (angbandContext->changes->rows[y]->xmin > x) {
3104 angbandContext->changes->rows[y]->xmin = x;
3106 if (angbandContext->changes->rows[y]->xmax < x + n - 1) {
3107 angbandContext->changes->rows[y]->xmax = x + n - 1;
3109 pc = angbandContext->changes->rows[y]->cell_changes + x;
3110 while (pc != angbandContext->changes->rows[y]->cell_changes + x + n) {
3114 angbandContext->changes->rows[y]->cell_changes + x + n) {
3116 * The second byte of the character is past the end. Ignore
3121 pc->c.w = convert_two_byte_eucjp_to_utf16_native(cp);
3124 pc->change_type = CELL_CHANGE_TEXT;
3127 * Fill in a dummy value since the previous character will take
3133 pc->change_type = CELL_CHANGE_TEXT;
3141 pc->change_type = CELL_CHANGE_TEXT;
3149 pc->change_type = CELL_CHANGE_TEXT;
3160 * Post a nonsense event so that our event loop wakes up
3162 static void wakeup_event_loop(void)
3164 /* Big hack - send a nonsense event to make us update */
3165 NSEvent *event = [NSEvent otherEventWithType:NSApplicationDefined location:NSZeroPoint modifierFlags:0 timestamp:0 windowNumber:0 context:NULL subtype:AngbandEventWakeup data1:0 data2:0];
3166 [NSApp postEvent:event atStart:NO];
3171 * Create and initialize window number "i"
3173 static term *term_data_link(int i)
3175 NSArray *terminalDefaults = [[NSUserDefaults standardUserDefaults] valueForKey: AngbandTerminalsDefaultsKey];
3176 NSInteger rows = 24;
3177 NSInteger columns = 80;
3179 if( i < (int)[terminalDefaults count] )
3181 NSDictionary *term = [terminalDefaults objectAtIndex: i];
3182 rows = [[term valueForKey: AngbandTerminalRowsDefaultsKey] integerValue];
3183 columns = [[term valueForKey: AngbandTerminalColumnsDefaultsKey] integerValue];
3187 term *newterm = ZNEW(term);
3189 /* Initialize the term */
3190 term_init(newterm, columns, rows, 256 /* keypresses, for some reason? */);
3192 /* Differentiate between BS/^h, Tab/^i, etc. */
3193 /* newterm->complex_input = TRUE; */
3195 /* Use a "software" cursor */
3196 newterm->soft_cursor = TRUE;
3198 /* Disable the per-row flush notifications since they are not used. */
3199 newterm->never_frosh = TRUE;
3201 /* Erase with "white space" */
3202 newterm->attr_blank = TERM_WHITE;
3203 newterm->char_blank = ' ';
3205 /* Prepare the init/nuke hooks */
3206 newterm->init_hook = Term_init_cocoa;
3207 newterm->nuke_hook = Term_nuke_cocoa;
3209 /* Prepare the function hooks */
3210 newterm->xtra_hook = Term_xtra_cocoa;
3211 newterm->wipe_hook = Term_wipe_cocoa;
3212 newterm->curs_hook = Term_curs_cocoa;
3213 newterm->bigcurs_hook = Term_bigcurs_cocoa;
3214 newterm->text_hook = Term_text_cocoa;
3215 newterm->pict_hook = Term_pict_cocoa;
3216 /* newterm->mbcs_hook = Term_mbcs_cocoa; */
3218 /* Global pointer */
3219 angband_term[i] = newterm;
3225 * Load preferences from preferences file for current host+current user+
3226 * current application.
3228 static void load_prefs()
3230 NSUserDefaults *defs = [NSUserDefaults angbandDefaults];
3232 /* Make some default defaults */
3233 NSMutableArray *defaultTerms = [[NSMutableArray alloc] init];
3235 /* The following default rows/cols were determined experimentally by first
3236 * finding the ideal window/font size combinations. But because of awful
3237 * temporal coupling in Term_init_cocoa(), it's impossible to set up the
3238 * defaults there, so we do it this way. */
3239 for( NSUInteger i = 0; i < ANGBAND_TERM_MAX; i++ )
3277 NSDictionary *standardTerm = [NSDictionary dictionaryWithObjectsAndKeys:
3278 [NSNumber numberWithInt: rows], AngbandTerminalRowsDefaultsKey,
3279 [NSNumber numberWithInt: columns], AngbandTerminalColumnsDefaultsKey,
3280 [NSNumber numberWithBool: visible], AngbandTerminalVisibleDefaultsKey,
3282 [defaultTerms addObject: standardTerm];
3285 NSDictionary *defaults = [[NSDictionary alloc] initWithObjectsAndKeys:
3287 @"Osaka", @"FontName",
3289 @"Menlo", @"FontName",
3291 [NSNumber numberWithFloat:13.f], @"FontSize",
3292 [NSNumber numberWithInt:60], AngbandFrameRateDefaultsKey,
3293 [NSNumber numberWithBool:YES], AngbandSoundDefaultsKey,
3294 [NSNumber numberWithInt:GRAPHICS_NONE], AngbandGraphicsDefaultsKey,
3295 defaultTerms, AngbandTerminalsDefaultsKey,
3297 [defs registerDefaults:defaults];
3299 [defaultTerms release];
3301 /* Preferred graphics mode */
3302 graf_mode_req = [defs integerForKey:AngbandGraphicsDefaultsKey];
3304 /* Use sounds; set the Angband global */
3305 use_sound = ([defs boolForKey:AngbandSoundDefaultsKey] == YES) ? TRUE : FALSE;
3308 frames_per_second = [defs integerForKey:AngbandFrameRateDefaultsKey];
3311 default_font = [[NSFont fontWithName:[defs valueForKey:@"FontName-0"] size:[defs floatForKey:@"FontSize-0"]] retain];
3312 if (! default_font) default_font = [[NSFont fontWithName:@"Menlo" size:13.] retain];
3316 * Arbitary limit on number of possible samples per event
3318 #define MAX_SAMPLES 16
3321 * Struct representing all data for a set of event samples
3325 int num; /* Number of available samples for this event */
3326 NSSound *sound[MAX_SAMPLES];
3327 } sound_sample_list;
3330 * Array of event sound structs
3332 static sound_sample_list samples[MSG_MAX];
3336 * Load sound effects based on sound.cfg within the xtra/sound directory;
3337 * bridge to Cocoa to use NSSound for simple loading and playback, avoiding
3338 * I/O latency by cacheing all sounds at the start. Inherits full sound
3339 * format support from Quicktime base/plugins.
3340 * pelpel favoured a plist-based parser for the future but .cfg support
3341 * improves cross-platform compatibility.
3343 static void load_sounds(void)
3345 char sound_dir[1024];
3350 /* Build the "sound" path */
3351 path_build(sound_dir, sizeof(sound_dir), ANGBAND_DIR_XTRA, "sound");
3353 /* Find and open the config file */
3354 path_build(path, sizeof(path), sound_dir, "sound.cfg");
3355 fff = my_fopen(path, "r");
3360 NSLog(@"The sound configuration file could not be opened.");
3364 /* Instantiate an autorelease pool for use by NSSound */
3365 NSAutoreleasePool *autorelease_pool;
3366 autorelease_pool = [[NSAutoreleasePool alloc] init];
3368 /* Use a dictionary to unique sounds, so we can share NSSounds across
3369 * multiple events */
3370 NSMutableDictionary *sound_dict = [NSMutableDictionary dictionary];
3373 * This loop may take a while depending on the count and size of samples
3377 /* Parse the file */
3378 /* Lines are always of the form "name = sample [sample ...]" */
3379 while (my_fgets(fff, buffer, sizeof(buffer)) == 0)
3382 char *cfg_sample_list;
3388 /* Skip anything not beginning with an alphabetic character */
3389 if (!buffer[0] || !isalpha((unsigned char)buffer[0])) continue;
3391 /* Split the line into two: message name, and the rest */
3392 search = strchr(buffer, ' ');
3393 cfg_sample_list = strchr(search + 1, ' ');
3394 if (!search) continue;
3395 if (!cfg_sample_list) continue;
3397 /* Set the message name, and terminate at first space */
3401 /* Make sure this is a valid event name */
3402 for (event = MSG_MAX - 1; event >= 0; event--)
3404 if (strcmp(msg_name, angband_sound_name[event]) == 0)
3407 if (event < 0) continue;
3409 /* Advance the sample list pointer so it's at the beginning of text */
3411 if (!cfg_sample_list[0]) continue;
3413 /* Terminate the current token */
3414 cur_token = cfg_sample_list;
3415 search = strchr(cur_token, ' ');
3419 next_token = search + 1;
3427 * Now we find all the sample names and add them one by one
3431 int num = samples[event].num;
3433 /* Don't allow too many samples */
3434 if (num >= MAX_SAMPLES) break;
3436 NSString *token_string = [NSString stringWithUTF8String:cur_token];
3437 NSSound *sound = [sound_dict objectForKey:token_string];
3443 /* We have to load the sound. Build the path to the sample */
3444 path_build(path, sizeof(path), sound_dir, cur_token);
3445 if (stat(path, &stb) == 0)
3448 /* Load the sound into memory */
3449 sound = [[[NSSound alloc] initWithContentsOfFile:[NSString stringWithUTF8String:path] byReference:YES] autorelease];
3450 if (sound) [sound_dict setObject:sound forKey:token_string];
3454 /* Store it if we loaded it */
3457 samples[event].sound[num] = [sound retain];
3459 /* Imcrement the sample count */
3460 samples[event].num++;
3464 /* Figure out next token */
3465 cur_token = next_token;
3468 /* Try to find a space */
3469 search = strchr(cur_token, ' ');
3471 /* If we can find one, terminate, and set new "next" */
3475 next_token = search + 1;
3479 /* Otherwise prevent infinite looping */
3486 /* Release the autorelease pool */
3487 [autorelease_pool release];
3489 /* Close the file */
3494 * Play sound effects asynchronously. Select a sound from any available
3495 * for the required event, and bridge to Cocoa to play it.
3497 static void play_sound(int event)
3500 if (event < 0 || event >= MSG_MAX) return;
3502 /* Load sounds just-in-time (once) */
3503 static BOOL loaded = NO;
3509 /* Check there are samples for this event */
3510 if (!samples[event].num) return;
3512 /* Instantiate an autorelease pool for use by NSSound */
3513 NSAutoreleasePool *autorelease_pool;
3514 autorelease_pool = [[NSAutoreleasePool alloc] init];
3516 /* Choose a random event */
3517 int s = randint0(samples[event].num);
3519 /* Stop the sound if it's currently playing */
3520 if ([samples[event].sound[s] isPlaying])
3521 [samples[event].sound[s] stop];
3523 /* Play the sound */
3524 [samples[event].sound[s] play];
3526 /* Release the autorelease pool */
3527 [autorelease_pool drain];
3533 static void init_windows(void)
3535 /* Create the main window */
3536 term *primary = term_data_link(0);
3538 /* Prepare to create any additional windows */
3540 for (i=1; i < ANGBAND_TERM_MAX; i++) {
3544 /* Activate the primary term */
3545 Term_activate(primary);
3549 * Handle the "open_when_ready" flag
3551 static void handle_open_when_ready(void)
3553 /* Check the flag XXX XXX XXX make a function for this */
3554 if (open_when_ready && initialized && !game_in_progress)
3557 open_when_ready = FALSE;
3559 /* Game is in progress */
3560 game_in_progress = TRUE;
3562 /* Wait for a keypress */
3563 pause_line(Term->hgt - 1);
3569 * Handle quit_when_ready, by Peter Ammon,
3570 * slightly modified to check inkey_flag.
3572 static void quit_calmly(void)
3574 /* Quit immediately if game's not started */
3575 if (!game_in_progress || !character_generated) quit(NULL);
3577 /* Save the game and Quit (if it's safe) */
3580 /* Hack -- Forget messages and term */
3582 Term->mapped_flag = FALSE;
3585 do_cmd_save_game(FALSE);
3586 record_current_savefile();
3592 /* Wait until inkey_flag is set */
3598 * Returns YES if we contain an AngbandView (and hence should direct our events
3601 static BOOL contains_angband_view(NSView *view)
3603 if ([view isKindOfClass:[AngbandView class]]) return YES;
3604 for (NSView *subview in [view subviews]) {
3605 if (contains_angband_view(subview)) return YES;
3612 * Queue mouse presses if they occur in the map section of the main window.
3614 static void AngbandHandleEventMouseDown( NSEvent *event )
3617 AngbandContext *angbandContext = [[[event window] contentView] angbandContext];
3618 AngbandContext *mainAngbandContext = angband_term[0]->data;
3620 if (mainAngbandContext->primaryWindow && [[event window] windowNumber] == [mainAngbandContext->primaryWindow windowNumber])
3622 int cols, rows, x, y;
3623 Term_get_size(&cols, &rows);
3624 NSSize tileSize = angbandContext->tileSize;
3625 NSSize border = angbandContext->borderSize;
3626 NSPoint windowPoint = [event locationInWindow];
3628 /* Adjust for border; add border height because window origin is at
3630 windowPoint = NSMakePoint( windowPoint.x - border.width, windowPoint.y + border.height );
3632 NSPoint p = [[[event window] contentView] convertPoint: windowPoint fromView: nil];
3633 x = floor( p.x / tileSize.width );
3634 y = floor( p.y / tileSize.height );
3636 /* Being safe about this, since xcode doesn't seem to like the
3637 * bool_hack stuff */
3638 BOOL displayingMapInterface = ((int)inkey_flag != 0);
3640 /* Sidebar plus border == thirteen characters; top row is reserved. */
3641 /* Coordinates run from (0,0) to (cols-1, rows-1). */
3642 BOOL mouseInMapSection = (x > 13 && x <= cols - 1 && y > 0 && y <= rows - 2);
3644 /* If we are displaying a menu, allow clicks anywhere; if we are
3645 * displaying the main game interface, only allow clicks in the map
3647 if (!displayingMapInterface || (displayingMapInterface && mouseInMapSection))
3649 /* [event buttonNumber] will return 0 for left click,
3650 * 1 for right click, but this is safer */
3651 int button = ([event type] == NSLeftMouseDown) ? 1 : 2;
3654 NSUInteger eventModifiers = [event modifierFlags];
3655 byte angbandModifiers = 0;
3656 angbandModifiers |= (eventModifiers & NSShiftKeyMask) ? KC_MOD_SHIFT : 0;
3657 angbandModifiers |= (eventModifiers & NSControlKeyMask) ? KC_MOD_CONTROL : 0;
3658 angbandModifiers |= (eventModifiers & NSAlternateKeyMask) ? KC_MOD_ALT : 0;
3659 button |= (angbandModifiers & 0x0F) << 4; /* encode modifiers in the button number (see Term_mousepress()) */
3662 Term_mousepress(x, y, button);
3666 /* Pass click through to permit focus change, resize, etc. */
3667 [NSApp sendEvent:event];
3673 * Encodes an NSEvent Angband-style, or forwards it along. Returns YES if the
3674 * event was sent to Angband, NO if Cocoa (or nothing) handled it */
3675 static BOOL send_event(NSEvent *event)
3678 /* If the receiving window is not an Angband window, then do nothing */
3679 if (! contains_angband_view([[event window] contentView]))
3681 [NSApp sendEvent:event];
3685 /* Analyze the event */
3686 switch ([event type])
3690 /* Try performing a key equivalent */
3691 if ([[NSApp mainMenu] performKeyEquivalent:event]) break;
3693 unsigned modifiers = [event modifierFlags];
3695 /* Send all NSCommandKeyMasks through */
3696 if (modifiers & NSCommandKeyMask)
3698 [NSApp sendEvent:event];
3702 if (! [[event characters] length]) break;
3705 /* Extract some modifiers */
3706 int mc = !! (modifiers & NSControlKeyMask);
3707 int ms = !! (modifiers & NSShiftKeyMask);
3708 int mo = !! (modifiers & NSAlternateKeyMask);
3709 int kp = !! (modifiers & NSNumericPadKeyMask);
3712 /* Get the Angband char corresponding to this unichar */
3713 unichar c = [[event characters] characterAtIndex:0];
3716 * Have anything from the numeric keypad generate a macro
3717 * trigger so that shift or control modifiers can be passed.
3719 if (c <= 0x7F && !kp)
3725 * The rest of Hengband uses Angband 2.7's or so key handling:
3726 * so for the rest do something like the encoding that
3727 * main-win.c does: send a macro trigger with the Unicode
3728 * value encoded into printable ASCII characters.
3733 /* override special keys */
3734 switch([event keyCode]) {
3735 case kVK_Return: ch = '\r'; break;
3736 case kVK_Escape: ch = 27; break;
3737 case kVK_Tab: ch = '\t'; break;
3738 case kVK_Delete: ch = '\b'; break;
3739 case kVK_ANSI_KeypadEnter: ch = '\r'; kp = TRUE; break;
3742 /* Hide the mouse pointer */
3743 [NSCursor setHiddenUntilMouseMoves:YES];
3753 * Could use the hexsym global but some characters overlap with
3754 * those used to indicate modifiers.
3756 const char encoded[16] = {
3757 '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b',
3761 /* Begin the macro trigger. */
3764 /* Send the modifiers. */
3765 if (mc) Term_keypress('C');
3766 if (ms) Term_keypress('S');
3767 if (mo) Term_keypress('O');
3768 if (kp) Term_keypress('K');
3771 Term_keypress(encoded[c & 0xF]);
3775 /* End the macro trigger. */
3782 case NSLeftMouseDown:
3783 case NSRightMouseDown:
3784 AngbandHandleEventMouseDown(event);
3787 case NSApplicationDefined:
3789 if ([event subtype] == AngbandEventWakeup)
3797 [NSApp sendEvent:event];
3804 * Check for Events, return TRUE if we process any
3806 static BOOL check_events(int wait)
3809 NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
3811 /* Handles the quit_when_ready flag */
3812 if (quit_when_ready) quit_calmly();
3815 if (wait == CHECK_EVENTS_WAIT) endDate = [NSDate distantFuture];
3816 else endDate = [NSDate distantPast];
3820 if (quit_when_ready)
3822 /* send escape events until we quit */
3823 Term_keypress(0x1B);
3828 event = [NSApp nextEventMatchingMask:-1 untilDate:endDate inMode:NSDefaultRunLoopMode dequeue:YES];
3834 if (send_event(event)) break;
3840 /* Something happened */
3846 * Hook to tell the user something important
3848 static void hook_plog(const char * str)
3852 NSString *msg = NSLocalizedStringWithDefaultValue(
3853 @"Warning", AngbandMessageCatalog, [NSBundle mainBundle],
3854 @"Warning", @"Alert text for generic warning");
3855 NSString *info = [NSString stringWithCString:str
3857 encoding:NSJapaneseEUCStringEncoding
3859 encoding:NSMacOSRomanStringEncoding
3862 NSAlert *alert = [[NSAlert alloc] init];
3864 alert.messageText = msg;
3865 alert.informativeText = info;
3866 NSModalResponse result = [alert runModal];
3873 * Hook to tell the user something, and then quit
3875 static void hook_quit(const char * str)
3882 * ------------------------------------------------------------------------
3884 * ------------------------------------------------------------------------ */
3886 @interface AngbandAppDelegate : NSObject {
3887 IBOutlet NSMenu *terminalsMenu;
3888 NSMenu *_graphicsMenu;
3889 NSMenu *_commandMenu;
3890 NSDictionary *_commandMenuTagMap;
3893 @property (nonatomic, retain) IBOutlet NSMenu *graphicsMenu;
3894 @property (nonatomic, retain) IBOutlet NSMenu *commandMenu;
3895 @property (nonatomic, retain) NSDictionary *commandMenuTagMap;
3897 - (IBAction)newGame:sender;
3898 - (IBAction)openGame:sender;
3900 - (IBAction)editFont:sender;
3901 - (IBAction)setGraphicsMode:(NSMenuItem *)sender;
3902 - (IBAction)toggleSound:(NSMenuItem *)sender;
3904 - (IBAction)setRefreshRate:(NSMenuItem *)menuItem;
3905 - (IBAction)selectWindow: (id)sender;
3909 @implementation AngbandAppDelegate
3911 @synthesize graphicsMenu=_graphicsMenu;
3912 @synthesize commandMenu=_commandMenu;
3913 @synthesize commandMenuTagMap=_commandMenuTagMap;
3915 - (IBAction)newGame:sender
3917 /* Game is in progress */
3918 game_in_progress = TRUE;
3922 - (IBAction)editFont:sender
3924 NSFontPanel *panel = [NSFontPanel sharedFontPanel];
3925 NSFont *termFont = default_font;
3928 for (i=0; i < ANGBAND_TERM_MAX; i++) {
3929 if ([(id)angband_term[i]->data isMainWindow]) {
3930 termFont = [(id)angband_term[i]->data selectionFont];
3935 [panel setPanelFont:termFont isMultiple:NO];
3936 [panel orderFront:self];
3940 * Implent NSObject's changeFont() method to receive a notification about the
3941 * changed font. Note that, as of 10.14, changeFont() is deprecated in
3942 * NSObject - it will be removed at some point and the application delegate
3943 * will have to be declared as implementing the NSFontChanging protocol.
3945 - (void)changeFont:(id)sender
3948 for (mainTerm=0; mainTerm < ANGBAND_TERM_MAX; mainTerm++) {
3949 if ([(id)angband_term[mainTerm]->data isMainWindow]) {
3954 /* Bug #1709: Only change font for angband windows */
3955 if (mainTerm == ANGBAND_TERM_MAX) return;
3957 NSFont *oldFont = default_font;
3958 NSFont *newFont = [sender convertFont:oldFont];
3959 if (! newFont) return; /*paranoia */
3961 /* Store as the default font if we changed the first term */
3962 if (mainTerm == 0) {
3964 [default_font release];
3965 default_font = newFont;
3968 /* Record it in the preferences */
3969 NSUserDefaults *defs = [NSUserDefaults angbandDefaults];
3970 [defs setValue:[newFont fontName]
3971 forKey:[NSString stringWithFormat:@"FontName-%d", mainTerm]];
3972 [defs setFloat:[newFont pointSize]
3973 forKey:[NSString stringWithFormat:@"FontSize-%d", mainTerm]];
3976 NSDisableScreenUpdates();
3979 AngbandContext *angbandContext = angband_term[mainTerm]->data;
3980 [(id)angbandContext setSelectionFont:newFont adjustTerminal: YES];
3982 NSEnableScreenUpdates();
3985 - (IBAction)openGame:sender
3987 NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init];
3988 BOOL selectedSomething = NO;
3991 /* Get where we think the save files are */
3992 NSURL *startingDirectoryURL = [NSURL fileURLWithPath:[NSString stringWithCString:ANGBAND_DIR_SAVE encoding:NSASCIIStringEncoding] isDirectory:YES];
3994 /* Set up an open panel */
3995 NSOpenPanel* panel = [NSOpenPanel openPanel];
3996 [panel setCanChooseFiles:YES];
3997 [panel setCanChooseDirectories:NO];
3998 [panel setResolvesAliases:YES];
3999 [panel setAllowsMultipleSelection:NO];
4000 [panel setTreatsFilePackagesAsDirectories:YES];
4001 [panel setDirectoryURL:startingDirectoryURL];
4004 panelResult = [panel runModal];
4005 if (panelResult == NSOKButton)
4007 NSArray* fileURLs = [panel URLs];
4008 if ([fileURLs count] > 0 && [[fileURLs objectAtIndex:0] isFileURL])
4010 NSURL* savefileURL = (NSURL *)[fileURLs objectAtIndex:0];
4011 /* The path property doesn't do the right thing except for
4012 * URLs with the file scheme. We had getFileSystemRepresentation
4013 * here before, but that wasn't introduced until OS X 10.9. */
4014 selectedSomething = [[savefileURL path] getCString:savefile
4015 maxLength:sizeof savefile encoding:NSMacOSRomanStringEncoding];
4019 if (selectedSomething)
4021 /* Remember this so we can select it by default next time */
4022 record_current_savefile();
4024 /* Game is in progress */
4025 game_in_progress = TRUE;
4032 - (IBAction)saveGame:sender
4034 /* Hack -- Forget messages */
4038 do_cmd_save_game(FALSE);
4040 /* Record the current save file so we can select it by default next time.
4041 * It's a little sketchy that this only happens when we save through the
4042 * menu; ideally game-triggered saves would trigger it too. */
4043 record_current_savefile();
4047 * Implement NSObject's validateMenuItem() method to override enabling or
4048 * disabling a menu item. Note that, as of 10.14, validateMenuItem() is
4049 * deprecated in NSObject - it will be removed at some point and the
4050 * application delegate will have to be declared as implementing the
4051 * NSMenuItemValidation protocol.
4053 - (BOOL)validateMenuItem:(NSMenuItem *)menuItem
4055 SEL sel = [menuItem action];
4056 NSInteger tag = [menuItem tag];
4058 if( tag >= AngbandWindowMenuItemTagBase && tag < AngbandWindowMenuItemTagBase + ANGBAND_TERM_MAX )
4060 if( tag == AngbandWindowMenuItemTagBase )
4062 /* The main window should always be available and visible */
4068 * Another window is only usable after Term_init_cocoa() has
4069 * been called for it. For Angband if window_flag[i] is nonzero
4070 * then that has happened for window i. For Hengband, that is
4071 * not the case so also test angband_term[i]->data.
4073 NSInteger subwindowNumber = tag - AngbandWindowMenuItemTagBase;
4074 return (angband_term[subwindowNumber]->data != 0
4075 && window_flag[subwindowNumber] > 0);
4081 if (sel == @selector(newGame:))
4083 return ! game_in_progress;
4085 else if (sel == @selector(editFont:))
4089 else if (sel == @selector(openGame:))
4091 return ! game_in_progress;
4093 else if (sel == @selector(setRefreshRate:) && [superitem(menuItem) tag] == 150)
4095 NSInteger fps = [[NSUserDefaults standardUserDefaults] integerForKey:AngbandFrameRateDefaultsKey];
4096 [menuItem setState: ([menuItem tag] == fps)];
4099 else if( sel == @selector(setGraphicsMode:) )
4101 NSInteger requestedGraphicsMode = [[NSUserDefaults standardUserDefaults] integerForKey:AngbandGraphicsDefaultsKey];
4102 [menuItem setState: (tag == requestedGraphicsMode)];
4105 else if( sel == @selector(toggleSound:) )
4107 BOOL is_on = [[NSUserDefaults standardUserDefaults]
4108 boolForKey:AngbandSoundDefaultsKey];
4110 [menuItem setState: ((is_on) ? NSOnState : NSOffState)];
4113 else if( sel == @selector(sendAngbandCommand:) )
4115 /* we only want to be able to send commands during an active game */
4116 return !!game_in_progress;
4122 - (IBAction)setRefreshRate:(NSMenuItem *)menuItem
4124 frames_per_second = [menuItem tag];
4125 [[NSUserDefaults angbandDefaults] setInteger:frames_per_second forKey:AngbandFrameRateDefaultsKey];
4128 - (IBAction)selectWindow: (id)sender
4130 NSInteger subwindowNumber = [(NSMenuItem *)sender tag] - AngbandWindowMenuItemTagBase;
4131 AngbandContext *context = angband_term[subwindowNumber]->data;
4132 [context->primaryWindow makeKeyAndOrderFront: self];
4133 [context saveWindowVisibleToDefaults: YES];
4136 - (void)prepareWindowsMenu
4138 /* Get the window menu with default items and add a separator and item for
4139 * the main window */
4140 NSMenu *windowsMenu = [[NSApplication sharedApplication] windowsMenu];
4141 [windowsMenu addItem: [NSMenuItem separatorItem]];
4143 NSString *title1 = [NSString stringWithCString:angband_term_name[0]
4145 encoding:NSJapaneseEUCStringEncoding
4147 encoding:NSMacOSRomanStringEncoding
4150 NSMenuItem *angbandItem = [[NSMenuItem alloc] initWithTitle:title1 action: @selector(selectWindow:) keyEquivalent: @"0"];
4151 [angbandItem setTarget: self];
4152 [angbandItem setTag: AngbandWindowMenuItemTagBase];
4153 [windowsMenu addItem: angbandItem];
4154 [angbandItem release];
4156 /* Add items for the additional term windows */
4157 for( NSInteger i = 1; i < ANGBAND_TERM_MAX; i++ )
4159 NSString *title = [NSString stringWithCString:angband_term_name[i]
4161 encoding:NSJapaneseEUCStringEncoding
4163 encoding:NSMacOSRomanStringEncoding
4166 NSString *keyEquivalent = [NSString stringWithFormat: @"%ld", (long)i];
4167 NSMenuItem *windowItem = [[NSMenuItem alloc] initWithTitle: title action: @selector(selectWindow:) keyEquivalent: keyEquivalent];
4168 [windowItem setTarget: self];
4169 [windowItem setTag: AngbandWindowMenuItemTagBase + i];
4170 [windowsMenu addItem: windowItem];
4171 [windowItem release];
4175 - (IBAction)setGraphicsMode:(NSMenuItem *)sender
4177 /* We stashed the graphics mode ID in the menu item's tag */
4178 graf_mode_req = [sender tag];
4180 /* Stash it in UserDefaults */
4181 [[NSUserDefaults angbandDefaults] setInteger:graf_mode_req forKey:AngbandGraphicsDefaultsKey];
4182 [[NSUserDefaults angbandDefaults] synchronize];
4184 if (game_in_progress)
4186 /* Hack -- Force redraw */
4189 /* Wake up the event loop so it notices the change */
4190 wakeup_event_loop();
4194 - (IBAction) toggleSound: (NSMenuItem *) sender
4196 BOOL is_on = (sender.state == NSOnState);
4198 /* Toggle the state and update the Angband global and preferences. */
4199 sender.state = (is_on) ? NSOffState : NSOnState;
4200 use_sound = (is_on) ? FALSE : TRUE;
4201 [[NSUserDefaults angbandDefaults] setBool:(! is_on)
4202 forKey:AngbandSoundDefaultsKey];
4206 * Send a command to Angband via a menu item. This places the appropriate key
4207 * down events into the queue so that it seems like the user pressed them
4208 * (instead of trying to use the term directly).
4210 - (void)sendAngbandCommand: (id)sender
4212 NSMenuItem *menuItem = (NSMenuItem *)sender;
4213 NSString *command = [self.commandMenuTagMap objectForKey: [NSNumber numberWithInteger: [menuItem tag]]];
4214 NSInteger windowNumber = [((AngbandContext *)angband_term[0]->data)->primaryWindow windowNumber];
4216 /* Send a \ to bypass keymaps */
4217 NSEvent *escape = [NSEvent keyEventWithType: NSKeyDown
4218 location: NSZeroPoint
4221 windowNumber: windowNumber
4224 charactersIgnoringModifiers: @"\\"
4227 [[NSApplication sharedApplication] postEvent: escape atStart: NO];
4229 /* Send the actual command (from the original command set) */
4230 NSEvent *keyDown = [NSEvent keyEventWithType: NSKeyDown
4231 location: NSZeroPoint
4234 windowNumber: windowNumber
4237 charactersIgnoringModifiers: command
4240 [[NSApplication sharedApplication] postEvent: keyDown atStart: NO];
4244 * Set up the command menu dynamically, based on CommandMenu.plist.
4246 - (void)prepareCommandMenu
4248 NSString *commandMenuPath = [[NSBundle mainBundle] pathForResource: @"CommandMenu" ofType: @"plist"];
4249 NSArray *commandMenuItems = [[NSArray alloc] initWithContentsOfFile: commandMenuPath];
4250 NSMutableDictionary *angbandCommands = [[NSMutableDictionary alloc] init];
4251 NSString *tblname = @"CommandMenu";
4252 NSInteger tagOffset = 0;
4254 for( NSDictionary *item in commandMenuItems )
4256 BOOL useShiftModifier = [[item valueForKey: @"ShiftModifier"] boolValue];
4257 BOOL useOptionModifier = [[item valueForKey: @"OptionModifier"] boolValue];
4258 NSUInteger keyModifiers = NSCommandKeyMask;
4259 keyModifiers |= (useShiftModifier) ? NSShiftKeyMask : 0;
4260 keyModifiers |= (useOptionModifier) ? NSAlternateKeyMask : 0;
4262 NSString *lookup = [item valueForKey: @"Title"];
4263 NSString *title = NSLocalizedStringWithDefaultValue(
4264 lookup, tblname, [NSBundle mainBundle], lookup, @"");
4265 NSString *key = [item valueForKey: @"KeyEquivalent"];
4266 NSMenuItem *menuItem = [[NSMenuItem alloc] initWithTitle: title action: @selector(sendAngbandCommand:) keyEquivalent: key];
4267 [menuItem setTarget: self];
4268 [menuItem setKeyEquivalentModifierMask: keyModifiers];
4269 [menuItem setTag: AngbandCommandMenuItemTagBase + tagOffset];
4270 [self.commandMenu addItem: menuItem];
4273 NSString *angbandCommand = [item valueForKey: @"AngbandCommand"];
4274 [angbandCommands setObject: angbandCommand forKey: [NSNumber numberWithInteger: [menuItem tag]]];
4278 [commandMenuItems release];
4280 NSDictionary *safeCommands = [[NSDictionary alloc] initWithDictionary: angbandCommands];
4281 self.commandMenuTagMap = safeCommands;
4282 [safeCommands release];
4283 [angbandCommands release];
4286 - (void)awakeFromNib
4288 [super awakeFromNib];
4290 [self prepareWindowsMenu];
4291 [self prepareCommandMenu];
4294 - (void)applicationDidFinishLaunching:sender
4296 [AngbandContext beginGame];
4298 /* Once beginGame finished, the game is over - that's how Angband works,
4299 * and we should quit */
4300 game_is_finished = TRUE;
4301 [NSApp terminate:self];
4304 - (NSApplicationTerminateReply)applicationShouldTerminate:(NSApplication *)sender
4306 if (p_ptr->playing == FALSE || game_is_finished == TRUE)
4308 return NSTerminateNow;
4310 else if (! inkey_flag)
4312 /* For compatibility with other ports, do not quit in this case */
4313 return NSTerminateCancel;
4318 /* player->upkeep->playing = FALSE; */
4320 /* Post an escape event so that we can return from our get-key-event
4322 wakeup_event_loop();
4323 quit_when_ready = true;
4324 /* Must return Cancel, not Later, because we need to get out of the
4325 * run loop and back to Angband's loop */
4326 return NSTerminateCancel;
4331 * Dynamically build the Graphics menu
4333 - (void)menuNeedsUpdate:(NSMenu *)menu {
4335 /* Only the graphics menu is dynamic */
4336 if (! [menu isEqual:self.graphicsMenu])
4339 /* If it's non-empty, then we've already built it. Currently graphics modes
4340 * won't change once created; if they ever can we can remove this check.
4341 * Note that the check mark does change, but that's handled in
4342 * validateMenuItem: instead of menuNeedsUpdate: */
4343 if ([menu numberOfItems] > 0)
4346 /* This is the action for all these menu items */
4347 SEL action = @selector(setGraphicsMode:);
4349 /* Add an initial Classic ASCII menu item */
4350 NSString *tblname = @"GraphicsMenu";
4351 NSString *key = @"Classic ASCII";
4352 NSString *title = NSLocalizedStringWithDefaultValue(
4353 key, tblname, [NSBundle mainBundle], key, @"");
4354 NSMenuItem *classicItem = [menu addItemWithTitle:title action:action keyEquivalent:@""];
4355 [classicItem setTag:GRAPHICS_NONE];
4357 /* Walk through the list of graphics modes */
4358 if (graphics_modes) {
4361 for (i=0; graphics_modes[i].pNext; i++)
4363 const graphics_mode *graf = &graphics_modes[i];
4365 if (graf->grafID == GRAPHICS_NONE) {
4368 /* Make the title. NSMenuItem throws on a nil title, so ensure it's
4370 key = [[NSString alloc] initWithUTF8String:graf->menuname];
4371 title = NSLocalizedStringWithDefaultValue(
4372 key, tblname, [NSBundle mainBundle], key, @"");
4375 NSMenuItem *item = [menu addItemWithTitle:title action:action keyEquivalent:@""];
4377 [item setTag:graf->grafID];
4383 * Delegate method that gets called if we're asked to open a file.
4385 - (BOOL)application:(NSApplication *)sender openFiles:(NSArray *)filenames
4387 /* Can't open a file once we've started */
4388 if (game_in_progress) return NO;
4390 /* We can only open one file. Use the last one. */
4391 NSString *file = [filenames lastObject];
4392 if (! file) return NO;
4394 /* Put it in savefile */
4395 if (! [file getFileSystemRepresentation:savefile maxLength:sizeof savefile])
4398 game_in_progress = TRUE;
4401 /* Wake us up in case this arrives while we're sitting at the Welcome
4403 wakeup_event_loop();
4410 int main(int argc, char* argv[])
4412 NSApplicationMain(argc, (void*)argv);
4416 #endif /* MACINTOSH || MACH_O_COCOA */