src/nsterm.m

   1 /* NeXT/Open/GNUstep / macOS communication module.      -*- coding: utf-8 -*-
   2
   3 Copyright (C) 1989, 1993-1994, 2005-2006, 2008-2017 Free Software
   4 Foundation, Inc.
   5
   6 This file is part of GNU Emacs.
   7
   8 GNU Emacs is free software: you can redistribute it and/or modify
   9 it under the terms of the GNU General Public License as published by
  10 the Free Software Foundation, either version 3 of the License, or (at
  11 your option) any later version.
  12
  13 GNU Emacs is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
  20
  21 /*
  22 Originally by Carl Edman
  23 Updated by Christian Limpach (chris@nice.ch)
  24 OpenStep/Rhapsody port by Scott Bender (sbender@harmony-ds.com)
  25 macOS/Aqua port by Christophe de Dinechin (descubes@earthlink.net)
  26 GNUstep port and post-20 update by Adrian Robert (arobert@cogsci.ucsd.edu)
  27 */
  28
  29 /* This should be the first include, as it may set up #defines affecting
  30    interpretation of even the system includes. */
  31 #include <config.h>
  32
  33 #include <fcntl.h>
  34 #include <math.h>
  35 #include <pthread.h>
  36 #include <sys/types.h>
  37 #include <time.h>
  38 #include <signal.h>
  39 #include <unistd.h>
  40
  41 #include <c-ctype.h>
  42 #include <c-strcase.h>
  43 #include <ftoastr.h>
  44
  45 #include "lisp.h"
  46 #include "blockinput.h"
  47 #include "sysselect.h"
  48 #include "nsterm.h"
  49 #include "systime.h"
  50 #include "character.h"
  51 #include "fontset.h"
  52 #include "composite.h"
  53 #include "ccl.h"
  54
  55 #include "termhooks.h"
  56 #include "termchar.h"
  57 #include "menu.h"
  58 #include "window.h"
  59 #include "keyboard.h"
  60 #include "buffer.h"
  61 #include "font.h"
  62
  63 #ifdef NS_IMPL_GNUSTEP
  64 #include "process.h"
  65 #endif
  66
  67 #ifdef NS_IMPL_COCOA
  68 #include "macfont.h"
  69 #endif
  70
  71 static EmacsMenu *dockMenu;
  72 #ifdef NS_IMPL_COCOA
  73 static EmacsMenu *mainMenu;
  74 #endif
  75
  76 /* ==========================================================================
  77
  78    NSTRACE, Trace support.
  79
  80    ========================================================================== */
  81
  82 #if NSTRACE_ENABLED
  83
  84 /* The following use "volatile" since they can be accessed from
  85    parallel threads. */
  86 volatile int nstrace_num = 0;
  87 volatile int nstrace_depth = 0;
  88
  89 /* When 0, no trace is emitted.  This is used by NSTRACE_WHEN and
  90    NSTRACE_UNLESS to silence functions called.
  91
  92    TODO: This should really be a thread-local variable, to avoid that
  93    a function with disabled trace thread silence trace output in
  94    another.  However, in practice this seldom is a problem. */
  95 volatile int nstrace_enabled_global = 1;
  96
  97 /* Called when nstrace_enabled goes out of scope. */
  98 void nstrace_leave(int * pointer_to_nstrace_enabled)
  99 {
 100   if (*pointer_to_nstrace_enabled)
 101     {
 102       --nstrace_depth;
 103     }
 104 }
 105
 106
 107 /* Called when nstrace_saved_enabled_global goes out of scope. */
 108 void nstrace_restore_global_trace_state(int * pointer_to_saved_enabled_global)
 109 {
 110   nstrace_enabled_global = *pointer_to_saved_enabled_global;
 111 }
 112
 113
 114 char const * nstrace_fullscreen_type_name (int fs_type)
 115 {
 116   switch (fs_type)
 117     {
 118     case -1:                   return "-1";
 119     case FULLSCREEN_NONE:      return "FULLSCREEN_NONE";
 120     case FULLSCREEN_WIDTH:     return "FULLSCREEN_WIDTH";
 121     case FULLSCREEN_HEIGHT:    return "FULLSCREEN_HEIGHT";
 122     case FULLSCREEN_BOTH:      return "FULLSCREEN_BOTH";
 123     case FULLSCREEN_MAXIMIZED: return "FULLSCREEN_MAXIMIZED";
 124     default:                   return "FULLSCREEN_?????";
 125     }
 126 }
 127 #endif
 128
 129
 130 /* ==========================================================================
 131
 132    NSColor, EmacsColor category.
 133
 134    ========================================================================== */
 135 @implementation NSColor (EmacsColor)
 136 + (NSColor *)colorForEmacsRed:(CGFloat)red green:(CGFloat)green
 137                          blue:(CGFloat)blue alpha:(CGFloat)alpha
 138 {
 139 #ifdef NS_IMPL_COCOA
 140 #if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_7
 141   if (ns_use_srgb_colorspace)
 142       return [NSColor colorWithSRGBRed: red
 143                                  green: green
 144                                   blue: blue
 145                                  alpha: alpha];
 146 #endif
 147 #endif
 148   return [NSColor colorWithCalibratedRed: red
 149                                    green: green
 150                                     blue: blue
 151                                    alpha: alpha];
 152 }
 153
 154 - (NSColor *)colorUsingDefaultColorSpace
 155 {
 156 #ifdef NS_IMPL_COCOA
 157 #if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_7
 158   if (ns_use_srgb_colorspace)
 159     return [self colorUsingColorSpace: [NSColorSpace sRGBColorSpace]];
 160 #endif
 161 #endif
 162   return [self colorUsingColorSpaceName: NSCalibratedRGBColorSpace];
 163 }
 164
 165 @end
 166
 167 /* ==========================================================================
 168
 169     Local declarations
 170
 171    ========================================================================== */
 172
 173 /* Convert a symbol indexed with an NSxxx value to a value as defined
 174    in keyboard.c (lispy_function_key). I hope this is a correct way
 175    of doing things... */
 176 static unsigned convert_ns_to_X_keysym[] =
 177 {
 178   NSHomeFunctionKey,            0x50,
 179   NSLeftArrowFunctionKey,       0x51,
 180   NSUpArrowFunctionKey,         0x52,
 181   NSRightArrowFunctionKey,      0x53,
 182   NSDownArrowFunctionKey,       0x54,
 183   NSPageUpFunctionKey,          0x55,
 184   NSPageDownFunctionKey,        0x56,
 185   NSEndFunctionKey,             0x57,
 186   NSBeginFunctionKey,           0x58,
 187   NSSelectFunctionKey,          0x60,
 188   NSPrintFunctionKey,           0x61,
 189   NSClearLineFunctionKey,       0x0B,
 190   NSExecuteFunctionKey,         0x62,
 191   NSInsertFunctionKey,          0x63,
 192   NSUndoFunctionKey,            0x65,
 193   NSRedoFunctionKey,            0x66,
 194   NSMenuFunctionKey,            0x67,
 195   NSFindFunctionKey,            0x68,
 196   NSHelpFunctionKey,            0x6A,
 197   NSBreakFunctionKey,           0x6B,
 198
 199   NSF1FunctionKey,              0xBE,
 200   NSF2FunctionKey,              0xBF,
 201   NSF3FunctionKey,              0xC0,
 202   NSF4FunctionKey,              0xC1,
 203   NSF5FunctionKey,              0xC2,
 204   NSF6FunctionKey,              0xC3,
 205   NSF7FunctionKey,              0xC4,
 206   NSF8FunctionKey,              0xC5,
 207   NSF9FunctionKey,              0xC6,
 208   NSF10FunctionKey,             0xC7,
 209   NSF11FunctionKey,             0xC8,
 210   NSF12FunctionKey,             0xC9,
 211   NSF13FunctionKey,             0xCA,
 212   NSF14FunctionKey,             0xCB,
 213   NSF15FunctionKey,             0xCC,
 214   NSF16FunctionKey,             0xCD,
 215   NSF17FunctionKey,             0xCE,
 216   NSF18FunctionKey,             0xCF,
 217   NSF19FunctionKey,             0xD0,
 218   NSF20FunctionKey,             0xD1,
 219   NSF21FunctionKey,             0xD2,
 220   NSF22FunctionKey,             0xD3,
 221   NSF23FunctionKey,             0xD4,
 222   NSF24FunctionKey,             0xD5,
 223
 224   NSBackspaceCharacter,         0x08,  /* 8: Not on some KBs. */
 225   NSDeleteCharacter,            0xFF,  /* 127: Big 'delete' key upper right. */
 226   NSDeleteFunctionKey,          0x9F,  /* 63272: Del forw key off main array. */
 227
 228   NSTabCharacter,               0x09,
 229   0x19,                         0x09,  /* left tab->regular since pass shift */
 230   NSCarriageReturnCharacter,    0x0D,
 231   NSNewlineCharacter,           0x0D,
 232   NSEnterCharacter,             0x8D,
 233
 234   0x41|NSEventModifierFlagNumericPad,   0xAE,  /* KP_Decimal */
 235   0x43|NSEventModifierFlagNumericPad,   0xAA,  /* KP_Multiply */
 236   0x45|NSEventModifierFlagNumericPad,   0xAB,  /* KP_Add */
 237   0x4B|NSEventModifierFlagNumericPad,   0xAF,  /* KP_Divide */
 238   0x4E|NSEventModifierFlagNumericPad,   0xAD,  /* KP_Subtract */
 239   0x51|NSEventModifierFlagNumericPad,   0xBD,  /* KP_Equal */
 240   0x52|NSEventModifierFlagNumericPad,   0xB0,  /* KP_0 */
 241   0x53|NSEventModifierFlagNumericPad,   0xB1,  /* KP_1 */
 242   0x54|NSEventModifierFlagNumericPad,   0xB2,  /* KP_2 */
 243   0x55|NSEventModifierFlagNumericPad,   0xB3,  /* KP_3 */
 244   0x56|NSEventModifierFlagNumericPad,   0xB4,  /* KP_4 */
 245   0x57|NSEventModifierFlagNumericPad,   0xB5,  /* KP_5 */
 246   0x58|NSEventModifierFlagNumericPad,   0xB6,  /* KP_6 */
 247   0x59|NSEventModifierFlagNumericPad,   0xB7,  /* KP_7 */
 248   0x5B|NSEventModifierFlagNumericPad,   0xB8,  /* KP_8 */
 249   0x5C|NSEventModifierFlagNumericPad,   0xB9,  /* KP_9 */
 250
 251   0x1B,                         0x1B   /* escape */
 252 };
 253
 254 /* On macOS picks up the default NSGlobalDomain AppleAntiAliasingThreshold,
 255    the maximum font size to NOT antialias.  On GNUstep there is currently
 256    no way to control this behavior. */
 257 float ns_antialias_threshold;
 258
 259 NSArray *ns_send_types = 0, *ns_return_types = 0;
 260 static NSArray *ns_drag_types = 0;
 261 NSString *ns_app_name = @"Emacs";  /* default changed later */
 262
 263 /* Display variables */
 264 struct ns_display_info *x_display_list; /* Chain of existing displays */
 265 long context_menu_value = 0;
 266
 267 /* display update */
 268 static struct frame *ns_updating_frame;
 269 static NSView *focus_view = NULL;
 270 static int ns_window_num = 0;
 271 #ifdef NS_IMPL_GNUSTEP
 272 static NSRect uRect;            // TODO: This is dead, remove it?
 273 #endif
 274 static BOOL gsaved = NO;
 275 static BOOL ns_fake_keydown = NO;
 276 #ifdef NS_IMPL_COCOA
 277 static BOOL ns_menu_bar_is_hidden = NO;
 278 #endif
 279 /*static int debug_lock = 0; */
 280
 281 /* event loop */
 282 static BOOL send_appdefined = YES;
 283 #define NO_APPDEFINED_DATA (-8)
 284 static int last_appdefined_event_data = NO_APPDEFINED_DATA;
 285 static NSTimer *timed_entry = 0;
 286 static NSTimer *scroll_repeat_entry = nil;
 287 static fd_set select_readfds, select_writefds;
 288 enum { SELECT_HAVE_READ = 1, SELECT_HAVE_WRITE = 2, SELECT_HAVE_TMO = 4 };
 289 static int select_nfds = 0, select_valid = 0;
 290 static struct timespec select_timeout = { 0, 0 };
 291 static int selfds[2] = { -1, -1 };
 292 static pthread_mutex_t select_mutex;
 293 static NSAutoreleasePool *outerpool;
 294 static struct input_event *emacs_event = NULL;
 295 static struct input_event *q_event_ptr = NULL;
 296 static int n_emacs_events_pending = 0;
 297 static NSMutableArray *ns_pending_files, *ns_pending_service_names,
 298   *ns_pending_service_args;
 299 static BOOL ns_do_open_file = NO;
 300 static BOOL ns_last_use_native_fullscreen;
 301
 302 /* Non-zero means that a HELP_EVENT has been generated since Emacs
 303    start.  */
 304
 305 static BOOL any_help_event_p = NO;
 306
 307 static struct {
 308   struct input_event *q;
 309   int nr, cap;
 310 } hold_event_q = {
 311   NULL, 0, 0
 312 };
 313
 314 static NSString *represented_filename = nil;
 315 static struct frame *represented_frame = 0;
 316
 317 #ifdef NS_IMPL_COCOA
 318 /*
 319  * State for pending menu activation:
 320  * MENU_NONE     Normal state
 321  * MENU_PENDING  A menu has been clicked on, but has been canceled so we can
 322  *               run lisp to update the menu.
 323  * MENU_OPENING  Menu is up to date, and the click event is redone so the menu
 324  *               will open.
 325  */
 326 #define MENU_NONE 0
 327 #define MENU_PENDING 1
 328 #define MENU_OPENING 2
 329 static int menu_will_open_state = MENU_NONE;
 330
 331 /* Saved position for menu click.  */
 332 static CGPoint menu_mouse_point;
 333 #endif
 334
 335 /* Convert modifiers in a NeXTstep event to emacs style modifiers.  */
 336 #define NS_FUNCTION_KEY_MASK 0x800000
 337 #define NSLeftControlKeyMask    (0x000001 | NSEventModifierFlagControl)
 338 #define NSRightControlKeyMask   (0x002000 | NSEventModifierFlagControl)
 339 #define NSLeftCommandKeyMask    (0x000008 | NSEventModifierFlagCommand)
 340 #define NSRightCommandKeyMask   (0x000010 | NSEventModifierFlagCommand)
 341 #define NSLeftAlternateKeyMask  (0x000020 | NSEventModifierFlagOption)
 342 #define NSRightAlternateKeyMask (0x000040 | NSEventModifierFlagOption)
 343 #define EV_MODIFIERS2(flags)                          \
 344     (((flags & NSEventModifierFlagHelp) ?           \
 345            hyper_modifier : 0)                        \
 346      | (!EQ (ns_right_alternate_modifier, Qleft) && \
 347         ((flags & NSRightAlternateKeyMask) \
 348          == NSRightAlternateKeyMask) ? \
 349            parse_solitary_modifier (ns_right_alternate_modifier) : 0) \
 350      | ((flags & NSEventModifierFlagOption) ?                 \
 351            parse_solitary_modifier (ns_alternate_modifier) : 0)   \
 352      | ((flags & NSEventModifierFlagShift) ?     \
 353            shift_modifier : 0)                        \
 354      | (!EQ (ns_right_control_modifier, Qleft) && \
 355         ((flags & NSRightControlKeyMask) \
 356          == NSRightControlKeyMask) ? \
 357            parse_solitary_modifier (ns_right_control_modifier) : 0) \
 358      | ((flags & NSEventModifierFlagControl) ?      \
 359            parse_solitary_modifier (ns_control_modifier) : 0)     \
 360      | ((flags & NS_FUNCTION_KEY_MASK) ?  \
 361            parse_solitary_modifier (ns_function_modifier) : 0)    \
 362      | (!EQ (ns_right_command_modifier, Qleft) && \
 363         ((flags & NSRightCommandKeyMask) \
 364          == NSRightCommandKeyMask) ? \
 365            parse_solitary_modifier (ns_right_command_modifier) : 0) \
 366      | ((flags & NSEventModifierFlagCommand) ?      \
 367            parse_solitary_modifier (ns_command_modifier):0))
 368 #define EV_MODIFIERS(e) EV_MODIFIERS2 ([e modifierFlags])
 369
 370 #define EV_UDMODIFIERS(e)                                      \
 371     ((([e type] == NSEventTypeLeftMouseDown) ? down_modifier : 0)       \
 372      | (([e type] == NSEventTypeRightMouseDown) ? down_modifier : 0)    \
 373      | (([e type] == NSEventTypeOtherMouseDown) ? down_modifier : 0)    \
 374      | (([e type] == NSEventTypeLeftMouseDragged) ? down_modifier : 0)  \
 375      | (([e type] == NSEventTypeRightMouseDragged) ? down_modifier : 0) \
 376      | (([e type] == NSEventTypeOtherMouseDragged) ? down_modifier : 0) \
 377      | (([e type] == NSEventTypeLeftMouseUp)   ? up_modifier   : 0)     \
 378      | (([e type] == NSEventTypeRightMouseUp)   ? up_modifier   : 0)    \
 379      | (([e type] == NSEventTypeOtherMouseUp)   ? up_modifier   : 0))
 380
 381 #define EV_BUTTON(e)                                                         \
 382     ((([e type] == NSEventTypeLeftMouseDown) || ([e type] == NSEventTypeLeftMouseUp)) ? 0 :    \
 383       (([e type] == NSEventTypeRightMouseDown) || ([e type] == NSEventTypeRightMouseUp)) ? 2 : \
 384      [e buttonNumber] - 1)
 385
 386 /* Convert the time field to a timestamp in milliseconds. */
 387 #define EV_TIMESTAMP(e) ([e timestamp] * 1000)
 388
 389 /* This is a piece of code which is common to all the event handling
 390    methods.  Maybe it should even be a function.  */
 391 #define EV_TRAILER(e)                                                   \
 392   {                                                                     \
 393     XSETFRAME (emacs_event->frame_or_window, emacsframe);               \
 394     EV_TRAILER2 (e);                                                    \
 395   }
 396
 397 #define EV_TRAILER2(e)                                                  \
 398   {                                                                     \
 399       if (e) emacs_event->timestamp = EV_TIMESTAMP (e);                 \
 400       if (q_event_ptr)                                                  \
 401         {                                                               \
 402           Lisp_Object tem = Vinhibit_quit;                              \
 403           Vinhibit_quit = Qt;                                           \
 404           n_emacs_events_pending++;                                     \
 405           kbd_buffer_store_event_hold (emacs_event, q_event_ptr);       \
 406           Vinhibit_quit = tem;                                          \
 407         }                                                               \
 408       else                                                              \
 409         hold_event (emacs_event);                                       \
 410       EVENT_INIT (*emacs_event);                                        \
 411       ns_send_appdefined (-1);                                          \
 412     }
 413
 414 /* TODO: get rid of need for these forward declarations */
 415 static void ns_condemn_scroll_bars (struct frame *f);
 416 static void ns_judge_scroll_bars (struct frame *f);
 417
 418
 419 /* ==========================================================================
 420
 421     Utilities
 422
 423    ========================================================================== */
 424
 425 void
 426 ns_set_represented_filename (NSString *fstr, struct frame *f)
 427 {
 428   represented_filename = [fstr retain];
 429   represented_frame = f;
 430 }
 431
 432 void
 433 ns_init_events (struct input_event *ev)
 434 {
 435   EVENT_INIT (*ev);
 436   emacs_event = ev;
 437 }
 438
 439 void
 440 ns_finish_events (void)
 441 {
 442   emacs_event = NULL;
 443 }
 444
 445 static void
 446 hold_event (struct input_event *event)
 447 {
 448   if (hold_event_q.nr == hold_event_q.cap)
 449     {
 450       if (hold_event_q.cap == 0) hold_event_q.cap = 10;
 451       else hold_event_q.cap *= 2;
 452       hold_event_q.q =
 453         xrealloc (hold_event_q.q, hold_event_q.cap * sizeof *hold_event_q.q);
 454     }
 455
 456   hold_event_q.q[hold_event_q.nr++] = *event;
 457   /* Make sure ns_read_socket is called, i.e. we have input.  */
 458   raise (SIGIO);
 459   send_appdefined = YES;
 460 }
 461
 462 static Lisp_Object
 463 append2 (Lisp_Object list, Lisp_Object item)
 464 /* --------------------------------------------------------------------------
 465    Utility to append to a list
 466    -------------------------------------------------------------------------- */
 467 {
 468   return CALLN (Fnconc, list, list1 (item));
 469 }
 470
 471
 472 const char *
 473 ns_etc_directory (void)
 474 /* If running as a self-contained app bundle, return as a string the
 475    filename of the etc directory, if present; else nil.  */
 476 {
 477   NSBundle *bundle = [NSBundle mainBundle];
 478   NSString *resourceDir = [bundle resourcePath];
 479   NSString *resourcePath;
 480   NSFileManager *fileManager = [NSFileManager defaultManager];
 481   BOOL isDir;
 482
 483   resourcePath = [resourceDir stringByAppendingPathComponent: @"etc"];
 484   if ([fileManager fileExistsAtPath: resourcePath isDirectory: &isDir])
 485     {
 486       if (isDir) return [resourcePath UTF8String];
 487     }
 488   return NULL;
 489 }
 490
 491
 492 const char *
 493 ns_exec_path (void)
 494 /* If running as a self-contained app bundle, return as a path string
 495    the filenames of the libexec and bin directories, ie libexec:bin.
 496    Otherwise, return nil.
 497    Normally, Emacs does not add its own bin/ directory to the PATH.
 498    However, a self-contained NS build has a different layout, with
 499    bin/ and libexec/ subdirectories in the directory that contains
 500    Emacs.app itself.
 501    We put libexec first, because init_callproc_1 uses the first
 502    element to initialize exec-directory.  An alternative would be
 503    for init_callproc to check for invocation-directory/libexec.
 504 */
 505 {
 506   NSBundle *bundle = [NSBundle mainBundle];
 507   NSString *resourceDir = [bundle resourcePath];
 508   NSString *binDir = [bundle bundlePath];
 509   NSString *resourcePath, *resourcePaths;
 510   NSRange range;
 511   NSString *pathSeparator = [NSString stringWithFormat: @"%c", SEPCHAR];
 512   NSFileManager *fileManager = [NSFileManager defaultManager];
 513   NSArray *paths;
 514   NSEnumerator *pathEnum;
 515   BOOL isDir;
 516
 517   range = [resourceDir rangeOfString: @"Contents"];
 518   if (range.location != NSNotFound)
 519     {
 520       binDir = [binDir stringByAppendingPathComponent: @"Contents"];
 521 #ifdef NS_IMPL_COCOA
 522       binDir = [binDir stringByAppendingPathComponent: @"MacOS"];
 523 #endif
 524     }
 525
 526   paths = [binDir stringsByAppendingPaths:
 527                 [NSArray arrayWithObjects: @"libexec", @"bin", nil]];
 528   pathEnum = [paths objectEnumerator];
 529   resourcePaths = @"";
 530
 531   while ((resourcePath = [pathEnum nextObject]))
 532     {
 533       if ([fileManager fileExistsAtPath: resourcePath isDirectory: &isDir])
 534         if (isDir)
 535           {
 536             if ([resourcePaths length] > 0)
 537               resourcePaths
 538                 = [resourcePaths stringByAppendingString: pathSeparator];
 539             resourcePaths
 540               = [resourcePaths stringByAppendingString: resourcePath];
 541           }
 542     }
 543   if ([resourcePaths length] > 0) return [resourcePaths UTF8String];
 544
 545   return NULL;
 546 }
 547
 548
 549 const char *
 550 ns_load_path (void)
 551 /* If running as a self-contained app bundle, return as a path string
 552    the filenames of the site-lisp and lisp directories.
 553    Ie, site-lisp:lisp.  Otherwise, return nil.  */
 554 {
 555   NSBundle *bundle = [NSBundle mainBundle];
 556   NSString *resourceDir = [bundle resourcePath];
 557   NSString *resourcePath, *resourcePaths;
 558   NSString *pathSeparator = [NSString stringWithFormat: @"%c", SEPCHAR];
 559   NSFileManager *fileManager = [NSFileManager defaultManager];
 560   BOOL isDir;
 561   NSArray *paths = [resourceDir stringsByAppendingPaths:
 562                               [NSArray arrayWithObjects:
 563                                          @"site-lisp", @"lisp", nil]];
 564   NSEnumerator *pathEnum = [paths objectEnumerator];
 565   resourcePaths = @"";
 566
 567   /* Hack to skip site-lisp.  */
 568   if (no_site_lisp) resourcePath = [pathEnum nextObject];
 569
 570   while ((resourcePath = [pathEnum nextObject]))
 571     {
 572       if ([fileManager fileExistsAtPath: resourcePath isDirectory: &isDir])
 573         if (isDir)
 574           {
 575             if ([resourcePaths length] > 0)
 576               resourcePaths
 577                 = [resourcePaths stringByAppendingString: pathSeparator];
 578             resourcePaths
 579               = [resourcePaths stringByAppendingString: resourcePath];
 580           }
 581     }
 582   if ([resourcePaths length] > 0) return [resourcePaths UTF8String];
 583
 584   return NULL;
 585 }
 586
 587
 588 void
 589 ns_init_locale (void)
 590 /* macOS doesn't set any environment variables for the locale when run
 591    from the GUI. Get the locale from the OS and set LANG. */
 592 {
 593   NSLocale *locale = [NSLocale currentLocale];
 594
 595   NSTRACE ("ns_init_locale");
 596
 597   @try
 598     {
 599       /* It seems macOS should probably use UTF-8 everywhere.
 600          'localeIdentifier' does not specify the encoding, and I can't
 601          find any way to get the OS to tell us which encoding to use,
 602          so hard-code '.UTF-8'. */
 603       NSString *localeID = [NSString stringWithFormat:@"%@.UTF-8",
 604                                      [locale localeIdentifier]];
 605
 606       /* Set LANG to locale, but not if LANG is already set. */
 607       setenv("LANG", [localeID UTF8String], 0);
 608     }
 609   @catch (NSException *e)
 610     {
 611       NSLog (@"Locale detection failed: %@: %@", [e name], [e reason]);
 612     }
 613 }
 614
 615
 616 void
 617 ns_release_object (void *obj)
 618 /* --------------------------------------------------------------------------
 619     Release an object (callable from C)
 620    -------------------------------------------------------------------------- */
 621 {
 622     [(id)obj release];
 623 }
 624
 625
 626 void
 627 ns_retain_object (void *obj)
 628 /* --------------------------------------------------------------------------
 629     Retain an object (callable from C)
 630    -------------------------------------------------------------------------- */
 631 {
 632     [(id)obj retain];
 633 }
 634
 635
 636 void *
 637 ns_alloc_autorelease_pool (void)
 638 /* --------------------------------------------------------------------------
 639      Allocate a pool for temporary objects (callable from C)
 640    -------------------------------------------------------------------------- */
 641 {
 642   return [[NSAutoreleasePool alloc] init];
 643 }
 644
 645
 646 void
 647 ns_release_autorelease_pool (void *pool)
 648 /* --------------------------------------------------------------------------
 649      Free a pool and temporary objects it refers to (callable from C)
 650    -------------------------------------------------------------------------- */
 651 {
 652   ns_release_object (pool);
 653 }
 654
 655
 656 static BOOL
 657 ns_menu_bar_should_be_hidden (void)
 658 /* True, if the menu bar should be hidden.  */
 659 {
 660   return !NILP (ns_auto_hide_menu_bar)
 661     && [NSApp respondsToSelector:@selector(setPresentationOptions:)];
 662 }
 663
 664
 665 struct EmacsMargins
 666 {
 667   CGFloat top;
 668   CGFloat bottom;
 669   CGFloat left;
 670   CGFloat right;
 671 };
 672
 673
 674 static struct EmacsMargins
 675 ns_screen_margins (NSScreen *screen)
 676 /* The parts of SCREEN used by the operating system.  */
 677 {
 678   NSTRACE ("ns_screen_margins");
 679
 680   struct EmacsMargins margins;
 681
 682   NSRect screenFrame = [screen frame];
 683   NSRect screenVisibleFrame = [screen visibleFrame];
 684
 685   /* Sometimes, visibleFrame isn't up-to-date with respect to a hidden
 686      menu bar, check this explicitly.  */
 687   if (ns_menu_bar_should_be_hidden())
 688     {
 689       margins.top = 0;
 690     }
 691   else
 692     {
 693       CGFloat frameTop = screenFrame.origin.y + screenFrame.size.height;
 694       CGFloat visibleFrameTop = (screenVisibleFrame.origin.y
 695                                  + screenVisibleFrame.size.height);
 696
 697       margins.top = frameTop - visibleFrameTop;
 698     }
 699
 700   {
 701     CGFloat frameRight = screenFrame.origin.x + screenFrame.size.width;
 702     CGFloat visibleFrameRight = (screenVisibleFrame.origin.x
 703                                  + screenVisibleFrame.size.width);
 704     margins.right = frameRight - visibleFrameRight;
 705   }
 706
 707   margins.bottom = screenVisibleFrame.origin.y - screenFrame.origin.y;
 708   margins.left   = screenVisibleFrame.origin.x - screenFrame.origin.x;
 709
 710   NSTRACE_MSG ("left:%g right:%g top:%g bottom:%g",
 711                margins.left,
 712                margins.right,
 713                margins.top,
 714                margins.bottom);
 715
 716   return margins;
 717 }
 718
 719
 720 /* A screen margin between 1 and DOCK_IGNORE_LIMIT (inclusive) is
 721    assumed to contain a hidden dock.  macOS currently use 4 pixels for
 722    this, however, to be future compatible, a larger value is used.  */
 723 #define DOCK_IGNORE_LIMIT 6
 724
 725 static struct EmacsMargins
 726 ns_screen_margins_ignoring_hidden_dock (NSScreen *screen)
 727 /* The parts of SCREEN used by the operating system, excluding the parts
 728 reserved for an hidden dock.  */
 729 {
 730   NSTRACE ("ns_screen_margins_ignoring_hidden_dock");
 731
 732   struct EmacsMargins margins = ns_screen_margins(screen);
 733
 734   /* macOS (currently) reserved 4 pixels along the edge where a hidden
 735      dock is located.  Unfortunately, it's not possible to find the
 736      location and information about if the dock is hidden.  Instead,
 737      it is assumed that if the margin of an edge is less than
 738      DOCK_IGNORE_LIMIT, it contains a hidden dock.  */
 739   if (margins.left <= DOCK_IGNORE_LIMIT)
 740     {
 741       margins.left = 0;
 742     }
 743   if (margins.right <= DOCK_IGNORE_LIMIT)
 744     {
 745       margins.right = 0;
 746     }
 747   if (margins.top <= DOCK_IGNORE_LIMIT)
 748     {
 749       margins.top = 0;
 750     }
 751   /* Note: This doesn't occur in current versions of macOS, but
 752      included for completeness and future compatibility.  */
 753   if (margins.bottom <= DOCK_IGNORE_LIMIT)
 754     {
 755       margins.bottom = 0;
 756     }
 757
 758   NSTRACE_MSG ("left:%g right:%g top:%g bottom:%g",
 759                margins.left,
 760                margins.right,
 761                margins.top,
 762                margins.bottom);
 763
 764   return margins;
 765 }
 766
 767
 768 static CGFloat
 769 ns_menu_bar_height (NSScreen *screen)
 770 /* The height of the menu bar, if visible.
 771
 772    Note: Don't use this when fullscreen is enabled -- the screen
 773    sometimes includes, sometimes excludes the menu bar area.  */
 774 {
 775   struct EmacsMargins margins = ns_screen_margins(screen);
 776
 777   CGFloat res = margins.top;
 778
 779   NSTRACE ("ns_menu_bar_height " NSTRACE_FMT_RETURN " %.0f", res);
 780
 781   return res;
 782 }
 783
 784
 785 /* ==========================================================================
 786
 787     Focus (clipping) and screen update
 788
 789    ========================================================================== */
 790
 791 //
 792 // Window constraining
 793 // -------------------
 794 //
 795 // To ensure that the windows are not placed under the menu bar, they
 796 // are typically moved by the call-back constrainFrameRect. However,
 797 // by overriding it, it's possible to inhibit this, leaving the window
 798 // in it's original position.
 799 //
 800 // It's possible to hide the menu bar. However, technically, it's only
 801 // possible to hide it when the application is active. To ensure that
 802 // this work properly, the menu bar and window constraining are
 803 // deferred until the application becomes active.
 804 //
 805 // Even though it's not possible to manually move a window above the
 806 // top of the screen, it is allowed if it's done programmatically,
 807 // when the menu is hidden. This allows the editable area to cover the
 808 // full screen height.
 809 //
 810 // Test cases
 811 // ----------
 812 //
 813 // Use the following extra files:
 814 //
 815 //    init.el:
 816 //       ;; Hide menu and place frame slightly above the top of the screen.
 817 //       (setq ns-auto-hide-menu-bar t)
 818 //       (set-frame-position (selected-frame) 0 -20)
 819 //
 820 // Test 1:
 821 //
 822 //    emacs -Q -l init.el
 823 //
 824 //    Result: No menu bar, and the title bar should be above the screen.
 825 //
 826 // Test 2:
 827 //
 828 //    emacs -Q
 829 //
 830 //    Result: Menu bar visible, frame placed immediately below the menu.
 831 //
 832
 833 static NSRect constrain_frame_rect(NSRect frameRect, bool isFullscreen)
 834 {
 835   NSTRACE ("constrain_frame_rect(" NSTRACE_FMT_RECT ")",
 836              NSTRACE_ARG_RECT (frameRect));
 837
 838   // --------------------
 839   // Collect information about the screen the frame is covering.
 840   //
 841
 842   NSArray *screens = [NSScreen screens];
 843   NSUInteger nr_screens = [screens count];
 844
 845   int i;
 846
 847   // The height of the menu bar, if present in any screen the frame is
 848   // displayed in.
 849   int menu_bar_height = 0;
 850
 851   // A rectangle covering all the screen the frame is displayed in.
 852   NSRect multiscreenRect = NSMakeRect(0, 0, 0, 0);
 853   for (i = 0; i < nr_screens; ++i )
 854     {
 855       NSScreen *s = [screens objectAtIndex: i];
 856       NSRect scrRect = [s frame];
 857
 858       NSTRACE_MSG ("Screen %d: " NSTRACE_FMT_RECT,
 859                    i, NSTRACE_ARG_RECT (scrRect));
 860
 861       if (NSIntersectionRect (frameRect, scrRect).size.height != 0)
 862         {
 863           multiscreenRect = NSUnionRect (multiscreenRect, scrRect);
 864
 865           if (!isFullscreen)
 866             {
 867               CGFloat screen_menu_bar_height = ns_menu_bar_height (s);
 868               menu_bar_height = max(menu_bar_height, screen_menu_bar_height);
 869             }
 870         }
 871     }
 872
 873   NSTRACE_RECT ("multiscreenRect", multiscreenRect);
 874
 875   NSTRACE_MSG ("menu_bar_height: %d", menu_bar_height);
 876
 877   if (multiscreenRect.size.width == 0
 878       || multiscreenRect.size.height == 0)
 879     {
 880       // Failed to find any monitor, give up.
 881       NSTRACE_MSG ("multiscreenRect empty");
 882       NSTRACE_RETURN_RECT (frameRect);
 883       return frameRect;
 884     }
 885
 886
 887   // --------------------
 888   // Find a suitable placement.
 889   //
 890
 891   if (ns_menu_bar_should_be_hidden())
 892     {
 893       // When the menu bar is hidden, the user may place part of the
 894       // frame above the top of the screen, for example to hide the
 895       // title bar.
 896       //
 897       // Hence, keep the original position.
 898     }
 899   else
 900     {
 901       // Ensure that the frame is below the menu bar, or below the top
 902       // of the screen.
 903       //
 904       // This assume that the menu bar is placed at the top in the
 905       // rectangle that covers the monitors.  (It doesn't have to be,
 906       // but if it's not it's hard to do anything useful.)
 907       CGFloat topOfWorkArea = (multiscreenRect.origin.y
 908                                + multiscreenRect.size.height
 909                                - menu_bar_height);
 910
 911       CGFloat topOfFrame = frameRect.origin.y + frameRect.size.height;
 912       if (topOfFrame > topOfWorkArea)
 913         {
 914           frameRect.origin.y -= topOfFrame - topOfWorkArea;
 915           NSTRACE_RECT ("After placement adjust", frameRect);
 916         }
 917     }
 918
 919   // Include the following section to restrict frame to the screens.
 920   // (If so, update it to allow the frame to stretch down below the
 921   // screen.)
 922 #if 0
 923   // --------------------
 924   // Ensure frame doesn't stretch below the screens.
 925   //
 926
 927   CGFloat diff = multiscreenRect.origin.y - frameRect.origin.y;
 928
 929   if (diff > 0)
 930     {
 931       frameRect.origin.y = multiscreenRect.origin.y;
 932       frameRect.size.height -= diff;
 933     }
 934 #endif
 935
 936   NSTRACE_RETURN_RECT (frameRect);
 937   return frameRect;
 938 }
 939
 940
 941 static void
 942 ns_constrain_all_frames (void)
 943 /* --------------------------------------------------------------------------
 944      Ensure that the menu bar doesn't cover any frames.
 945    -------------------------------------------------------------------------- */
 946 {
 947   Lisp_Object tail, frame;
 948
 949   NSTRACE ("ns_constrain_all_frames");
 950
 951   block_input ();
 952
 953   FOR_EACH_FRAME (tail, frame)
 954     {
 955       struct frame *f = XFRAME (frame);
 956       if (FRAME_NS_P (f))
 957         {
 958           EmacsView *view = FRAME_NS_VIEW (f);
 959
 960           if (![view isFullscreen])
 961             {
 962               [[view window]
 963                 setFrame:constrain_frame_rect([[view window] frame], false)
 964                  display:NO];
 965             }
 966         }
 967     }
 968
 969   unblock_input ();
 970 }
 971
 972
 973 static void
 974 ns_update_auto_hide_menu_bar (void)
 975 /* --------------------------------------------------------------------------
 976      Show or hide the menu bar, based on user setting.
 977    -------------------------------------------------------------------------- */
 978 {
 979 #ifdef NS_IMPL_COCOA
 980   NSTRACE ("ns_update_auto_hide_menu_bar");
 981
 982   block_input ();
 983
 984   if (NSApp != nil && [NSApp isActive])
 985     {
 986       // Note, "setPresentationOptions" triggers an error unless the
 987       // application is active.
 988       BOOL menu_bar_should_be_hidden = ns_menu_bar_should_be_hidden ();
 989
 990       if (menu_bar_should_be_hidden != ns_menu_bar_is_hidden)
 991         {
 992           NSApplicationPresentationOptions options
 993             = NSApplicationPresentationDefault;
 994
 995           if (menu_bar_should_be_hidden)
 996             options |= NSApplicationPresentationAutoHideMenuBar
 997               | NSApplicationPresentationAutoHideDock;
 998
 999           [NSApp setPresentationOptions: options];
1000
1001           ns_menu_bar_is_hidden = menu_bar_should_be_hidden;
1002
1003           if (!ns_menu_bar_is_hidden)
1004             {
1005               ns_constrain_all_frames ();
1006             }
1007         }
1008     }
1009
1010   unblock_input ();
1011 #endif
1012 }
1013
1014
1015 static void
1016 ns_update_begin (struct frame *f)
1017 /* --------------------------------------------------------------------------
1018    Prepare for a grouped sequence of drawing calls
1019    external (RIF) call; whole frame, called before update_window_begin
1020    -------------------------------------------------------------------------- */
1021 {
1022   EmacsView *view = FRAME_NS_VIEW (f);
1023   NSTRACE_WHEN (NSTRACE_GROUP_UPDATES, "ns_update_begin");
1024
1025   ns_update_auto_hide_menu_bar ();
1026
1027 #ifdef NS_IMPL_COCOA
1028   if ([view isFullscreen] && [view fsIsNative])
1029   {
1030     // Fix reappearing tool bar in fullscreen for Mac OS X 10.7
1031     BOOL tbar_visible = FRAME_EXTERNAL_TOOL_BAR (f) ? YES : NO;
1032     NSToolbar *toolbar = [FRAME_NS_VIEW (f) toolbar];
1033     if (! tbar_visible != ! [toolbar isVisible])
1034       [toolbar setVisible: tbar_visible];
1035   }
1036 #endif
1037
1038   ns_updating_frame = f;
1039   [view lockFocus];
1040
1041   /* drawRect may have been called for say the minibuffer, and then clip path
1042      is for the minibuffer.  But the display engine may draw more because
1043      we have set the frame as garbaged.  So reset clip path to the whole
1044      view.  */
1045 #ifdef NS_IMPL_COCOA
1046   {
1047     NSBezierPath *bp;
1048     NSRect r = [view frame];
1049     NSRect cr = [[view window] frame];
1050     /* If a large frame size is set, r may be larger than the window frame
1051        before constrained.  In that case don't change the clip path, as we
1052        will clear in to the tool bar and title bar.  */
1053     if (r.size.height
1054         + FRAME_NS_TITLEBAR_HEIGHT (f)
1055         + FRAME_TOOLBAR_HEIGHT (f) <= cr.size.height)
1056       {
1057         bp = [[NSBezierPath bezierPathWithRect: r] retain];
1058         [bp setClip];
1059         [bp release];
1060       }
1061   }
1062 #endif
1063
1064 #ifdef NS_IMPL_GNUSTEP
1065   uRect = NSMakeRect (0, 0, 0, 0);
1066 #endif
1067 }
1068
1069
1070 static void
1071 ns_update_window_begin (struct window *w)
1072 /* --------------------------------------------------------------------------
1073    Prepare for a grouped sequence of drawing calls
1074    external (RIF) call; for one window, called after update_begin
1075    -------------------------------------------------------------------------- */
1076 {
1077   struct frame *f = XFRAME (WINDOW_FRAME (w));
1078   Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (f);
1079
1080   NSTRACE_WHEN (NSTRACE_GROUP_UPDATES, "ns_update_window_begin");
1081   w->output_cursor = w->cursor;
1082
1083   block_input ();
1084
1085   if (f == hlinfo->mouse_face_mouse_frame)
1086     {
1087       /* Don't do highlighting for mouse motion during the update.  */
1088       hlinfo->mouse_face_defer = 1;
1089
1090         /* If the frame needs to be redrawn,
1091            simply forget about any prior mouse highlighting.  */
1092       if (FRAME_GARBAGED_P (f))
1093         hlinfo->mouse_face_window = Qnil;
1094
1095       /* (further code for mouse faces ifdef'd out in other terms elided) */
1096     }
1097
1098   unblock_input ();
1099 }
1100
1101
1102 static void
1103 ns_update_window_end (struct window *w, bool cursor_on_p,
1104                       bool mouse_face_overwritten_p)
1105 /* --------------------------------------------------------------------------
1106    Finished a grouped sequence of drawing calls
1107    external (RIF) call; for one window called before update_end
1108    -------------------------------------------------------------------------- */
1109 {
1110   NSTRACE_WHEN (NSTRACE_GROUP_UPDATES, "ns_update_window_end");
1111
1112   /* note: this fn is nearly identical in all terms */
1113   if (!w->pseudo_window_p)
1114     {
1115       block_input ();
1116
1117       if (cursor_on_p)
1118         display_and_set_cursor (w, 1,
1119                                 w->output_cursor.hpos, w->output_cursor.vpos,
1120                                 w->output_cursor.x, w->output_cursor.y);
1121
1122       if (draw_window_fringes (w, 1))
1123         {
1124           if (WINDOW_RIGHT_DIVIDER_WIDTH (w))
1125             x_draw_right_divider (w);
1126           else
1127             x_draw_vertical_border (w);
1128         }
1129
1130       unblock_input ();
1131     }
1132
1133   /* If a row with mouse-face was overwritten, arrange for
1134      frame_up_to_date to redisplay the mouse highlight.  */
1135   if (mouse_face_overwritten_p)
1136     reset_mouse_highlight (MOUSE_HL_INFO (XFRAME (w->frame)));
1137 }
1138
1139
1140 static void
1141 ns_update_end (struct frame *f)
1142 /* --------------------------------------------------------------------------
1143    Finished a grouped sequence of drawing calls
1144    external (RIF) call; for whole frame, called after update_window_end
1145    -------------------------------------------------------------------------- */
1146 {
1147   EmacsView *view = FRAME_NS_VIEW (f);
1148
1149   NSTRACE_WHEN (NSTRACE_GROUP_UPDATES, "ns_update_end");
1150
1151 /*   if (f == MOUSE_HL_INFO (f)->mouse_face_mouse_frame) */
1152   MOUSE_HL_INFO (f)->mouse_face_defer = 0;
1153
1154   block_input ();
1155
1156   [view unlockFocus];
1157   [[view window] flushWindow];
1158
1159   unblock_input ();
1160   ns_updating_frame = NULL;
1161 }
1162
1163 static void
1164 ns_focus (struct frame *f, NSRect *r, int n)
1165 /* --------------------------------------------------------------------------
1166    Internal: Focus on given frame.  During small local updates this is used to
1167      draw, however during large updates, ns_update_begin and ns_update_end are
1168      called to wrap the whole thing, in which case these calls are stubbed out.
1169      Except, on GNUstep, we accumulate the rectangle being drawn into, because
1170      the back end won't do this automatically, and will just end up flushing
1171      the entire window.
1172    -------------------------------------------------------------------------- */
1173 {
1174   NSTRACE_WHEN (NSTRACE_GROUP_FOCUS, "ns_focus");
1175   if (r != NULL)
1176     {
1177       NSTRACE_RECT ("r", *r);
1178     }
1179
1180   if (f != ns_updating_frame)
1181     {
1182       NSView *view = FRAME_NS_VIEW (f);
1183       if (view != focus_view)
1184         {
1185           if (focus_view != NULL)
1186             {
1187               [focus_view unlockFocus];
1188               [[focus_view window] flushWindow];
1189 /*debug_lock--; */
1190             }
1191
1192           if (view)
1193             [view lockFocus];
1194           focus_view = view;
1195 /*if (view) debug_lock++; */
1196         }
1197     }
1198
1199   /* clipping */
1200   if (r)
1201     {
1202       [[NSGraphicsContext currentContext] saveGraphicsState];
1203       if (n == 2)
1204         NSRectClipList (r, 2);
1205       else
1206         NSRectClip (*r);
1207       gsaved = YES;
1208     }
1209 }
1210
1211
1212 static void
1213 ns_unfocus (struct frame *f)
1214 /* --------------------------------------------------------------------------
1215      Internal: Remove focus on given frame
1216    -------------------------------------------------------------------------- */
1217 {
1218   NSTRACE_WHEN (NSTRACE_GROUP_FOCUS, "ns_unfocus");
1219
1220   if (gsaved)
1221     {
1222       [[NSGraphicsContext currentContext] restoreGraphicsState];
1223       gsaved = NO;
1224     }
1225
1226   if (f != ns_updating_frame)
1227     {
1228       if (focus_view != NULL)
1229         {
1230           [focus_view unlockFocus];
1231           [[focus_view window] flushWindow];
1232           focus_view = NULL;
1233 /*debug_lock--; */
1234         }
1235     }
1236 }
1237
1238
1239 static void
1240 ns_clip_to_row (struct window *w, struct glyph_row *row,
1241                 enum glyph_row_area area, BOOL gc)
1242 /* --------------------------------------------------------------------------
1243      Internal (but parallels other terms): Focus drawing on given row
1244    -------------------------------------------------------------------------- */
1245 {
1246   struct frame *f = XFRAME (WINDOW_FRAME (w));
1247   NSRect clip_rect;
1248   int window_x, window_y, window_width;
1249
1250   window_box (w, area, &window_x, &window_y, &window_width, 0);
1251
1252   clip_rect.origin.x = window_x;
1253   clip_rect.origin.y = WINDOW_TO_FRAME_PIXEL_Y (w, max (0, row->y));
1254   clip_rect.origin.y = max (clip_rect.origin.y, window_y);
1255   clip_rect.size.width = window_width;
1256   clip_rect.size.height = row->visible_height;
1257
1258   ns_focus (f, &clip_rect, 1);
1259 }
1260
1261
1262 /* ==========================================================================
1263
1264     Visible bell and beep.
1265
1266    ========================================================================== */
1267
1268
1269 // This bell implementation shows the visual bell image asynchronously
1270 // from the rest of Emacs. This is done by adding a NSView to the
1271 // superview of the Emacs window and removing it using a timer.
1272 //
1273 // Unfortunately, some Emacs operations, like scrolling, is done using
1274 // low-level primitives that copy the content of the window, including
1275 // the bell image. To some extent, this is handled by removing the
1276 // image prior to scrolling and marking that the window is in need for
1277 // redisplay.
1278 //
1279 // To test this code, make sure that there is no artifacts of the bell
1280 // image in the following situations. Use a non-empty buffer (like the
1281 // tutorial) to ensure that a scroll is performed:
1282 //
1283 // * Single-window: C-g C-v
1284 //
1285 // * Side-by-windows: C-x 3 C-g C-v
1286 //
1287 // * Windows above each other: C-x 2 C-g C-v
1288
1289 @interface EmacsBell : NSImageView
1290 {
1291   // Number of currently active bell:s.
1292   unsigned int nestCount;
1293   NSView * mView;
1294   bool isAttached;
1295 }
1296 - (void)show:(NSView *)view;
1297 - (void)hide;
1298 - (void)remove;
1299 @end
1300
1301 @implementation EmacsBell
1302
1303 - (id)init;
1304 {
1305   NSTRACE ("[EmacsBell init]");
1306   if ((self = [super init]))
1307     {
1308       nestCount = 0;
1309       isAttached = false;
1310 #ifdef NS_IMPL_GNUSTEP
1311       // GNUstep doesn't provide named images.  This was reported in
1312       // 2011, see https://savannah.gnu.org/bugs/?33396
1313       //
1314       // As a drop in replacement, a semitransparent gray square is used.
1315       self.image = [[NSImage alloc] initWithSize:NSMakeSize(32 * 5, 32 * 5)];
1316       [self.image lockFocus];
1317       [[NSColor colorForEmacsRed:0.5 green:0.5 blue:0.5 alpha:0.5] set];
1318       NSRectFill(NSMakeRect(0, 0, 32, 32));
1319       [self.image unlockFocus];
1320 #else
1321       self.image = [NSImage imageNamed:NSImageNameCaution];
1322       [self.image setSize:NSMakeSize(self.image.size.width * 5,
1323                                      self.image.size.height * 5)];
1324 #endif
1325     }
1326   return self;
1327 }
1328
1329 - (void)show:(NSView *)view
1330 {
1331   NSTRACE ("[EmacsBell show:]");
1332   NSTRACE_MSG ("nestCount: %u", nestCount);
1333
1334   // Show the image, unless it's already shown.
1335   if (nestCount == 0)
1336     {
1337       NSRect rect = [view bounds];
1338       NSPoint pos;
1339       pos.x = rect.origin.x + (rect.size.width  - self.image.size.width )/2;
1340       pos.y = rect.origin.y + (rect.size.height - self.image.size.height)/2;
1341
1342       [self setFrameOrigin:pos];
1343       [self setFrameSize:self.image.size];
1344
1345       isAttached = true;
1346       mView = view;
1347       [[[view window] contentView] addSubview:self
1348                                    positioned:NSWindowAbove
1349                                    relativeTo:nil];
1350     }
1351
1352   ++nestCount;
1353
1354   [self performSelector:@selector(hide) withObject:self afterDelay:0.5];
1355 }
1356
1357
1358 - (void)hide
1359 {
1360   // Note: Trace output from this method isn't shown, reason unknown.
1361   // NSTRACE ("[EmacsBell hide]");
1362
1363   if (nestCount > 0)
1364     --nestCount;
1365
1366   // Remove the image once the last bell became inactive.
1367   if (nestCount == 0)
1368     {
1369       [self remove];
1370     }
1371 }
1372
1373
1374 -(void)remove
1375 {
1376   NSTRACE ("[EmacsBell remove]");
1377   if (isAttached)
1378     {
1379       NSTRACE_MSG ("removeFromSuperview");
1380       [self removeFromSuperview];
1381       mView.needsDisplay = YES;
1382       isAttached = false;
1383     }
1384 }
1385
1386 @end
1387
1388
1389 static EmacsBell * bell_view = nil;
1390
1391 static void
1392 ns_ring_bell (struct frame *f)
1393 /* --------------------------------------------------------------------------
1394      "Beep" routine
1395    -------------------------------------------------------------------------- */
1396 {
1397   NSTRACE ("ns_ring_bell");
1398   if (visible_bell)
1399     {
1400       struct frame *frame = SELECTED_FRAME ();
1401       NSView *view;
1402
1403       if (bell_view == nil)
1404         {
1405           bell_view = [[EmacsBell alloc] init];
1406           [bell_view retain];
1407         }
1408
1409       block_input ();
1410
1411       view = FRAME_NS_VIEW (frame);
1412       if (view != nil)
1413         {
1414           [bell_view show:view];
1415         }
1416
1417       unblock_input ();
1418     }
1419   else
1420     {
1421       NSBeep ();
1422     }
1423 }
1424
1425
1426 static void
1427 hide_bell (void)
1428 /* --------------------------------------------------------------------------
1429      Ensure the bell is hidden.
1430    -------------------------------------------------------------------------- */
1431 {
1432   NSTRACE ("hide_bell");
1433
1434   if (bell_view != nil)
1435     {
1436       [bell_view remove];
1437     }
1438 }
1439
1440
1441 /* ==========================================================================
1442
1443     Frame / window manager related functions
1444
1445    ========================================================================== */
1446
1447
1448 static void
1449 ns_raise_frame (struct frame *f)
1450 /* --------------------------------------------------------------------------
1451      Bring window to foreground and make it active
1452    -------------------------------------------------------------------------- */
1453 {
1454   NSView *view;
1455
1456   check_window_system (f);
1457   view = FRAME_NS_VIEW (f);
1458   block_input ();
1459   if (FRAME_VISIBLE_P (f))
1460     [[view window] makeKeyAndOrderFront: NSApp];
1461   unblock_input ();
1462 }
1463
1464
1465 static void
1466 ns_lower_frame (struct frame *f)
1467 /* --------------------------------------------------------------------------
1468      Send window to back
1469    -------------------------------------------------------------------------- */
1470 {
1471   NSView *view;
1472
1473   check_window_system (f);
1474   view = FRAME_NS_VIEW (f);
1475   block_input ();
1476   [[view window] orderBack: NSApp];
1477   unblock_input ();
1478 }
1479
1480
1481 static void
1482 ns_frame_raise_lower (struct frame *f, bool raise)
1483 /* --------------------------------------------------------------------------
1484      External (hook)
1485    -------------------------------------------------------------------------- */
1486 {
1487   NSTRACE ("ns_frame_raise_lower");
1488
1489   if (raise)
1490     ns_raise_frame (f);
1491   else
1492     ns_lower_frame (f);
1493 }
1494
1495
1496 static void
1497 ns_frame_rehighlight (struct frame *frame)
1498 /* --------------------------------------------------------------------------
1499      External (hook): called on things like window switching within frame
1500    -------------------------------------------------------------------------- */
1501 {
1502   struct ns_display_info *dpyinfo = FRAME_DISPLAY_INFO (frame);
1503   struct frame *old_highlight = dpyinfo->x_highlight_frame;
1504
1505   NSTRACE ("ns_frame_rehighlight");
1506   if (dpyinfo->x_focus_frame)
1507     {
1508       dpyinfo->x_highlight_frame
1509         = (FRAMEP (FRAME_FOCUS_FRAME (dpyinfo->x_focus_frame))
1510            ? XFRAME (FRAME_FOCUS_FRAME (dpyinfo->x_focus_frame))
1511            : dpyinfo->x_focus_frame);
1512       if (!FRAME_LIVE_P (dpyinfo->x_highlight_frame))
1513         {
1514           fset_focus_frame (dpyinfo->x_focus_frame, Qnil);
1515           dpyinfo->x_highlight_frame = dpyinfo->x_focus_frame;
1516         }
1517     }
1518   else
1519       dpyinfo->x_highlight_frame = 0;
1520
1521   if (dpyinfo->x_highlight_frame &&
1522          dpyinfo->x_highlight_frame != old_highlight)
1523     {
1524       if (old_highlight)
1525         {
1526           x_update_cursor (old_highlight, 1);
1527           x_set_frame_alpha (old_highlight);
1528         }
1529       if (dpyinfo->x_highlight_frame)
1530         {
1531           x_update_cursor (dpyinfo->x_highlight_frame, 1);
1532           x_set_frame_alpha (dpyinfo->x_highlight_frame);
1533         }
1534     }
1535 }
1536
1537
1538 void
1539 x_make_frame_visible (struct frame *f)
1540 /* --------------------------------------------------------------------------
1541      External: Show the window (X11 semantics)
1542    -------------------------------------------------------------------------- */
1543 {
1544   NSTRACE ("x_make_frame_visible");
1545   /* XXX: at some points in past this was not needed, as the only place that
1546      called this (frame.c:Fraise_frame ()) also called raise_lower;
1547      if this ends up the case again, comment this out again. */
1548   if (!FRAME_VISIBLE_P (f))
1549     {
1550       EmacsView *view = (EmacsView *)FRAME_NS_VIEW (f);
1551
1552       SET_FRAME_VISIBLE (f, 1);
1553       ns_raise_frame (f);
1554
1555       /* Making a new frame from a fullscreen frame will make the new frame
1556          fullscreen also.  So skip handleFS as this will print an error.  */
1557       if ([view fsIsNative] && f->want_fullscreen == FULLSCREEN_BOTH
1558           && [view isFullscreen])
1559         return;
1560
1561       if (f->want_fullscreen != FULLSCREEN_NONE)
1562         {
1563           block_input ();
1564           [view handleFS];
1565           unblock_input ();
1566         }
1567     }
1568 }
1569
1570
1571 void
1572 x_make_frame_invisible (struct frame *f)
1573 /* --------------------------------------------------------------------------
1574      External: Hide the window (X11 semantics)
1575    -------------------------------------------------------------------------- */
1576 {
1577   NSView *view;
1578   NSTRACE ("x_make_frame_invisible");
1579   check_window_system (f);
1580   view = FRAME_NS_VIEW (f);
1581   [[view window] orderOut: NSApp];
1582   SET_FRAME_VISIBLE (f, 0);
1583   SET_FRAME_ICONIFIED (f, 0);
1584 }
1585
1586
1587 void
1588 x_iconify_frame (struct frame *f)
1589 /* --------------------------------------------------------------------------
1590      External: Iconify window
1591    -------------------------------------------------------------------------- */
1592 {
1593   NSView *view;
1594   struct ns_display_info *dpyinfo;
1595
1596   NSTRACE ("x_iconify_frame");
1597   check_window_system (f);
1598   view = FRAME_NS_VIEW (f);
1599   dpyinfo = FRAME_DISPLAY_INFO (f);
1600
1601   if (dpyinfo->x_highlight_frame == f)
1602     dpyinfo->x_highlight_frame = 0;
1603
1604   if ([[view window] windowNumber] <= 0)
1605     {
1606       /* the window is still deferred.  Make it very small, bring it
1607          on screen and order it out. */
1608       NSRect s = { { 100, 100}, {0, 0} };
1609       NSRect t;
1610       t = [[view window] frame];
1611       [[view window] setFrame: s display: NO];
1612       [[view window] orderBack: NSApp];
1613       [[view window] orderOut: NSApp];
1614       [[view window] setFrame: t display: NO];
1615     }
1616
1617   /* Processing input while Emacs is being minimized can cause a
1618      crash, so block it for the duration. */
1619   block_input();
1620   [[view window] miniaturize: NSApp];
1621   unblock_input();
1622 }
1623
1624 /* Free X resources of frame F.  */
1625
1626 void
1627 x_free_frame_resources (struct frame *f)
1628 {
1629   NSView *view;
1630   struct ns_display_info *dpyinfo;
1631   Mouse_HLInfo *hlinfo;
1632
1633   NSTRACE ("x_free_frame_resources");
1634   check_window_system (f);
1635   view = FRAME_NS_VIEW (f);
1636   dpyinfo = FRAME_DISPLAY_INFO (f);
1637   hlinfo = MOUSE_HL_INFO (f);
1638
1639   [(EmacsView *)view setWindowClosing: YES]; /* may not have been informed */
1640
1641   block_input ();
1642
1643   free_frame_menubar (f);
1644   free_frame_faces (f);
1645
1646   if (f == dpyinfo->x_focus_frame)
1647     dpyinfo->x_focus_frame = 0;
1648   if (f == dpyinfo->x_highlight_frame)
1649     dpyinfo->x_highlight_frame = 0;
1650   if (f == hlinfo->mouse_face_mouse_frame)
1651     reset_mouse_highlight (hlinfo);
1652
1653   if (f->output_data.ns->miniimage != nil)
1654     [f->output_data.ns->miniimage release];
1655
1656   [[view window] close];
1657   [view release];
1658
1659   xfree (f->output_data.ns);
1660
1661   unblock_input ();
1662 }
1663
1664 void
1665 x_destroy_window (struct frame *f)
1666 /* --------------------------------------------------------------------------
1667      External: Delete the window
1668    -------------------------------------------------------------------------- */
1669 {
1670   NSTRACE ("x_destroy_window");
1671   check_window_system (f);
1672   x_free_frame_resources (f);
1673   ns_window_num--;
1674 }
1675
1676
1677 void
1678 x_set_offset (struct frame *f, int xoff, int yoff, int change_grav)
1679 /* --------------------------------------------------------------------------
1680      External: Position the window
1681    -------------------------------------------------------------------------- */
1682 {
1683   NSView *view = FRAME_NS_VIEW (f);
1684   NSArray *screens = [NSScreen screens];
1685   NSScreen *fscreen = [screens objectAtIndex: 0];
1686   NSScreen *screen = [[view window] screen];
1687
1688   NSTRACE ("x_set_offset");
1689
1690   block_input ();
1691
1692   f->left_pos = xoff;
1693   f->top_pos = yoff;
1694
1695   if (view != nil && screen && fscreen)
1696     {
1697       f->left_pos = f->size_hint_flags & XNegative
1698         ? [screen visibleFrame].size.width + f->left_pos - FRAME_PIXEL_WIDTH (f)
1699         : f->left_pos;
1700       /* We use visibleFrame here to take menu bar into account.
1701          Ideally we should also adjust left/top with visibleFrame.origin.  */
1702
1703       f->top_pos = f->size_hint_flags & YNegative
1704         ? ([screen visibleFrame].size.height + f->top_pos
1705            - FRAME_PIXEL_HEIGHT (f) - FRAME_NS_TITLEBAR_HEIGHT (f)
1706            - FRAME_TOOLBAR_HEIGHT (f))
1707         : f->top_pos;
1708 #ifdef NS_IMPL_GNUSTEP
1709       if (f->left_pos < 100)
1710         f->left_pos = 100;  /* don't overlap menu */
1711 #endif
1712       /* Constrain the setFrameTopLeftPoint so we don't move behind the
1713          menu bar.  */
1714       NSPoint pt = NSMakePoint (SCREENMAXBOUND (f->left_pos),
1715                                 SCREENMAXBOUND ([fscreen frame].size.height
1716                                                 - NS_TOP_POS (f)));
1717       NSTRACE_POINT ("setFrameTopLeftPoint", pt);
1718       [[view window] setFrameTopLeftPoint: pt];
1719       f->size_hint_flags &= ~(XNegative|YNegative);
1720     }
1721
1722   unblock_input ();
1723 }
1724
1725
1726 void
1727 x_set_window_size (struct frame *f,
1728                    bool change_gravity,
1729                    int width,
1730                    int height,
1731                    bool pixelwise)
1732 /* --------------------------------------------------------------------------
1733      Adjust window pixel size based on given character grid size
1734      Impl is a bit more complex than other terms, need to do some
1735      internal clipping.
1736    -------------------------------------------------------------------------- */
1737 {
1738   EmacsView *view = FRAME_NS_VIEW (f);
1739   NSWindow *window = [view window];
1740   NSRect wr = [window frame];
1741   int tb = FRAME_EXTERNAL_TOOL_BAR (f);
1742   int pixelwidth, pixelheight;
1743   int orig_height = wr.size.height;
1744
1745   NSTRACE ("x_set_window_size");
1746
1747   if (view == nil)
1748     return;
1749
1750   NSTRACE_RECT ("current", wr);
1751   NSTRACE_MSG ("Width:%d Height:%d Pixelwise:%d", width, height, pixelwise);
1752   NSTRACE_MSG ("Font %d x %d", FRAME_COLUMN_WIDTH (f), FRAME_LINE_HEIGHT (f));
1753
1754   block_input ();
1755
1756   if (pixelwise)
1757     {
1758       pixelwidth = FRAME_TEXT_TO_PIXEL_WIDTH (f, width);
1759       pixelheight = FRAME_TEXT_TO_PIXEL_HEIGHT (f, height);
1760     }
1761   else
1762     {
1763       pixelwidth =  FRAME_TEXT_COLS_TO_PIXEL_WIDTH   (f, width);
1764       pixelheight = FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f, height);
1765     }
1766
1767   /* If we have a toolbar, take its height into account. */
1768   if (tb && ! [view isFullscreen])
1769     {
1770     /* NOTE: previously this would generate wrong result if toolbar not
1771              yet displayed and fixing toolbar_height=32 helped, but
1772              now (200903) seems no longer needed */
1773     FRAME_TOOLBAR_HEIGHT (f) =
1774       NSHeight ([window frameRectForContentRect: NSMakeRect (0, 0, 0, 0)])
1775         - FRAME_NS_TITLEBAR_HEIGHT (f);
1776 #if 0
1777       /* Only breaks things here, removed by martin 2015-09-30.  */
1778 #ifdef NS_IMPL_GNUSTEP
1779       FRAME_TOOLBAR_HEIGHT (f) -= 3;
1780 #endif
1781 #endif
1782     }
1783   else
1784     FRAME_TOOLBAR_HEIGHT (f) = 0;
1785
1786   wr.size.width = pixelwidth + f->border_width;
1787   wr.size.height = pixelheight;
1788   if (! [view isFullscreen])
1789     wr.size.height += FRAME_NS_TITLEBAR_HEIGHT (f)
1790       + FRAME_TOOLBAR_HEIGHT (f);
1791
1792   /* Do not try to constrain to this screen.  We may have multiple
1793      screens, and want Emacs to span those.  Constraining to screen
1794      prevents that, and that is not nice to the user.  */
1795  if (f->output_data.ns->zooming)
1796    f->output_data.ns->zooming = 0;
1797  else
1798    wr.origin.y += orig_height - wr.size.height;
1799
1800  frame_size_history_add
1801    (f, Qx_set_window_size_1, width, height,
1802     list5 (Fcons (make_number (pixelwidth), make_number (pixelheight)),
1803            Fcons (make_number (wr.size.width), make_number (wr.size.height)),
1804            make_number (f->border_width),
1805            make_number (FRAME_NS_TITLEBAR_HEIGHT (f)),
1806            make_number (FRAME_TOOLBAR_HEIGHT (f))));
1807
1808   [window setFrame: wr display: YES];
1809
1810   [view updateFrameSize: NO];
1811   unblock_input ();
1812 }
1813
1814
1815 static void
1816 ns_fullscreen_hook (struct frame *f)
1817 {
1818   EmacsView *view = (EmacsView *)FRAME_NS_VIEW (f);
1819
1820   NSTRACE ("ns_fullscreen_hook");
1821
1822   if (!FRAME_VISIBLE_P (f))
1823     return;
1824
1825    if (! [view fsIsNative] && f->want_fullscreen == FULLSCREEN_BOTH)
1826     {
1827       /* Old style fs don't initiate correctly if created from
1828          init/default-frame alist, so use a timer (not nice...).
1829       */
1830       [NSTimer scheduledTimerWithTimeInterval: 0.5 target: view
1831                                      selector: @selector (handleFS)
1832                                      userInfo: nil repeats: NO];
1833       return;
1834     }
1835
1836   block_input ();
1837   [view handleFS];
1838   unblock_input ();
1839 }
1840
1841 /* ==========================================================================
1842
1843     Color management
1844
1845    ========================================================================== */
1846
1847
1848 NSColor *
1849 ns_lookup_indexed_color (unsigned long idx, struct frame *f)
1850 {
1851   struct ns_color_table *color_table = FRAME_DISPLAY_INFO (f)->color_table;
1852   if (idx < 1 || idx >= color_table->avail)
1853     return nil;
1854   return color_table->colors[idx];
1855 }
1856
1857
1858 unsigned long
1859 ns_index_color (NSColor *color, struct frame *f)
1860 {
1861   struct ns_color_table *color_table = FRAME_DISPLAY_INFO (f)->color_table;
1862   ptrdiff_t idx;
1863   ptrdiff_t i;
1864
1865   if (!color_table->colors)
1866     {
1867       color_table->size = NS_COLOR_CAPACITY;
1868       color_table->avail = 1; /* skip idx=0 as marker */
1869       color_table->colors = xmalloc (color_table->size * sizeof (NSColor *));
1870       color_table->colors[0] = nil;
1871       color_table->empty_indices = [[NSMutableSet alloc] init];
1872     }
1873
1874   /* Do we already have this color?  */
1875   for (i = 1; i < color_table->avail; i++)
1876     if (color_table->colors[i] && [color_table->colors[i] isEqual: color])
1877       return i;
1878
1879   if ([color_table->empty_indices count] > 0)
1880     {
1881       NSNumber *index = [color_table->empty_indices anyObject];
1882       [color_table->empty_indices removeObject: index];
1883       idx = [index unsignedLongValue];
1884     }
1885   else
1886     {
1887       if (color_table->avail == color_table->size)
1888         color_table->colors =
1889           xpalloc (color_table->colors, &color_table->size, 1,
1890                    min (ULONG_MAX, PTRDIFF_MAX), sizeof *color_table->colors);
1891       idx = color_table->avail++;
1892     }
1893
1894   color_table->colors[idx] = color;
1895   [color retain];
1896 /*fprintf(stderr, "color_table: allocated %d\n",idx);*/
1897   return idx;
1898 }
1899
1900
1901 static int
1902 ns_get_color (const char *name, NSColor **col)
1903 /* --------------------------------------------------------------------------
1904      Parse a color name
1905    -------------------------------------------------------------------------- */
1906 /* On *Step, we attempt to mimic the X11 platform here, down to installing an
1907    X11 rgb.txt-compatible color list in Emacs.clr (see ns_term_init()).
1908    See: http://thread.gmane.org/gmane.emacs.devel/113050/focus=113272). */
1909 {
1910   NSColor *new = nil;
1911   static char hex[20];
1912   int scaling = 0;
1913   float r = -1.0, g, b;
1914   NSString *nsname = [NSString stringWithUTF8String: name];
1915
1916   NSTRACE ("ns_get_color(%s, **)", name);
1917
1918   block_input ();
1919
1920   if ([nsname isEqualToString: @"ns_selection_bg_color"])
1921     {
1922 #ifdef NS_IMPL_COCOA
1923       NSString *defname = [[NSUserDefaults standardUserDefaults]
1924                             stringForKey: @"AppleHighlightColor"];
1925       if (defname != nil)
1926         nsname = defname;
1927       else
1928 #endif
1929       if ((new = [NSColor selectedTextBackgroundColor]) != nil)
1930         {
1931           *col = [new colorUsingDefaultColorSpace];
1932           unblock_input ();
1933           return 0;
1934         }
1935       else
1936         nsname = NS_SELECTION_BG_COLOR_DEFAULT;
1937
1938       name = [nsname UTF8String];
1939     }
1940   else if ([nsname isEqualToString: @"ns_selection_fg_color"])
1941     {
1942       /* NOTE: macOS applications normally don't set foreground
1943          selection, but text may be unreadable if we don't.
1944       */
1945       if ((new = [NSColor selectedTextColor]) != nil)
1946         {
1947           *col = [new colorUsingDefaultColorSpace];
1948           unblock_input ();
1949           return 0;
1950         }
1951
1952       nsname = NS_SELECTION_FG_COLOR_DEFAULT;
1953       name = [nsname UTF8String];
1954     }
1955
1956   /* First, check for some sort of numeric specification. */
1957   hex[0] = '\0';
1958
1959   if (name[0] == '0' || name[0] == '1' || name[0] == '.')  /* RGB decimal */
1960     {
1961       NSScanner *scanner = [NSScanner scannerWithString: nsname];
1962       [scanner scanFloat: &r];
1963       [scanner scanFloat: &g];
1964       [scanner scanFloat: &b];
1965     }
1966   else if (!strncmp(name, "rgb:", 4))  /* A newer X11 format -- rgb:r/g/b */
1967     scaling = (snprintf (hex, sizeof hex, "%s", name + 4) - 2) / 3;
1968   else if (name[0] == '#')        /* An old X11 format; convert to newer */
1969     {
1970       int len = (strlen(name) - 1);
1971       int start = (len % 3 == 0) ? 1 : len / 4 + 1;
1972       int i;
1973       scaling = strlen(name+start) / 3;
1974       for (i = 0; i < 3; i++)
1975         sprintf (hex + i * (scaling + 1), "%.*s/", scaling,
1976                  name + start + i * scaling);
1977       hex[3 * (scaling + 1) - 1] = '\0';
1978     }
1979
1980   if (hex[0])
1981     {
1982       unsigned int rr, gg, bb;
1983       float fscale = scaling == 4 ? 65535.0 : (scaling == 2 ? 255.0 : 15.0);
1984       if (sscanf (hex, "%x/%x/%x", &rr, &gg, &bb))
1985         {
1986           r = rr / fscale;
1987           g = gg / fscale;
1988           b = bb / fscale;
1989         }
1990     }
1991
1992   if (r >= 0.0F)
1993     {
1994       *col = [NSColor colorForEmacsRed: r green: g blue: b alpha: 1.0];
1995       unblock_input ();
1996       return 0;
1997     }
1998
1999   /* Otherwise, color is expected to be from a list */
2000   {
2001     NSEnumerator *lenum, *cenum;
2002     NSString *name;
2003     NSColorList *clist;
2004
2005 #ifdef NS_IMPL_GNUSTEP
2006     /* XXX: who is wrong, the requestor or the implementation? */
2007     if ([nsname compare: @"Highlight" options: NSCaseInsensitiveSearch]
2008         == NSOrderedSame)
2009       nsname = @"highlightColor";
2010 #endif
2011
2012     lenum = [[NSColorList availableColorLists] objectEnumerator];
2013     while ( (clist = [lenum nextObject]) && new == nil)
2014       {
2015         cenum = [[clist allKeys] objectEnumerator];
2016         while ( (name = [cenum nextObject]) && new == nil )
2017           {
2018             if ([name compare: nsname
2019                       options: NSCaseInsensitiveSearch] == NSOrderedSame )
2020               new = [clist colorWithKey: name];
2021           }
2022       }
2023   }
2024
2025   if (new)
2026     *col = [new colorUsingDefaultColorSpace];
2027   unblock_input ();
2028   return new ? 0 : 1;
2029 }
2030
2031
2032 int
2033 ns_lisp_to_color (Lisp_Object color, NSColor **col)
2034 /* --------------------------------------------------------------------------
2035      Convert a Lisp string object to a NS color
2036    -------------------------------------------------------------------------- */
2037 {
2038   NSTRACE ("ns_lisp_to_color");
2039   if (STRINGP (color))
2040     return ns_get_color (SSDATA (color), col);
2041   else if (SYMBOLP (color))
2042     return ns_get_color (SSDATA (SYMBOL_NAME (color)), col);
2043   return 1;
2044 }
2045
2046
2047 void
2048 ns_query_color(void *col, XColor *color_def, int setPixel)
2049 /* --------------------------------------------------------------------------
2050          Get ARGB values out of NSColor col and put them into color_def.
2051          If setPixel, set the pixel to a concatenated version.
2052          and set color_def pixel to the resulting index.
2053    -------------------------------------------------------------------------- */
2054 {
2055   EmacsCGFloat r, g, b, a;
2056
2057   [((NSColor *)col) getRed: &r green: &g blue: &b alpha: &a];
2058   color_def->red   = r * 65535;
2059   color_def->green = g * 65535;
2060   color_def->blue  = b * 65535;
2061
2062   if (setPixel == YES)
2063     color_def->pixel
2064       = ARGB_TO_ULONG((int)(a*255),
2065                       (int)(r*255), (int)(g*255), (int)(b*255));
2066 }
2067
2068
2069 bool
2070 ns_defined_color (struct frame *f,
2071                   const char *name,
2072                   XColor *color_def,
2073                   bool alloc,
2074                   bool makeIndex)
2075 /* --------------------------------------------------------------------------
2076          Return true if named color found, and set color_def rgb accordingly.
2077          If makeIndex and alloc are nonzero put the color in the color_table,
2078          and set color_def pixel to the resulting index.
2079          If makeIndex is zero, set color_def pixel to ARGB.
2080          Return false if not found
2081    -------------------------------------------------------------------------- */
2082 {
2083   NSColor *col;
2084   NSTRACE_WHEN (NSTRACE_GROUP_COLOR, "ns_defined_color");
2085
2086   block_input ();
2087   if (ns_get_color (name, &col) != 0) /* Color not found  */
2088     {
2089       unblock_input ();
2090       return 0;
2091     }
2092   if (makeIndex && alloc)
2093     color_def->pixel = ns_index_color (col, f);
2094   ns_query_color (col, color_def, !makeIndex);
2095   unblock_input ();
2096   return 1;
2097 }
2098
2099
2100 void
2101 x_set_frame_alpha (struct frame *f)
2102 /* --------------------------------------------------------------------------
2103      change the entire-frame transparency
2104    -------------------------------------------------------------------------- */
2105 {
2106   struct ns_display_info *dpyinfo = FRAME_DISPLAY_INFO (f);
2107   double alpha = 1.0;
2108   double alpha_min = 1.0;
2109
2110   NSTRACE ("x_set_frame_alpha");
2111
2112   if (dpyinfo->x_highlight_frame == f)
2113     alpha = f->alpha[0];
2114   else
2115     alpha = f->alpha[1];
2116
2117   if (FLOATP (Vframe_alpha_lower_limit))
2118     alpha_min = XFLOAT_DATA (Vframe_alpha_lower_limit);
2119   else if (INTEGERP (Vframe_alpha_lower_limit))
2120     alpha_min = (XINT (Vframe_alpha_lower_limit)) / 100.0;
2121
2122   if (alpha < 0.0)
2123     return;
2124   else if (1.0 < alpha)
2125     alpha = 1.0;
2126   else if (0.0 <= alpha && alpha < alpha_min && alpha_min <= 1.0)
2127     alpha = alpha_min;
2128
2129 #ifdef NS_IMPL_COCOA
2130   {
2131     EmacsView *view = FRAME_NS_VIEW (f);
2132   [[view window] setAlphaValue: alpha];
2133   }
2134 #endif
2135 }
2136
2137
2138 /* ==========================================================================
2139
2140     Mouse handling
2141
2142    ========================================================================== */
2143
2144
2145 void
2146 frame_set_mouse_pixel_position (struct frame *f, int pix_x, int pix_y)
2147 /* --------------------------------------------------------------------------
2148      Programmatically reposition mouse pointer in pixel coordinates
2149    -------------------------------------------------------------------------- */
2150 {
2151   NSTRACE ("frame_set_mouse_pixel_position");
2152   ns_raise_frame (f);
2153 #if 0
2154   /* FIXME: this does not work, and what about GNUstep? */
2155 #ifdef NS_IMPL_COCOA
2156   [FRAME_NS_VIEW (f) lockFocus];
2157   PSsetmouse ((float)pix_x, (float)pix_y);
2158   [FRAME_NS_VIEW (f) unlockFocus];
2159 #endif
2160 #endif
2161 }
2162
2163 static int
2164 note_mouse_movement (struct frame *frame, CGFloat x, CGFloat y)
2165 /*   ------------------------------------------------------------------------
2166      Called by EmacsView on mouseMovement events.  Passes on
2167      to emacs mainstream code if we moved off of a rect of interest
2168      known as last_mouse_glyph.
2169      ------------------------------------------------------------------------ */
2170 {
2171   struct ns_display_info *dpyinfo = FRAME_DISPLAY_INFO (frame);
2172   NSRect *r;
2173
2174 //  NSTRACE ("note_mouse_movement");
2175
2176   dpyinfo->last_mouse_motion_frame = frame;
2177   r = &dpyinfo->last_mouse_glyph;
2178
2179   /* Note, this doesn't get called for enter/leave, since we don't have a
2180      position.  Those are taken care of in the corresponding NSView methods. */
2181
2182   /* has movement gone beyond last rect we were tracking? */
2183   if (x < r->origin.x || x >= r->origin.x + r->size.width
2184       || y < r->origin.y || y >= r->origin.y + r->size.height)
2185     {
2186       ns_update_begin (frame);
2187       frame->mouse_moved = 1;
2188       note_mouse_highlight (frame, x, y);
2189       remember_mouse_glyph (frame, x, y, r);
2190       ns_update_end (frame);
2191       return 1;
2192     }
2193
2194   return 0;
2195 }
2196
2197
2198 static void
2199 ns_mouse_position (struct frame **fp, int insist, Lisp_Object *bar_window,
2200                    enum scroll_bar_part *part, Lisp_Object *x, Lisp_Object *y,
2201                    Time *time)
2202 /* --------------------------------------------------------------------------
2203     External (hook): inform emacs about mouse position and hit parts.
2204     If a scrollbar is being dragged, set bar_window, part, x, y, time.
2205     x & y should be position in the scrollbar (the whole bar, not the handle)
2206     and length of scrollbar respectively
2207    -------------------------------------------------------------------------- */
2208 {
2209   id view;
2210   NSPoint position;
2211   Lisp_Object frame, tail;
2212   struct frame *f;
2213   struct ns_display_info *dpyinfo;
2214
2215   NSTRACE ("ns_mouse_position");
2216
2217   if (*fp == NULL)
2218     {
2219       fprintf (stderr, "Warning: ns_mouse_position () called with null *fp.\n");
2220       return;
2221     }
2222
2223   dpyinfo = FRAME_DISPLAY_INFO (*fp);
2224
2225   block_input ();
2226
2227   /* Clear the mouse-moved flag for every frame on this display.  */
2228   FOR_EACH_FRAME (tail, frame)
2229     if (FRAME_NS_P (XFRAME (frame))
2230         && FRAME_NS_DISPLAY (XFRAME (frame)) == FRAME_NS_DISPLAY (*fp))
2231       XFRAME (frame)->mouse_moved = 0;
2232
2233   dpyinfo->last_mouse_scroll_bar = nil;
2234   if (dpyinfo->last_mouse_frame
2235       && FRAME_LIVE_P (dpyinfo->last_mouse_frame))
2236     f = dpyinfo->last_mouse_frame;
2237   else
2238     f = dpyinfo->x_focus_frame ? dpyinfo->x_focus_frame : SELECTED_FRAME ();
2239
2240   if (f && FRAME_NS_P (f))
2241     {
2242       view = FRAME_NS_VIEW (*fp);
2243
2244       position = [[view window] mouseLocationOutsideOfEventStream];
2245       position = [view convertPoint: position fromView: nil];
2246       remember_mouse_glyph (f, position.x, position.y,
2247                             &dpyinfo->last_mouse_glyph);
2248       NSTRACE_POINT ("position", position);
2249
2250       if (bar_window) *bar_window = Qnil;
2251       if (part) *part = scroll_bar_above_handle;
2252
2253       if (x) XSETINT (*x, lrint (position.x));
2254       if (y) XSETINT (*y, lrint (position.y));
2255       if (time)
2256         *time = dpyinfo->last_mouse_movement_time;
2257       *fp = f;
2258     }
2259
2260   unblock_input ();
2261 }
2262
2263
2264 static void
2265 ns_frame_up_to_date (struct frame *f)
2266 /* --------------------------------------------------------------------------
2267     External (hook): Fix up mouse highlighting right after a full update.
2268     Can't use FRAME_MOUSE_UPDATE due to ns_frame_begin and ns_frame_end calls.
2269    -------------------------------------------------------------------------- */
2270 {
2271   NSTRACE_WHEN (NSTRACE_GROUP_UPDATES, "ns_frame_up_to_date");
2272
2273   if (FRAME_NS_P (f))
2274     {
2275       Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (f);
2276       if (f == hlinfo->mouse_face_mouse_frame)
2277         {
2278           block_input ();
2279           ns_update_begin(f);
2280           note_mouse_highlight (hlinfo->mouse_face_mouse_frame,
2281                                 hlinfo->mouse_face_mouse_x,
2282                                 hlinfo->mouse_face_mouse_y);
2283           ns_update_end(f);
2284           unblock_input ();
2285         }
2286     }
2287 }
2288
2289
2290 static void
2291 ns_define_frame_cursor (struct frame *f, Cursor cursor)
2292 /* --------------------------------------------------------------------------
2293     External (RIF): set frame mouse pointer type.
2294    -------------------------------------------------------------------------- */
2295 {
2296   NSTRACE ("ns_define_frame_cursor");
2297   if (FRAME_POINTER_TYPE (f) != cursor)
2298     {
2299       EmacsView *view = FRAME_NS_VIEW (f);
2300       FRAME_POINTER_TYPE (f) = cursor;
2301       [[view window] invalidateCursorRectsForView: view];
2302       /* Redisplay assumes this function also draws the changed frame
2303          cursor, but this function doesn't, so do it explicitly.  */
2304       x_update_cursor (f, 1);
2305     }
2306 }
2307
2308
2309
2310 /* ==========================================================================
2311
2312     Keyboard handling
2313
2314    ========================================================================== */
2315
2316
2317 static unsigned
2318 ns_convert_key (unsigned code)
2319 /* --------------------------------------------------------------------------
2320     Internal call used by NSView-keyDown.
2321    -------------------------------------------------------------------------- */
2322 {
2323   const unsigned last_keysym = ARRAYELTS (convert_ns_to_X_keysym);
2324   unsigned keysym;
2325   /* An array would be faster, but less easy to read. */
2326   for (keysym = 0; keysym < last_keysym; keysym += 2)
2327     if (code == convert_ns_to_X_keysym[keysym])
2328       return 0xFF00 | convert_ns_to_X_keysym[keysym+1];
2329   return 0;
2330 /* if decide to use keyCode and Carbon table, use this line:
2331      return code > 0xff ? 0 : 0xFF00 | ns_keycode_to_xkeysym_table[code]; */
2332 }
2333
2334
2335 char *
2336 x_get_keysym_name (int keysym)
2337 /* --------------------------------------------------------------------------
2338     Called by keyboard.c.  Not sure if the return val is important, except
2339     that it be unique.
2340    -------------------------------------------------------------------------- */
2341 {
2342   static char value[16];
2343   NSTRACE ("x_get_keysym_name");
2344   sprintf (value, "%d", keysym);
2345   return value;
2346 }
2347
2348
2349
2350 /* ==========================================================================
2351
2352     Block drawing operations
2353
2354    ========================================================================== */
2355
2356
2357 static void
2358 ns_redraw_scroll_bars (struct frame *f)
2359 {
2360   int i;
2361   id view;
2362   NSArray *subviews = [[FRAME_NS_VIEW (f) superview] subviews];
2363   NSTRACE ("ns_redraw_scroll_bars");
2364   for (i =[subviews count]-1; i >= 0; i--)
2365     {
2366       view = [subviews objectAtIndex: i];
2367       if (![view isKindOfClass: [EmacsScroller class]]) continue;
2368       [view display];
2369     }
2370 }
2371
2372
2373 void
2374 ns_clear_frame (struct frame *f)
2375 /* --------------------------------------------------------------------------
2376       External (hook): Erase the entire frame
2377    -------------------------------------------------------------------------- */
2378 {
2379   NSView *view = FRAME_NS_VIEW (f);
2380   NSRect r;
2381
2382   NSTRACE_WHEN (NSTRACE_GROUP_UPDATES, "ns_clear_frame");
2383
2384  /* comes on initial frame because we have
2385     after-make-frame-functions = select-frame */
2386  if (!FRAME_DEFAULT_FACE (f))
2387    return;
2388
2389   mark_window_cursors_off (XWINDOW (FRAME_ROOT_WINDOW (f)));
2390
2391   r = [view bounds];
2392
2393   block_input ();
2394   ns_focus (f, &r, 1);
2395   [ns_lookup_indexed_color (NS_FACE_BACKGROUND
2396                             (FACE_FROM_ID (f, DEFAULT_FACE_ID)), f) set];
2397   NSRectFill (r);
2398   ns_unfocus (f);
2399
2400   /* as of 2006/11 or so this is now needed */
2401   ns_redraw_scroll_bars (f);
2402   unblock_input ();
2403 }
2404
2405
2406 static void
2407 ns_clear_frame_area (struct frame *f, int x, int y, int width, int height)
2408 /* --------------------------------------------------------------------------
2409     External (RIF):  Clear section of frame
2410    -------------------------------------------------------------------------- */
2411 {
2412   NSRect r = NSMakeRect (x, y, width, height);
2413   NSView *view = FRAME_NS_VIEW (f);
2414   struct face *face = FRAME_DEFAULT_FACE (f);
2415
2416   if (!view || !face)
2417     return;
2418
2419   NSTRACE_WHEN (NSTRACE_GROUP_UPDATES, "ns_clear_frame_area");
2420
2421   r = NSIntersectionRect (r, [view frame]);
2422   ns_focus (f, &r, 1);
2423   [ns_lookup_indexed_color (NS_FACE_BACKGROUND (face), f) set];
2424
2425   NSRectFill (r);
2426
2427   ns_unfocus (f);
2428   return;
2429 }
2430
2431 static void
2432 ns_copy_bits (struct frame *f, NSRect src, NSRect dest)
2433 {
2434   NSTRACE ("ns_copy_bits");
2435
2436   if (FRAME_NS_VIEW (f))
2437     {
2438       hide_bell();              // Ensure the bell image isn't scrolled.
2439
2440       ns_focus (f, &dest, 1);
2441       [FRAME_NS_VIEW (f) scrollRect: src
2442                                  by: NSMakeSize (dest.origin.x - src.origin.x,
2443                                                  dest.origin.y - src.origin.y)];
2444       ns_unfocus (f);
2445     }
2446 }
2447
2448 static void
2449 ns_scroll_run (struct window *w, struct run *run)
2450 /* --------------------------------------------------------------------------
2451     External (RIF):  Insert or delete n lines at line vpos
2452    -------------------------------------------------------------------------- */
2453 {
2454   struct frame *f = XFRAME (w->frame);
2455   int x, y, width, height, from_y, to_y, bottom_y;
2456
2457   NSTRACE ("ns_scroll_run");
2458
2459   /* begin copy from other terms */
2460   /* Get frame-relative bounding box of the text display area of W,
2461      without mode lines.  Include in this box the left and right
2462      fringe of W.  */
2463   window_box (w, ANY_AREA, &x, &y, &width, &height);
2464
2465   from_y = WINDOW_TO_FRAME_PIXEL_Y (w, run->current_y);
2466   to_y = WINDOW_TO_FRAME_PIXEL_Y (w, run->desired_y);
2467   bottom_y = y + height;
2468
2469   if (to_y < from_y)
2470     {
2471       /* Scrolling up.  Make sure we don't copy part of the mode
2472          line at the bottom.  */
2473       if (from_y + run->height > bottom_y)
2474         height = bottom_y - from_y;
2475       else
2476         height = run->height;
2477     }
2478   else
2479     {
2480       /* Scrolling down.  Make sure we don't copy over the mode line.
2481          at the bottom.  */
2482       if (to_y + run->height > bottom_y)
2483         height = bottom_y - to_y;
2484       else
2485         height = run->height;
2486     }
2487   /* end copy from other terms */
2488
2489   if (height == 0)
2490       return;
2491
2492   block_input ();
2493
2494   x_clear_cursor (w);
2495
2496   {
2497     NSRect srcRect = NSMakeRect (x, from_y, width, height);
2498     NSRect dstRect = NSMakeRect (x, to_y, width, height);
2499
2500     ns_copy_bits (f, srcRect , dstRect);
2501   }
2502
2503   unblock_input ();
2504 }
2505
2506
2507 static void
2508 ns_after_update_window_line (struct window *w, struct glyph_row *desired_row)
2509 /* --------------------------------------------------------------------------
2510     External (RIF): preparatory to fringe update after text was updated
2511    -------------------------------------------------------------------------- */
2512 {
2513   struct frame *f;
2514   int width, height;
2515
2516   NSTRACE_WHEN (NSTRACE_GROUP_UPDATES, "ns_after_update_window_line");
2517
2518   /* begin copy from other terms */
2519   eassert (w);
2520
2521   if (!desired_row->mode_line_p && !w->pseudo_window_p)
2522     desired_row->redraw_fringe_bitmaps_p = 1;
2523
2524   /* When a window has disappeared, make sure that no rest of
2525      full-width rows stays visible in the internal border.  */
2526   if (windows_or_buffers_changed
2527       && desired_row->full_width_p
2528       && (f = XFRAME (w->frame),
2529           width = FRAME_INTERNAL_BORDER_WIDTH (f),
2530           width != 0)
2531       && (height = desired_row->visible_height,
2532           height > 0))
2533     {
2534       int y = WINDOW_TO_FRAME_PIXEL_Y (w, max (0, desired_row->y));
2535
2536       block_input ();
2537       ns_clear_frame_area (f, 0, y, width, height);
2538       ns_clear_frame_area (f,
2539                            FRAME_PIXEL_WIDTH (f) - width,
2540                            y, width, height);
2541       unblock_input ();
2542     }
2543 }
2544
2545
2546 static void
2547 ns_shift_glyphs_for_insert (struct frame *f,
2548                            int x, int y, int width, int height,
2549                            int shift_by)
2550 /* --------------------------------------------------------------------------
2551     External (RIF): copy an area horizontally, don't worry about clearing src
2552    -------------------------------------------------------------------------- */
2553 {
2554   NSRect srcRect = NSMakeRect (x, y, width, height);
2555   NSRect dstRect = NSMakeRect (x+shift_by, y, width, height);
2556
2557   NSTRACE ("ns_shift_glyphs_for_insert");
2558
2559   ns_copy_bits (f, srcRect, dstRect);
2560 }
2561
2562
2563
2564 /* ==========================================================================
2565
2566     Character encoding and metrics
2567
2568    ========================================================================== */
2569
2570
2571 static void
2572 ns_compute_glyph_string_overhangs (struct glyph_string *s)
2573 /* --------------------------------------------------------------------------
2574      External (RIF); compute left/right overhang of whole string and set in s
2575    -------------------------------------------------------------------------- */
2576 {
2577   struct font *font = s->font;
2578
2579   if (s->char2b)
2580     {
2581       struct font_metrics metrics;
2582       unsigned int codes[2];
2583       codes[0] = *(s->char2b);
2584       codes[1] = *(s->char2b + s->nchars - 1);
2585
2586       font->driver->text_extents (font, codes, 2, &metrics);
2587       s->left_overhang = -metrics.lbearing;
2588       s->right_overhang
2589         = metrics.rbearing > metrics.width
2590         ? metrics.rbearing - metrics.width : 0;
2591     }
2592   else
2593     {
2594       s->left_overhang = 0;
2595       if (EQ (font->driver->type, Qns))
2596         s->right_overhang = ((struct nsfont_info *)font)->ital ?
2597           FONT_HEIGHT (font) * 0.2 : 0;
2598       else
2599         s->right_overhang = 0;
2600     }
2601 }
2602
2603
2604
2605 /* ==========================================================================
2606
2607     Fringe and cursor drawing
2608
2609    ========================================================================== */
2610
2611
2612 extern int max_used_fringe_bitmap;
2613 static void
2614 ns_draw_fringe_bitmap (struct window *w, struct glyph_row *row,
2615                       struct draw_fringe_bitmap_params *p)
2616 /* --------------------------------------------------------------------------
2617     External (RIF); fringe-related
2618    -------------------------------------------------------------------------- */
2619 {
2620   /* Fringe bitmaps comes in two variants, normal and periodic.  A
2621      periodic bitmap is used to create a continuous pattern.  Since a
2622      bitmap is rendered one text line at a time, the start offset (dh)
2623      of the bitmap varies.  Concretely, this is used for the empty
2624      line indicator.
2625
2626      For a bitmap, "h + dh" is the full height and is always
2627      invariant.  For a normal bitmap "dh" is zero.
2628
2629      For example, when the period is three and the full height is 72
2630      the following combinations exists:
2631
2632        h=72 dh=0
2633        h=71 dh=1
2634        h=70 dh=2 */
2635
2636   struct frame *f = XFRAME (WINDOW_FRAME (w));
2637   struct face *face = p->face;
2638   static EmacsImage **bimgs = NULL;
2639   static int nBimgs = 0;
2640
2641   NSTRACE_WHEN (NSTRACE_GROUP_FRINGE, "ns_draw_fringe_bitmap");
2642   NSTRACE_MSG ("which:%d cursor:%d overlay:%d width:%d height:%d period:%d",
2643                p->which, p->cursor_p, p->overlay_p, p->wd, p->h, p->dh);
2644
2645   /* grow bimgs if needed */
2646   if (nBimgs < max_used_fringe_bitmap)
2647     {
2648       bimgs = xrealloc (bimgs, max_used_fringe_bitmap * sizeof *bimgs);
2649       memset (bimgs + nBimgs, 0,
2650               (max_used_fringe_bitmap - nBimgs) * sizeof *bimgs);
2651       nBimgs = max_used_fringe_bitmap;
2652     }
2653
2654   /* Must clip because of partially visible lines.  */
2655   ns_clip_to_row (w, row, ANY_AREA, YES);
2656
2657   if (!p->overlay_p)
2658     {
2659       int bx = p->bx, by = p->by, nx = p->nx, ny = p->ny;
2660
2661       if (bx >= 0 && nx > 0)
2662         {
2663           NSRect r = NSMakeRect (bx, by, nx, ny);
2664           NSRectClip (r);
2665           [ns_lookup_indexed_color (face->background, f) set];
2666           NSRectFill (r);
2667         }
2668     }
2669
2670   if (p->which)
2671     {
2672       NSRect r = NSMakeRect (p->x, p->y, p->wd, p->h);
2673       EmacsImage *img = bimgs[p->which - 1];
2674
2675       if (!img)
2676         {
2677           // Note: For "periodic" images, allocate one EmacsImage for
2678           // the base image, and use it for all dh:s.
2679           unsigned short *bits = p->bits;
2680           int full_height = p->h + p->dh;
2681           int i;
2682           unsigned char *cbits = xmalloc (full_height);
2683
2684           for (i = 0; i < full_height; i++)
2685             cbits[i] = bits[i];
2686           img = [[EmacsImage alloc] initFromXBM: cbits width: 8
2687                                          height: full_height
2688                                              fg: 0 bg: 0];
2689           bimgs[p->which - 1] = img;
2690           xfree (cbits);
2691         }
2692
2693       NSTRACE_RECT ("r", r);
2694
2695       NSRectClip (r);
2696       /* Since we composite the bitmap instead of just blitting it, we need
2697          to erase the whole background. */
2698       [ns_lookup_indexed_color(face->background, f) set];
2699       NSRectFill (r);
2700
2701       {
2702         NSColor *bm_color;
2703         if (!p->cursor_p)
2704           bm_color = ns_lookup_indexed_color(face->foreground, f);
2705         else if (p->overlay_p)
2706           bm_color = ns_lookup_indexed_color(face->background, f);
2707         else
2708           bm_color = f->output_data.ns->cursor_color;
2709         [img setXBMColor: bm_color];
2710       }
2711
2712 #ifdef NS_IMPL_COCOA
2713       // Note: For periodic images, the full image height is "h + hd".
2714       // By using the height h, a suitable part of the image is used.
2715       NSRect fromRect = NSMakeRect(0, 0, p->wd, p->h);
2716
2717       NSTRACE_RECT ("fromRect", fromRect);
2718
2719       [img drawInRect: r
2720               fromRect: fromRect
2721              operation: NSCompositingOperationSourceOver
2722               fraction: 1.0
2723            respectFlipped: YES
2724                 hints: nil];
2725 #else
2726       {
2727         NSPoint pt = r.origin;
2728         pt.y += p->h;
2729         [img compositeToPoint: pt operation: NSCompositingOperationSourceOver];
2730       }
2731 #endif
2732     }
2733   ns_unfocus (f);
2734 }
2735
2736
2737 static void
2738 ns_draw_window_cursor (struct window *w, struct glyph_row *glyph_row,
2739                        int x, int y, enum text_cursor_kinds cursor_type,
2740                        int cursor_width, bool on_p, bool active_p)
2741 /* --------------------------------------------------------------------------
2742      External call (RIF): draw cursor.
2743      Note that CURSOR_WIDTH is meaningful only for (h)bar cursors.
2744    -------------------------------------------------------------------------- */
2745 {
2746   NSRect r, s;
2747   int fx, fy, h, cursor_height;
2748   struct frame *f = WINDOW_XFRAME (w);
2749   struct glyph *phys_cursor_glyph;
2750   struct glyph *cursor_glyph;
2751   struct face *face;
2752   NSColor *hollow_color = FRAME_BACKGROUND_COLOR (f);
2753
2754   /* If cursor is out of bounds, don't draw garbage.  This can happen
2755      in mini-buffer windows when switching between echo area glyphs
2756      and mini-buffer.  */
2757
2758   NSTRACE ("ns_draw_window_cursor");
2759
2760   if (!on_p)
2761     return;
2762
2763   w->phys_cursor_type = cursor_type;
2764   w->phys_cursor_on_p = on_p;
2765
2766   if (cursor_type == NO_CURSOR)
2767     {
2768       w->phys_cursor_width = 0;
2769       return;
2770     }
2771
2772   if ((phys_cursor_glyph = get_phys_cursor_glyph (w)) == NULL)
2773     {
2774       if (glyph_row->exact_window_width_line_p
2775           && w->phys_cursor.hpos >= glyph_row->used[TEXT_AREA])
2776         {
2777           glyph_row->cursor_in_fringe_p = 1;
2778           draw_fringe_bitmap (w, glyph_row, 0);
2779         }
2780       return;
2781     }
2782
2783   /* We draw the cursor (with NSRectFill), then draw the glyph on top
2784      (other terminals do it the other way round).  We must set
2785      w->phys_cursor_width to the cursor width.  For bar cursors, that
2786      is CURSOR_WIDTH; for box cursors, it is the glyph width.  */
2787   get_phys_cursor_geometry (w, glyph_row, phys_cursor_glyph, &fx, &fy, &h);
2788
2789   /* The above get_phys_cursor_geometry call set w->phys_cursor_width
2790      to the glyph width; replace with CURSOR_WIDTH for (V)BAR cursors. */
2791   if (cursor_type == BAR_CURSOR)
2792     {
2793       if (cursor_width < 1)
2794         cursor_width = max (FRAME_CURSOR_WIDTH (f), 1);
2795
2796       /* The bar cursor should never be wider than the glyph. */
2797       if (cursor_width < w->phys_cursor_width)
2798         w->phys_cursor_width = cursor_width;
2799     }
2800   /* If we have an HBAR, "cursor_width" MAY specify height. */
2801   else if (cursor_type == HBAR_CURSOR)
2802     {
2803       cursor_height = (cursor_width < 1) ? lrint (0.25 * h) : cursor_width;
2804       if (cursor_height > glyph_row->height)
2805         cursor_height = glyph_row->height;
2806       if (h > cursor_height) // Cursor smaller than line height, move down
2807         fy += h - cursor_height;
2808       h = cursor_height;
2809     }
2810
2811   r.origin.x = fx, r.origin.y = fy;
2812   r.size.height = h;
2813   r.size.width = w->phys_cursor_width;
2814
2815   /* Prevent the cursor from being drawn outside the text area. */
2816   ns_clip_to_row (w, glyph_row, TEXT_AREA, NO); /* do ns_focus(f, &r, 1); if remove */
2817
2818
2819   face = FACE_FROM_ID_OR_NULL (f, phys_cursor_glyph->face_id);
2820   if (face && NS_FACE_BACKGROUND (face)
2821       == ns_index_color (FRAME_CURSOR_COLOR (f), f))
2822     {
2823       [ns_lookup_indexed_color (NS_FACE_FOREGROUND (face), f) set];
2824       hollow_color = FRAME_CURSOR_COLOR (f);
2825     }
2826   else
2827     [FRAME_CURSOR_COLOR (f) set];
2828
2829 #ifdef NS_IMPL_COCOA
2830   /* TODO: This makes drawing of cursor plus that of phys_cursor_glyph
2831            atomic.  Cleaner ways of doing this should be investigated.
2832            One way would be to set a global variable DRAWING_CURSOR
2833            when making the call to draw_phys..(), don't focus in that
2834            case, then move the ns_unfocus() here after that call. */
2835   NSDisableScreenUpdates ();
2836 #endif
2837
2838   switch (cursor_type)
2839     {
2840     case DEFAULT_CURSOR:
2841     case NO_CURSOR:
2842       break;
2843     case FILLED_BOX_CURSOR:
2844       NSRectFill (r);
2845       break;
2846     case HOLLOW_BOX_CURSOR:
2847       NSRectFill (r);
2848       [hollow_color set];
2849       NSRectFill (NSInsetRect (r, 1, 1));
2850       [FRAME_CURSOR_COLOR (f) set];
2851       break;
2852     case HBAR_CURSOR:
2853       NSRectFill (r);
2854       break;
2855     case BAR_CURSOR:
2856       s = r;
2857       /* If the character under cursor is R2L, draw the bar cursor
2858          on the right of its glyph, rather than on the left.  */
2859       cursor_glyph = get_phys_cursor_glyph (w);
2860       if ((cursor_glyph->resolved_level & 1) != 0)
2861         s.origin.x += cursor_glyph->pixel_width - s.size.width;
2862
2863       NSRectFill (s);
2864       break;
2865     }
2866   ns_unfocus (f);
2867
2868   /* draw the character under the cursor */
2869   if (cursor_type != NO_CURSOR)
2870     draw_phys_cursor_glyph (w, glyph_row, DRAW_CURSOR);
2871
2872 #ifdef NS_IMPL_COCOA
2873   NSEnableScreenUpdates ();
2874 #endif
2875
2876 }
2877
2878
2879 static void
2880 ns_draw_vertical_window_border (struct window *w, int x, int y0, int y1)
2881 /* --------------------------------------------------------------------------
2882      External (RIF): Draw a vertical line.
2883    -------------------------------------------------------------------------- */
2884 {
2885   struct frame *f = XFRAME (WINDOW_FRAME (w));
2886   struct face *face;
2887   NSRect r = NSMakeRect (x, y0, 1, y1-y0);
2888
2889   NSTRACE ("ns_draw_vertical_window_border");
2890
2891   face = FACE_FROM_ID_OR_NULL (f, VERTICAL_BORDER_FACE_ID);
2892
2893   ns_focus (f, &r, 1);
2894   if (face)
2895     [ns_lookup_indexed_color(face->foreground, f) set];
2896
2897   NSRectFill(r);
2898   ns_unfocus (f);
2899 }
2900
2901
2902 static void
2903 ns_draw_window_divider (struct window *w, int x0, int x1, int y0, int y1)
2904 /* --------------------------------------------------------------------------
2905      External (RIF): Draw a window divider.
2906    -------------------------------------------------------------------------- */
2907 {
2908   struct frame *f = XFRAME (WINDOW_FRAME (w));
2909   struct face *face;
2910   NSRect r = NSMakeRect (x0, y0, x1-x0, y1-y0);
2911
2912   NSTRACE ("ns_draw_window_divider");
2913
2914   face = FACE_FROM_ID_OR_NULL (f, WINDOW_DIVIDER_FACE_ID);
2915
2916   ns_focus (f, &r, 1);
2917   if (face)
2918     [ns_lookup_indexed_color(face->foreground, f) set];
2919
2920   NSRectFill(r);
2921   ns_unfocus (f);
2922 }
2923
2924 static void
2925 ns_show_hourglass (struct frame *f)
2926 {
2927   /* TODO: add NSProgressIndicator to all frames.  */
2928 }
2929
2930 static void
2931 ns_hide_hourglass (struct frame *f)
2932 {
2933   /* TODO: remove NSProgressIndicator from all frames.  */
2934 }
2935
2936 /* ==========================================================================
2937
2938     Glyph drawing operations
2939
2940    ========================================================================== */
2941
2942 static int
2943 ns_get_glyph_string_clip_rect (struct glyph_string *s, NativeRectangle *nr)
2944 /* --------------------------------------------------------------------------
2945     Wrapper utility to account for internal border width on full-width lines,
2946     and allow top full-width rows to hit the frame top.  nr should be pointer
2947     to two successive NSRects.  Number of rects actually used is returned.
2948    -------------------------------------------------------------------------- */
2949 {
2950   int n = get_glyph_string_clip_rects (s, nr, 2);
2951   return n;
2952 }
2953
2954 /* --------------------------------------------------------------------
2955    Draw a wavy line under glyph string s. The wave fills wave_height
2956    pixels from y.
2957
2958                     x          wave_length = 2
2959                                  --
2960                 y    *   *   *   *   *
2961                      |* * * * * * * * *
2962     wave_height = 3  | *   *   *   *
2963   --------------------------------------------------------------------- */
2964
2965 static void
2966 ns_draw_underwave (struct glyph_string *s, EmacsCGFloat width, EmacsCGFloat x)
2967 {
2968   int wave_height = 3, wave_length = 2;
2969   int y, dx, dy, odd, xmax;
2970   NSPoint a, b;
2971   NSRect waveClip;
2972
2973   dx = wave_length;
2974   dy = wave_height - 1;
2975   y =  s->ybase - wave_height + 3;
2976   xmax = x + width;
2977
2978   /* Find and set clipping rectangle */
2979   waveClip = NSMakeRect (x, y, width, wave_height);
2980   [[NSGraphicsContext currentContext] saveGraphicsState];
2981   NSRectClip (waveClip);
2982
2983   /* Draw the waves */
2984   a.x = x - ((int)(x) % dx) + (EmacsCGFloat) 0.5;
2985   b.x = a.x + dx;
2986   odd = (int)(a.x/dx) % 2;
2987   a.y = b.y = y + 0.5;
2988
2989   if (odd)
2990     a.y += dy;
2991   else
2992     b.y += dy;
2993
2994   while (a.x <= xmax)
2995     {
2996       [NSBezierPath strokeLineFromPoint:a toPoint:b];
2997       a.x = b.x, a.y = b.y;
2998       b.x += dx, b.y = y + 0.5 + odd*dy;
2999       odd = !odd;
3000     }
3001
3002   /* Restore previous clipping rectangle(s) */
3003   [[NSGraphicsContext currentContext] restoreGraphicsState];
3004 }
3005
3006
3007
3008 static void
3009 ns_draw_text_decoration (struct glyph_string *s, struct face *face,
3010                          NSColor *defaultCol, CGFloat width, CGFloat x)
3011 /* --------------------------------------------------------------------------
3012    Draw underline, overline, and strike-through on glyph string s.
3013    -------------------------------------------------------------------------- */
3014 {
3015   if (s->for_overlaps)
3016     return;
3017
3018   /* Do underline. */
3019   if (face->underline_p)
3020     {
3021       if (s->face->underline_type == FACE_UNDER_WAVE)
3022         {
3023           if (face->underline_defaulted_p)
3024             [defaultCol set];
3025           else
3026             [ns_lookup_indexed_color (face->underline_color, s->f) set];
3027
3028           ns_draw_underwave (s, width, x);
3029         }
3030       else if (s->face->underline_type == FACE_UNDER_LINE)
3031         {
3032
3033           NSRect r;
3034           unsigned long thickness, position;
3035
3036           /* If the prev was underlined, match its appearance. */
3037           if (s->prev && s->prev->face->underline_p
3038               && s->prev->face->underline_type == FACE_UNDER_LINE
3039               && s->prev->underline_thickness > 0)
3040             {
3041               thickness = s->prev->underline_thickness;
3042               position = s->prev->underline_position;
3043             }
3044           else
3045             {
3046               struct font *font = font_for_underline_metrics (s);
3047               unsigned long descent = s->y + s->height - s->ybase;
3048
3049               /* Use underline thickness of font, defaulting to 1. */
3050               thickness = (font && font->underline_thickness > 0)
3051                 ? font->underline_thickness : 1;
3052
3053               /* Determine the offset of underlining from the baseline. */
3054               if (x_underline_at_descent_line)
3055                 position = descent - thickness;
3056               else if (x_use_underline_position_properties
3057                        && font && font->underline_position >= 0)
3058                 position = font->underline_position;
3059               else if (font)
3060                 position = lround (font->descent / 2);
3061               else
3062                 position = underline_minimum_offset;
3063
3064               position = max (position, underline_minimum_offset);
3065
3066               /* Ensure underlining is not cropped. */
3067               if (descent <= position)
3068                 {
3069                   position = descent - 1;
3070                   thickness = 1;
3071                 }
3072               else if (descent < position + thickness)
3073                 thickness = 1;
3074             }
3075
3076           s->underline_thickness = thickness;
3077           s->underline_position = position;
3078
3079           r = NSMakeRect (x, s->ybase + position, width, thickness);
3080
3081           if (face->underline_defaulted_p)
3082             [defaultCol set];
3083           else
3084             [ns_lookup_indexed_color (face->underline_color, s->f) set];
3085           NSRectFill (r);
3086         }
3087     }
3088   /* Do overline. We follow other terms in using a thickness of 1
3089      and ignoring overline_margin. */
3090   if (face->overline_p)
3091     {
3092       NSRect r;
3093       r = NSMakeRect (x, s->y, width, 1);
3094
3095       if (face->overline_color_defaulted_p)
3096         [defaultCol set];
3097       else
3098         [ns_lookup_indexed_color (face->overline_color, s->f) set];
3099       NSRectFill (r);
3100     }
3101
3102   /* Do strike-through.  We follow other terms for thickness and
3103      vertical position.*/
3104   if (face->strike_through_p)
3105     {
3106       NSRect r;
3107       /* Y-coordinate and height of the glyph string's first glyph.
3108          We cannot use s->y and s->height because those could be
3109          larger if there are taller display elements (e.g., characters
3110          displayed with a larger font) in the same glyph row.  */
3111       int glyph_y = s->ybase - s->first_glyph->ascent;
3112       int glyph_height = s->first_glyph->ascent + s->first_glyph->descent;
3113       /* Strike-through width and offset from the glyph string's
3114          top edge.  */
3115       unsigned long h = 1;
3116       unsigned long dy;
3117
3118       dy = lrint ((glyph_height - h) / 2);
3119       r = NSMakeRect (x, glyph_y + dy, width, 1);
3120
3121       if (face->strike_through_color_defaulted_p)
3122         [defaultCol set];
3123       else
3124         [ns_lookup_indexed_color (face->strike_through_color, s->f) set];
3125       NSRectFill (r);
3126     }
3127 }
3128
3129 static void
3130 ns_draw_box (NSRect r, CGFloat thickness, NSColor *col,
3131              char left_p, char right_p)
3132 /* --------------------------------------------------------------------------
3133     Draw an unfilled rect inside r, optionally leaving left and/or right open.
3134     Note we can't just use an NSDrawRect command, because of the possibility
3135     of some sides not being drawn, and because the rect will be filled.
3136    -------------------------------------------------------------------------- */
3137 {
3138   NSRect s = r;
3139   [col set];
3140
3141   /* top, bottom */
3142   s.size.height = thickness;
3143   NSRectFill (s);
3144   s.origin.y += r.size.height - thickness;
3145   NSRectFill (s);
3146
3147   s.size.height = r.size.height;
3148   s.origin.y = r.origin.y;
3149
3150   /* left, right (optional) */
3151   s.size.width = thickness;
3152   if (left_p)
3153     NSRectFill (s);
3154   if (right_p)
3155     {
3156       s.origin.x += r.size.width - thickness;
3157       NSRectFill (s);
3158     }
3159 }
3160
3161
3162 static void
3163 ns_draw_relief (NSRect r, int thickness, char raised_p,
3164                char top_p, char bottom_p, char left_p, char right_p,
3165                struct glyph_string *s)
3166 /* --------------------------------------------------------------------------
3167     Draw a relief rect inside r, optionally leaving some sides open.
3168     Note we can't just use an NSDrawBezel command, because of the possibility
3169     of some sides not being drawn, and because the rect will be filled.
3170    -------------------------------------------------------------------------- */
3171 {
3172   static NSColor *baseCol = nil, *lightCol = nil, *darkCol = nil;
3173   NSColor *newBaseCol = nil;
3174   NSRect sr = r;
3175
3176   NSTRACE ("ns_draw_relief");
3177
3178   /* set up colors */
3179
3180   if (s->face->use_box_color_for_shadows_p)
3181     {
3182       newBaseCol = ns_lookup_indexed_color (s->face->box_color, s->f);
3183     }
3184 /*     else if (s->first_glyph->type == IMAGE_GLYPH
3185            && s->img->pixmap
3186            && !IMAGE_BACKGROUND_TRANSPARENT (s->img, s->f, 0))
3187        {
3188          newBaseCol = IMAGE_BACKGROUND  (s->img, s->f, 0);
3189        } */
3190   else
3191     {
3192       newBaseCol = ns_lookup_indexed_color (s->face->background, s->f);
3193     }
3194
3195   if (newBaseCol == nil)
3196     newBaseCol = [NSColor grayColor];
3197
3198   if (newBaseCol != baseCol)  /* TODO: better check */
3199     {
3200       [baseCol release];
3201       baseCol = [newBaseCol retain];
3202       [lightCol release];
3203       lightCol = [[baseCol highlightWithLevel: 0.2] retain];
3204       [darkCol release];
3205       darkCol = [[baseCol shadowWithLevel: 0.3] retain];
3206     }
3207
3208   [(raised_p ? lightCol : darkCol) set];
3209
3210   /* TODO: mitering. Using NSBezierPath doesn't work because of color switch. */
3211
3212   /* top */
3213   sr.size.height = thickness;
3214   if (top_p) NSRectFill (sr);
3215
3216   /* left */
3217   sr.size.height = r.size.height;
3218   sr.size.width = thickness;
3219   if (left_p) NSRectFill (sr);
3220
3221   [(raised_p ? darkCol : lightCol) set];
3222
3223   /* bottom */
3224   sr.size.width = r.size.width;
3225   sr.size.height = thickness;
3226   sr.origin.y += r.size.height - thickness;
3227   if (bottom_p) NSRectFill (sr);
3228
3229   /* right */
3230   sr.size.height = r.size.height;
3231   sr.origin.y = r.origin.y;
3232   sr.size.width = thickness;
3233   sr.origin.x += r.size.width - thickness;
3234   if (right_p) NSRectFill (sr);
3235 }
3236
3237
3238 static void
3239 ns_dumpglyphs_box_or_relief (struct glyph_string *s)
3240 /* --------------------------------------------------------------------------
3241       Function modeled after x_draw_glyph_string_box ().
3242       Sets up parameters for drawing.
3243    -------------------------------------------------------------------------- */
3244 {
3245   int right_x, last_x;
3246   char left_p, right_p;
3247   struct glyph *last_glyph;
3248   NSRect r;
3249   int thickness;
3250   struct face *face;
3251
3252   if (s->hl == DRAW_MOUSE_FACE)
3253     {
3254       face = FACE_FROM_ID_OR_NULL (s->f,
3255                                    MOUSE_HL_INFO (s->f)->mouse_face_face_id);
3256       if (!face)
3257         face = FACE_FROM_ID (s->f, MOUSE_FACE_ID);
3258     }
3259   else
3260     face = s->face;
3261
3262   thickness = face->box_line_width;
3263
3264   NSTRACE ("ns_dumpglyphs_box_or_relief");
3265
3266   last_x = ((s->row->full_width_p && !s->w->pseudo_window_p)
3267             ? WINDOW_RIGHT_EDGE_X (s->w)
3268             : window_box_right (s->w, s->area));
3269   last_glyph = (s->cmp || s->img
3270                 ? s->first_glyph : s->first_glyph + s->nchars-1);
3271
3272   right_x = ((s->row->full_width_p && s->extends_to_end_of_line_p
3273               ? last_x - 1 : min (last_x, s->x + s->background_width) - 1));
3274
3275   left_p = (s->first_glyph->left_box_line_p
3276             || (s->hl == DRAW_MOUSE_FACE
3277                 && (s->prev == NULL || s->prev->hl != s->hl)));
3278   right_p = (last_glyph->right_box_line_p
3279              || (s->hl == DRAW_MOUSE_FACE
3280                  && (s->next == NULL || s->next->hl != s->hl)));
3281
3282   r = NSMakeRect (s->x, s->y, right_x - s->x + 1, s->height);
3283
3284   /* TODO: Sometimes box_color is 0 and this seems wrong; should investigate. */
3285   if (s->face->box == FACE_SIMPLE_BOX && s->face->box_color)
3286     {
3287       ns_draw_box (r, abs (thickness),
3288                    ns_lookup_indexed_color (face->box_color, s->f),
3289                   left_p, right_p);
3290     }
3291   else
3292     {
3293       ns_draw_relief (r, abs (thickness), s->face->box == FACE_RAISED_BOX,
3294                      1, 1, left_p, right_p, s);
3295     }
3296 }
3297
3298
3299 static void
3300 ns_maybe_dumpglyphs_background (struct glyph_string *s, char force_p)
3301 /* --------------------------------------------------------------------------
3302       Modeled after x_draw_glyph_string_background, which draws BG in
3303       certain cases.  Others are left to the text rendering routine.
3304    -------------------------------------------------------------------------- */
3305 {
3306   NSTRACE ("ns_maybe_dumpglyphs_background");
3307
3308   if (!s->background_filled_p/* || s->hl == DRAW_MOUSE_FACE*/)
3309     {
3310       int box_line_width = max (s->face->box_line_width, 0);
3311       if (FONT_HEIGHT (s->font) < s->height - 2 * box_line_width
3312           /* When xdisp.c ignores FONT_HEIGHT, we cannot trust font
3313              dimensions, since the actual glyphs might be much
3314              smaller.  So in that case we always clear the rectangle
3315              with background color.  */
3316           || FONT_TOO_HIGH (s->font)
3317           || s->font_not_found_p || s->extends_to_end_of_line_p || force_p)
3318         {
3319           struct face *face;
3320           if (s->hl == DRAW_MOUSE_FACE)
3321             {
3322               face
3323                 = FACE_FROM_ID_OR_NULL (s->f,
3324                                         MOUSE_HL_INFO (s->f)->mouse_face_face_id);
3325               if (!face)
3326                 face = FACE_FROM_ID (s->f, MOUSE_FACE_ID);
3327             }
3328           else
3329             face = FACE_FROM_ID (s->f, s->first_glyph->face_id);
3330           if (!face->stipple)
3331             [(NS_FACE_BACKGROUND (face) != 0
3332               ? ns_lookup_indexed_color (NS_FACE_BACKGROUND (face), s->f)
3333               : FRAME_BACKGROUND_COLOR (s->f)) set];
3334           else
3335             {
3336               struct ns_display_info *dpyinfo = FRAME_DISPLAY_INFO (s->f);
3337               [[dpyinfo->bitmaps[face->stipple-1].img stippleMask] set];
3338             }
3339
3340           if (s->hl != DRAW_CURSOR)
3341             {
3342               NSRect r = NSMakeRect (s->x, s->y + box_line_width,
3343                                     s->background_width,
3344                                     s->height-2*box_line_width);
3345               NSRectFill (r);
3346             }
3347
3348           s->background_filled_p = 1;
3349         }
3350     }
3351 }
3352
3353
3354 static void
3355 ns_dumpglyphs_image (struct glyph_string *s, NSRect r)
3356 /* --------------------------------------------------------------------------
3357       Renders an image and associated borders.
3358    -------------------------------------------------------------------------- */
3359 {
3360   EmacsImage *img = s->img->pixmap;
3361   int box_line_vwidth = max (s->face->box_line_width, 0);
3362   int x = s->x, y = s->ybase - image_ascent (s->img, s->face, &s->slice);
3363   int bg_x, bg_y, bg_height;
3364   int th;
3365   char raised_p;
3366   NSRect br;
3367   struct face *face;
3368   NSColor *tdCol;
3369
3370   NSTRACE ("ns_dumpglyphs_image");
3371
3372   if (s->face->box != FACE_NO_BOX
3373       && s->first_glyph->left_box_line_p && s->slice.x == 0)
3374     x += abs (s->face->box_line_width);
3375
3376   bg_x = x;
3377   bg_y =  s->slice.y == 0 ? s->y : s->y + box_line_vwidth;
3378   bg_height = s->height;
3379   /* other terms have this, but was causing problems w/tabbar mode */
3380   /* - 2 * box_line_vwidth; */
3381
3382   if (s->slice.x == 0) x += s->img->hmargin;
3383   if (s->slice.y == 0) y += s->img->vmargin;
3384
3385   /* Draw BG: if we need larger area than image itself cleared, do that,
3386      otherwise, since we composite the image under NS (instead of mucking
3387      with its background color), we must clear just the image area. */
3388   if (s->hl == DRAW_MOUSE_FACE)
3389     {
3390       face = FACE_FROM_ID_OR_NULL (s->f,
3391                                    MOUSE_HL_INFO (s->f)->mouse_face_face_id);
3392       if (!face)
3393        face = FACE_FROM_ID (s->f, MOUSE_FACE_ID);
3394     }
3395   else
3396     face = FACE_FROM_ID (s->f, s->first_glyph->face_id);
3397
3398   [ns_lookup_indexed_color (NS_FACE_BACKGROUND (face), s->f) set];
3399
3400   if (bg_height > s->slice.height || s->img->hmargin || s->img->vmargin
3401       || s->img->mask || s->img->pixmap == 0 || s->width != s->background_width)
3402     {
3403       br = NSMakeRect (bg_x, bg_y, s->background_width, bg_height);
3404       s->background_filled_p = 1;
3405     }
3406   else
3407     {
3408       br = NSMakeRect (x, y, s->slice.width, s->slice.height);
3409     }
3410
3411   NSRectFill (br);
3412
3413   /* Draw the image.. do we need to draw placeholder if img ==nil? */
3414   if (img != nil)
3415     {
3416 #ifdef NS_IMPL_COCOA
3417       NSRect dr = NSMakeRect (x, y, s->slice.width, s->slice.height);
3418       NSRect ir = NSMakeRect (s->slice.x,
3419                               s->img->height - s->slice.y - s->slice.height,
3420                               s->slice.width, s->slice.height);
3421       [img drawInRect: dr
3422              fromRect: ir
3423              operation: NSCompositingOperationSourceOver
3424               fraction: 1.0
3425            respectFlipped: YES
3426                 hints: nil];
3427 #else
3428       [img compositeToPoint: NSMakePoint (x, y + s->slice.height)
3429                   operation: NSCompositingOperationSourceOver];
3430 #endif
3431     }
3432
3433   if (s->hl == DRAW_CURSOR)
3434     {
3435     [FRAME_CURSOR_COLOR (s->f) set];
3436     if (s->w->phys_cursor_type == FILLED_BOX_CURSOR)
3437       tdCol = ns_lookup_indexed_color (NS_FACE_BACKGROUND (face), s->f);
3438     else
3439       /* Currently on NS img->mask is always 0. Since
3440          get_window_cursor_type specifies a hollow box cursor when on
3441          a non-masked image we never reach this clause. But we put it
3442          in in anticipation of better support for image masks on
3443          NS. */
3444       tdCol = ns_lookup_indexed_color (NS_FACE_FOREGROUND (face), s->f);
3445     }
3446   else
3447     {
3448       tdCol = ns_lookup_indexed_color (NS_FACE_FOREGROUND (face), s->f);
3449     }
3450
3451   /* Draw underline, overline, strike-through. */
3452   ns_draw_text_decoration (s, face, tdCol, br.size.width, br.origin.x);
3453
3454   /* Draw relief, if requested */
3455   if (s->img->relief || s->hl ==DRAW_IMAGE_RAISED || s->hl ==DRAW_IMAGE_SUNKEN)
3456     {
3457       if (s->hl == DRAW_IMAGE_SUNKEN || s->hl == DRAW_IMAGE_RAISED)
3458         {
3459           th = tool_bar_button_relief >= 0 ?
3460             tool_bar_button_relief : DEFAULT_TOOL_BAR_BUTTON_RELIEF;
3461           raised_p = (s->hl == DRAW_IMAGE_RAISED);
3462         }
3463       else
3464         {
3465           th = abs (s->img->relief);
3466           raised_p = (s->img->relief > 0);
3467         }
3468
3469       r.origin.x = x - th;
3470       r.origin.y = y - th;
3471       r.size.width = s->slice.width + 2*th-1;
3472       r.size.height = s->slice.height + 2*th-1;
3473       ns_draw_relief (r, th, raised_p,
3474                       s->slice.y == 0,
3475                       s->slice.y + s->slice.height == s->img->height,
3476                       s->slice.x == 0,
3477                       s->slice.x + s->slice.width == s->img->width, s);
3478     }
3479
3480   /* If there is no mask, the background won't be seen,
3481      so draw a rectangle on the image for the cursor.
3482      Do this for all images, getting transparency right is not reliable.  */
3483   if (s->hl == DRAW_CURSOR)
3484     {
3485       int thickness = abs (s->img->relief);
3486       if (thickness == 0) thickness = 1;
3487       ns_draw_box (br, thickness, FRAME_CURSOR_COLOR (s->f), 1, 1);
3488     }
3489 }
3490
3491
3492 static void
3493 ns_dumpglyphs_stretch (struct glyph_string *s)
3494 {
3495   NSRect r[2];
3496   int n, i;
3497   struct face *face;
3498   NSColor *fgCol, *bgCol;
3499
3500   if (!s->background_filled_p)
3501     {
3502       n = ns_get_glyph_string_clip_rect (s, r);
3503       *r = NSMakeRect (s->x, s->y, s->background_width, s->height);
3504
3505       ns_focus (s->f, r, n);
3506
3507       if (s->hl == DRAW_MOUSE_FACE)
3508        {
3509          face = FACE_FROM_ID_OR_NULL (s->f,
3510                                       MOUSE_HL_INFO (s->f)->mouse_face_face_id);
3511          if (!face)
3512            face = FACE_FROM_ID (s->f, MOUSE_FACE_ID);
3513        }
3514       else
3515        face = FACE_FROM_ID (s->f, s->first_glyph->face_id);
3516
3517       bgCol = ns_lookup_indexed_color (NS_FACE_BACKGROUND (face), s->f);
3518       fgCol = ns_lookup_indexed_color (NS_FACE_FOREGROUND (face), s->f);
3519
3520       for (i = 0; i < n; ++i)
3521         {
3522           if (!s->row->full_width_p)
3523             {
3524               int overrun, leftoverrun;
3525
3526               /* truncate to avoid overwriting fringe and/or scrollbar */
3527               overrun = max (0, (s->x + s->background_width)
3528                              - (WINDOW_BOX_RIGHT_EDGE_X (s->w)
3529                                 - WINDOW_RIGHT_FRINGE_WIDTH (s->w)));
3530               r[i].size.width -= overrun;
3531
3532               /* truncate to avoid overwriting to left of the window box */
3533               leftoverrun = (WINDOW_BOX_LEFT_EDGE_X (s->w)
3534                              + WINDOW_LEFT_FRINGE_WIDTH (s->w)) - s->x;
3535
3536               if (leftoverrun > 0)
3537                 {
3538                   r[i].origin.x += leftoverrun;
3539                   r[i].size.width -= leftoverrun;
3540                 }
3541
3542               /* XXX: Try to work between problem where a stretch glyph on
3543                  a partially-visible bottom row will clear part of the
3544                  modeline, and another where list-buffers headers and similar
3545                  rows erroneously have visible_height set to 0.  Not sure
3546                  where this is coming from as other terms seem not to show. */
3547               r[i].size.height = min (s->height, s->row->visible_height);
3548             }
3549
3550           [bgCol set];
3551
3552           /* NOTE: under NS this is NOT used to draw cursors, but we must avoid
3553              overwriting cursor (usually when cursor on a tab) */
3554           if (s->hl == DRAW_CURSOR)
3555             {
3556               CGFloat x, width;
3557
3558               x = r[i].origin.x;
3559               width = s->w->phys_cursor_width;
3560               r[i].size.width -= width;
3561               r[i].origin.x += width;
3562
3563               NSRectFill (r[i]);
3564
3565               /* Draw overlining, etc. on the cursor. */
3566               if (s->w->phys_cursor_type == FILLED_BOX_CURSOR)
3567                 ns_draw_text_decoration (s, face, bgCol, width, x);
3568               else
3569                 ns_draw_text_decoration (s, face, fgCol, width, x);
3570             }
3571           else
3572             {
3573               NSRectFill (r[i]);
3574             }
3575
3576           /* Draw overlining, etc. on the stretch glyph (or the part
3577              of the stretch glyph after the cursor). */
3578           ns_draw_text_decoration (s, face, fgCol, r[i].size.width,
3579                                    r[i].origin.x);
3580         }
3581       ns_unfocus (s->f);
3582       s->background_filled_p = 1;
3583     }
3584 }
3585
3586
3587 static void
3588 ns_draw_glyph_string_foreground (struct glyph_string *s)
3589 {
3590   int x, flags;
3591   struct font *font = s->font;
3592
3593   /* If first glyph of S has a left box line, start drawing the text
3594      of S to the right of that box line.  */
3595   if (s->face && s->face->box != FACE_NO_BOX
3596       && s->first_glyph->left_box_line_p)
3597     x = s->x + eabs (s->face->box_line_width);
3598   else
3599     x = s->x;
3600
3601   flags = s->hl == DRAW_CURSOR ? NS_DUMPGLYPH_CURSOR :
3602     (s->hl == DRAW_MOUSE_FACE ? NS_DUMPGLYPH_MOUSEFACE :
3603      (s->for_overlaps ? NS_DUMPGLYPH_FOREGROUND :
3604       NS_DUMPGLYPH_NORMAL));
3605
3606   font->driver->draw
3607     (s, s->cmp_from, s->nchars, x, s->ybase,
3608      (flags == NS_DUMPGLYPH_NORMAL && !s->background_filled_p)
3609      || flags == NS_DUMPGLYPH_MOUSEFACE);
3610 }
3611
3612
3613 static void
3614 ns_draw_composite_glyph_string_foreground (struct glyph_string *s)
3615 {
3616   int i, j, x;
3617   struct font *font = s->font;
3618
3619   /* If first glyph of S has a left box line, start drawing the text
3620      of S to the right of that box line.  */
3621   if (s->face && s->face->box != FACE_NO_BOX
3622       && s->first_glyph->left_box_line_p)
3623     x = s->x + eabs (s->face->box_line_width);
3624   else
3625     x = s->x;
3626
3627   /* S is a glyph string for a composition.  S->cmp_from is the index
3628      of the first character drawn for glyphs of this composition.
3629      S->cmp_from == 0 means we are drawing the very first character of
3630      this composition.  */
3631
3632   /* Draw a rectangle for the composition if the font for the very
3633      first character of the composition could not be loaded.  */
3634   if (s->font_not_found_p)
3635     {
3636       if (s->cmp_from == 0)
3637         {
3638           NSRect r = NSMakeRect (s->x, s->y, s->width-1, s->height -1);
3639           ns_draw_box (r, 1, FRAME_CURSOR_COLOR (s->f), 1, 1);
3640         }
3641     }
3642   else if (! s->first_glyph->u.cmp.automatic)
3643     {
3644       int y = s->ybase;
3645
3646       for (i = 0, j = s->cmp_from; i < s->nchars; i++, j++)
3647         /* TAB in a composition means display glyphs with padding
3648            space on the left or right.  */
3649         if (COMPOSITION_GLYPH (s->cmp, j) != '\t')
3650           {
3651             int xx = x + s->cmp->offsets[j * 2];
3652             int yy = y - s->cmp->offsets[j * 2 + 1];
3653
3654             font->driver->draw (s, j, j + 1, xx, yy, false);
3655             if (s->face->overstrike)
3656               font->driver->draw (s, j, j + 1, xx + 1, yy, false);
3657           }
3658     }
3659   else
3660     {
3661       Lisp_Object gstring = composition_gstring_from_id (s->cmp_id);
3662       Lisp_Object glyph;
3663       int y = s->ybase;
3664       int width = 0;
3665
3666       for (i = j = s->cmp_from; i < s->cmp_to; i++)
3667         {
3668           glyph = LGSTRING_GLYPH (gstring, i);
3669           if (NILP (LGLYPH_ADJUSTMENT (glyph)))
3670             width += LGLYPH_WIDTH (glyph);
3671           else
3672             {
3673               int xoff, yoff, wadjust;
3674
3675               if (j < i)
3676                 {
3677                   font->driver->draw (s, j, i, x, y, false);
3678                   if (s->face->overstrike)
3679                     font->driver->draw (s, j, i, x + 1, y, false);
3680                   x += width;
3681                 }
3682               xoff = LGLYPH_XOFF (glyph);
3683               yoff = LGLYPH_YOFF (glyph);
3684               wadjust = LGLYPH_WADJUST (glyph);
3685               font->driver->draw (s, i, i + 1, x + xoff, y + yoff, false);
3686               if (s->face->overstrike)
3687                 font->driver->draw (s, i, i + 1, x + xoff + 1, y + yoff,
3688                                     false);
3689               x += wadjust;
3690               j = i + 1;
3691               width = 0;
3692             }
3693         }
3694       if (j < i)
3695         {
3696           font->driver->draw (s, j, i, x, y, false);
3697           if (s->face->overstrike)
3698             font->driver->draw (s, j, i, x + 1, y, false);
3699         }
3700     }
3701 }
3702
3703 static void
3704 ns_draw_glyph_string (struct glyph_string *s)
3705 /* --------------------------------------------------------------------------
3706       External (RIF): Main draw-text call.
3707    -------------------------------------------------------------------------- */
3708 {
3709   /* TODO (optimize): focus for box and contents draw */
3710   NSRect r[2];
3711   int n;
3712   char box_drawn_p = 0;
3713   struct font *font = s->face->font;
3714   if (! font) font = FRAME_FONT (s->f);
3715
3716   NSTRACE_WHEN (NSTRACE_GROUP_GLYPHS, "ns_draw_glyph_string");
3717
3718   if (s->next && s->right_overhang && !s->for_overlaps/*&&s->hl!=DRAW_CURSOR*/)
3719     {
3720       int width;
3721       struct glyph_string *next;
3722
3723       for (width = 0, next = s->next;
3724            next && width < s->right_overhang;
3725            width += next->width, next = next->next)
3726         if (next->first_glyph->type != IMAGE_GLYPH)
3727           {
3728             if (next->first_glyph->type != STRETCH_GLYPH)
3729               {
3730                 n = ns_get_glyph_string_clip_rect (s->next, r);
3731                 ns_focus (s->f, r, n);
3732                 ns_maybe_dumpglyphs_background (s->next, 1);
3733                 ns_unfocus (s->f);
3734               }
3735             else
3736               {
3737                 ns_dumpglyphs_stretch (s->next);
3738               }
3739             next->num_clips = 0;
3740           }
3741     }
3742
3743   if (!s->for_overlaps && s->face->box != FACE_NO_BOX
3744         && (s->first_glyph->type == CHAR_GLYPH
3745             || s->first_glyph->type == COMPOSITE_GLYPH))
3746     {
3747       n = ns_get_glyph_string_clip_rect (s, r);
3748       ns_focus (s->f, r, n);
3749       ns_maybe_dumpglyphs_background (s, 1);
3750       ns_dumpglyphs_box_or_relief (s);
3751       ns_unfocus (s->f);
3752       box_drawn_p = 1;
3753     }
3754
3755   switch (s->first_glyph->type)
3756     {
3757
3758     case IMAGE_GLYPH:
3759       n = ns_get_glyph_string_clip_rect (s, r);
3760       ns_focus (s->f, r, n);
3761       ns_dumpglyphs_image (s, r[0]);
3762       ns_unfocus (s->f);
3763       break;
3764
3765     case STRETCH_GLYPH:
3766       ns_dumpglyphs_stretch (s);
3767       break;
3768
3769     case CHAR_GLYPH:
3770     case COMPOSITE_GLYPH:
3771       n = ns_get_glyph_string_clip_rect (s, r);
3772       ns_focus (s->f, r, n);
3773
3774       if (s->for_overlaps || (s->cmp_from > 0
3775                               && ! s->first_glyph->u.cmp.automatic))
3776         s->background_filled_p = 1;
3777       else
3778         ns_maybe_dumpglyphs_background
3779           (s, s->first_glyph->type == COMPOSITE_GLYPH);
3780
3781       if (s->hl == DRAW_CURSOR && s->w->phys_cursor_type == FILLED_BOX_CURSOR)
3782         {
3783           unsigned long tmp = NS_FACE_BACKGROUND (s->face);
3784           NS_FACE_BACKGROUND (s->face) = NS_FACE_FOREGROUND (s->face);
3785           NS_FACE_FOREGROUND (s->face) = tmp;
3786         }
3787
3788       {
3789         BOOL isComposite = s->first_glyph->type == COMPOSITE_GLYPH;
3790
3791         if (isComposite)
3792           ns_draw_composite_glyph_string_foreground (s);
3793         else
3794           ns_draw_glyph_string_foreground (s);
3795       }
3796
3797       {
3798         NSColor *col = (NS_FACE_FOREGROUND (s->face) != 0
3799                         ? ns_lookup_indexed_color (NS_FACE_FOREGROUND (s->face),
3800                                                    s->f)
3801                         : FRAME_FOREGROUND_COLOR (s->f));
3802         [col set];
3803
3804         /* Draw underline, overline, strike-through. */
3805         ns_draw_text_decoration (s, s->face, col, s->width, s->x);
3806       }
3807
3808       if (s->hl == DRAW_CURSOR && s->w->phys_cursor_type == FILLED_BOX_CURSOR)
3809         {
3810           unsigned long tmp = NS_FACE_BACKGROUND (s->face);
3811           NS_FACE_BACKGROUND (s->face) = NS_FACE_FOREGROUND (s->face);
3812           NS_FACE_FOREGROUND (s->face) = tmp;
3813         }
3814
3815       ns_unfocus (s->f);
3816       break;
3817
3818     case GLYPHLESS_GLYPH:
3819       n = ns_get_glyph_string_clip_rect (s, r);
3820       ns_focus (s->f, r, n);
3821
3822       if (s->for_overlaps || (s->cmp_from > 0
3823                               && ! s->first_glyph->u.cmp.automatic))
3824         s->background_filled_p = 1;
3825       else
3826         ns_maybe_dumpglyphs_background
3827           (s, s->first_glyph->type == COMPOSITE_GLYPH);
3828       /* ... */
3829       /* Not yet implemented.  */
3830       /* ... */
3831       ns_unfocus (s->f);
3832       break;
3833
3834     default:
3835       emacs_abort ();
3836     }
3837
3838   /* Draw box if not done already. */
3839   if (!s->for_overlaps && !box_drawn_p && s->face->box != FACE_NO_BOX)
3840     {
3841       n = ns_get_glyph_string_clip_rect (s, r);
3842       ns_focus (s->f, r, n);
3843       ns_dumpglyphs_box_or_relief (s);
3844       ns_unfocus (s->f);
3845     }
3846
3847   s->num_clips = 0;
3848 }
3849
3850
3851
3852 /* ==========================================================================
3853
3854     Event loop
3855
3856    ========================================================================== */
3857
3858
3859 static void
3860 ns_send_appdefined (int value)
3861 /* --------------------------------------------------------------------------
3862     Internal: post an appdefined event which EmacsApp-sendEvent will
3863               recognize and take as a command to halt the event loop.
3864    -------------------------------------------------------------------------- */
3865 {
3866   NSTRACE_WHEN (NSTRACE_GROUP_EVENTS, "ns_send_appdefined(%d)", value);
3867
3868   // GNUstep needs postEvent to happen on the main thread.
3869   // Cocoa needs nextEventMatchingMask to happen on the main thread too.
3870   if (! [[NSThread currentThread] isMainThread])
3871     {
3872       EmacsApp *app = (EmacsApp *)NSApp;
3873       app->nextappdefined = value;
3874       [app performSelectorOnMainThread:@selector (sendFromMainThread:)
3875                             withObject:nil
3876                          waitUntilDone:YES];
3877       return;
3878     }
3879
3880   /* Only post this event if we haven't already posted one.  This will end
3881        the [NXApp run] main loop after having processed all events queued at
3882        this moment.  */
3883
3884 #ifdef NS_IMPL_COCOA
3885   if (! send_appdefined)
3886     {
3887       /* OS X 10.10.1 swallows the AppDefined event we are sending ourselves
3888          in certain situations (rapid incoming events).
3889          So check if we have one, if not add one.  */
3890       NSEvent *appev = [NSApp nextEventMatchingMask:NSEventMaskApplicationDefined
3891                                           untilDate:[NSDate distantPast]
3892                                              inMode:NSDefaultRunLoopMode
3893                                             dequeue:NO];
3894       if (! appev) send_appdefined = YES;
3895     }
3896 #endif
3897
3898   if (send_appdefined)
3899     {
3900       NSEvent *nxev;
3901
3902       /* We only need one NX_APPDEFINED event to stop NXApp from running.  */
3903       send_appdefined = NO;
3904
3905       /* Don't need wakeup timer any more */
3906       if (timed_entry)
3907         {
3908           [timed_entry invalidate];
3909           [timed_entry release];
3910           timed_entry = nil;
3911         }
3912
3913       nxev = [NSEvent otherEventWithType: NSEventTypeApplicationDefined
3914                                 location: NSMakePoint (0, 0)
3915                            modifierFlags: 0
3916                                timestamp: 0
3917                             windowNumber: [[NSApp mainWindow] windowNumber]
3918                                  context: [NSApp context]
3919                                  subtype: 0
3920                                    data1: value
3921                                    data2: 0];
3922
3923       /* Post an application defined event on the event queue.  When this is
3924          received the [NXApp run] will return, thus having processed all
3925          events which are currently queued.  */
3926       [NSApp postEvent: nxev atStart: NO];
3927     }
3928 }
3929
3930 #ifdef HAVE_NATIVE_FS
3931 static void
3932 check_native_fs ()
3933 {
3934   Lisp_Object frame, tail;
3935
3936   if (ns_last_use_native_fullscreen == ns_use_native_fullscreen)
3937     return;
3938
3939   ns_last_use_native_fullscreen = ns_use_native_fullscreen;
3940
3941   FOR_EACH_FRAME (tail, frame)
3942     {
3943       struct frame *f = XFRAME (frame);
3944       if (FRAME_NS_P (f))
3945         {
3946           EmacsView *view = FRAME_NS_VIEW (f);
3947           [view updateCollectionBehavior];
3948         }
3949     }
3950 }
3951 #endif
3952
3953 /* GNUstep does not have cancelTracking.  */
3954 #ifdef NS_IMPL_COCOA
3955 /* Check if menu open should be canceled or continued as normal.  */
3956 void
3957 ns_check_menu_open (NSMenu *menu)
3958 {
3959   /* Click in menu bar? */
3960   NSArray *a = [[NSApp mainMenu] itemArray];
3961   int i;
3962   BOOL found = NO;
3963
3964   if (menu == nil) // Menu tracking ended.
3965     {
3966       if (menu_will_open_state == MENU_OPENING)
3967         menu_will_open_state = MENU_NONE;
3968       return;
3969     }
3970
3971   for (i = 0; ! found && i < [a count]; i++)
3972     found = menu == [[a objectAtIndex:i] submenu];
3973   if (found)
3974     {
3975       if (menu_will_open_state == MENU_NONE && emacs_event)
3976         {
3977           NSEvent *theEvent = [NSApp currentEvent];
3978           struct frame *emacsframe = SELECTED_FRAME ();
3979
3980           [menu cancelTracking];
3981           menu_will_open_state = MENU_PENDING;
3982           emacs_event->kind = MENU_BAR_ACTIVATE_EVENT;
3983           EV_TRAILER (theEvent);
3984
3985           CGEventRef ourEvent = CGEventCreate (NULL);
3986           menu_mouse_point = CGEventGetLocation (ourEvent);
3987           CFRelease (ourEvent);
3988         }
3989       else if (menu_will_open_state == MENU_OPENING)
3990         {
3991           menu_will_open_state = MENU_NONE;
3992         }
3993     }
3994 }
3995
3996 /* Redo saved menu click if state is MENU_PENDING.  */
3997 void
3998 ns_check_pending_open_menu ()
3999 {
4000   if (menu_will_open_state == MENU_PENDING)
4001     {
4002       CGEventSourceRef source
4003         = CGEventSourceCreate (kCGEventSourceStateHIDSystemState);
4004
4005       CGEventRef event = CGEventCreateMouseEvent (source,
4006                                                   kCGEventLeftMouseDown,
4007                                                   menu_mouse_point,
4008                                                   kCGMouseButtonLeft);
4009       CGEventSetType (event, kCGEventLeftMouseDown);
4010       CGEventPost (kCGHIDEventTap, event);
4011       CFRelease (event);
4012       CFRelease (source);
4013
4014       menu_will_open_state = MENU_OPENING;
4015     }
4016 }
4017 #endif /* NS_IMPL_COCOA */
4018
4019 static int
4020 ns_read_socket (struct terminal *terminal, struct input_event *hold_quit)
4021 /* --------------------------------------------------------------------------
4022      External (hook): Post an event to ourself and keep reading events until
4023      we read it back again.  In effect process all events which were waiting.
4024      From 21+ we have to manage the event buffer ourselves.
4025    -------------------------------------------------------------------------- */
4026 {
4027   struct input_event ev;
4028   int nevents;
4029
4030   NSTRACE_WHEN (NSTRACE_GROUP_EVENTS, "ns_read_socket");
4031
4032 #ifdef HAVE_NATIVE_FS
4033   check_native_fs ();
4034 #endif
4035
4036   if ([NSApp modalWindow] != nil)
4037     return -1;
4038
4039   if (hold_event_q.nr > 0)
4040     {
4041       int i;
4042       for (i = 0; i < hold_event_q.nr; ++i)
4043         kbd_buffer_store_event_hold (&hold_event_q.q[i], hold_quit);
4044       hold_event_q.nr = 0;
4045       return i;
4046     }
4047
4048   if ([NSThread isMainThread])
4049     {
4050       block_input ();
4051       n_emacs_events_pending = 0;
4052       ns_init_events (&ev);
4053       q_event_ptr = hold_quit;
4054
4055       /* we manage autorelease pools by allocate/reallocate each time around
4056          the loop; strict nesting is occasionally violated but seems not to
4057          matter.. earlier methods using full nesting caused major memory leaks */
4058       [outerpool release];
4059       outerpool = [[NSAutoreleasePool alloc] init];
4060
4061       /* If have pending open-file requests, attend to the next one of those. */
4062       if (ns_pending_files && [ns_pending_files count] != 0
4063           && [(EmacsApp *)NSApp openFile: [ns_pending_files objectAtIndex: 0]])
4064         {
4065           [ns_pending_files removeObjectAtIndex: 0];
4066         }
4067       /* Deal with pending service requests. */
4068       else if (ns_pending_service_names && [ns_pending_service_names count] != 0
4069                && [(EmacsApp *)
4070                     NSApp fulfillService: [ns_pending_service_names objectAtIndex: 0]
4071                                  withArg: [ns_pending_service_args objectAtIndex: 0]])
4072         {
4073           [ns_pending_service_names removeObjectAtIndex: 0];
4074           [ns_pending_service_args removeObjectAtIndex: 0];
4075         }
4076       else
4077         {
4078           ptrdiff_t specpdl_count = SPECPDL_INDEX ();
4079           /* Run and wait for events.  We must always send one NX_APPDEFINED event
4080              to ourself, otherwise [NXApp run] will never exit.  */
4081           send_appdefined = YES;
4082           ns_send_appdefined (-1);
4083
4084           [NSApp run];
4085         }
4086
4087       nevents = n_emacs_events_pending;
4088       n_emacs_events_pending = 0;
4089       ns_finish_events ();
4090       q_event_ptr = NULL;
4091       unblock_input ();
4092     }
4093
4094   return nevents;
4095 }
4096
4097
4098 int
4099 ns_select (int nfds, fd_set *readfds, fd_set *writefds,
4100            fd_set *exceptfds, struct timespec const *timeout,
4101            sigset_t const *sigmask)
4102 /* --------------------------------------------------------------------------
4103      Replacement for select, checking for events
4104    -------------------------------------------------------------------------- */
4105 {
4106   int result;
4107   int t, k, nr = 0;
4108   struct input_event event;
4109   char c;
4110
4111   NSTRACE_WHEN (NSTRACE_GROUP_EVENTS, "ns_select");
4112
4113 #ifdef HAVE_NATIVE_FS
4114   check_native_fs ();
4115 #endif
4116
4117   if (hold_event_q.nr > 0)
4118     {
4119       /* We already have events pending. */
4120       raise (SIGIO);
4121       errno = EINTR;
4122       return -1;
4123     }
4124
4125   for (k = 0; k < nfds+1; k++)
4126     {
4127       if (readfds && FD_ISSET(k, readfds)) ++nr;
4128       if (writefds && FD_ISSET(k, writefds)) ++nr;
4129     }
4130
4131   if (NSApp == nil
4132       || ![NSThread isMainThread]
4133       || (timeout && timeout->tv_sec == 0 && timeout->tv_nsec == 0))
4134     return pselect (nfds, readfds, writefds, exceptfds, timeout, sigmask);
4135
4136   [outerpool release];
4137   outerpool = [[NSAutoreleasePool alloc] init];
4138
4139
4140   send_appdefined = YES;
4141   if (nr > 0)
4142     {
4143       pthread_mutex_lock (&select_mutex);
4144       select_nfds = nfds;
4145       select_valid = 0;
4146       if (readfds)
4147         {
4148           select_readfds = *readfds;
4149           select_valid += SELECT_HAVE_READ;
4150         }
4151       if (writefds)
4152         {
4153           select_writefds = *writefds;
4154           select_valid += SELECT_HAVE_WRITE;
4155         }
4156
4157       if (timeout)
4158         {
4159           select_timeout = *timeout;
4160           select_valid += SELECT_HAVE_TMO;
4161         }
4162
4163       pthread_mutex_unlock (&select_mutex);
4164
4165       /* Inform fd_handler that select should be called */
4166       c = 'g';
4167       emacs_write_sig (selfds[1], &c, 1);
4168     }
4169   else if (nr == 0 && timeout)
4170     {
4171       /* No file descriptor, just a timeout, no need to wake fd_handler  */
4172       double time = timespectod (*timeout);
4173       timed_entry = [[NSTimer scheduledTimerWithTimeInterval: time
4174                                                       target: NSApp
4175                                                     selector:
4176                                   @selector (timeout_handler:)
4177                                                     userInfo: 0
4178                                                      repeats: NO]
4179                       retain];
4180     }
4181   else /* No timeout and no file descriptors, can this happen?  */
4182     {
4183       /* Send appdefined so we exit from the loop */
4184       ns_send_appdefined (-1);
4185     }
4186
4187   block_input ();
4188   ns_init_events (&event);
4189
4190   [NSApp run];
4191
4192   ns_finish_events ();
4193   if (nr > 0 && readfds)
4194     {
4195       c = 's';
4196       emacs_write_sig (selfds[1], &c, 1);
4197     }
4198   unblock_input ();
4199
4200   t = last_appdefined_event_data;
4201
4202   if (t != NO_APPDEFINED_DATA)
4203     {
4204       last_appdefined_event_data = NO_APPDEFINED_DATA;
4205
4206       if (t == -2)
4207         {
4208           /* The NX_APPDEFINED event we received was a timeout. */
4209           result = 0;
4210         }
4211       else if (t == -1)
4212         {
4213           /* The NX_APPDEFINED event we received was the result of
4214              at least one real input event arriving.  */
4215           errno = EINTR;
4216           result = -1;
4217         }
4218       else
4219         {
4220           /* Received back from select () in fd_handler; copy the results */
4221           pthread_mutex_lock (&select_mutex);
4222           if (readfds) *readfds = select_readfds;
4223           if (writefds) *writefds = select_writefds;
4224           pthread_mutex_unlock (&select_mutex);
4225           result = t;
4226         }
4227     }
4228   else
4229     {
4230       errno = EINTR;
4231       result = -1;
4232     }
4233
4234   return result;
4235 }
4236
4237
4238
4239 /* ==========================================================================
4240
4241     Scrollbar handling
4242
4243    ========================================================================== */
4244
4245
4246 static void
4247 ns_set_vertical_scroll_bar (struct window *window,
4248                            int portion, int whole, int position)
4249 /* --------------------------------------------------------------------------
4250       External (hook): Update or add scrollbar
4251    -------------------------------------------------------------------------- */
4252 {
4253   Lisp_Object win;
4254   NSRect r, v;
4255   struct frame *f = XFRAME (WINDOW_FRAME (window));
4256   EmacsView *view = FRAME_NS_VIEW (f);
4257   EmacsScroller *bar;
4258   int window_y, window_height;
4259   int top, left, height, width;
4260   BOOL update_p = YES;
4261
4262   /* optimization; display engine sends WAY too many of these.. */
4263   if (!NILP (window->vertical_scroll_bar))
4264     {
4265       bar = XNS_SCROLL_BAR (window->vertical_scroll_bar);
4266       if ([bar checkSamePosition: position portion: portion whole: whole])
4267         {
4268           if (view->scrollbarsNeedingUpdate == 0)
4269             {
4270               if (!windows_or_buffers_changed)
4271                   return;
4272             }
4273           else
4274             view->scrollbarsNeedingUpdate--;
4275           update_p = NO;
4276         }
4277     }
4278
4279   NSTRACE ("ns_set_vertical_scroll_bar");
4280
4281   /* Get dimensions.  */
4282   window_box (window, ANY_AREA, 0, &window_y, 0, &window_height);
4283   top = window_y;
4284   height = window_height;
4285   width = NS_SCROLL_BAR_WIDTH (f);
4286   left = WINDOW_SCROLL_BAR_AREA_X (window);
4287
4288   r = NSMakeRect (left, top, width, height);
4289   /* the parent view is flipped, so we need to flip y value */
4290   v = [view frame];
4291   r.origin.y = (v.size.height - r.size.height - r.origin.y);
4292
4293   XSETWINDOW (win, window);
4294   block_input ();
4295
4296   /* we want at least 5 lines to display a scrollbar */
4297   if (WINDOW_TOTAL_LINES (window) < 5)
4298     {
4299       if (!NILP (window->vertical_scroll_bar))
4300         {
4301           bar = XNS_SCROLL_BAR (window->vertical_scroll_bar);
4302           [bar removeFromSuperview];
4303           wset_vertical_scroll_bar (window, Qnil);
4304           [bar release];
4305         }
4306       ns_clear_frame_area (f, left, top, width, height);
4307       unblock_input ();
4308       return;
4309     }
4310
4311   if (NILP (window->vertical_scroll_bar))
4312     {
4313       if (width > 0 && height > 0)
4314         ns_clear_frame_area (f, left, top, width, height);
4315
4316       bar = [[EmacsScroller alloc] initFrame: r window: win];
4317       wset_vertical_scroll_bar (window, make_save_ptr (bar));
4318       update_p = YES;
4319     }
4320   else
4321     {
4322       NSRect oldRect;
4323       bar = XNS_SCROLL_BAR (window->vertical_scroll_bar);
4324       oldRect = [bar frame];
4325       r.size.width = oldRect.size.width;
4326       if (FRAME_LIVE_P (f) && !NSEqualRects (oldRect, r))
4327         {
4328           if (oldRect.origin.x != r.origin.x)
4329               ns_clear_frame_area (f, left, top, width, height);
4330           [bar setFrame: r];
4331         }
4332     }
4333
4334   if (update_p)
4335     [bar setPosition: position portion: portion whole: whole];
4336   unblock_input ();
4337 }
4338
4339
4340 static void
4341 ns_set_horizontal_scroll_bar (struct window *window,
4342                               int portion, int whole, int position)
4343 /* --------------------------------------------------------------------------
4344       External (hook): Update or add scrollbar
4345    -------------------------------------------------------------------------- */
4346 {
4347   Lisp_Object win;
4348   NSRect r, v;
4349   struct frame *f = XFRAME (WINDOW_FRAME (window));
4350   EmacsView *view = FRAME_NS_VIEW (f);
4351   EmacsScroller *bar;
4352   int top, height, left, width;
4353   int window_x, window_width;
4354   BOOL update_p = YES;
4355
4356   /* optimization; display engine sends WAY too many of these.. */
4357   if (!NILP (window->horizontal_scroll_bar))
4358     {
4359       bar = XNS_SCROLL_BAR (window->horizontal_scroll_bar);
4360       if ([bar checkSamePosition: position portion: portion whole: whole])
4361         {
4362           if (view->scrollbarsNeedingUpdate == 0)
4363             {
4364               if (!windows_or_buffers_changed)
4365                   return;
4366             }
4367           else
4368             view->scrollbarsNeedingUpdate--;
4369           update_p = NO;
4370         }
4371     }
4372
4373   NSTRACE ("ns_set_horizontal_scroll_bar");
4374
4375   /* Get dimensions.  */
4376   window_box (window, ANY_AREA, &window_x, 0, &window_width, 0);
4377   left = window_x;
4378   width = window_width;
4379   height = NS_SCROLL_BAR_HEIGHT (f);
4380   top = WINDOW_SCROLL_BAR_AREA_Y (window);
4381
4382   r = NSMakeRect (left, top, width, height);
4383   /* the parent view is flipped, so we need to flip y value */
4384   v = [view frame];
4385   r.origin.y = (v.size.height - r.size.height - r.origin.y);
4386
4387   XSETWINDOW (win, window);
4388   block_input ();
4389
4390   if (NILP (window->horizontal_scroll_bar))
4391     {
4392       if (width > 0 && height > 0)
4393         ns_clear_frame_area (f, left, top, width, height);
4394
4395       bar = [[EmacsScroller alloc] initFrame: r window: win];
4396       wset_horizontal_scroll_bar (window, make_save_ptr (bar));
4397       update_p = YES;
4398     }
4399   else
4400     {
4401       NSRect oldRect;
4402       bar = XNS_SCROLL_BAR (window->horizontal_scroll_bar);
4403       oldRect = [bar frame];
4404       if (FRAME_LIVE_P (f) && !NSEqualRects (oldRect, r))
4405         {
4406           if (oldRect.origin.y != r.origin.y)
4407             ns_clear_frame_area (f, left, top, width, height);
4408           [bar setFrame: r];
4409           update_p = YES;
4410         }
4411     }
4412
4413   /* If there are both horizontal and vertical scroll-bars they leave
4414      a square that belongs to neither. We need to clear it otherwise
4415      it fills with junk. */
4416   if (!NILP (window->vertical_scroll_bar))
4417     ns_clear_frame_area (f, WINDOW_SCROLL_BAR_AREA_X (window), top,
4418                          NS_SCROLL_BAR_HEIGHT (f), height);
4419
4420   if (update_p)
4421     [bar setPosition: position portion: portion whole: whole];
4422   unblock_input ();
4423 }
4424
4425
4426 static void
4427 ns_condemn_scroll_bars (struct frame *f)
4428 /* --------------------------------------------------------------------------
4429      External (hook): arrange for all frame's scrollbars to be removed
4430      at next call to judge_scroll_bars, except for those redeemed.
4431    -------------------------------------------------------------------------- */
4432 {
4433   int i;
4434   id view;
4435   NSArray *subviews = [[FRAME_NS_VIEW (f) superview] subviews];
4436
4437   NSTRACE ("ns_condemn_scroll_bars");
4438
4439   for (i =[subviews count]-1; i >= 0; i--)
4440     {
4441       view = [subviews objectAtIndex: i];
4442       if ([view isKindOfClass: [EmacsScroller class]])
4443         [view condemn];
4444     }
4445 }
4446
4447
4448 static void
4449 ns_redeem_scroll_bar (struct window *window)
4450 /* --------------------------------------------------------------------------
4451      External (hook): arrange to spare this window's scrollbar
4452      at next call to judge_scroll_bars.
4453    -------------------------------------------------------------------------- */
4454 {
4455   id bar;
4456   NSTRACE ("ns_redeem_scroll_bar");
4457   if (!NILP (window->vertical_scroll_bar)
4458       && WINDOW_HAS_VERTICAL_SCROLL_BAR (window))
4459     {
4460       bar = XNS_SCROLL_BAR (window->vertical_scroll_bar);
4461       [bar reprieve];
4462     }
4463
4464   if (!NILP (window->horizontal_scroll_bar)
4465       && WINDOW_HAS_HORIZONTAL_SCROLL_BAR (window))
4466     {
4467       bar = XNS_SCROLL_BAR (window->horizontal_scroll_bar);
4468       [bar reprieve];
4469     }
4470 }
4471
4472
4473 static void
4474 ns_judge_scroll_bars (struct frame *f)
4475 /* --------------------------------------------------------------------------
4476      External (hook): destroy all scrollbars on frame that weren't
4477      redeemed after call to condemn_scroll_bars.
4478    -------------------------------------------------------------------------- */
4479 {
4480   int i;
4481   id view;
4482   EmacsView *eview = FRAME_NS_VIEW (f);
4483   NSArray *subviews = [[eview superview] subviews];
4484   BOOL removed = NO;
4485
4486   NSTRACE ("ns_judge_scroll_bars");
4487   for (i = [subviews count]-1; i >= 0; --i)
4488     {
4489       view = [subviews objectAtIndex: i];
4490       if (![view isKindOfClass: [EmacsScroller class]]) continue;
4491       if ([view judge])
4492         removed = YES;
4493     }
4494
4495   if (removed)
4496     [eview updateFrameSize: NO];
4497 }
4498
4499 /* ==========================================================================
4500
4501     Initialization
4502
4503    ========================================================================== */
4504
4505 int
4506 x_display_pixel_height (struct ns_display_info *dpyinfo)
4507 {
4508   NSArray *screens = [NSScreen screens];
4509   NSEnumerator *enumerator = [screens objectEnumerator];
4510   NSScreen *screen;
4511   NSRect frame;
4512
4513   frame = NSZeroRect;
4514   while ((screen = [enumerator nextObject]) != nil)
4515     frame = NSUnionRect (frame, [screen frame]);
4516
4517   return NSHeight (frame);
4518 }
4519
4520 int
4521 x_display_pixel_width (struct ns_display_info *dpyinfo)
4522 {
4523   NSArray *screens = [NSScreen screens];
4524   NSEnumerator *enumerator = [screens objectEnumerator];
4525   NSScreen *screen;
4526   NSRect frame;
4527
4528   frame = NSZeroRect;
4529   while ((screen = [enumerator nextObject]) != nil)
4530     frame = NSUnionRect (frame, [screen frame]);
4531
4532   return NSWidth (frame);
4533 }
4534
4535
4536 static Lisp_Object ns_string_to_lispmod (const char *s)
4537 /* --------------------------------------------------------------------------
4538      Convert modifier name to lisp symbol
4539    -------------------------------------------------------------------------- */
4540 {
4541   if (!strncmp (SSDATA (SYMBOL_NAME (Qmeta)), s, 10))
4542     return Qmeta;
4543   else if (!strncmp (SSDATA (SYMBOL_NAME (Qsuper)), s, 10))
4544     return Qsuper;
4545   else if (!strncmp (SSDATA (SYMBOL_NAME (Qcontrol)), s, 10))
4546     return Qcontrol;
4547   else if (!strncmp (SSDATA (SYMBOL_NAME (Qalt)), s, 10))
4548     return Qalt;
4549   else if (!strncmp (SSDATA (SYMBOL_NAME (Qhyper)), s, 10))
4550     return Qhyper;
4551   else if (!strncmp (SSDATA (SYMBOL_NAME (Qnone)), s, 10))
4552     return Qnone;
4553   else
4554     return Qnil;
4555 }
4556
4557
4558 static void
4559 ns_default (const char *parameter, Lisp_Object *result,
4560            Lisp_Object yesval, Lisp_Object noval,
4561            BOOL is_float, BOOL is_modstring)
4562 /* --------------------------------------------------------------------------
4563       Check a parameter value in user's preferences
4564    -------------------------------------------------------------------------- */
4565 {
4566   const char *value = ns_get_defaults_value (parameter);
4567
4568   if (value)
4569     {
4570       double f;
4571       char *pos;
4572       if (c_strcasecmp (value, "YES") == 0)
4573         *result = yesval;
4574       else if (c_strcasecmp (value, "NO") == 0)
4575         *result = noval;
4576       else if (is_float && (f = strtod (value, &pos), pos != value))
4577         *result = make_float (f);
4578       else if (is_modstring && value)
4579         *result = ns_string_to_lispmod (value);
4580       else fprintf (stderr,
4581                    "Bad value for default \"%s\": \"%s\"\n", parameter, value);
4582     }
4583 }
4584
4585
4586 static void
4587 ns_initialize_display_info (struct ns_display_info *dpyinfo)
4588 /* --------------------------------------------------------------------------
4589       Initialize global info and storage for display.
4590    -------------------------------------------------------------------------- */
4591 {
4592     NSScreen *screen = [NSScreen mainScreen];
4593     NSWindowDepth depth = [screen depth];
4594
4595     dpyinfo->resx = 72.27; /* used 75.0, but this makes pt == pixel, expected */
4596     dpyinfo->resy = 72.27;
4597     dpyinfo->color_p = ![NSDeviceWhiteColorSpace isEqualToString:
4598                                                   NSColorSpaceFromDepth (depth)]
4599                 && ![NSCalibratedWhiteColorSpace isEqualToString:
4600                                                  NSColorSpaceFromDepth (depth)];
4601     dpyinfo->n_planes = NSBitsPerPixelFromDepth (depth);
4602     dpyinfo->color_table = xmalloc (sizeof *dpyinfo->color_table);
4603     dpyinfo->color_table->colors = NULL;
4604     dpyinfo->root_window = 42; /* a placeholder.. */
4605     dpyinfo->x_highlight_frame = dpyinfo->x_focus_frame = NULL;
4606     dpyinfo->n_fonts = 0;
4607     dpyinfo->smallest_font_height = 1;
4608     dpyinfo->smallest_char_width = 1;
4609
4610     reset_mouse_highlight (&dpyinfo->mouse_highlight);
4611 }
4612
4613
4614 /* This and next define (many of the) public functions in this file. */
4615 /* x_... are generic versions in xdisp.c that we, and other terms, get away
4616          with using despite presence in the "system dependent" redisplay
4617          interface.  In addition, many of the ns_ methods have code that is
4618          shared with all terms, indicating need for further refactoring. */
4619 extern frame_parm_handler ns_frame_parm_handlers[];
4620 static struct redisplay_interface ns_redisplay_interface =
4621 {
4622   ns_frame_parm_handlers,
4623   x_produce_glyphs,
4624   x_write_glyphs,
4625   x_insert_glyphs,
4626   x_clear_end_of_line,
4627   ns_scroll_run,
4628   ns_after_update_window_line,
4629   ns_update_window_begin,
4630   ns_update_window_end,
4631   0, /* flush_display */
4632   x_clear_window_mouse_face,
4633   x_get_glyph_overhangs,
4634   x_fix_overlapping_area,
4635   ns_draw_fringe_bitmap,
4636   0, /* define_fringe_bitmap */ /* FIXME: simplify ns_draw_fringe_bitmap */
4637   0, /* destroy_fringe_bitmap */
4638   ns_compute_glyph_string_overhangs,
4639   ns_draw_glyph_string,
4640   ns_define_frame_cursor,
4641   ns_clear_frame_area,
4642   ns_draw_window_cursor,
4643   ns_draw_vertical_window_border,
4644   ns_draw_window_divider,
4645   ns_shift_glyphs_for_insert,
4646   ns_show_hourglass,
4647   ns_hide_hourglass
4648 };
4649
4650
4651 static void
4652 ns_delete_display (struct ns_display_info *dpyinfo)
4653 {
4654   /* TODO... */
4655 }
4656
4657
4658 /* This function is called when the last frame on a display is deleted. */
4659 static void
4660 ns_delete_terminal (struct terminal *terminal)
4661 {
4662   struct ns_display_info *dpyinfo = terminal->display_info.ns;
4663
4664   NSTRACE ("ns_delete_terminal");
4665
4666   /* Protect against recursive calls.  delete_frame in
4667      delete_terminal calls us back when it deletes our last frame.  */
4668   if (!terminal->name)
4669     return;
4670
4671   block_input ();
4672
4673   x_destroy_all_bitmaps (dpyinfo);
4674   ns_delete_display (dpyinfo);
4675   unblock_input ();
4676 }
4677
4678
4679 static struct terminal *
4680 ns_create_terminal (struct ns_display_info *dpyinfo)
4681 /* --------------------------------------------------------------------------
4682       Set up use of NS before we make the first connection.
4683    -------------------------------------------------------------------------- */
4684 {
4685   struct terminal *terminal;
4686
4687   NSTRACE ("ns_create_terminal");
4688
4689   terminal = create_terminal (output_ns, &ns_redisplay_interface);
4690
4691   terminal->display_info.ns = dpyinfo;
4692   dpyinfo->terminal = terminal;
4693
4694   terminal->clear_frame_hook = ns_clear_frame;
4695   terminal->ring_bell_hook = ns_ring_bell;
4696   terminal->update_begin_hook = ns_update_begin;
4697   terminal->update_end_hook = ns_update_end;
4698   terminal->read_socket_hook = ns_read_socket;
4699   terminal->frame_up_to_date_hook = ns_frame_up_to_date;
4700   terminal->mouse_position_hook = ns_mouse_position;
4701   terminal->frame_rehighlight_hook = ns_frame_rehighlight;
4702   terminal->frame_raise_lower_hook = ns_frame_raise_lower;
4703   terminal->fullscreen_hook = ns_fullscreen_hook;
4704   terminal->menu_show_hook = ns_menu_show;
4705   terminal->popup_dialog_hook = ns_popup_dialog;
4706   terminal->set_vertical_scroll_bar_hook = ns_set_vertical_scroll_bar;
4707   terminal->set_horizontal_scroll_bar_hook = ns_set_horizontal_scroll_bar;
4708   terminal->condemn_scroll_bars_hook = ns_condemn_scroll_bars;
4709   terminal->redeem_scroll_bar_hook = ns_redeem_scroll_bar;
4710   terminal->judge_scroll_bars_hook = ns_judge_scroll_bars;
4711   terminal->delete_frame_hook = x_destroy_window;
4712   terminal->delete_terminal_hook = ns_delete_terminal;
4713   /* Other hooks are NULL by default.  */
4714
4715   return terminal;
4716 }
4717
4718
4719 struct ns_display_info *
4720 ns_term_init (Lisp_Object display_name)
4721 /* --------------------------------------------------------------------------
4722      Start the Application and get things rolling.
4723    -------------------------------------------------------------------------- */
4724 {
4725   struct terminal *terminal;
4726   struct ns_display_info *dpyinfo;
4727   static int ns_initialized = 0;
4728   Lisp_Object tmp;
4729
4730   if (ns_initialized) return x_display_list;
4731   ns_initialized = 1;
4732
4733   block_input ();
4734
4735   NSTRACE ("ns_term_init");
4736
4737   [outerpool release];
4738   outerpool = [[NSAutoreleasePool alloc] init];
4739
4740   /* count object allocs (About, click icon); on macOS use ObjectAlloc tool */
4741   /*GSDebugAllocationActive (YES); */
4742   block_input ();
4743
4744   baud_rate = 38400;
4745   Fset_input_interrupt_mode (Qnil);
4746
4747   if (selfds[0] == -1)
4748     {
4749       if (emacs_pipe (selfds) != 0)
4750         {
4751           fprintf (stderr, "Failed to create pipe: %s\n",
4752                    emacs_strerror (errno));
4753           emacs_abort ();
4754         }
4755
4756       fcntl (selfds[0], F_SETFL, O_NONBLOCK|fcntl (selfds[0], F_GETFL));
4757       FD_ZERO (&select_readfds);
4758       FD_ZERO (&select_writefds);
4759       pthread_mutex_init (&select_mutex, NULL);
4760     }
4761
4762   ns_pending_files = [[NSMutableArray alloc] init];
4763   ns_pending_service_names = [[NSMutableArray alloc] init];
4764   ns_pending_service_args = [[NSMutableArray alloc] init];
4765
4766 /* Start app and create the main menu, window, view.
4767      Needs to be here because ns_initialize_display_info () uses AppKit classes.
4768      The view will then ask the NSApp to stop and return to Emacs. */
4769   [EmacsApp sharedApplication];
4770   if (NSApp == nil)
4771     return NULL;
4772   [NSApp setDelegate: NSApp];
4773
4774   /* Start the select thread.  */
4775   [NSThread detachNewThreadSelector:@selector (fd_handler:)
4776                            toTarget:NSApp
4777                          withObject:nil];
4778
4779   /* debugging: log all notifications */
4780   /*   [[NSNotificationCenter defaultCenter] addObserver: NSApp
4781                                          selector: @selector (logNotification:)
4782                                              name: nil object: nil]; */
4783
4784   dpyinfo = xzalloc (sizeof *dpyinfo);
4785
4786   ns_initialize_display_info (dpyinfo);
4787   terminal = ns_create_terminal (dpyinfo);
4788
4789   terminal->kboard = allocate_kboard (Qns);
4790   /* Don't let the initial kboard remain current longer than necessary.
4791      That would cause problems if a file loaded on startup tries to
4792      prompt in the mini-buffer.  */
4793   if (current_kboard == initial_kboard)
4794     current_kboard = terminal->kboard;
4795   terminal->kboard->reference_count++;
4796
4797   dpyinfo->next = x_display_list;
4798   x_display_list = dpyinfo;
4799
4800   dpyinfo->name_list_element = Fcons (display_name, Qnil);
4801
4802   terminal->name = xlispstrdup (display_name);
4803
4804   unblock_input ();
4805
4806   if (!inhibit_x_resources)
4807     {
4808       ns_default ("GSFontAntiAlias", &ns_antialias_text,
4809                  Qt, Qnil, NO, NO);
4810       tmp = Qnil;
4811       /* this is a standard variable */
4812       ns_default ("AppleAntiAliasingThreshold", &tmp,
4813                  make_float (10.0), make_float (6.0), YES, NO);
4814       ns_antialias_threshold = NILP (tmp) ? 10.0 : extract_float (tmp);
4815     }
4816
4817   NSTRACE_MSG ("Colors");
4818
4819   {
4820     NSColorList *cl = [NSColorList colorListNamed: @"Emacs"];
4821
4822     if ( cl == nil )
4823       {
4824         Lisp_Object color_file, color_map, color;
4825         unsigned long c;
4826         char *name;
4827
4828         color_file = Fexpand_file_name (build_string ("rgb.txt"),
4829                          Fsymbol_value (intern ("data-directory")));
4830
4831         color_map = Fx_load_color_file (color_file);
4832         if (NILP (color_map))
4833           fatal ("Could not read %s.\n", SDATA (color_file));
4834
4835         cl = [[NSColorList alloc] initWithName: @"Emacs"];
4836         for ( ; CONSP (color_map); color_map = XCDR (color_map))
4837           {
4838             color = XCAR (color_map);
4839             name = SSDATA (XCAR (color));
4840             c = XINT (XCDR (color));
4841             [cl setColor:
4842                   [NSColor colorForEmacsRed: RED_FROM_ULONG (c) / 255.0
4843                                       green: GREEN_FROM_ULONG (c) / 255.0
4844                                        blue: BLUE_FROM_ULONG (c) / 255.0
4845                                       alpha: 1.0]
4846                   forKey: [NSString stringWithUTF8String: name]];
4847           }
4848         [cl writeToFile: nil];
4849       }
4850   }
4851
4852   NSTRACE_MSG ("Versions");
4853
4854   {
4855 #ifdef NS_IMPL_GNUSTEP
4856     Vwindow_system_version = build_string (gnustep_base_version);
4857 #else
4858     /*PSnextrelease (128, c); */
4859     char c[DBL_BUFSIZE_BOUND];
4860     int len = dtoastr (c, sizeof c, 0, 0, NSAppKitVersionNumber);
4861     Vwindow_system_version = make_unibyte_string (c, len);
4862 #endif
4863   }
4864
4865   delete_keyboard_wait_descriptor (0);
4866
4867   ns_app_name = [[NSProcessInfo processInfo] processName];
4868
4869   /* Set up macOS app menu */
4870
4871   NSTRACE_MSG ("Menu init");
4872
4873 #ifdef NS_IMPL_COCOA
4874   {
4875     NSMenu *appMenu;
4876     NSMenuItem *item;
4877     /* set up the application menu */
4878     svcsMenu = [[EmacsMenu alloc] initWithTitle: @"Services"];
4879     [svcsMenu setAutoenablesItems: NO];
4880     appMenu = [[EmacsMenu alloc] initWithTitle: @"Emacs"];
4881     [appMenu setAutoenablesItems: NO];
4882     mainMenu = [[EmacsMenu alloc] initWithTitle: @""];
4883     dockMenu = [[EmacsMenu alloc] initWithTitle: @""];
4884
4885     [appMenu insertItemWithTitle: @"About Emacs"
4886                           action: @selector (orderFrontStandardAboutPanel:)
4887                    keyEquivalent: @""
4888                          atIndex: 0];
4889     [appMenu insertItem: [NSMenuItem separatorItem] atIndex: 1];
4890     [appMenu insertItemWithTitle: @"Preferences..."
4891                           action: @selector (showPreferencesWindow:)
4892                    keyEquivalent: @","
4893                          atIndex: 2];
4894     [appMenu insertItem: [NSMenuItem separatorItem] atIndex: 3];
4895     item = [appMenu insertItemWithTitle: @"Services"
4896                                  action: @selector (menuDown:)
4897                           keyEquivalent: @""
4898                                 atIndex: 4];
4899     [appMenu setSubmenu: svcsMenu forItem: item];
4900     [appMenu insertItem: [NSMenuItem separatorItem] atIndex: 5];
4901     [appMenu insertItemWithTitle: @"Hide Emacs"
4902                           action: @selector (hide:)
4903                    keyEquivalent: @"h"
4904                          atIndex: 6];
4905     item =  [appMenu insertItemWithTitle: @"Hide Others"
4906                           action: @selector (hideOtherApplications:)
4907                    keyEquivalent: @"h"
4908                          atIndex: 7];
4909     [item setKeyEquivalentModifierMask: NSEventModifierFlagCommand | NSEventModifierFlagOption];
4910     [appMenu insertItem: [NSMenuItem separatorItem] atIndex: 8];
4911     [appMenu insertItemWithTitle: @"Quit Emacs"
4912                           action: @selector (terminate:)
4913                    keyEquivalent: @"q"
4914                          atIndex: 9];
4915
4916     item = [mainMenu insertItemWithTitle: ns_app_name
4917                                   action: @selector (menuDown:)
4918                            keyEquivalent: @""
4919                                  atIndex: 0];
4920     [mainMenu setSubmenu: appMenu forItem: item];
4921     [dockMenu insertItemWithTitle: @"New Frame"
4922                            action: @selector (newFrame:)
4923                     keyEquivalent: @""
4924                           atIndex: 0];
4925
4926     [NSApp setMainMenu: mainMenu];
4927     [NSApp setAppleMenu: appMenu];
4928     [NSApp setServicesMenu: svcsMenu];
4929     /* Needed at least on Cocoa, to get dock menu to show windows */
4930     [NSApp setWindowsMenu: [[NSMenu alloc] init]];
4931
4932     [[NSNotificationCenter defaultCenter]
4933       addObserver: mainMenu
4934          selector: @selector (trackingNotification:)
4935              name: NSMenuDidBeginTrackingNotification object: mainMenu];
4936     [[NSNotificationCenter defaultCenter]
4937       addObserver: mainMenu
4938          selector: @selector (trackingNotification:)
4939              name: NSMenuDidEndTrackingNotification object: mainMenu];
4940   }
4941 #endif /* macOS menu setup */
4942
4943   /* Register our external input/output types, used for determining
4944      applicable services and also drag/drop eligibility. */
4945
4946   NSTRACE_MSG ("Input/output types");
4947
4948   ns_send_types = [[NSArray arrayWithObjects: NSStringPboardType, nil] retain];
4949   ns_return_types = [[NSArray arrayWithObjects: NSStringPboardType, nil]
4950                       retain];
4951   ns_drag_types = [[NSArray arrayWithObjects:
4952                             NSStringPboardType,
4953                             NSTabularTextPboardType,
4954                             NSFilenamesPboardType,
4955                             NSURLPboardType, nil] retain];
4956
4957   /* If fullscreen is in init/default-frame-alist, focus isn't set
4958      right for fullscreen windows, so set this.  */
4959   [NSApp activateIgnoringOtherApps:YES];
4960
4961   NSTRACE_MSG ("Call NSApp run");
4962
4963   [NSApp run];
4964   ns_do_open_file = YES;
4965
4966 #ifdef NS_IMPL_GNUSTEP
4967   /* GNUstep steals SIGCHLD for use in NSTask, but we don't use NSTask.
4968      We must re-catch it so subprocess works.  */
4969   catch_child_signal ();
4970 #endif
4971
4972   NSTRACE_MSG ("ns_term_init done");
4973
4974   unblock_input ();
4975
4976   return dpyinfo;
4977 }
4978
4979
4980 void
4981 ns_term_shutdown (int sig)
4982 {
4983   [[NSUserDefaults standardUserDefaults] synchronize];
4984
4985   /* code not reached in emacs.c after this is called by shut_down_emacs: */
4986   if (STRINGP (Vauto_save_list_file_name))
4987     unlink (SSDATA (Vauto_save_list_file_name));
4988
4989   if (sig == 0 || sig == SIGTERM)
4990     {
4991       [NSApp terminate: NSApp];
4992     }
4993   else // force a stack trace to happen
4994     {
4995       emacs_abort ();
4996     }
4997 }
4998
4999
5000 /* ==========================================================================
5001
5002     EmacsApp implementation
5003
5004    ========================================================================== */
5005
5006
5007 @implementation EmacsApp
5008
5009 - (id)init
5010 {
5011   NSTRACE ("[EmacsApp init]");
5012
5013   if ((self = [super init]))
5014     {
5015 #ifdef NS_IMPL_COCOA
5016       self->isFirst = YES;
5017 #endif
5018 #ifdef NS_IMPL_GNUSTEP
5019       self->applicationDidFinishLaunchingCalled = NO;
5020 #endif
5021     }
5022
5023   return self;
5024 }
5025
5026 #ifdef NS_IMPL_COCOA
5027 - (void)run
5028 {
5029   NSTRACE ("[EmacsApp run]");
5030
5031 #ifndef NSAppKitVersionNumber10_9
5032 #define NSAppKitVersionNumber10_9 1265
5033 #endif
5034
5035     if ((int)NSAppKitVersionNumber != NSAppKitVersionNumber10_9)
5036       {
5037         [super run];
5038         return;
5039       }
5040
5041   NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
5042
5043   if (isFirst) [self finishLaunching];
5044   isFirst = NO;
5045
5046   shouldKeepRunning = YES;
5047   do
5048     {
5049       [pool release];
5050       pool = [[NSAutoreleasePool alloc] init];
5051
5052       NSEvent *event =
5053         [self nextEventMatchingMask:NSEventMaskAny
5054                           untilDate:[NSDate distantFuture]
5055                              inMode:NSDefaultRunLoopMode
5056                             dequeue:YES];
5057
5058       [self sendEvent:event];
5059       [self updateWindows];
5060     } while (shouldKeepRunning);
5061
5062   [pool release];
5063 }
5064
5065 - (void)stop: (id)sender
5066 {
5067   NSTRACE ("[EmacsApp stop:]");
5068
5069     shouldKeepRunning = NO;
5070     // Stop possible dialog also.  Noop if no dialog present.
5071     // The file dialog still leaks 7k - 10k on 10.9 though.
5072     [super stop:sender];
5073 }
5074 #endif /* NS_IMPL_COCOA */
5075
5076 - (void)logNotification: (NSNotification *)notification
5077 {
5078   NSTRACE ("[EmacsApp logNotification:]");
5079
5080   const char *name = [[notification name] UTF8String];
5081   if (!strstr (name, "Update") && !strstr (name, "NSMenu")
5082       && !strstr (name, "WindowNumber"))
5083     NSLog (@"notification: '%@'", [notification name]);
5084 }
5085
5086
5087 - (void)sendEvent: (NSEvent *)theEvent
5088 /* --------------------------------------------------------------------------
5089      Called when NSApp is running for each event received.  Used to stop
5090      the loop when we choose, since there's no way to just run one iteration.
5091    -------------------------------------------------------------------------- */
5092 {
5093   int type = [theEvent type];
5094   NSWindow *window = [theEvent window];
5095
5096   NSTRACE_WHEN (NSTRACE_GROUP_EVENTS, "[EmacsApp sendEvent:]");
5097   NSTRACE_MSG ("Type: %d", type);
5098
5099 #ifdef NS_IMPL_GNUSTEP
5100   // Keyboard events aren't propagated to file dialogs for some reason.
5101   if ([NSApp modalWindow] != nil &&
5102       (type == NSEventTypeKeyDown || type == NSEventTypeKeyUp || type == NSEventTypeFlagsChanged))
5103     {
5104       [[NSApp modalWindow] sendEvent: theEvent];
5105       return;
5106     }
5107 #endif
5108
5109   if (represented_filename != nil && represented_frame)
5110     {
5111       NSString *fstr = represented_filename;
5112       NSView *view = FRAME_NS_VIEW (represented_frame);
5113 #ifdef NS_IMPL_COCOA
5114       /* work around a bug observed on 10.3 and later where
5115          setTitleWithRepresentedFilename does not clear out previous state
5116          if given filename does not exist */
5117       if (! [[NSFileManager defaultManager] fileExistsAtPath: fstr])
5118         [[view window] setRepresentedFilename: @""];
5119 #endif
5120       [[view window] setRepresentedFilename: fstr];
5121       [represented_filename release];
5122       represented_filename = nil;
5123       represented_frame = NULL;
5124     }
5125
5126   if (type == NSEventTypeApplicationDefined)
5127     {
5128       switch ([theEvent data2])
5129         {
5130 #ifdef NS_IMPL_COCOA
5131         case NSAPP_DATA2_RUNASSCRIPT:
5132           ns_run_ascript ();
5133           [self stop: self];
5134           return;
5135 #endif
5136         case NSAPP_DATA2_RUNFILEDIALOG:
5137           ns_run_file_dialog ();
5138           [self stop: self];
5139           return;
5140         }
5141     }
5142
5143   if (type == NSEventTypeCursorUpdate && window == nil)
5144     {
5145       fprintf (stderr, "Dropping external cursor update event.\n");
5146       return;
5147     }
5148
5149   if (type == NSEventTypeApplicationDefined)
5150     {
5151       /* Events posted by ns_send_appdefined interrupt the run loop here.
5152          But, if a modal window is up, an appdefined can still come through,
5153          (e.g., from a makeKeyWindow event) but stopping self also stops the
5154          modal loop. Just defer it until later. */
5155       if ([NSApp modalWindow] == nil)
5156         {
5157           last_appdefined_event_data = [theEvent data1];
5158           [self stop: self];
5159         }
5160       else
5161         {
5162           send_appdefined = YES;
5163         }
5164     }
5165
5166
5167 #ifdef NS_IMPL_COCOA
5168   /* If no dialog and none of our frames have focus and it is a move, skip it.
5169      It is a mouse move in an auxiliary menu, i.e. on the top right on macOS,
5170      such as Wifi, sound, date or similar.
5171      This prevents "spooky" highlighting in the frame under the menu.  */
5172   if (type == NSEventTypeMouseMoved && [NSApp modalWindow] == nil)
5173     {
5174       struct ns_display_info *di;
5175       BOOL has_focus = NO;
5176       for (di = x_display_list; ! has_focus && di; di = di->next)
5177         has_focus = di->x_focus_frame != 0;
5178       if (! has_focus)
5179         return;
5180     }
5181 #endif
5182
5183   NSTRACE_UNSILENCE();
5184
5185   [super sendEvent: theEvent];
5186 }
5187
5188
5189 - (void)showPreferencesWindow: (id)sender
5190 {
5191   struct frame *emacsframe = SELECTED_FRAME ();
5192   NSEvent *theEvent = [NSApp currentEvent];
5193
5194   if (!emacs_event)
5195     return;
5196   emacs_event->kind = NS_NONKEY_EVENT;
5197   emacs_event->code = KEY_NS_SHOW_PREFS;
5198   emacs_event->modifiers = 0;
5199   EV_TRAILER (theEvent);
5200 }
5201
5202
5203 - (void)newFrame: (id)sender
5204 {
5205   NSTRACE ("[EmacsApp newFrame:]");
5206
5207   struct frame *emacsframe = SELECTED_FRAME ();
5208   NSEvent *theEvent = [NSApp currentEvent];
5209
5210   if (!emacs_event)
5211     return;
5212   emacs_event->kind = NS_NONKEY_EVENT;
5213   emacs_event->code = KEY_NS_NEW_FRAME;
5214   emacs_event->modifiers = 0;
5215   EV_TRAILER (theEvent);
5216 }
5217
5218
5219 /* Open a file (used by below, after going into queue read by ns_read_socket) */
5220 - (BOOL) openFile: (NSString *)fileName
5221 {
5222   NSTRACE ("[EmacsApp openFile:]");
5223
5224   struct frame *emacsframe = SELECTED_FRAME ();
5225   NSEvent *theEvent = [NSApp currentEvent];
5226
5227   if (!emacs_event)
5228     return NO;
5229
5230   emacs_event->kind = NS_NONKEY_EVENT;
5231   emacs_event->code = KEY_NS_OPEN_FILE_LINE;
5232   ns_input_file = append2 (ns_input_file, build_string ([fileName UTF8String]));
5233   ns_input_line = Qnil; /* can be start or cons start,end */
5234   emacs_event->modifiers =0;
5235   EV_TRAILER (theEvent);
5236
5237   return YES;
5238 }
5239
5240
5241 /* **************************************************************************
5242
5243       EmacsApp delegate implementation
5244
5245    ************************************************************************** */
5246
5247 - (void)applicationDidFinishLaunching: (NSNotification *)notification
5248 /* --------------------------------------------------------------------------
5249      When application is loaded, terminate event loop in ns_term_init
5250    -------------------------------------------------------------------------- */
5251 {
5252   NSTRACE ("[EmacsApp applicationDidFinishLaunching:]");
5253
5254 #ifdef NS_IMPL_GNUSTEP
5255   ((EmacsApp *)self)->applicationDidFinishLaunchingCalled = YES;
5256 #endif
5257   [NSApp setServicesProvider: NSApp];
5258
5259   [self antialiasThresholdDidChange:nil];
5260 #ifdef NS_IMPL_COCOA
5261   [[NSNotificationCenter defaultCenter]
5262     addObserver:self
5263        selector:@selector(antialiasThresholdDidChange:)
5264            name:NSAntialiasThresholdChangedNotification
5265          object:nil];
5266 #endif
5267
5268   ns_send_appdefined (-2);
5269 }
5270
5271 - (void)antialiasThresholdDidChange:(NSNotification *)notification
5272 {
5273 #ifdef NS_IMPL_COCOA
5274   macfont_update_antialias_threshold ();
5275 #endif
5276 }
5277
5278
5279 /* Termination sequences:
5280     C-x C-c:
5281     Cmd-Q:
5282     MenuBar | File | Exit:
5283     Select Quit from App menubar:
5284         -terminate
5285         KEY_NS_POWER_OFF, (save-buffers-kill-emacs)
5286         ns_term_shutdown()
5287
5288     Select Quit from Dock menu:
5289     Logout attempt:
5290         -appShouldTerminate
5291           Cancel -> Nothing else
5292           Accept ->
5293
5294           -terminate
5295           KEY_NS_POWER_OFF, (save-buffers-kill-emacs)
5296           ns_term_shutdown()
5297
5298 */
5299
5300 - (void) terminate: (id)sender
5301 {
5302   NSTRACE ("[EmacsApp terminate:]");
5303
5304   struct frame *emacsframe = SELECTED_FRAME ();
5305
5306   if (!emacs_event)
5307     return;
5308
5309   emacs_event->kind = NS_NONKEY_EVENT;
5310   emacs_event->code = KEY_NS_POWER_OFF;
5311   emacs_event->arg = Qt; /* mark as non-key event */
5312   EV_TRAILER ((id)nil);
5313 }
5314
5315 static bool
5316 runAlertPanel(NSString *title,
5317               NSString *msgFormat,
5318               NSString *defaultButton,
5319               NSString *alternateButton)
5320 {
5321 #if !defined (NS_IMPL_COCOA) || \
5322   MAC_OS_X_VERSION_MAX_ALLOWED <= MAC_OS_X_VERSION_10_9
5323   return NSRunAlertPanel(title, msgFormat, defaultButton, alternateButton, nil)
5324     == NSAlertDefaultReturn;
5325 #else
5326   NSAlert *alert = [[NSAlert alloc] init];
5327   [alert setAlertStyle: NSAlertStyleCritical];
5328   [alert setMessageText: msgFormat];
5329   [alert addButtonWithTitle: defaultButton];
5330   [alert addButtonWithTitle: alternateButton];
5331   NSInteger ret = [alert runModal];
5332   [alert release];
5333   return ret == NSAlertFirstButtonReturn;
5334 #endif
5335 }
5336
5337
5338 - (NSApplicationTerminateReply)applicationShouldTerminate: (id)sender
5339 {
5340   NSTRACE ("[EmacsApp applicationShouldTerminate:]");
5341
5342   bool ret;
5343
5344   if (NILP (ns_confirm_quit)) //   || ns_shutdown_properly  --> TO DO
5345     return NSTerminateNow;
5346
5347   ret = runAlertPanel(ns_app_name,
5348                       @"Exit requested.  Would you like to Save Buffers and Exit, or Cancel the request?",
5349                       @"Save Buffers and Exit", @"Cancel");
5350
5351   return ret ? NSTerminateNow : NSTerminateCancel;
5352 }
5353
5354 static int
5355 not_in_argv (NSString *arg)
5356 {
5357   int k;
5358   const char *a = [arg UTF8String];
5359   for (k = 1; k < initial_argc; ++k)
5360     if (strcmp (a, initial_argv[k]) == 0) return 0;
5361   return 1;
5362 }
5363
5364 /*   Notification from the Workspace to open a file */
5365 - (BOOL)application: sender openFile: (NSString *)file
5366 {
5367   if (ns_do_open_file || not_in_argv (file))
5368     [ns_pending_files addObject: file];
5369   return YES;
5370 }
5371
5372
5373 /*   Open a file as a temporary file */
5374 - (BOOL)application: sender openTempFile: (NSString *)file
5375 {
5376   if (ns_do_open_file || not_in_argv (file))
5377     [ns_pending_files addObject: file];
5378   return YES;
5379 }
5380
5381
5382 /*   Notification from the Workspace to open a file noninteractively (?) */
5383 - (BOOL)application: sender openFileWithoutUI: (NSString *)file
5384 {
5385   if (ns_do_open_file || not_in_argv (file))
5386     [ns_pending_files addObject: file];
5387   return YES;
5388 }
5389
5390 /*   Notification from the Workspace to open multiple files */
5391 - (void)application: sender openFiles: (NSArray *)fileList
5392 {
5393   NSEnumerator *files = [fileList objectEnumerator];
5394   NSString *file;
5395   /* Don't open files from the command line unconditionally,
5396      Cocoa parses the command line wrong, --option value tries to open value
5397      if --option is the last option.  */
5398   while ((file = [files nextObject]) != nil)
5399     if (ns_do_open_file || not_in_argv (file))
5400       [ns_pending_files addObject: file];
5401
5402   [self replyToOpenOrPrint: NSApplicationDelegateReplySuccess];
5403
5404 }
5405
5406
5407 /* Handle dock menu requests.  */
5408 - (NSMenu *)applicationDockMenu: (NSApplication *) sender
5409 {
5410   return dockMenu;
5411 }
5412
5413
5414 /* TODO: these may help w/IO switching btwn terminal and NSApp */
5415 - (void)applicationWillBecomeActive: (NSNotification *)notification
5416 {
5417   NSTRACE ("[EmacsApp applicationWillBecomeActive:]");
5418   //ns_app_active=YES;
5419 }
5420
5421 - (void)applicationDidBecomeActive: (NSNotification *)notification
5422 {
5423   NSTRACE ("[EmacsApp applicationDidBecomeActive:]");
5424
5425 #ifdef NS_IMPL_GNUSTEP
5426   if (! applicationDidFinishLaunchingCalled)
5427     [self applicationDidFinishLaunching:notification];
5428 #endif
5429   //ns_app_active=YES;
5430
5431   ns_update_auto_hide_menu_bar ();
5432   // No constraining takes place when the application is not active.
5433   ns_constrain_all_frames ();
5434 }
5435 - (void)applicationDidResignActive: (NSNotification *)notification
5436 {
5437   NSTRACE ("[EmacsApp applicationDidResignActive:]");
5438
5439   //ns_app_active=NO;
5440   ns_send_appdefined (-1);
5441 }
5442
5443
5444
5445 /* ==========================================================================
5446
5447     EmacsApp aux handlers for managing event loop
5448
5449    ========================================================================== */
5450
5451
5452 - (void)timeout_handler: (NSTimer *)timedEntry
5453 /* --------------------------------------------------------------------------
5454      The timeout specified to ns_select has passed.
5455    -------------------------------------------------------------------------- */
5456 {
5457   /*NSTRACE ("timeout_handler"); */
5458   ns_send_appdefined (-2);
5459 }
5460
5461 - (void)sendFromMainThread:(id)unused
5462 {
5463   ns_send_appdefined (nextappdefined);
5464 }
5465
5466 - (void)fd_handler:(id)unused
5467 /* --------------------------------------------------------------------------
5468      Check data waiting on file descriptors and terminate if so
5469    -------------------------------------------------------------------------- */
5470 {
5471   int result;
5472   int waiting = 1, nfds;
5473   char c;
5474
5475   fd_set readfds, writefds, *wfds;
5476   struct timespec timeout, *tmo;
5477   NSAutoreleasePool *pool = nil;
5478
5479   /* NSTRACE ("fd_handler"); */
5480
5481   for (;;)
5482     {
5483       [pool release];
5484       pool = [[NSAutoreleasePool alloc] init];
5485
5486       if (waiting)
5487         {
5488           fd_set fds;
5489           FD_ZERO (&fds);
5490           FD_SET (selfds[0], &fds);
5491           result = select (selfds[0]+1, &fds, NULL, NULL, NULL);
5492           if (result > 0 && read (selfds[0], &c, 1) == 1 && c == 'g')
5493             waiting = 0;
5494         }
5495       else
5496         {
5497           pthread_mutex_lock (&select_mutex);
5498           nfds = select_nfds;
5499
5500           if (select_valid & SELECT_HAVE_READ)
5501             readfds = select_readfds;
5502           else
5503             FD_ZERO (&readfds);
5504
5505           if (select_valid & SELECT_HAVE_WRITE)
5506             {
5507               writefds = select_writefds;
5508               wfds = &writefds;
5509             }
5510           else
5511             wfds = NULL;
5512           if (select_valid & SELECT_HAVE_TMO)
5513             {
5514               timeout = select_timeout;
5515               tmo = &timeout;
5516             }
5517           else
5518             tmo = NULL;
5519
5520           pthread_mutex_unlock (&select_mutex);
5521
5522           FD_SET (selfds[0], &readfds);
5523           if (selfds[0] >= nfds) nfds = selfds[0]+1;
5524
5525           result = pselect (nfds, &readfds, wfds, NULL, tmo, NULL);
5526
5527           if (result == 0)
5528             ns_send_appdefined (-2);
5529           else if (result > 0)
5530             {
5531               if (FD_ISSET (selfds[0], &readfds))
5532                 {
5533                   if (read (selfds[0], &c, 1) == 1 && c == 's')
5534                     waiting = 1;
5535                 }
5536               else
5537                 {
5538                   pthread_mutex_lock (&select_mutex);
5539                   if (select_valid & SELECT_HAVE_READ)
5540                     select_readfds = readfds;
5541                   if (select_valid & SELECT_HAVE_WRITE)
5542                     select_writefds = writefds;
5543                   if (select_valid & SELECT_HAVE_TMO)
5544                     select_timeout = timeout;
5545                   pthread_mutex_unlock (&select_mutex);
5546
5547                   ns_send_appdefined (result);
5548                 }
5549             }
5550           waiting = 1;
5551         }
5552     }
5553 }
5554
5555
5556
5557 /* ==========================================================================
5558
5559     Service provision
5560
5561    ========================================================================== */
5562
5563 /* called from system: queue for next pass through event loop */
5564 - (void)requestService: (NSPasteboard *)pboard
5565               userData: (NSString *)userData
5566                  error: (NSString **)error
5567 {
5568   [ns_pending_service_names addObject: userData];
5569   [ns_pending_service_args addObject: [NSString stringWithUTF8String:
5570       SSDATA (ns_string_from_pasteboard (pboard))]];
5571 }
5572
5573
5574 /* called from ns_read_socket to clear queue */
5575 - (BOOL)fulfillService: (NSString *)name withArg: (NSString *)arg
5576 {
5577   struct frame *emacsframe = SELECTED_FRAME ();
5578   NSEvent *theEvent = [NSApp currentEvent];
5579
5580   NSTRACE ("[EmacsApp fulfillService:withArg:]");
5581
5582   if (!emacs_event)
5583     return NO;
5584
5585   emacs_event->kind = NS_NONKEY_EVENT;
5586   emacs_event->code = KEY_NS_SPI_SERVICE_CALL;
5587   ns_input_spi_name = build_string ([name UTF8String]);
5588   ns_input_spi_arg = build_string ([arg UTF8String]);
5589   emacs_event->modifiers = EV_MODIFIERS (theEvent);
5590   EV_TRAILER (theEvent);
5591
5592   return YES;
5593 }
5594
5595
5596 @end  /* EmacsApp */
5597
5598
5599
5600 /* ==========================================================================
5601
5602     EmacsView implementation
5603
5604    ========================================================================== */
5605
5606
5607 @implementation EmacsView
5608
5609 /* needed to inform when window closed from LISP */
5610 - (void) setWindowClosing: (BOOL)closing
5611 {
5612   NSTRACE ("[EmacsView setWindowClosing:%d]", closing);
5613
5614   windowClosing = closing;
5615 }
5616
5617
5618 - (void)dealloc
5619 {
5620   NSTRACE ("[EmacsView dealloc]");
5621   [toolbar release];
5622   if (fs_state == FULLSCREEN_BOTH)
5623     [nonfs_window release];
5624   [super dealloc];
5625 }
5626
5627
5628 /* called on font panel selection */
5629 - (void)changeFont: (id)sender
5630 {
5631   NSEvent *e = [[self window] currentEvent];
5632   struct face *face = FACE_FROM_ID (emacsframe, DEFAULT_FACE_ID);
5633   struct font *font = face->font;
5634   id newFont;
5635   CGFloat size;
5636   NSFont *nsfont;
5637
5638   NSTRACE ("[EmacsView changeFont:]");
5639
5640   if (!emacs_event)
5641     return;
5642
5643 #ifdef NS_IMPL_GNUSTEP
5644   nsfont = ((struct nsfont_info *)font)->nsfont;
5645 #endif
5646 #ifdef NS_IMPL_COCOA
5647   nsfont = (NSFont *) macfont_get_nsctfont (font);
5648 #endif
5649
5650   if ((newFont = [sender convertFont: nsfont]))
5651     {
5652       SET_FRAME_GARBAGED (emacsframe); /* now needed as of 2008/10 */
5653
5654       emacs_event->kind = NS_NONKEY_EVENT;
5655       emacs_event->modifiers = 0;
5656       emacs_event->code = KEY_NS_CHANGE_FONT;
5657
5658       size = [newFont pointSize];
5659       ns_input_fontsize = make_number (lrint (size));
5660       ns_input_font = build_string ([[newFont familyName] UTF8String]);
5661       EV_TRAILER (e);
5662     }
5663 }
5664
5665
5666 - (BOOL)acceptsFirstResponder
5667 {
5668   NSTRACE ("[EmacsView acceptsFirstResponder]");
5669   return YES;
5670 }
5671
5672
5673 - (void)resetCursorRects
5674 {
5675   NSRect visible = [self visibleRect];
5676   NSCursor *currentCursor = FRAME_POINTER_TYPE (emacsframe);
5677   NSTRACE ("[EmacsView resetCursorRects]");
5678
5679   if (currentCursor == nil)
5680     currentCursor = [NSCursor arrowCursor];
5681
5682   if (!NSIsEmptyRect (visible))
5683     [self addCursorRect: visible cursor: currentCursor];
5684   [currentCursor setOnMouseEntered: YES];
5685 }
5686
5687
5688
5689 /*****************************************************************************/
5690 /* Keyboard handling. */
5691 #define NS_KEYLOG 0
5692
5693 - (void)keyDown: (NSEvent *)theEvent
5694 {
5695   Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (emacsframe);
5696   int code;
5697   unsigned fnKeysym = 0;
5698   static NSMutableArray *nsEvArray;
5699   int left_is_none;
5700   unsigned int flags = [theEvent modifierFlags];
5701
5702   NSTRACE ("[EmacsView keyDown:]");
5703
5704   /* Rhapsody and macOS give up and down events for the arrow keys */
5705   if (ns_fake_keydown == YES)
5706     ns_fake_keydown = NO;
5707   else if ([theEvent type] != NSEventTypeKeyDown)
5708     return;
5709
5710   if (!emacs_event)
5711     return;
5712
5713  if (![[self window] isKeyWindow]
5714      && [[theEvent window] isKindOfClass: [EmacsWindow class]]
5715      /* we must avoid an infinite loop here. */
5716      && (EmacsView *)[[theEvent window] delegate] != self)
5717    {
5718      /* XXX: There is an occasional condition in which, when Emacs display
5719          updates a different frame from the current one, and temporarily
5720          selects it, then processes some interrupt-driven input
5721          (dispnew.c:3878), OS will send the event to the correct NSWindow, but
5722          for some reason that window has its first responder set to the NSView
5723          most recently updated (I guess), which is not the correct one. */
5724      [(EmacsView *)[[theEvent window] delegate] keyDown: theEvent];
5725      return;
5726    }
5727
5728   if (nsEvArray == nil)
5729     nsEvArray = [[NSMutableArray alloc] initWithCapacity: 1];
5730
5731   [NSCursor setHiddenUntilMouseMoves: YES];
5732
5733   if (hlinfo->mouse_face_hidden && INTEGERP (Vmouse_highlight))
5734     {
5735       clear_mouse_face (hlinfo);
5736       hlinfo->mouse_face_hidden = 1;
5737     }
5738
5739   if (!processingCompose)
5740     {
5741       /* When using screen sharing, no left or right information is sent,
5742          so use Left key in those cases.  */
5743       int is_left_key, is_right_key;
5744
5745       code = ([[theEvent charactersIgnoringModifiers] length] == 0) ?
5746         0 : [[theEvent charactersIgnoringModifiers] characterAtIndex: 0];
5747
5748       /* (Carbon way: [theEvent keyCode]) */
5749
5750       /* is it a "function key"? */
5751       /* Note: Sometimes a plain key will have the NSEventModifierFlagNumericPad
5752          flag set (this is probably a bug in the OS).
5753       */
5754       if (code < 0x00ff && (flags&NSEventModifierFlagNumericPad))
5755         {
5756           fnKeysym = ns_convert_key ([theEvent keyCode] | NSEventModifierFlagNumericPad);
5757         }
5758       if (fnKeysym == 0)
5759         {
5760           fnKeysym = ns_convert_key (code);
5761         }
5762
5763       if (fnKeysym)
5764         {
5765           /* COUNTERHACK: map 'Delete' on upper-right main KB to 'Backspace',
5766              because Emacs treats Delete and KP-Delete same (in simple.el). */
5767           if ((fnKeysym == 0xFFFF && [theEvent keyCode] == 0x33)
5768 #ifdef NS_IMPL_GNUSTEP
5769               /*  GNUstep uses incompatible keycodes, even for those that are
5770                   supposed to be hardware independent.  Just check for delete.
5771                   Keypad delete does not have keysym 0xFFFF.
5772                   See http://savannah.gnu.org/bugs/?25395
5773               */
5774               || (fnKeysym == 0xFFFF && code == 127)
5775 #endif
5776             )
5777             code = 0xFF08; /* backspace */
5778           else
5779             code = fnKeysym;
5780         }
5781
5782       /* are there modifiers? */
5783       emacs_event->modifiers = 0;
5784
5785       if (flags & NSEventModifierFlagHelp)
5786           emacs_event->modifiers |= hyper_modifier;
5787
5788       if (flags & NSEventModifierFlagShift)
5789         emacs_event->modifiers |= shift_modifier;
5790
5791       is_right_key = (flags & NSRightCommandKeyMask) == NSRightCommandKeyMask;
5792       is_left_key = (flags & NSLeftCommandKeyMask) == NSLeftCommandKeyMask
5793         || (! is_right_key && (flags & NSEventModifierFlagCommand) == NSEventModifierFlagCommand);
5794
5795       if (is_right_key)
5796         emacs_event->modifiers |= parse_solitary_modifier
5797           (EQ (ns_right_command_modifier, Qleft)
5798            ? ns_command_modifier
5799            : ns_right_command_modifier);
5800
5801       if (is_left_key)
5802         {
5803           emacs_event->modifiers |= parse_solitary_modifier
5804             (ns_command_modifier);
5805
5806           /* if super (default), take input manager's word so things like
5807              dvorak / qwerty layout work */
5808           if (EQ (ns_command_modifier, Qsuper)
5809               && !fnKeysym
5810               && [[theEvent characters] length] != 0)
5811             {
5812               /* XXX: the code we get will be unshifted, so if we have
5813                  a shift modifier, must convert ourselves */
5814               if (!(flags & NSEventModifierFlagShift))
5815                 code = [[theEvent characters] characterAtIndex: 0];
5816 #if 0
5817               /* this is ugly and also requires linking w/Carbon framework
5818                  (for LMGetKbdType) so for now leave this rare (?) case
5819                  undealt with.. in future look into CGEvent methods */
5820               else
5821                 {
5822                   long smv = GetScriptManagerVariable (smKeyScript);
5823                   Handle uchrHandle = GetResource
5824                     ('uchr', GetScriptVariable (smv, smScriptKeys));
5825                   UInt32 dummy = 0;
5826                   UCKeyTranslate ((UCKeyboardLayout *) *uchrHandle,
5827                                  [[theEvent characters] characterAtIndex: 0],
5828                                  kUCKeyActionDisplay,
5829                                  (flags & ~NSEventModifierFlagCommand) >> 8,
5830                                  LMGetKbdType (), kUCKeyTranslateNoDeadKeysMask,
5831                                  &dummy, 1, &dummy, &code);
5832                   code &= 0xFF;
5833                 }
5834 #endif
5835             }
5836         }
5837
5838       is_right_key = (flags & NSRightControlKeyMask) == NSRightControlKeyMask;
5839       is_left_key = (flags & NSLeftControlKeyMask) == NSLeftControlKeyMask
5840         || (! is_right_key && (flags & NSEventModifierFlagControl) == NSEventModifierFlagControl);
5841
5842       if (is_right_key)
5843           emacs_event->modifiers |= parse_solitary_modifier
5844               (EQ (ns_right_control_modifier, Qleft)
5845                ? ns_control_modifier
5846                : ns_right_control_modifier);
5847
5848       if (is_left_key)
5849         emacs_event->modifiers |= parse_solitary_modifier
5850           (ns_control_modifier);
5851
5852       if (flags & NS_FUNCTION_KEY_MASK && !fnKeysym)
5853           emacs_event->modifiers |=
5854             parse_solitary_modifier (ns_function_modifier);
5855
5856       left_is_none = NILP (ns_alternate_modifier)
5857         || EQ (ns_alternate_modifier, Qnone);
5858
5859       is_right_key = (flags & NSRightAlternateKeyMask)
5860         == NSRightAlternateKeyMask;
5861       is_left_key = (flags & NSLeftAlternateKeyMask) == NSLeftAlternateKeyMask
5862         || (! is_right_key
5863             && (flags & NSEventModifierFlagOption) == NSEventModifierFlagOption);
5864
5865       if (is_right_key)
5866         {
5867           if ((NILP (ns_right_alternate_modifier)
5868                || EQ (ns_right_alternate_modifier, Qnone)
5869                || (EQ (ns_right_alternate_modifier, Qleft) && left_is_none))
5870               && !fnKeysym)
5871             {   /* accept pre-interp alt comb */
5872               if ([[theEvent characters] length] > 0)
5873                 code = [[theEvent characters] characterAtIndex: 0];
5874               /*HACK: clear lone shift modifier to stop next if from firing */
5875               if (emacs_event->modifiers == shift_modifier)
5876                 emacs_event->modifiers = 0;
5877             }
5878           else
5879             emacs_event->modifiers |= parse_solitary_modifier
5880               (EQ (ns_right_alternate_modifier, Qleft)
5881                ? ns_alternate_modifier
5882                : ns_right_alternate_modifier);
5883         }
5884
5885       if (is_left_key) /* default = meta */
5886         {
5887           if (left_is_none && !fnKeysym)
5888             {   /* accept pre-interp alt comb */
5889               if ([[theEvent characters] length] > 0)
5890                 code = [[theEvent characters] characterAtIndex: 0];
5891               /*HACK: clear lone shift modifier to stop next if from firing */
5892               if (emacs_event->modifiers == shift_modifier)
5893                 emacs_event->modifiers = 0;
5894             }
5895           else
5896               emacs_event->modifiers |=
5897                 parse_solitary_modifier (ns_alternate_modifier);
5898         }
5899
5900   if (NS_KEYLOG)
5901     fprintf (stderr, "keyDown: code =%x\tfnKey =%x\tflags = %x\tmods = %x\n",
5902              (unsigned) code, fnKeysym, flags, emacs_event->modifiers);
5903
5904       /* if it was a function key or had modifiers, pass it directly to emacs */
5905       if (fnKeysym || (emacs_event->modifiers
5906                        && (emacs_event->modifiers != shift_modifier)
5907                        && [[theEvent charactersIgnoringModifiers] length] > 0))
5908 /*[[theEvent characters] length] */
5909         {
5910           emacs_event->kind = NON_ASCII_KEYSTROKE_EVENT;
5911           if (code < 0x20)
5912             code |= (1<<28)|(3<<16);
5913           else if (code == 0x7f)
5914             code |= (1<<28)|(3<<16);
5915           else if (!fnKeysym)
5916             emacs_event->kind = code > 0xFF
5917               ? MULTIBYTE_CHAR_KEYSTROKE_EVENT : ASCII_KEYSTROKE_EVENT;
5918
5919           emacs_event->code = code;
5920           EV_TRAILER (theEvent);
5921           processingCompose = NO;
5922           return;
5923         }
5924     }
5925
5926
5927   if (NS_KEYLOG && !processingCompose)
5928     fprintf (stderr, "keyDown: Begin compose sequence.\n");
5929
5930   processingCompose = YES;
5931   [nsEvArray addObject: theEvent];
5932   [self interpretKeyEvents: nsEvArray];
5933   [nsEvArray removeObject: theEvent];
5934 }
5935
5936
5937 /* <NSTextInput> implementation (called through super interpretKeyEvents:]). */
5938
5939
5940 /* <NSTextInput>: called when done composing;
5941    NOTE: also called when we delete over working text, followed immed.
5942          by doCommandBySelector: deleteBackward: */
5943 - (void)insertText: (id)aString
5944 {
5945   int code;
5946   int len = [(NSString *)aString length];
5947   int i;
5948
5949   NSTRACE ("[EmacsView insertText:]");
5950
5951   if (NS_KEYLOG)
5952     NSLog (@"insertText '%@'\tlen = %d", aString, len);
5953   processingCompose = NO;
5954
5955   if (!emacs_event)
5956     return;
5957
5958   /* first, clear any working text */
5959   if (workingText != nil)
5960     [self deleteWorkingText];
5961
5962   /* now insert the string as keystrokes */
5963   for (i =0; i<len; i++)
5964     {
5965       code = [aString characterAtIndex: i];
5966       /* TODO: still need this? */
5967       if (code == 0x2DC)
5968         code = '~'; /* 0x7E */
5969       if (code != 32) /* Space */
5970         emacs_event->modifiers = 0;
5971       emacs_event->kind
5972         = code > 0xFF ? MULTIBYTE_CHAR_KEYSTROKE_EVENT : ASCII_KEYSTROKE_EVENT;
5973       emacs_event->code = code;
5974       EV_TRAILER ((id)nil);
5975     }
5976 }
5977
5978
5979 /* <NSTextInput>: inserts display of composing characters */
5980 - (void)setMarkedText: (id)aString selectedRange: (NSRange)selRange
5981 {
5982   NSString *str = [aString respondsToSelector: @selector (string)] ?
5983     [aString string] : aString;
5984
5985   NSTRACE ("[EmacsView setMarkedText:selectedRange:]");
5986
5987   if (NS_KEYLOG)
5988     NSLog (@"setMarkedText '%@' len =%lu range %lu from %lu",
5989            str, (unsigned long)[str length],
5990            (unsigned long)selRange.length,
5991            (unsigned long)selRange.location);
5992
5993   if (workingText != nil)
5994     [self deleteWorkingText];
5995   if ([str length] == 0)
5996     return;
5997
5998   if (!emacs_event)
5999     return;
6000
6001   processingCompose = YES;
6002   workingText = [str copy];
6003   ns_working_text = build_string ([workingText UTF8String]);
6004
6005   emacs_event->kind = NS_TEXT_EVENT;
6006   emacs_event->code = KEY_NS_PUT_WORKING_TEXT;
6007   EV_TRAILER ((id)nil);
6008 }
6009
6010
6011 /* delete display of composing characters [not in <NSTextInput>] */
6012 - (void)deleteWorkingText
6013 {
6014   NSTRACE ("[EmacsView deleteWorkingText]");
6015
6016   if (workingText == nil)
6017     return;
6018   if (NS_KEYLOG)
6019     NSLog(@"deleteWorkingText len =%lu\n", (unsigned long)[workingText length]);
6020   [workingText release];
6021   workingText = nil;
6022   processingCompose = NO;
6023
6024   if (!emacs_event)
6025     return;
6026
6027   emacs_event->kind = NS_TEXT_EVENT;
6028   emacs_event->code = KEY_NS_UNPUT_WORKING_TEXT;
6029   EV_TRAILER ((id)nil);
6030 }
6031
6032
6033 - (BOOL)hasMarkedText
6034 {
6035   NSTRACE ("[EmacsView hasMarkedText]");
6036
6037   return workingText != nil;
6038 }
6039
6040
6041 - (NSRange)markedRange
6042 {
6043   NSTRACE ("[EmacsView markedRange]");
6044
6045   NSRange rng = workingText != nil
6046     ? NSMakeRange (0, [workingText length]) : NSMakeRange (NSNotFound, 0);
6047   if (NS_KEYLOG)
6048     NSLog (@"markedRange request");
6049   return rng;
6050 }
6051
6052
6053 - (void)unmarkText
6054 {
6055   NSTRACE ("[EmacsView unmarkText]");
6056
6057   if (NS_KEYLOG)
6058     NSLog (@"unmark (accept) text");
6059   [self deleteWorkingText];
6060   processingCompose = NO;
6061 }
6062
6063
6064 /* used to position char selection windows, etc. */
6065 - (NSRect)firstRectForCharacterRange: (NSRange)theRange
6066 {
6067   NSRect rect;
6068   NSPoint pt;
6069   struct window *win = XWINDOW (FRAME_SELECTED_WINDOW (emacsframe));
6070
6071   NSTRACE ("[EmacsView firstRectForCharacterRange:]");
6072
6073   if (NS_KEYLOG)
6074     NSLog (@"firstRectForCharRange request");
6075
6076   rect.size.width = theRange.length * FRAME_COLUMN_WIDTH (emacsframe);
6077   rect.size.height = FRAME_LINE_HEIGHT (emacsframe);
6078   pt.x = WINDOW_TEXT_TO_FRAME_PIXEL_X (win, win->phys_cursor.x);
6079   pt.y = WINDOW_TO_FRAME_PIXEL_Y (win, win->phys_cursor.y
6080                                        +FRAME_LINE_HEIGHT (emacsframe));
6081
6082   pt = [self convertPoint: pt toView: nil];
6083 #if !defined (NS_IMPL_COCOA) || \
6084   MAC_OS_X_VERSION_MAX_ALLOWED < MAC_OS_X_VERSION_10_7
6085   pt = [[self window] convertBaseToScreen: pt];
6086   rect.origin = pt;
6087 #else
6088   rect.origin = pt;
6089   rect = [[self window] convertRectToScreen: rect];
6090 #endif
6091   return rect;
6092 }
6093
6094
6095 - (NSInteger)conversationIdentifier
6096 {
6097   return (NSInteger)self;
6098 }
6099
6100
6101 - (void)doCommandBySelector: (SEL)aSelector
6102 {
6103   NSTRACE ("[EmacsView doCommandBySelector:]");
6104
6105   if (NS_KEYLOG)
6106     NSLog (@"doCommandBySelector: %@", NSStringFromSelector (aSelector));
6107
6108   processingCompose = NO;
6109   if (aSelector == @selector (deleteBackward:))
6110     {
6111       /* happens when user backspaces over an ongoing composition:
6112          throw a 'delete' into the event queue */
6113       if (!emacs_event)
6114         return;
6115       emacs_event->kind = NON_ASCII_KEYSTROKE_EVENT;
6116       emacs_event->code = 0xFF08;
6117       EV_TRAILER ((id)nil);
6118     }
6119 }
6120
6121 - (NSArray *)validAttributesForMarkedText
6122 {
6123   static NSArray *arr = nil;
6124   if (arr == nil) arr = [NSArray new];
6125  /* [[NSArray arrayWithObject: NSUnderlineStyleAttributeName] retain]; */
6126   return arr;
6127 }
6128
6129 - (NSRange)selectedRange
6130 {
6131   if (NS_KEYLOG)
6132     NSLog (@"selectedRange request");
6133   return NSMakeRange (NSNotFound, 0);
6134 }
6135
6136 #if defined (NS_IMPL_COCOA) || GNUSTEP_GUI_MAJOR_VERSION > 0 || \
6137     GNUSTEP_GUI_MINOR_VERSION > 22
6138 - (NSUInteger)characterIndexForPoint: (NSPoint)thePoint
6139 #else
6140 - (unsigned int)characterIndexForPoint: (NSPoint)thePoint
6141 #endif
6142 {
6143   if (NS_KEYLOG)
6144     NSLog (@"characterIndexForPoint request");
6145   return 0;
6146 }
6147
6148 - (NSAttributedString *)attributedSubstringFromRange: (NSRange)theRange
6149 {
6150   static NSAttributedString *str = nil;
6151   if (str == nil) str = [NSAttributedString new];
6152   if (NS_KEYLOG)
6153     NSLog (@"attributedSubstringFromRange request");
6154   return str;
6155 }
6156
6157 /* End <NSTextInput> impl. */
6158 /*****************************************************************************/
6159
6160
6161 /* This is what happens when the user presses a mouse button.  */
6162 - (void)mouseDown: (NSEvent *)theEvent
6163 {
6164   struct ns_display_info *dpyinfo = FRAME_DISPLAY_INFO (emacsframe);
6165   NSPoint p = [self convertPoint: [theEvent locationInWindow] fromView: nil];
6166
6167   NSTRACE ("[EmacsView mouseDown:]");
6168
6169   [self deleteWorkingText];
6170
6171   if (!emacs_event)
6172     return;
6173
6174   dpyinfo->last_mouse_frame = emacsframe;
6175   /* appears to be needed to prevent spurious movement events generated on
6176      button clicks */
6177   emacsframe->mouse_moved = 0;
6178
6179   if ([theEvent type] == NSEventTypeScrollWheel)
6180     {
6181       CGFloat delta = [theEvent deltaY];
6182       /* Mac notebooks send wheel events w/delta =0 when trackpad scrolling */
6183       if (delta == 0)
6184         {
6185           delta = [theEvent deltaX];
6186           if (delta == 0)
6187             {
6188               NSTRACE_MSG ("deltaIsZero");
6189               return;
6190             }
6191           emacs_event->kind = HORIZ_WHEEL_EVENT;
6192         }
6193       else
6194         emacs_event->kind = WHEEL_EVENT;
6195
6196       emacs_event->code = 0;
6197       emacs_event->modifiers = EV_MODIFIERS (theEvent) |
6198         ((delta > 0) ? up_modifier : down_modifier);
6199     }
6200   else
6201     {
6202       emacs_event->kind = MOUSE_CLICK_EVENT;
6203       emacs_event->code = EV_BUTTON (theEvent);
6204       emacs_event->modifiers = EV_MODIFIERS (theEvent)
6205                              | EV_UDMODIFIERS (theEvent);
6206     }
6207   XSETINT (emacs_event->x, lrint (p.x));
6208   XSETINT (emacs_event->y, lrint (p.y));
6209   EV_TRAILER (theEvent);
6210 }
6211
6212
6213 - (void)rightMouseDown: (NSEvent *)theEvent
6214 {
6215   NSTRACE ("[EmacsView rightMouseDown:]");
6216   [self mouseDown: theEvent];
6217 }
6218
6219
6220 - (void)otherMouseDown: (NSEvent *)theEvent
6221 {
6222   NSTRACE ("[EmacsView otherMouseDown:]");
6223   [self mouseDown: theEvent];
6224 }
6225
6226
6227 - (void)mouseUp: (NSEvent *)theEvent
6228 {
6229   NSTRACE ("[EmacsView mouseUp:]");
6230   [self mouseDown: theEvent];
6231 }
6232
6233
6234 - (void)rightMouseUp: (NSEvent *)theEvent
6235 {
6236   NSTRACE ("[EmacsView rightMouseUp:]");
6237   [self mouseDown: theEvent];
6238 }
6239
6240
6241 - (void)otherMouseUp: (NSEvent *)theEvent
6242 {
6243   NSTRACE ("[EmacsView otherMouseUp:]");
6244   [self mouseDown: theEvent];
6245 }
6246
6247
6248 - (void) scrollWheel: (NSEvent *)theEvent
6249 {
6250   NSTRACE ("[EmacsView scrollWheel:]");
6251   [self mouseDown: theEvent];
6252 }
6253
6254
6255 /* Tell emacs the mouse has moved. */
6256 - (void)mouseMoved: (NSEvent *)e
6257 {
6258   Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (emacsframe);
6259   struct ns_display_info *dpyinfo = FRAME_DISPLAY_INFO (emacsframe);
6260   Lisp_Object frame;
6261   NSPoint pt;
6262
6263   NSTRACE_WHEN (NSTRACE_GROUP_EVENTS, "[EmacsView mouseMoved:]");
6264
6265   dpyinfo->last_mouse_movement_time = EV_TIMESTAMP (e);
6266   pt = [self convertPoint: [e locationInWindow] fromView: nil];
6267   dpyinfo->last_mouse_motion_x = pt.x;
6268   dpyinfo->last_mouse_motion_y = pt.y;
6269
6270   /* update any mouse face */
6271   if (hlinfo->mouse_face_hidden)
6272     {
6273       hlinfo->mouse_face_hidden = 0;
6274       clear_mouse_face (hlinfo);
6275     }
6276
6277   /* tooltip handling */
6278   previous_help_echo_string = help_echo_string;
6279   help_echo_string = Qnil;
6280
6281   if (!NILP (Vmouse_autoselect_window))
6282     {
6283       NSTRACE_MSG ("mouse_autoselect_window");
6284       static Lisp_Object last_mouse_window;
6285       Lisp_Object window
6286         = window_from_coordinates (emacsframe, pt.x, pt.y, 0, 0);
6287
6288       if (WINDOWP (window)
6289           && !EQ (window, last_mouse_window)
6290           && !EQ (window, selected_window)
6291           && (focus_follows_mouse
6292               || (EQ (XWINDOW (window)->frame,
6293                       XWINDOW (selected_window)->frame))))
6294         {
6295           NSTRACE_MSG ("in_window");
6296           emacs_event->kind = SELECT_WINDOW_EVENT;
6297           emacs_event->frame_or_window = window;
6298           EV_TRAILER2 (e);
6299         }
6300       /* Remember the last window where we saw the mouse.  */
6301       last_mouse_window = window;
6302     }
6303
6304   if (!note_mouse_movement (emacsframe, pt.x, pt.y))
6305     help_echo_string = previous_help_echo_string;
6306
6307   XSETFRAME (frame, emacsframe);
6308   if (!NILP (help_echo_string) || !NILP (previous_help_echo_string))
6309     {
6310       /* NOTE: help_echo_{window,pos,object} are set in xdisp.c
6311          (note_mouse_highlight), which is called through the
6312          note_mouse_movement () call above */
6313       any_help_event_p = YES;
6314       gen_help_event (help_echo_string, frame, help_echo_window,
6315                       help_echo_object, help_echo_pos);
6316     }
6317
6318   if (emacsframe->mouse_moved && send_appdefined)
6319     ns_send_appdefined (-1);
6320 }
6321
6322
6323 - (void)mouseDragged: (NSEvent *)e
6324 {
6325   NSTRACE ("[EmacsView mouseDragged:]");
6326   [self mouseMoved: e];
6327 }
6328
6329
6330 - (void)rightMouseDragged: (NSEvent *)e
6331 {
6332   NSTRACE ("[EmacsView rightMouseDragged:]");
6333   [self mouseMoved: e];
6334 }
6335
6336
6337 - (void)otherMouseDragged: (NSEvent *)e
6338 {
6339   NSTRACE ("[EmacsView otherMouseDragged:]");
6340   [self mouseMoved: e];
6341 }
6342
6343
6344 - (BOOL)windowShouldClose: (id)sender
6345 {
6346   NSEvent *e =[[self window] currentEvent];
6347
6348   NSTRACE ("[EmacsView windowShouldClose:]");
6349   windowClosing = YES;
6350   if (!emacs_event)
6351     return NO;
6352   emacs_event->kind = DELETE_WINDOW_EVENT;
6353   emacs_event->modifiers = 0;
6354   emacs_event->code = 0;
6355   EV_TRAILER (e);
6356   /* Don't close this window, let this be done from lisp code.  */
6357   return NO;
6358 }
6359
6360 - (void) updateFrameSize: (BOOL) delay;
6361 {
6362   NSWindow *window = [self window];
6363   NSRect wr = [window frame];
6364   int extra = 0;
6365   int oldc = cols, oldr = rows;
6366   int oldw = FRAME_PIXEL_WIDTH (emacsframe);
6367   int oldh = FRAME_PIXEL_HEIGHT (emacsframe);
6368   int neww, newh;
6369
6370   NSTRACE ("[EmacsView updateFrameSize:]");
6371   NSTRACE_SIZE ("Original size", NSMakeSize (oldw, oldh));
6372   NSTRACE_RECT ("Original frame", wr);
6373   NSTRACE_MSG  ("Original columns: %d", cols);
6374   NSTRACE_MSG  ("Original rows: %d", rows);
6375
6376   if (! [self isFullscreen])
6377     {
6378 #ifdef NS_IMPL_GNUSTEP
6379       // GNUstep does not always update the tool bar height.  Force it.
6380       if (toolbar && [toolbar isVisible])
6381           update_frame_tool_bar (emacsframe);
6382 #endif
6383
6384       extra = FRAME_NS_TITLEBAR_HEIGHT (emacsframe)
6385         + FRAME_TOOLBAR_HEIGHT (emacsframe);
6386     }
6387
6388   if (wait_for_tool_bar)
6389     {
6390       if (FRAME_TOOLBAR_HEIGHT (emacsframe) == 0)
6391         {
6392           NSTRACE_MSG ("Waiting for toolbar");
6393           return;
6394         }
6395       wait_for_tool_bar = NO;
6396     }
6397
6398   neww = (int)wr.size.width - emacsframe->border_width;
6399   newh = (int)wr.size.height - extra;
6400
6401   NSTRACE_SIZE ("New size", NSMakeSize (neww, newh));
6402   NSTRACE_MSG ("tool_bar_height: %d", emacsframe->tool_bar_height);
6403
6404   cols = FRAME_PIXEL_WIDTH_TO_TEXT_COLS (emacsframe, neww);
6405   rows = FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (emacsframe, newh);
6406
6407   if (cols < MINWIDTH)
6408     cols = MINWIDTH;
6409
6410   if (rows < MINHEIGHT)
6411     rows = MINHEIGHT;
6412
6413   NSTRACE_MSG ("New columns: %d", cols);
6414   NSTRACE_MSG ("New rows: %d", rows);
6415
6416   if (oldr != rows || oldc != cols || neww != oldw || newh != oldh)
6417     {
6418       NSView *view = FRAME_NS_VIEW (emacsframe);
6419
6420       change_frame_size (emacsframe,
6421                          FRAME_PIXEL_TO_TEXT_WIDTH (emacsframe, neww),
6422                          FRAME_PIXEL_TO_TEXT_HEIGHT (emacsframe, newh),
6423                          0, delay, 0, 1);
6424       SET_FRAME_GARBAGED (emacsframe);
6425       cancel_mouse_face (emacsframe);
6426
6427       wr = NSMakeRect (0, 0, neww, newh);
6428
6429       [view setFrame: wr];
6430
6431       // to do: consider using [NSNotificationCenter postNotificationName:].
6432       [self windowDidMove: // Update top/left.
6433               [NSNotification notificationWithName:NSWindowDidMoveNotification
6434                                             object:[view window]]];
6435     }
6436   else
6437     {
6438       NSTRACE_MSG ("No change");
6439     }
6440 }
6441
6442 - (NSSize)windowWillResize: (NSWindow *)sender toSize: (NSSize)frameSize
6443 /* normalize frame to gridded text size */
6444 {
6445   int extra = 0;
6446
6447   NSTRACE ("[EmacsView windowWillResize:toSize: " NSTRACE_FMT_SIZE "]",
6448            NSTRACE_ARG_SIZE (frameSize));
6449   NSTRACE_RECT   ("[sender frame]", [sender frame]);
6450   NSTRACE_FSTYPE ("fs_state", fs_state);
6451
6452   if (fs_state == FULLSCREEN_MAXIMIZED
6453       && (maximized_width != (int)frameSize.width
6454           || maximized_height != (int)frameSize.height))
6455     [self setFSValue: FULLSCREEN_NONE];
6456   else if (fs_state == FULLSCREEN_WIDTH
6457            && maximized_width != (int)frameSize.width)
6458     [self setFSValue: FULLSCREEN_NONE];
6459   else if (fs_state == FULLSCREEN_HEIGHT
6460            && maximized_height != (int)frameSize.height)
6461     [self setFSValue: FULLSCREEN_NONE];
6462
6463   if (fs_state == FULLSCREEN_NONE)
6464     maximized_width = maximized_height = -1;
6465
6466   if (! [self isFullscreen])
6467     {
6468       extra = FRAME_NS_TITLEBAR_HEIGHT (emacsframe)
6469         + FRAME_TOOLBAR_HEIGHT (emacsframe);
6470     }
6471
6472   cols = FRAME_PIXEL_WIDTH_TO_TEXT_COLS (emacsframe, frameSize.width);
6473   if (cols < MINWIDTH)
6474     cols = MINWIDTH;
6475
6476   rows = FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (emacsframe,
6477                                            frameSize.height - extra);
6478   if (rows < MINHEIGHT)
6479     rows = MINHEIGHT;
6480 #ifdef NS_IMPL_COCOA
6481   {
6482     /* this sets window title to have size in it; the wm does this under GS */
6483     NSRect r = [[self window] frame];
6484     if (r.size.height == frameSize.height && r.size.width == frameSize.width)
6485       {
6486         if (old_title != 0)
6487           {
6488             xfree (old_title);
6489             old_title = 0;
6490           }
6491       }
6492     else if (fs_state == FULLSCREEN_NONE && ! maximizing_resize)
6493       {
6494         char *size_title;
6495         NSWindow *window = [self window];
6496         if (old_title == 0)
6497           {
6498             char *t = strdup ([[[self window] title] UTF8String]);
6499             char *pos = strstr (t, "  —  ");
6500             if (pos)
6501               *pos = '\0';
6502             old_title = t;
6503           }
6504         size_title = xmalloc (strlen (old_title) + 40);
6505         esprintf (size_title, "%s  —  (%d x %d)", old_title, cols, rows);
6506         [window setTitle: [NSString stringWithUTF8String: size_title]];
6507         [window display];
6508         xfree (size_title);
6509       }
6510   }
6511 #endif /* NS_IMPL_COCOA */
6512
6513   NSTRACE_MSG ("cols: %d  rows: %d", cols, rows);
6514
6515   /* Restrict the new size to the text gird.
6516
6517      Don't restrict the width if the user only adjusted the height, and
6518      vice versa.  (Without this, the frame would shrink, and move
6519      slightly, if the window was resized by dragging one of its
6520      borders.) */
6521   if (!frame_resize_pixelwise)
6522     {
6523       NSRect r = [[self window] frame];
6524
6525       if (r.size.width != frameSize.width)
6526         {
6527           frameSize.width =
6528             FRAME_TEXT_COLS_TO_PIXEL_WIDTH  (emacsframe, cols);
6529         }
6530
6531       if (r.size.height != frameSize.height)
6532         {
6533           frameSize.height =
6534             FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (emacsframe, rows) + extra;
6535         }
6536     }
6537
6538   NSTRACE_RETURN_SIZE (frameSize);
6539
6540   return frameSize;
6541 }
6542
6543
6544 - (void)windowDidResize: (NSNotification *)notification
6545 {
6546   NSTRACE ("[EmacsView windowDidResize:]");
6547   if (!FRAME_LIVE_P (emacsframe))
6548     {
6549       NSTRACE_MSG ("Ignored (frame dead)");
6550       return;
6551     }
6552   if (emacsframe->output_data.ns->in_animation)
6553     {
6554       NSTRACE_MSG ("Ignored (in animation)");
6555       return;
6556     }
6557
6558   if (! [self fsIsNative])
6559     {
6560       NSWindow *theWindow = [notification object];
6561       /* We can get notification on the non-FS window when in
6562          fullscreen mode.  */
6563       if ([self window] != theWindow) return;
6564     }
6565
6566   NSTRACE_RECT ("frame", [[notification object] frame]);
6567
6568 #ifdef NS_IMPL_GNUSTEP
6569   NSWindow *theWindow = [notification object];
6570
6571    /* In GNUstep, at least currently, it's possible to get a didResize
6572       without getting a willResize.. therefore we need to act as if we got
6573       the willResize now */
6574   NSSize sz = [theWindow frame].size;
6575   sz = [self windowWillResize: theWindow toSize: sz];
6576 #endif /* NS_IMPL_GNUSTEP */
6577
6578   if (cols > 0 && rows > 0)
6579     {
6580       [self updateFrameSize: YES];
6581     }
6582
6583   ns_send_appdefined (-1);
6584 }
6585
6586 #ifdef NS_IMPL_COCOA
6587 - (void)viewDidEndLiveResize
6588 {
6589   NSTRACE ("[EmacsView viewDidEndLiveResize]");
6590
6591   [super viewDidEndLiveResize];
6592   if (old_title != 0)
6593     {
6594       [[self window] setTitle: [NSString stringWithUTF8String: old_title]];
6595       xfree (old_title);
6596       old_title = 0;
6597     }
6598   maximizing_resize = NO;
6599 }
6600 #endif /* NS_IMPL_COCOA */
6601
6602
6603 - (void)windowDidBecomeKey: (NSNotification *)notification
6604 /* cf. x_detect_focus_change(), x_focus_changed(), x_new_focus_frame() */
6605 {
6606   [self windowDidBecomeKey];
6607 }
6608
6609
6610 - (void)windowDidBecomeKey      /* for direct calls */
6611 {
6612   struct ns_display_info *dpyinfo = FRAME_DISPLAY_INFO (emacsframe);
6613   struct frame *old_focus = dpyinfo->x_focus_frame;
6614
6615   NSTRACE ("[EmacsView windowDidBecomeKey]");
6616
6617   if (emacsframe != old_focus)
6618     dpyinfo->x_focus_frame = emacsframe;
6619
6620   ns_frame_rehighlight (emacsframe);
6621
6622   if (emacs_event)
6623     {
6624       emacs_event->kind = FOCUS_IN_EVENT;
6625       EV_TRAILER ((id)nil);
6626     }
6627 }
6628
6629
6630 - (void)windowDidResignKey: (NSNotification *)notification
6631 /* cf. x_detect_focus_change(), x_focus_changed(), x_new_focus_frame() */
6632 {
6633   struct ns_display_info *dpyinfo = FRAME_DISPLAY_INFO (emacsframe);
6634   BOOL is_focus_frame = dpyinfo->x_focus_frame == emacsframe;
6635   NSTRACE ("[EmacsView windowDidResignKey:]");
6636
6637   if (is_focus_frame)
6638     dpyinfo->x_focus_frame = 0;
6639
6640   emacsframe->mouse_moved = 0;
6641   ns_frame_rehighlight (emacsframe);
6642
6643   /* FIXME: for some reason needed on second and subsequent clicks away
6644             from sole-frame Emacs to get hollow box to show */
6645   if (!windowClosing && [[self window] isVisible] == YES)
6646     {
6647       x_update_cursor (emacsframe, 1);
6648       x_set_frame_alpha (emacsframe);
6649     }
6650
6651   if (any_help_event_p)
6652     {
6653       Lisp_Object frame;
6654       XSETFRAME (frame, emacsframe);
6655       help_echo_string = Qnil;
6656       gen_help_event (Qnil, frame, Qnil, Qnil, 0);
6657     }
6658
6659   if (emacs_event && is_focus_frame)
6660     {
6661       [self deleteWorkingText];
6662       emacs_event->kind = FOCUS_OUT_EVENT;
6663       EV_TRAILER ((id)nil);
6664     }
6665 }
6666
6667
6668 - (void)windowWillMiniaturize: sender
6669 {
6670   NSTRACE ("[EmacsView windowWillMiniaturize:]");
6671 }
6672
6673
6674 - (void)setFrame:(NSRect)frameRect;
6675 {
6676   NSTRACE ("[EmacsView setFrame:" NSTRACE_FMT_RECT "]",
6677            NSTRACE_ARG_RECT (frameRect));
6678
6679   [super setFrame:(NSRect)frameRect];
6680 }
6681
6682
6683 - (BOOL)isFlipped
6684 {
6685   return YES;
6686 }
6687
6688
6689 - (BOOL)isOpaque
6690 {
6691   return NO;
6692 }
6693
6694
6695 - initFrameFromEmacs: (struct frame *)f
6696 {
6697   NSRect r, wr;
6698   Lisp_Object tem;
6699   NSWindow *win;
6700   NSColor *col;
6701   NSString *name;
6702
6703   NSTRACE ("[EmacsView initFrameFromEmacs:]");
6704   NSTRACE_MSG ("cols:%d lines:%d", f->text_cols, f->text_lines);
6705
6706   windowClosing = NO;
6707   processingCompose = NO;
6708   scrollbarsNeedingUpdate = 0;
6709   fs_state = FULLSCREEN_NONE;
6710   fs_before_fs = next_maximized = -1;
6711 #ifdef HAVE_NATIVE_FS
6712   fs_is_native = ns_use_native_fullscreen;
6713 #else
6714   fs_is_native = NO;
6715 #endif
6716   maximized_width = maximized_height = -1;
6717   nonfs_window = nil;
6718
6719   ns_userRect = NSMakeRect (0, 0, 0, 0);
6720   r = NSMakeRect (0, 0, FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f, f->text_cols),
6721                  FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f, f->text_lines));
6722   [self initWithFrame: r];
6723   [self setAutoresizingMask: NSViewWidthSizable | NSViewHeightSizable];
6724
6725   FRAME_NS_VIEW (f) = self;
6726   emacsframe = f;
6727 #ifdef NS_IMPL_COCOA
6728   old_title = 0;
6729   maximizing_resize = NO;
6730 #endif
6731
6732   win = [[EmacsWindow alloc]
6733             initWithContentRect: r
6734                       styleMask: (NSWindowStyleMaskResizable |
6735 #if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_7
6736                                   NSWindowStyleMaskTitled |
6737 #endif
6738                                   NSWindowStyleMaskMiniaturizable |
6739                                   NSWindowStyleMaskClosable)
6740                         backing: NSBackingStoreBuffered
6741                           defer: YES];
6742
6743 #ifdef HAVE_NATIVE_FS
6744     [win setCollectionBehavior:NSWindowCollectionBehaviorFullScreenPrimary];
6745 #endif
6746
6747   wr = [win frame];
6748   bwidth = f->border_width = wr.size.width - r.size.width;
6749   tibar_height = FRAME_NS_TITLEBAR_HEIGHT (f) = wr.size.height - r.size.height;
6750
6751   [win setAcceptsMouseMovedEvents: YES];
6752   [win setDelegate: self];
6753 #if !defined (NS_IMPL_COCOA) || \
6754   MAC_OS_X_VERSION_MAX_ALLOWED <= MAC_OS_X_VERSION_10_9
6755   [win useOptimizedDrawing: YES];
6756 #endif
6757
6758   [[win contentView] addSubview: self];
6759
6760   if (ns_drag_types)
6761     [self registerForDraggedTypes: ns_drag_types];
6762
6763   tem = f->name;
6764   name = [NSString stringWithUTF8String:
6765                    NILP (tem) ? "Emacs" : SSDATA (tem)];
6766   [win setTitle: name];
6767
6768   /* toolbar support */
6769   toolbar = [[EmacsToolbar alloc] initForView: self withIdentifier:
6770                          [NSString stringWithFormat: @"Emacs Frame %d",
6771                                    ns_window_num]];
6772   [win setToolbar: toolbar];
6773   [toolbar setVisible: NO];
6774
6775   /* Don't set frame garbaged until tool bar is up to date?
6776      This avoids an extra clear and redraw (flicker) at frame creation.  */
6777   if (FRAME_EXTERNAL_TOOL_BAR (f)) wait_for_tool_bar = YES;
6778   else wait_for_tool_bar = NO;
6779
6780
6781 #ifdef NS_IMPL_COCOA
6782   {
6783     NSButton *toggleButton;
6784   toggleButton = [win standardWindowButton: NSWindowToolbarButton];
6785   [toggleButton setTarget: self];
6786   [toggleButton setAction: @selector (toggleToolbar: )];
6787   }
6788 #endif
6789   FRAME_TOOLBAR_HEIGHT (f) = 0;
6790
6791   tem = f->icon_name;
6792   if (!NILP (tem))
6793     [win setMiniwindowTitle:
6794            [NSString stringWithUTF8String: SSDATA (tem)]];
6795
6796   {
6797     NSScreen *screen = [win screen];
6798
6799     if (screen != 0)
6800       {
6801         NSPoint pt = NSMakePoint
6802           (IN_BOUND (-SCREENMAX, f->left_pos, SCREENMAX),
6803            IN_BOUND (-SCREENMAX,
6804                      [screen frame].size.height - NS_TOP_POS (f), SCREENMAX));
6805
6806         [win setFrameTopLeftPoint: pt];
6807
6808         NSTRACE_RECT ("new frame", [win frame]);
6809       }
6810   }
6811
6812   [win makeFirstResponder: self];
6813
6814   col = ns_lookup_indexed_color (NS_FACE_BACKGROUND
6815                                  (FACE_FROM_ID (emacsframe, DEFAULT_FACE_ID)),
6816                                  emacsframe);
6817   [win setBackgroundColor: col];
6818   if ([col alphaComponent] != (EmacsCGFloat) 1.0)
6819     [win setOpaque: NO];
6820
6821 #if !defined (NS_IMPL_COCOA) || \
6822   MAC_OS_X_VERSION_MAX_ALLOWED <= MAC_OS_X_VERSION_10_9
6823   [self allocateGState];
6824 #endif
6825   [NSApp registerServicesMenuSendTypes: ns_send_types
6826                            returnTypes: nil];
6827
6828   ns_window_num++;
6829   return self;
6830 }
6831
6832
6833 - (void)windowDidMove: sender
6834 {
6835   NSWindow *win = [self window];
6836   NSRect r = [win frame];
6837   NSArray *screens = [NSScreen screens];
6838   NSScreen *screen = [screens objectAtIndex: 0];
6839
6840   NSTRACE ("[EmacsView windowDidMove:]");
6841
6842   if (!emacsframe->output_data.ns)
6843     return;
6844   if (screen != nil)
6845     {
6846       emacsframe->left_pos = r.origin.x;
6847       emacsframe->top_pos =
6848         [screen frame].size.height - (r.origin.y + r.size.height);
6849     }
6850 }
6851
6852
6853 /* Called AFTER method below, but before our windowWillResize call there leads
6854    to windowDidResize -> x_set_window_size.  Update emacs' notion of frame
6855    location so set_window_size moves the frame. */
6856 - (BOOL)windowShouldZoom: (NSWindow *)sender toFrame: (NSRect)newFrame
6857 {
6858   NSTRACE (("[EmacsView windowShouldZoom:toFrame:" NSTRACE_FMT_RECT "]"
6859             NSTRACE_FMT_RETURN "YES"),
6860            NSTRACE_ARG_RECT (newFrame));
6861
6862   emacsframe->output_data.ns->zooming = 1;
6863   return YES;
6864 }
6865
6866
6867 /* Override to do something slightly nonstandard, but nice.  First click on
6868    zoom button will zoom vertically.  Second will zoom completely.  Third
6869    returns to original. */
6870 - (NSRect)windowWillUseStandardFrame:(NSWindow *)sender
6871                         defaultFrame:(NSRect)defaultFrame
6872 {
6873   // TODO: Rename to "currentFrame" and assign "result" properly in
6874   // all paths.
6875   NSRect result = [sender frame];
6876
6877   NSTRACE (("[EmacsView windowWillUseStandardFrame:defaultFrame:"
6878             NSTRACE_FMT_RECT "]"),
6879            NSTRACE_ARG_RECT (defaultFrame));
6880   NSTRACE_FSTYPE ("fs_state", fs_state);
6881   NSTRACE_FSTYPE ("fs_before_fs", fs_before_fs);
6882   NSTRACE_FSTYPE ("next_maximized", next_maximized);
6883   NSTRACE_RECT   ("ns_userRect", ns_userRect);
6884   NSTRACE_RECT   ("[sender frame]", [sender frame]);
6885
6886   if (fs_before_fs != -1) /* Entering fullscreen */
6887     {
6888       NSTRACE_MSG ("Entering fullscreen");
6889       result = defaultFrame;
6890     }
6891   else
6892     {
6893       // Save the window size and position (frame) before the resize.
6894       if (fs_state != FULLSCREEN_MAXIMIZED
6895           && fs_state != FULLSCREEN_WIDTH)
6896         {
6897           ns_userRect.size.width = result.size.width;
6898           ns_userRect.origin.x   = result.origin.x;
6899         }
6900
6901       if (fs_state != FULLSCREEN_MAXIMIZED
6902           && fs_state != FULLSCREEN_HEIGHT)
6903         {
6904           ns_userRect.size.height = result.size.height;
6905           ns_userRect.origin.y    = result.origin.y;
6906         }
6907
6908       NSTRACE_RECT ("ns_userRect (2)", ns_userRect);
6909
6910       if (next_maximized == FULLSCREEN_HEIGHT
6911           || (next_maximized == -1
6912               && abs ((int)(defaultFrame.size.height - result.size.height))
6913               > FRAME_LINE_HEIGHT (emacsframe)))
6914         {
6915           /* first click */
6916           NSTRACE_MSG ("FULLSCREEN_HEIGHT");
6917           maximized_height = result.size.height = defaultFrame.size.height;
6918           maximized_width = -1;
6919           result.origin.y = defaultFrame.origin.y;
6920           if (ns_userRect.size.height != 0)
6921             {
6922               result.origin.x = ns_userRect.origin.x;
6923               result.size.width = ns_userRect.size.width;
6924             }
6925           [self setFSValue: FULLSCREEN_HEIGHT];
6926 #ifdef NS_IMPL_COCOA
6927           maximizing_resize = YES;
6928 #endif
6929         }
6930       else if (next_maximized == FULLSCREEN_WIDTH)
6931         {
6932           NSTRACE_MSG ("FULLSCREEN_WIDTH");
6933           maximized_width = result.size.width = defaultFrame.size.width;
6934           maximized_height = -1;
6935           result.origin.x = defaultFrame.origin.x;
6936           if (ns_userRect.size.width != 0)
6937             {
6938               result.origin.y = ns_userRect.origin.y;
6939               result.size.height = ns_userRect.size.height;
6940             }
6941           [self setFSValue: FULLSCREEN_WIDTH];
6942         }
6943       else if (next_maximized == FULLSCREEN_MAXIMIZED
6944                || (next_maximized == -1
6945                    && abs ((int)(defaultFrame.size.width - result.size.width))
6946                    > FRAME_COLUMN_WIDTH (emacsframe)))
6947         {
6948           NSTRACE_MSG ("FULLSCREEN_MAXIMIZED");
6949
6950           result = defaultFrame;  /* second click */
6951           maximized_width = result.size.width;
6952           maximized_height = result.size.height;
6953           [self setFSValue: FULLSCREEN_MAXIMIZED];
6954 #ifdef NS_IMPL_COCOA
6955           maximizing_resize = YES;
6956 #endif
6957         }
6958       else
6959         {
6960           /* restore */
6961           NSTRACE_MSG ("Restore");
6962           result = ns_userRect.size.height ? ns_userRect : result;
6963           NSTRACE_RECT ("restore (2)", result);
6964           ns_userRect = NSMakeRect (0, 0, 0, 0);
6965 #ifdef NS_IMPL_COCOA
6966           maximizing_resize = fs_state != FULLSCREEN_NONE;
6967 #endif
6968           [self setFSValue: FULLSCREEN_NONE];
6969           maximized_width = maximized_height = -1;
6970         }
6971     }
6972
6973   if (fs_before_fs == -1) next_maximized = -1;
6974
6975   NSTRACE_RECT   ("Final ns_userRect", ns_userRect);
6976   NSTRACE_MSG    ("Final maximized_width: %d", maximized_width);
6977   NSTRACE_MSG    ("Final maximized_height: %d", maximized_height);
6978   NSTRACE_FSTYPE ("Final next_maximized", next_maximized);
6979
6980   [self windowWillResize: sender toSize: result.size];
6981
6982   NSTRACE_RETURN_RECT (result);
6983
6984   return result;
6985 }
6986
6987
6988 - (void)windowDidDeminiaturize: sender
6989 {
6990   NSTRACE ("[EmacsView windowDidDeminiaturize:]");
6991   if (!emacsframe->output_data.ns)
6992     return;
6993
6994   SET_FRAME_ICONIFIED (emacsframe, 0);
6995   SET_FRAME_VISIBLE (emacsframe, 1);
6996   windows_or_buffers_changed = 63;
6997
6998   if (emacs_event)
6999     {
7000       emacs_event->kind = DEICONIFY_EVENT;
7001       EV_TRAILER ((id)nil);
7002     }
7003 }
7004
7005
7006 - (void)windowDidExpose: sender
7007 {
7008   NSTRACE ("[EmacsView windowDidExpose:]");
7009   if (!emacsframe->output_data.ns)
7010     return;
7011
7012   SET_FRAME_VISIBLE (emacsframe, 1);
7013   SET_FRAME_GARBAGED (emacsframe);
7014
7015   if (send_appdefined)
7016     ns_send_appdefined (-1);
7017 }
7018
7019
7020 - (void)windowDidMiniaturize: sender
7021 {
7022   NSTRACE ("[EmacsView windowDidMiniaturize:]");
7023   if (!emacsframe->output_data.ns)
7024     return;
7025
7026   SET_FRAME_ICONIFIED (emacsframe, 1);
7027   SET_FRAME_VISIBLE (emacsframe, 0);
7028
7029   if (emacs_event)
7030     {
7031       emacs_event->kind = ICONIFY_EVENT;
7032       EV_TRAILER ((id)nil);
7033     }
7034 }
7035
7036 #ifdef HAVE_NATIVE_FS
7037 - (NSApplicationPresentationOptions)window:(NSWindow *)window
7038       willUseFullScreenPresentationOptions:
7039   (NSApplicationPresentationOptions)proposedOptions
7040 {
7041   return proposedOptions|NSApplicationPresentationAutoHideToolbar;
7042 }
7043 #endif
7044
7045 - (void)windowWillEnterFullScreen:(NSNotification *)notification
7046 {
7047   NSTRACE ("[EmacsView windowWillEnterFullScreen:]");
7048   [self windowWillEnterFullScreen];
7049 }
7050 - (void)windowWillEnterFullScreen /* provided for direct calls */
7051 {
7052   NSTRACE ("[EmacsView windowWillEnterFullScreen]");
7053   fs_before_fs = fs_state;
7054 }
7055
7056 - (void)windowDidEnterFullScreen:(NSNotification *)notification
7057 {
7058   NSTRACE ("[EmacsView windowDidEnterFullScreen:]");
7059   [self windowDidEnterFullScreen];
7060 }
7061
7062 - (void)windowDidEnterFullScreen /* provided for direct calls */
7063 {
7064   NSTRACE ("[EmacsView windowDidEnterFullScreen]");
7065   [self setFSValue: FULLSCREEN_BOTH];
7066   if (! [self fsIsNative])
7067     {
7068       [self windowDidBecomeKey];
7069       [nonfs_window orderOut:self];
7070     }
7071   else
7072     {
7073       BOOL tbar_visible = FRAME_EXTERNAL_TOOL_BAR (emacsframe) ? YES : NO;
7074 #ifdef NS_IMPL_COCOA
7075 #if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_7
7076       unsigned val = (unsigned)[NSApp presentationOptions];
7077
7078       // Mac OS X 10.7 bug fix, the menu won't appear without this.
7079       // val is non-zero on other macOS versions.
7080       if (val == 0)
7081         {
7082           NSApplicationPresentationOptions options
7083             = NSApplicationPresentationAutoHideDock
7084             | NSApplicationPresentationAutoHideMenuBar
7085             | NSApplicationPresentationFullScreen
7086             | NSApplicationPresentationAutoHideToolbar;
7087
7088           [NSApp setPresentationOptions: options];
7089         }
7090 #endif
7091 #endif
7092       [toolbar setVisible:tbar_visible];
7093     }
7094 }
7095
7096 - (void)windowWillExitFullScreen:(NSNotification *)notification
7097 {
7098   NSTRACE ("[EmacsView windowWillExitFullScreen:]");
7099   [self windowWillExitFullScreen];
7100 }
7101
7102 - (void)windowWillExitFullScreen /* provided for direct calls */
7103 {
7104   NSTRACE ("[EmacsView windowWillExitFullScreen]");
7105   if (!FRAME_LIVE_P (emacsframe))
7106     {
7107       NSTRACE_MSG ("Ignored (frame dead)");
7108       return;
7109     }
7110   if (next_maximized != -1)
7111     fs_before_fs = next_maximized;
7112 }
7113
7114 - (void)windowDidExitFullScreen:(NSNotification *)notification
7115 {
7116   NSTRACE ("[EmacsView windowDidExitFullScreen:]");
7117   [self windowDidExitFullScreen];
7118 }
7119
7120 - (void)windowDidExitFullScreen /* provided for direct calls */
7121 {
7122   NSTRACE ("[EmacsView windowDidExitFullScreen]");
7123   if (!FRAME_LIVE_P (emacsframe))
7124     {
7125       NSTRACE_MSG ("Ignored (frame dead)");
7126       return;
7127     }
7128   [self setFSValue: fs_before_fs];
7129   fs_before_fs = -1;
7130 #ifdef HAVE_NATIVE_FS
7131   [self updateCollectionBehavior];
7132 #endif
7133   if (FRAME_EXTERNAL_TOOL_BAR (emacsframe))
7134     {
7135       [toolbar setVisible:YES];
7136       update_frame_tool_bar (emacsframe);
7137       [self updateFrameSize:YES];
7138       [[self window] display];
7139     }
7140   else
7141     [toolbar setVisible:NO];
7142
7143   if (next_maximized != -1)
7144     [[self window] performZoom:self];
7145 }
7146
7147 - (BOOL)fsIsNative
7148 {
7149   return fs_is_native;
7150 }
7151
7152 - (BOOL)isFullscreen
7153 {
7154   BOOL res;
7155
7156   if (! fs_is_native)
7157     {
7158       res = (nonfs_window != nil);
7159     }
7160   else
7161     {
7162 #ifdef HAVE_NATIVE_FS
7163       res = (([[self window] styleMask] & NSWindowStyleMaskFullScreen) != 0);
7164 #else
7165       res = NO;
7166 #endif
7167     }
7168
7169   NSTRACE ("[EmacsView isFullscreen] " NSTRACE_FMT_RETURN " %d",
7170            (int) res);
7171
7172   return res;
7173 }
7174
7175 #ifdef HAVE_NATIVE_FS
7176 - (void)updateCollectionBehavior
7177 {
7178   NSTRACE ("[EmacsView updateCollectionBehavior]");
7179
7180   if (! [self isFullscreen])
7181     {
7182       NSWindow *win = [self window];
7183       NSWindowCollectionBehavior b = [win collectionBehavior];
7184       if (ns_use_native_fullscreen)
7185         b |= NSWindowCollectionBehaviorFullScreenPrimary;
7186       else
7187         b &= ~NSWindowCollectionBehaviorFullScreenPrimary;
7188
7189       [win setCollectionBehavior: b];
7190       fs_is_native = ns_use_native_fullscreen;
7191     }
7192 }
7193 #endif
7194
7195 - (void)toggleFullScreen: (id)sender
7196 {
7197   NSWindow *w, *fw;
7198   BOOL onFirstScreen;
7199   struct frame *f;
7200   NSRect r, wr;
7201   NSColor *col;
7202
7203   NSTRACE ("[EmacsView toggleFullScreen:]");
7204
7205   if (fs_is_native)
7206     {
7207 #ifdef HAVE_NATIVE_FS
7208       [[self window] toggleFullScreen:sender];
7209 #endif
7210       return;
7211     }
7212
7213   w = [self window];
7214   onFirstScreen = [[w screen] isEqual:[[NSScreen screens] objectAtIndex:0]];
7215   f = emacsframe;
7216   wr = [w frame];
7217   col = ns_lookup_indexed_color (NS_FACE_BACKGROUND
7218                                  (FACE_FROM_ID (f, DEFAULT_FACE_ID)),
7219                                  f);
7220
7221   if (fs_state != FULLSCREEN_BOTH)
7222     {
7223       NSScreen *screen = [w screen];
7224
7225 #if defined (NS_IMPL_COCOA) && \
7226   MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_9
7227       /* Hide ghost menu bar on secondary monitor? */
7228       if (! onFirstScreen)
7229         onFirstScreen = [NSScreen screensHaveSeparateSpaces];
7230 #endif
7231       /* Hide dock and menubar if we are on the primary screen.  */
7232       if (onFirstScreen)
7233         {
7234 #ifdef NS_IMPL_COCOA
7235           NSApplicationPresentationOptions options
7236             = NSApplicationPresentationAutoHideDock
7237             | NSApplicationPresentationAutoHideMenuBar;
7238
7239           [NSApp setPresentationOptions: options];
7240 #else
7241           [NSMenu setMenuBarVisible:NO];
7242 #endif
7243         }
7244
7245       fw = [[EmacsFSWindow alloc]
7246                        initWithContentRect:[w contentRectForFrameRect:wr]
7247                                  styleMask:NSWindowStyleMaskBorderless
7248                                    backing:NSBackingStoreBuffered
7249                                      defer:YES
7250                                     screen:screen];
7251
7252       [fw setContentView:[w contentView]];
7253       [fw setTitle:[w title]];
7254       [fw setDelegate:self];
7255       [fw setAcceptsMouseMovedEvents: YES];
7256 #if !defined (NS_IMPL_COCOA) || \
7257   MAC_OS_X_VERSION_MAX_ALLOWED <= MAC_OS_X_VERSION_10_9
7258       [fw useOptimizedDrawing: YES];
7259 #endif
7260       [fw setBackgroundColor: col];
7261       if ([col alphaComponent] != (EmacsCGFloat) 1.0)
7262         [fw setOpaque: NO];
7263
7264       f->border_width = 0;
7265       FRAME_NS_TITLEBAR_HEIGHT (f) = 0;
7266       tobar_height = FRAME_TOOLBAR_HEIGHT (f);
7267       FRAME_TOOLBAR_HEIGHT (f) = 0;
7268
7269       nonfs_window = w;
7270
7271       [self windowWillEnterFullScreen];
7272       [fw makeKeyAndOrderFront:NSApp];
7273       [fw makeFirstResponder:self];
7274       [w orderOut:self];
7275       r = [fw frameRectForContentRect:[screen frame]];
7276       [fw setFrame: r display:YES animate:ns_use_fullscreen_animation];
7277       [self windowDidEnterFullScreen];
7278       [fw display];
7279     }
7280   else
7281     {
7282       fw = w;
7283       w = nonfs_window;
7284       nonfs_window = nil;
7285
7286       if (onFirstScreen)
7287         {
7288 #ifdef NS_IMPL_COCOA
7289           [NSApp setPresentationOptions: NSApplicationPresentationDefault];
7290 #else
7291           [NSMenu setMenuBarVisible:YES];
7292 #endif
7293         }
7294
7295       [w setContentView:[fw contentView]];
7296       [w setBackgroundColor: col];
7297       if ([col alphaComponent] != (EmacsCGFloat) 1.0)
7298         [w setOpaque: NO];
7299
7300       f->border_width = bwidth;
7301       FRAME_NS_TITLEBAR_HEIGHT (f) = tibar_height;
7302       if (FRAME_EXTERNAL_TOOL_BAR (f))
7303         FRAME_TOOLBAR_HEIGHT (f) = tobar_height;
7304
7305       // to do: consider using [NSNotificationCenter postNotificationName:] to send notifications.
7306
7307       [self windowWillExitFullScreen];
7308       [fw setFrame: [w frame] display:YES animate:ns_use_fullscreen_animation];
7309       [fw close];
7310       [w makeKeyAndOrderFront:NSApp];
7311       [self windowDidExitFullScreen];
7312       [self updateFrameSize:YES];
7313     }
7314 }
7315
7316 - (void)handleFS
7317 {
7318   NSTRACE ("[EmacsView handleFS]");
7319
7320   if (fs_state != emacsframe->want_fullscreen)
7321     {
7322       if (fs_state == FULLSCREEN_BOTH)
7323         {
7324           NSTRACE_MSG ("fs_state == FULLSCREEN_BOTH");
7325           [self toggleFullScreen:self];
7326         }
7327
7328       switch (emacsframe->want_fullscreen)
7329         {
7330         case FULLSCREEN_BOTH:
7331           NSTRACE_MSG ("FULLSCREEN_BOTH");
7332           [self toggleFullScreen:self];
7333           break;
7334         case FULLSCREEN_WIDTH:
7335           NSTRACE_MSG ("FULLSCREEN_WIDTH");
7336           next_maximized = FULLSCREEN_WIDTH;
7337           if (fs_state != FULLSCREEN_BOTH)
7338             [[self window] performZoom:self];
7339           break;
7340         case FULLSCREEN_HEIGHT:
7341           NSTRACE_MSG ("FULLSCREEN_HEIGHT");
7342           next_maximized = FULLSCREEN_HEIGHT;
7343           if (fs_state != FULLSCREEN_BOTH)
7344             [[self window] performZoom:self];
7345           break;
7346         case FULLSCREEN_MAXIMIZED:
7347           NSTRACE_MSG ("FULLSCREEN_MAXIMIZED");
7348           next_maximized = FULLSCREEN_MAXIMIZED;
7349           if (fs_state != FULLSCREEN_BOTH)
7350             [[self window] performZoom:self];
7351           break;
7352         case FULLSCREEN_NONE:
7353           NSTRACE_MSG ("FULLSCREEN_NONE");
7354           if (fs_state != FULLSCREEN_BOTH)
7355             {
7356               next_maximized = FULLSCREEN_NONE;
7357               [[self window] performZoom:self];
7358             }
7359           break;
7360         }
7361
7362       emacsframe->want_fullscreen = FULLSCREEN_NONE;
7363     }
7364
7365 }
7366
7367 - (void) setFSValue: (int)value
7368 {
7369   NSTRACE ("[EmacsView setFSValue:" NSTRACE_FMT_FSTYPE "]",
7370            NSTRACE_ARG_FSTYPE(value));
7371
7372   Lisp_Object lval = Qnil;
7373   switch (value)
7374     {
7375     case FULLSCREEN_BOTH:
7376       lval = Qfullboth;
7377       break;
7378     case FULLSCREEN_WIDTH:
7379       lval = Qfullwidth;
7380       break;
7381     case FULLSCREEN_HEIGHT:
7382       lval = Qfullheight;
7383       break;
7384     case FULLSCREEN_MAXIMIZED:
7385       lval = Qmaximized;
7386       break;
7387     }
7388   store_frame_param (emacsframe, Qfullscreen, lval);
7389   fs_state = value;
7390 }
7391
7392 - (void)mouseEntered: (NSEvent *)theEvent
7393 {
7394   NSTRACE ("[EmacsView mouseEntered:]");
7395   if (emacsframe)
7396     FRAME_DISPLAY_INFO (emacsframe)->last_mouse_movement_time
7397       = EV_TIMESTAMP (theEvent);
7398 }
7399
7400
7401 - (void)mouseExited: (NSEvent *)theEvent
7402 {
7403   Mouse_HLInfo *hlinfo = emacsframe ? MOUSE_HL_INFO (emacsframe) : NULL;
7404
7405   NSTRACE ("[EmacsView mouseExited:]");
7406
7407   if (!hlinfo)
7408     return;
7409
7410   FRAME_DISPLAY_INFO (emacsframe)->last_mouse_movement_time
7411     = EV_TIMESTAMP (theEvent);
7412
7413   if (emacsframe == hlinfo->mouse_face_mouse_frame)
7414     {
7415       clear_mouse_face (hlinfo);
7416       hlinfo->mouse_face_mouse_frame = 0;
7417     }
7418 }
7419
7420
7421 - menuDown: sender
7422 {
7423   NSTRACE ("[EmacsView menuDown:]");
7424   if (context_menu_value == -1)
7425     context_menu_value = [sender tag];
7426   else
7427     {
7428       NSInteger tag = [sender tag];
7429       find_and_call_menu_selection (emacsframe, emacsframe->menu_bar_items_used,
7430                                     emacsframe->menu_bar_vector,
7431                                     (void *)tag);
7432     }
7433
7434   ns_send_appdefined (-1);
7435   return self;
7436 }
7437
7438
7439 - (EmacsToolbar *)toolbar
7440 {
7441   return toolbar;
7442 }
7443
7444
7445 /* this gets called on toolbar button click */
7446 - toolbarClicked: (id)item
7447 {
7448   NSEvent *theEvent;
7449   int idx = [item tag] * TOOL_BAR_ITEM_NSLOTS;
7450
7451   NSTRACE ("[EmacsView toolbarClicked:]");
7452
7453   if (!emacs_event)
7454     return self;
7455
7456   /* send first event (for some reason two needed) */
7457   theEvent = [[self window] currentEvent];
7458   emacs_event->kind = TOOL_BAR_EVENT;
7459   XSETFRAME (emacs_event->arg, emacsframe);
7460   EV_TRAILER (theEvent);
7461
7462   emacs_event->kind = TOOL_BAR_EVENT;
7463 /*   XSETINT (emacs_event->code, 0); */
7464   emacs_event->arg = AREF (emacsframe->tool_bar_items,
7465                            idx + TOOL_BAR_ITEM_KEY);
7466   emacs_event->modifiers = EV_MODIFIERS (theEvent);
7467   EV_TRAILER (theEvent);
7468   return self;
7469 }
7470
7471
7472 - toggleToolbar: (id)sender
7473 {
7474   NSTRACE ("[EmacsView toggleToolbar:]");
7475
7476   if (!emacs_event)
7477     return self;
7478
7479   emacs_event->kind = NS_NONKEY_EVENT;
7480   emacs_event->code = KEY_NS_TOGGLE_TOOLBAR;
7481   EV_TRAILER ((id)nil);
7482   return self;
7483 }
7484
7485
7486 - (void)drawRect: (NSRect)rect
7487 {
7488   int x = NSMinX (rect), y = NSMinY (rect);
7489   int width = NSWidth (rect), height = NSHeight (rect);
7490
7491   NSTRACE ("[EmacsView drawRect:" NSTRACE_FMT_RECT "]",
7492            NSTRACE_ARG_RECT(rect));
7493
7494   if (!emacsframe || !emacsframe->output_data.ns)
7495     return;
7496
7497   ns_clear_frame_area (emacsframe, x, y, width, height);
7498   block_input ();
7499   expose_frame (emacsframe, x, y, width, height);
7500   unblock_input ();
7501
7502   /*
7503     drawRect: may be called (at least in Mac OS X 10.5) for invisible
7504     views as well for some reason.  Thus, do not infer visibility
7505     here.
7506
7507     emacsframe->async_visible = 1;
7508     emacsframe->async_iconified = 0;
7509   */
7510 }
7511
7512
7513 /* NSDraggingDestination protocol methods.  Actually this is not really a
7514    protocol, but a category of Object.  O well...  */
7515
7516 -(NSDragOperation) draggingEntered: (id <NSDraggingInfo>) sender
7517 {
7518   NSTRACE ("[EmacsView draggingEntered:]");
7519   return NSDragOperationGeneric;
7520 }
7521
7522
7523 -(BOOL)prepareForDragOperation: (id <NSDraggingInfo>) sender
7524 {
7525   return YES;
7526 }
7527
7528
7529 -(BOOL)performDragOperation: (id <NSDraggingInfo>) sender
7530 {
7531   id pb;
7532   int x, y;
7533   NSString *type;
7534   NSEvent *theEvent = [[self window] currentEvent];
7535   NSPoint position;
7536   NSDragOperation op = [sender draggingSourceOperationMask];
7537   int modifiers = 0;
7538
7539   NSTRACE ("[EmacsView performDragOperation:]");
7540
7541   if (!emacs_event)
7542     return NO;
7543
7544   position = [self convertPoint: [sender draggingLocation] fromView: nil];
7545   x = lrint (position.x);  y = lrint (position.y);
7546
7547   pb = [sender draggingPasteboard];
7548   type = [pb availableTypeFromArray: ns_drag_types];
7549
7550   if (! (op & (NSDragOperationMove|NSDragOperationDelete)) &&
7551       // URL drags contain all operations (0xf), don't allow all to be set.
7552       (op & 0xf) != 0xf)
7553     {
7554       if (op & NSDragOperationLink)
7555         modifiers |= NSEventModifierFlagControl;
7556       if (op & NSDragOperationCopy)
7557         modifiers |= NSEventModifierFlagOption;
7558       if (op & NSDragOperationGeneric)
7559         modifiers |= NSEventModifierFlagCommand;
7560     }
7561
7562   modifiers = EV_MODIFIERS2 (modifiers);
7563   if (type == 0)
7564     {
7565       return NO;
7566     }
7567   else if ([type isEqualToString: NSFilenamesPboardType])
7568     {
7569       NSArray *files;
7570       NSEnumerator *fenum;
7571       NSString *file;
7572
7573       if (!(files = [pb propertyListForType: type]))
7574         return NO;
7575
7576       fenum = [files objectEnumerator];
7577       while ( (file = [fenum nextObject]) )
7578         {
7579           emacs_event->kind = DRAG_N_DROP_EVENT;
7580           XSETINT (emacs_event->x, x);
7581           XSETINT (emacs_event->y, y);
7582           ns_input_file = append2 (ns_input_file,
7583                                    build_string ([file UTF8String]));
7584           emacs_event->modifiers = modifiers;
7585           emacs_event->arg =  list2 (Qfile, build_string ([file UTF8String]));
7586           EV_TRAILER (theEvent);
7587         }
7588       return YES;
7589     }
7590   else if ([type isEqualToString: NSURLPboardType])
7591     {
7592       NSURL *url = [NSURL URLFromPasteboard: pb];
7593       if (url == nil) return NO;
7594
7595       emacs_event->kind = DRAG_N_DROP_EVENT;
7596       XSETINT (emacs_event->x, x);
7597       XSETINT (emacs_event->y, y);
7598       emacs_event->modifiers = modifiers;
7599       emacs_event->arg =  list2 (Qurl,
7600                                  build_string ([[url absoluteString]
7601                                                  UTF8String]));
7602       EV_TRAILER (theEvent);
7603
7604       if ([url isFileURL] != NO)
7605         {
7606           NSString *file = [url path];
7607           ns_input_file = append2 (ns_input_file,
7608                                    build_string ([file UTF8String]));
7609         }
7610       return YES;
7611     }
7612   else if ([type isEqualToString: NSStringPboardType]
7613            || [type isEqualToString: NSTabularTextPboardType])
7614     {
7615       NSString *data;
7616
7617       if (! (data = [pb stringForType: type]))
7618         return NO;
7619
7620       emacs_event->kind = DRAG_N_DROP_EVENT;
7621       XSETINT (emacs_event->x, x);
7622       XSETINT (emacs_event->y, y);
7623       emacs_event->modifiers = modifiers;
7624       emacs_event->arg =  list2 (Qnil, build_string ([data UTF8String]));
7625       EV_TRAILER (theEvent);
7626       return YES;
7627     }
7628   else
7629     {
7630       fprintf (stderr, "Invalid data type in dragging pasteboard");
7631       return NO;
7632     }
7633 }
7634
7635
7636 - (id) validRequestorForSendType: (NSString *)typeSent
7637                       returnType: (NSString *)typeReturned
7638 {
7639   NSTRACE ("[EmacsView validRequestorForSendType:returnType:]");
7640   if (typeSent != nil && [ns_send_types indexOfObject: typeSent] != NSNotFound
7641       && typeReturned == nil)
7642     {
7643       if (! NILP (ns_get_local_selection (QPRIMARY, QUTF8_STRING)))
7644         return self;
7645     }
7646
7647   return [super validRequestorForSendType: typeSent
7648                                returnType: typeReturned];
7649 }
7650
7651
7652 /* The next two methods are part of NSServicesRequests informal protocol,
7653    supposedly called when a services menu item is chosen from this app.
7654    But this should not happen because we override the services menu with our
7655    own entries which call ns-perform-service.
7656    Nonetheless, it appeared to happen (under strange circumstances): bug#1435.
7657    So let's at least stub them out until further investigation can be done. */
7658
7659 - (BOOL) readSelectionFromPasteboard: (NSPasteboard *)pb
7660 {
7661   /* we could call ns_string_from_pasteboard(pboard) here but then it should
7662      be written into the buffer in place of the existing selection..
7663      ordinary service calls go through functions defined in ns-win.el */
7664   return NO;
7665 }
7666
7667 - (BOOL) writeSelectionToPasteboard: (NSPasteboard *)pb types: (NSArray *)types
7668 {
7669   NSArray *typesDeclared;
7670   Lisp_Object val;
7671
7672   NSTRACE ("[EmacsView writeSelectionToPasteboard:types:]");
7673
7674   /* We only support NSStringPboardType */
7675   if ([types containsObject:NSStringPboardType] == NO) {
7676     return NO;
7677   }
7678
7679   val = ns_get_local_selection (QPRIMARY, QUTF8_STRING);
7680   if (CONSP (val) && SYMBOLP (XCAR (val)))
7681     {
7682       val = XCDR (val);
7683       if (CONSP (val) && NILP (XCDR (val)))
7684         val = XCAR (val);
7685     }
7686   if (! STRINGP (val))
7687     return NO;
7688
7689   typesDeclared = [NSArray arrayWithObject:NSStringPboardType];
7690   [pb declareTypes:typesDeclared owner:nil];
7691   ns_string_to_pasteboard (pb, val);
7692   return YES;
7693 }
7694
7695
7696 /* setMini =YES means set from internal (gives a finder icon), NO means set nil
7697    (gives a miniaturized version of the window); currently we use the latter for
7698    frames whose active buffer doesn't correspond to any file
7699    (e.g., '*scratch*') */
7700 - setMiniwindowImage: (BOOL) setMini
7701 {
7702   id image = [[self window] miniwindowImage];
7703   NSTRACE ("[EmacsView setMiniwindowImage:%d]", setMini);
7704
7705   /* NOTE: under Cocoa miniwindowImage always returns nil, documentation
7706      about "AppleDockIconEnabled" notwithstanding, however the set message
7707      below has its effect nonetheless. */
7708   if (image != emacsframe->output_data.ns->miniimage)
7709     {
7710       if (image && [image isKindOfClass: [EmacsImage class]])
7711         [image release];
7712       [[self window] setMiniwindowImage:
7713                        setMini ? emacsframe->output_data.ns->miniimage : nil];
7714     }
7715
7716   return self;
7717 }
7718
7719
7720 - (void) setRows: (int) r andColumns: (int) c
7721 {
7722   NSTRACE ("[EmacsView setRows:%d andColumns:%d]", r, c);
7723   rows = r;
7724   cols = c;
7725 }
7726
7727 - (int) fullscreenState
7728 {
7729   return fs_state;
7730 }
7731
7732 @end  /* EmacsView */
7733
7734
7735
7736 /* ==========================================================================
7737
7738     EmacsWindow implementation
7739
7740    ========================================================================== */
7741
7742 @implementation EmacsWindow
7743
7744 #ifdef NS_IMPL_COCOA
7745 - (id)accessibilityAttributeValue:(NSString *)attribute
7746 {
7747   Lisp_Object str = Qnil;
7748   struct frame *f = SELECTED_FRAME ();
7749   struct buffer *curbuf = XBUFFER (XWINDOW (f->selected_window)->contents);
7750
7751   NSTRACE ("[EmacsWindow accessibilityAttributeValue:]");
7752
7753   if ([attribute isEqualToString:NSAccessibilityRoleAttribute])
7754     return NSAccessibilityTextFieldRole;
7755
7756   if ([attribute isEqualToString:NSAccessibilitySelectedTextAttribute]
7757       && curbuf && ! NILP (BVAR (curbuf, mark_active)))
7758     {
7759       str = ns_get_local_selection (QPRIMARY, QUTF8_STRING);
7760     }
7761   else if (curbuf && [attribute isEqualToString:NSAccessibilityValueAttribute])
7762     {
7763       if (! NILP (BVAR (curbuf, mark_active)))
7764           str = ns_get_local_selection (QPRIMARY, QUTF8_STRING);
7765
7766       if (NILP (str))
7767         {
7768           ptrdiff_t start_byte = BUF_BEGV_BYTE (curbuf);
7769           ptrdiff_t byte_range = BUF_ZV_BYTE (curbuf) - start_byte;
7770           ptrdiff_t range = BUF_ZV (curbuf) - BUF_BEGV (curbuf);
7771
7772           if (! NILP (BVAR (curbuf, enable_multibyte_characters)))
7773             str = make_uninit_multibyte_string (range, byte_range);
7774           else
7775             str = make_uninit_string (range);
7776           /* To check: This returns emacs-utf-8, which is a superset of utf-8.
7777              Is this a problem?  */
7778           memcpy (SDATA (str), BYTE_POS_ADDR (start_byte), byte_range);
7779         }
7780     }
7781
7782
7783   if (! NILP (str))
7784     {
7785       if (CONSP (str) && SYMBOLP (XCAR (str)))
7786         {
7787           str = XCDR (str);
7788           if (CONSP (str) && NILP (XCDR (str)))
7789             str = XCAR (str);
7790         }
7791       if (STRINGP (str))
7792         {
7793           const char *utfStr = SSDATA (str);
7794           NSString *nsStr = [NSString stringWithUTF8String: utfStr];
7795           return nsStr;
7796         }
7797     }
7798
7799   return [super accessibilityAttributeValue:attribute];
7800 }
7801 #endif /* NS_IMPL_COCOA */
7802
7803 /* Constrain size and placement of a frame.
7804
7805    By returning the original "frameRect", the frame is not
7806    constrained. This can lead to unwanted situations where, for
7807    example, the menu bar covers the frame.
7808
7809    The default implementation (accessed using "super") constrains the
7810    frame to the visible area of SCREEN, minus the menu bar (if
7811    present) and the Dock.  Note that default implementation also calls
7812    windowWillResize, with the frame it thinks should have.  (This can
7813    make the frame exit maximized mode.)
7814
7815    Note that this should work in situations where multiple monitors
7816    are present.  Common configurations are side-by-side monitors and a
7817    monitor on top of another (e.g. when a laptop is placed under a
7818    large screen). */
7819 - (NSRect)constrainFrameRect:(NSRect)frameRect toScreen:(NSScreen *)screen
7820 {
7821   NSTRACE ("[EmacsWindow constrainFrameRect:" NSTRACE_FMT_RECT " toScreen:]",
7822              NSTRACE_ARG_RECT (frameRect));
7823
7824 #ifdef NS_IMPL_COCOA
7825 #if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_9
7826   // If separate spaces is on, it is like each screen is independent.  There is
7827   // no spanning of frames across screens.
7828   if ([NSScreen screensHaveSeparateSpaces])
7829     {
7830       NSTRACE_MSG ("Screens have separate spaces");
7831       frameRect = [super constrainFrameRect:frameRect toScreen:screen];
7832       NSTRACE_RETURN_RECT (frameRect);
7833       return frameRect;
7834     }
7835 #endif
7836 #endif
7837
7838   return constrain_frame_rect(frameRect,
7839                               [(EmacsView *)[self delegate] isFullscreen]);
7840 }
7841
7842
7843 - (void)performZoom:(id)sender
7844 {
7845   NSTRACE ("[EmacsWindow performZoom:]");
7846
7847   return [super performZoom:sender];
7848 }
7849
7850 - (void)zoom:(id)sender
7851 {
7852   NSTRACE ("[EmacsWindow zoom:]");
7853
7854   ns_update_auto_hide_menu_bar();
7855
7856   // Below are three zoom implementations.  In the final commit, the
7857   // idea is that the last should be included.
7858
7859 #if 0
7860   // Native zoom done using the standard zoom animation.  Size of the
7861   // resulting frame reduced to accommodate the Dock and, if present,
7862   // the menu-bar.
7863   [super zoom:sender];
7864
7865 #elif 0
7866   // Native zoom done using the standard zoom animation, plus an
7867   // explicit resize to cover the full screen, except the menu-bar and
7868   // dock, if present.
7869   [super zoom:sender];
7870
7871   // After the native zoom, resize the resulting frame to fill the
7872   // entire screen, except the menu-bar.
7873   //
7874   // This works for all practical purposes.  (The only minor oddity is
7875   // when transiting from full-height frame to a maximized, the
7876   // animation reduces the height of the frame slightly (to the 4
7877   // pixels needed to accommodate the Doc) before it snaps back into
7878   // full height.  The user would need a very trained eye to spot
7879   // this.)
7880   NSScreen * screen = [self screen];
7881   if (screen != nil)
7882     {
7883       int fs_state = [(EmacsView *)[self delegate] fullscreenState];
7884
7885       NSTRACE_FSTYPE ("fullscreenState", fs_state);
7886
7887       NSRect sr = [screen frame];
7888       struct EmacsMargins margins
7889         = ns_screen_margins_ignoring_hidden_dock(screen);
7890
7891       NSRect wr = [self frame];
7892       NSTRACE_RECT ("Rect after zoom", wr);
7893
7894       NSRect newWr = wr;
7895
7896       if (fs_state == FULLSCREEN_MAXIMIZED
7897           || fs_state == FULLSCREEN_HEIGHT)
7898         {
7899           newWr.origin.y = sr.origin.y + margins.bottom;
7900           newWr.size.height = sr.size.height - margins.top - margins.bottom;
7901         }
7902
7903       if (fs_state == FULLSCREEN_MAXIMIZED
7904           || fs_state == FULLSCREEN_WIDTH)
7905         {
7906           newWr.origin.x = sr.origin.x + margins.left;
7907           newWr.size.width = sr.size.width - margins.right - margins.left;
7908         }
7909
7910       if (newWr.size.width     != wr.size.width
7911           || newWr.size.height != wr.size.height
7912           || newWr.origin.x    != wr.origin.x
7913           || newWr.origin.y    != wr.origin.y)
7914         {
7915           NSTRACE_MSG ("New frame different");
7916           [self setFrame: newWr display: NO];
7917         }
7918     }
7919 #else
7920   // Non-native zoom which is done instantaneously.  The resulting
7921   // frame covers the entire screen, except the menu-bar and dock, if
7922   // present.
7923   NSScreen * screen = [self screen];
7924   if (screen != nil)
7925     {
7926       NSRect sr = [screen frame];
7927       struct EmacsMargins margins
7928         = ns_screen_margins_ignoring_hidden_dock(screen);
7929
7930       sr.size.height -= (margins.top + margins.bottom);
7931       sr.size.width  -= (margins.left + margins.right);
7932       sr.origin.x += margins.left;
7933       sr.origin.y += margins.bottom;
7934
7935       sr = [[self delegate] windowWillUseStandardFrame:self
7936                                           defaultFrame:sr];
7937       [self setFrame: sr display: NO];
7938     }
7939 #endif
7940 }
7941
7942 - (void)setFrame:(NSRect)windowFrame
7943          display:(BOOL)displayViews
7944 {
7945   NSTRACE ("[EmacsWindow setFrame:" NSTRACE_FMT_RECT " display:%d]",
7946            NSTRACE_ARG_RECT (windowFrame), displayViews);
7947
7948   [super setFrame:windowFrame display:displayViews];
7949 }
7950
7951 - (void)setFrame:(NSRect)windowFrame
7952          display:(BOOL)displayViews
7953          animate:(BOOL)performAnimation
7954 {
7955   NSTRACE ("[EmacsWindow setFrame:" NSTRACE_FMT_RECT
7956            " display:%d performAnimation:%d]",
7957            NSTRACE_ARG_RECT (windowFrame), displayViews, performAnimation);
7958
7959   [super setFrame:windowFrame display:displayViews animate:performAnimation];
7960 }
7961
7962 - (void)setFrameTopLeftPoint:(NSPoint)point
7963 {
7964   NSTRACE ("[EmacsWindow setFrameTopLeftPoint:" NSTRACE_FMT_POINT "]",
7965            NSTRACE_ARG_POINT (point));
7966
7967   [super setFrameTopLeftPoint:point];
7968 }
7969 @end /* EmacsWindow */
7970
7971
7972 @implementation EmacsFSWindow
7973
7974 - (BOOL)canBecomeKeyWindow
7975 {
7976   return YES;
7977 }
7978
7979 - (BOOL)canBecomeMainWindow
7980 {
7981   return YES;
7982 }
7983
7984 @end
7985
7986 /* ==========================================================================
7987
7988     EmacsScroller implementation
7989
7990    ========================================================================== */
7991
7992
7993 @implementation EmacsScroller
7994
7995 /* for repeat button push */
7996 #define SCROLL_BAR_FIRST_DELAY 0.5
7997 #define SCROLL_BAR_CONTINUOUS_DELAY (1.0 / 15)
7998
7999 + (CGFloat) scrollerWidth
8000 {
8001   /* TODO: if we want to allow variable widths, this is the place to do it,
8002            however neither GNUstep nor Cocoa support it very well */
8003   CGFloat r;
8004 #if !defined (NS_IMPL_COCOA) || \
8005   MAC_OS_X_VERSION_MAX_ALLOWED < MAC_OS_X_VERSION_10_7
8006   r = [NSScroller scrollerWidth];
8007 #else
8008   r = [NSScroller scrollerWidthForControlSize: NSControlSizeRegular
8009                                 scrollerStyle: NSScrollerStyleLegacy];
8010 #endif
8011   return r;
8012 }
8013
8014 - initFrame: (NSRect )r window: (Lisp_Object)nwin
8015 {
8016   NSTRACE ("[EmacsScroller initFrame: window:]");
8017
8018   if (r.size.width > r.size.height)
8019       horizontal = YES;
8020   else
8021       horizontal = NO;
8022
8023   [super initWithFrame: r/*NSMakeRect (0, 0, 0, 0)*/];
8024   [self setContinuous: YES];
8025   [self setEnabled: YES];
8026
8027   /* Ensure auto resizing of scrollbars occurs within the emacs frame's view
8028      locked against the top and bottom edges, and right edge on macOS, where
8029      scrollers are on right. */
8030 #ifdef NS_IMPL_GNUSTEP
8031   [self setAutoresizingMask: NSViewMaxXMargin | NSViewHeightSizable];
8032 #else
8033   [self setAutoresizingMask: NSViewMinXMargin | NSViewHeightSizable];
8034 #endif
8035
8036   window = XWINDOW (nwin);
8037   condemned = NO;
8038   if (horizontal)
8039     pixel_length = NSWidth (r);
8040   else
8041     pixel_length = NSHeight (r);
8042   if (pixel_length == 0) pixel_length = 1;
8043   min_portion = 20 / pixel_length;
8044
8045   frame = XFRAME (window->frame);
8046   if (FRAME_LIVE_P (frame))
8047     {
8048       int i;
8049       EmacsView *view = FRAME_NS_VIEW (frame);
8050       NSView *sview = [[view window] contentView];
8051       NSArray *subs = [sview subviews];
8052
8053       /* disable optimization stopping redraw of other scrollbars */
8054       view->scrollbarsNeedingUpdate = 0;
8055       for (i =[subs count]-1; i >= 0; i--)
8056         if ([[subs objectAtIndex: i] isKindOfClass: [EmacsScroller class]])
8057           view->scrollbarsNeedingUpdate++;
8058       [sview addSubview: self];
8059     }
8060
8061 /*  [self setFrame: r]; */
8062
8063   return self;
8064 }
8065
8066
8067 - (void)setFrame: (NSRect)newRect
8068 {
8069   NSTRACE ("[EmacsScroller setFrame:]");
8070
8071 /*  block_input (); */
8072   if (horizontal)
8073     pixel_length = NSWidth (newRect);
8074   else
8075     pixel_length = NSHeight (newRect);
8076   if (pixel_length == 0) pixel_length = 1;
8077   min_portion = 20 / pixel_length;
8078   [super setFrame: newRect];
8079 /*  unblock_input (); */
8080 }
8081
8082
8083 - (void)dealloc
8084 {
8085   NSTRACE ("[EmacsScroller dealloc]");
8086   if (window)
8087     {
8088       if (horizontal)
8089         wset_horizontal_scroll_bar (window, Qnil);
8090       else
8091         wset_vertical_scroll_bar (window, Qnil);
8092     }
8093   window = 0;
8094   [super dealloc];
8095 }
8096
8097
8098 - condemn
8099 {
8100   NSTRACE ("[EmacsScroller condemn]");
8101   condemned =YES;
8102   return self;
8103 }
8104
8105
8106 - reprieve
8107 {
8108   NSTRACE ("[EmacsScroller reprieve]");
8109   condemned =NO;
8110   return self;
8111 }
8112
8113
8114 -(bool)judge
8115 {
8116   NSTRACE ("[EmacsScroller judge]");
8117   bool ret = condemned;
8118   if (condemned)
8119     {
8120       EmacsView *view;
8121       block_input ();
8122       /* ensure other scrollbar updates after deletion */
8123       view = (EmacsView *)FRAME_NS_VIEW (frame);
8124       if (view != nil)
8125         view->scrollbarsNeedingUpdate++;
8126       if (window)
8127         {
8128           if (horizontal)
8129             wset_horizontal_scroll_bar (window, Qnil);
8130           else
8131             wset_vertical_scroll_bar (window, Qnil);
8132         }
8133       window = 0;
8134       [self removeFromSuperview];
8135       [self release];
8136       unblock_input ();
8137     }
8138   return ret;
8139 }
8140
8141
8142 - (void)resetCursorRects
8143 {
8144   NSRect visible = [self visibleRect];
8145   NSTRACE ("[EmacsScroller resetCursorRects]");
8146
8147   if (!NSIsEmptyRect (visible))
8148     [self addCursorRect: visible cursor: [NSCursor arrowCursor]];
8149   [[NSCursor arrowCursor] setOnMouseEntered: YES];
8150 }
8151
8152
8153 - (int) checkSamePosition: (int) position portion: (int) portion
8154                     whole: (int) whole
8155 {
8156   return em_position ==position && em_portion ==portion && em_whole ==whole
8157     && portion != whole; /* needed for resize empty buf */
8158 }
8159
8160
8161 - setPosition: (int)position portion: (int)portion whole: (int)whole
8162 {
8163   NSTRACE ("[EmacsScroller setPosition:portion:whole:]");
8164
8165   em_position = position;
8166   em_portion = portion;
8167   em_whole = whole;
8168
8169   if (portion >= whole)
8170     {
8171 #ifdef NS_IMPL_COCOA
8172       [self setKnobProportion: 1.0];
8173       [self setDoubleValue: 1.0];
8174 #else
8175       [self setFloatValue: 0.0 knobProportion: 1.0];
8176 #endif
8177     }
8178   else
8179     {
8180       float pos;
8181       CGFloat por;
8182       portion = max ((float)whole*min_portion/pixel_length, portion);
8183       pos = (float)position / (whole - portion);
8184       por = (CGFloat)portion/whole;
8185 #ifdef NS_IMPL_COCOA
8186       [self setKnobProportion: por];
8187       [self setDoubleValue: pos];
8188 #else
8189       [self setFloatValue: pos knobProportion: por];
8190 #endif
8191     }
8192
8193   return self;
8194 }
8195
8196 /* set up emacs_event */
8197 - (void) sendScrollEventAtLoc: (float)loc fromEvent: (NSEvent *)e
8198 {
8199   Lisp_Object win;
8200
8201   NSTRACE ("[EmacsScroller sendScrollEventAtLoc:fromEvent:]");
8202
8203   if (!emacs_event)
8204     return;
8205
8206   emacs_event->part = last_hit_part;
8207   emacs_event->code = 0;
8208   emacs_event->modifiers = EV_MODIFIERS (e) | down_modifier;
8209   XSETWINDOW (win, window);
8210   emacs_event->frame_or_window = win;
8211   emacs_event->timestamp = EV_TIMESTAMP (e);
8212   emacs_event->arg = Qnil;
8213
8214   if (horizontal)
8215     {
8216       emacs_event->kind = HORIZONTAL_SCROLL_BAR_CLICK_EVENT;
8217       XSETINT (emacs_event->x, em_whole * loc / pixel_length);
8218       XSETINT (emacs_event->y, em_whole);
8219     }
8220   else
8221     {
8222       emacs_event->kind = SCROLL_BAR_CLICK_EVENT;
8223       XSETINT (emacs_event->x, loc);
8224       XSETINT (emacs_event->y, pixel_length-20);
8225     }
8226
8227   if (q_event_ptr)
8228     {
8229       n_emacs_events_pending++;
8230       kbd_buffer_store_event_hold (emacs_event, q_event_ptr);
8231     }
8232   else
8233     hold_event (emacs_event);
8234   EVENT_INIT (*emacs_event);
8235   ns_send_appdefined (-1);
8236 }
8237
8238
8239 /* called manually thru timer to implement repeated button action w/hold-down */
8240 - repeatScroll: (NSTimer *)scrollEntry
8241 {
8242   NSEvent *e = [[self window] currentEvent];
8243   NSPoint p =  [[self window] mouseLocationOutsideOfEventStream];
8244   BOOL inKnob = [self testPart: p] == NSScrollerKnob;
8245
8246   NSTRACE ("[EmacsScroller repeatScroll:]");
8247
8248   /* clear timer if need be */
8249   if (inKnob || [scroll_repeat_entry timeInterval] == SCROLL_BAR_FIRST_DELAY)
8250     {
8251         [scroll_repeat_entry invalidate];
8252         [scroll_repeat_entry release];
8253         scroll_repeat_entry = nil;
8254
8255         if (inKnob)
8256           return self;
8257
8258         scroll_repeat_entry
8259           = [[NSTimer scheduledTimerWithTimeInterval:
8260                         SCROLL_BAR_CONTINUOUS_DELAY
8261                                             target: self
8262                                           selector: @selector (repeatScroll:)
8263                                           userInfo: 0
8264                                            repeats: YES]
8265               retain];
8266     }
8267
8268   [self sendScrollEventAtLoc: 0 fromEvent: e];
8269   return self;
8270 }
8271
8272
8273 /* Asynchronous mouse tracking for scroller.  This allows us to dispatch
8274    mouseDragged events without going into a modal loop. */
8275 - (void)mouseDown: (NSEvent *)e
8276 {
8277   NSRect sr, kr;
8278   /* hitPart is only updated AFTER event is passed on */
8279   NSScrollerPart part = [self testPart: [e locationInWindow]];
8280   CGFloat loc, kloc, pos UNINIT;
8281   int edge = 0;
8282
8283   NSTRACE ("[EmacsScroller mouseDown:]");
8284
8285   switch (part)
8286     {
8287     case NSScrollerDecrementPage:
8288       last_hit_part = horizontal ? scroll_bar_before_handle : scroll_bar_above_handle; break;
8289     case NSScrollerIncrementPage:
8290       last_hit_part = horizontal ? scroll_bar_after_handle : scroll_bar_below_handle; break;
8291     case NSScrollerDecrementLine:
8292       last_hit_part = horizontal ? scroll_bar_left_arrow : scroll_bar_up_arrow; break;
8293     case NSScrollerIncrementLine:
8294       last_hit_part = horizontal ? scroll_bar_right_arrow : scroll_bar_down_arrow; break;
8295     case NSScrollerKnob:
8296       last_hit_part = horizontal ? scroll_bar_horizontal_handle : scroll_bar_handle; break;
8297     case NSScrollerKnobSlot:  /* GNUstep-only */
8298       last_hit_part = scroll_bar_move_ratio; break;
8299     default:  /* NSScrollerNoPart? */
8300       fprintf (stderr, "EmacsScoller-mouseDown: unexpected part %ld\n",
8301                (long) part);
8302       return;
8303     }
8304
8305   if (part == NSScrollerKnob || part == NSScrollerKnobSlot)
8306     {
8307       /* handle, or on GNUstep possibly slot */
8308       NSEvent *fake_event;
8309       int length;
8310
8311       /* compute float loc in slot and mouse offset on knob */
8312       sr = [self convertRect: [self rectForPart: NSScrollerKnobSlot]
8313                       toView: nil];
8314       if (horizontal)
8315         {
8316           length = NSWidth (sr);
8317           loc = ([e locationInWindow].x - NSMinX (sr));
8318         }
8319       else
8320         {
8321           length = NSHeight (sr);
8322           loc = length - ([e locationInWindow].y - NSMinY (sr));
8323         }
8324
8325       if (loc <= 0.0)
8326         {
8327           loc = 0.0;
8328           edge = -1;
8329         }
8330       else if (loc >= length)
8331         {
8332           loc = length;
8333           edge = 1;
8334         }
8335
8336       if (edge)
8337         kloc = 0.5 * edge;
8338       else
8339         {
8340           kr = [self convertRect: [self rectForPart: NSScrollerKnob]
8341                           toView: nil];
8342           if (horizontal)
8343             kloc = ([e locationInWindow].x - NSMinX (kr));
8344           else
8345             kloc = NSHeight (kr) - ([e locationInWindow].y - NSMinY (kr));
8346         }
8347       last_mouse_offset = kloc;
8348
8349       if (part != NSScrollerKnob)
8350         /* this is a slot click on GNUstep: go straight there */
8351         pos = loc;
8352
8353       /* send a fake mouse-up to super to preempt modal -trackKnob: mode */
8354       fake_event = [NSEvent mouseEventWithType: NSEventTypeLeftMouseUp
8355                                       location: [e locationInWindow]
8356                                  modifierFlags: [e modifierFlags]
8357                                      timestamp: [e timestamp]
8358                                   windowNumber: [e windowNumber]
8359                                        context: [e context]
8360                                    eventNumber: [e eventNumber]
8361                                     clickCount: [e clickCount]
8362                                       pressure: [e pressure]];
8363       [super mouseUp: fake_event];
8364     }
8365   else
8366     {
8367       pos = 0;      /* ignored */
8368
8369       /* set a timer to repeat, as we can't let superclass do this modally */
8370       scroll_repeat_entry
8371         = [[NSTimer scheduledTimerWithTimeInterval: SCROLL_BAR_FIRST_DELAY
8372                                             target: self
8373                                           selector: @selector (repeatScroll:)
8374                                           userInfo: 0
8375                                            repeats: YES]
8376             retain];
8377     }
8378
8379   if (part != NSScrollerKnob)
8380     [self sendScrollEventAtLoc: pos fromEvent: e];
8381 }
8382
8383
8384 /* Called as we manually track scroller drags, rather than superclass. */
8385 - (void)mouseDragged: (NSEvent *)e
8386 {
8387     NSRect sr;
8388     double loc, pos;
8389     int length;
8390
8391     NSTRACE ("[EmacsScroller mouseDragged:]");
8392
8393       sr = [self convertRect: [self rectForPart: NSScrollerKnobSlot]
8394                       toView: nil];
8395
8396       if (horizontal)
8397         {
8398           length = NSWidth (sr);
8399           loc = ([e locationInWindow].x - NSMinX (sr));
8400         }
8401       else
8402         {
8403           length = NSHeight (sr);
8404           loc = length - ([e locationInWindow].y - NSMinY (sr));
8405         }
8406
8407       if (loc <= 0.0)
8408         {
8409           loc = 0.0;
8410         }
8411       else if (loc >= length + last_mouse_offset)
8412         {
8413           loc = length + last_mouse_offset;
8414         }
8415
8416       pos = (loc - last_mouse_offset);
8417       [self sendScrollEventAtLoc: pos fromEvent: e];
8418 }
8419
8420
8421 - (void)mouseUp: (NSEvent *)e
8422 {
8423   NSTRACE ("[EmacsScroller mouseUp:]");
8424
8425   if (scroll_repeat_entry)
8426     {
8427       [scroll_repeat_entry invalidate];
8428       [scroll_repeat_entry release];
8429       scroll_repeat_entry = nil;
8430     }
8431   last_hit_part = scroll_bar_above_handle;
8432 }
8433
8434
8435 /* treat scrollwheel events in the bar as though they were in the main window */
8436 - (void) scrollWheel: (NSEvent *)theEvent
8437 {
8438   NSTRACE ("[EmacsScroller scrollWheel:]");
8439
8440   EmacsView *view = (EmacsView *)FRAME_NS_VIEW (frame);
8441   [view mouseDown: theEvent];
8442 }
8443
8444 @end  /* EmacsScroller */
8445
8446
8447 #ifdef NS_IMPL_GNUSTEP
8448 /* Dummy class to get rid of startup warnings.  */
8449 @implementation EmacsDocument
8450
8451 @end
8452 #endif
8453
8454
8455 /* ==========================================================================
8456
8457    Font-related functions; these used to be in nsfaces.m
8458
8459    ========================================================================== */
8460
8461
8462 Lisp_Object
8463 x_new_font (struct frame *f, Lisp_Object font_object, int fontset)
8464 {
8465   struct font *font = XFONT_OBJECT (font_object);
8466   EmacsView *view = FRAME_NS_VIEW (f);
8467   int font_ascent, font_descent;
8468
8469   if (fontset < 0)
8470     fontset = fontset_from_font (font_object);
8471   FRAME_FONTSET (f) = fontset;
8472
8473   if (FRAME_FONT (f) == font)
8474     /* This font is already set in frame F.  There's nothing more to
8475        do.  */
8476     return font_object;
8477
8478   FRAME_FONT (f) = font;
8479
8480   FRAME_BASELINE_OFFSET (f) = font->baseline_offset;
8481   FRAME_COLUMN_WIDTH (f) = font->average_width;
8482   get_font_ascent_descent (font, &font_ascent, &font_descent);
8483   FRAME_LINE_HEIGHT (f) = font_ascent + font_descent;
8484
8485   /* Compute the scroll bar width in character columns.  */
8486   if (FRAME_CONFIG_SCROLL_BAR_WIDTH (f) > 0)
8487     {
8488       int wid = FRAME_COLUMN_WIDTH (f);
8489       FRAME_CONFIG_SCROLL_BAR_COLS (f)
8490         = (FRAME_CONFIG_SCROLL_BAR_WIDTH (f) + wid - 1) / wid;
8491     }
8492   else
8493     {
8494       int wid = FRAME_COLUMN_WIDTH (f);
8495       FRAME_CONFIG_SCROLL_BAR_COLS (f) = (14 + wid - 1) / wid;
8496     }
8497
8498   /* Compute the scroll bar height in character lines.  */
8499   if (FRAME_CONFIG_SCROLL_BAR_HEIGHT (f) > 0)
8500     {
8501       int height = FRAME_LINE_HEIGHT (f);
8502       FRAME_CONFIG_SCROLL_BAR_LINES (f)
8503         = (FRAME_CONFIG_SCROLL_BAR_HEIGHT (f) + height - 1) / height;
8504     }
8505   else
8506     {
8507       int height = FRAME_LINE_HEIGHT (f);
8508       FRAME_CONFIG_SCROLL_BAR_LINES (f) = (14 + height - 1) / height;
8509     }
8510
8511   /* Now make the frame display the given font.  */
8512   if (FRAME_NS_WINDOW (f) != 0 && ! [view isFullscreen])
8513     adjust_frame_size (f, FRAME_COLS (f) * FRAME_COLUMN_WIDTH (f),
8514                        FRAME_LINES (f) * FRAME_LINE_HEIGHT (f), 3,
8515                        false, Qfont);
8516
8517   return font_object;
8518 }
8519
8520
8521 /* XLFD: -foundry-family-weight-slant-swidth-adstyle-pxlsz-ptSz-resx-resy-spc-avgWidth-rgstry-encoding */
8522 /* Note: ns_font_to_xlfd and ns_fontname_to_xlfd no longer needed, removed
8523          in 1.43. */
8524
8525 const char *
8526 ns_xlfd_to_fontname (const char *xlfd)
8527 /* --------------------------------------------------------------------------
8528     Convert an X font name (XLFD) to an NS font name.
8529     Only family is used.
8530     The string returned is temporarily allocated.
8531    -------------------------------------------------------------------------- */
8532 {
8533   char *name = xmalloc (180);
8534   int i, len;
8535   const char *ret;
8536
8537   if (!strncmp (xlfd, "--", 2))
8538     sscanf (xlfd, "--%*[^-]-%[^-]179-", name);
8539   else
8540     sscanf (xlfd, "-%*[^-]-%[^-]179-", name);
8541
8542   /* stopgap for malformed XLFD input */
8543   if (strlen (name) == 0)
8544     strcpy (name, "Monaco");
8545
8546   /* undo hack in ns_fontname_to_xlfd, converting '$' to '-', '_' to ' '
8547      also uppercase after '-' or ' ' */
8548   name[0] = c_toupper (name[0]);
8549   for (len =strlen (name), i =0; i<len; i++)
8550     {
8551       if (name[i] == '$')
8552         {
8553           name[i] = '-';
8554           if (i+1<len)
8555             name[i+1] = c_toupper (name[i+1]);
8556         }
8557       else if (name[i] == '_')
8558         {
8559           name[i] = ' ';
8560           if (i+1<len)
8561             name[i+1] = c_toupper (name[i+1]);
8562         }
8563     }
8564 /*fprintf (stderr, "converted '%s' to '%s'\n",xlfd,name);  */
8565   ret = [[NSString stringWithUTF8String: name] UTF8String];
8566   xfree (name);
8567   return ret;
8568 }
8569
8570
8571 void
8572 syms_of_nsterm (void)
8573 {
8574   NSTRACE ("syms_of_nsterm");
8575
8576   ns_antialias_threshold = 10.0;
8577
8578   /* from 23+ we need to tell emacs what modifiers there are.. */
8579   DEFSYM (Qmodifier_value, "modifier-value");
8580   DEFSYM (Qalt, "alt");
8581   DEFSYM (Qhyper, "hyper");
8582   DEFSYM (Qmeta, "meta");
8583   DEFSYM (Qsuper, "super");
8584   DEFSYM (Qcontrol, "control");
8585   DEFSYM (QUTF8_STRING, "UTF8_STRING");
8586
8587   DEFSYM (Qfile, "file");
8588   DEFSYM (Qurl, "url");
8589
8590   Fput (Qalt, Qmodifier_value, make_number (alt_modifier));
8591   Fput (Qhyper, Qmodifier_value, make_number (hyper_modifier));
8592   Fput (Qmeta, Qmodifier_value, make_number (meta_modifier));
8593   Fput (Qsuper, Qmodifier_value, make_number (super_modifier));
8594   Fput (Qcontrol, Qmodifier_value, make_number (ctrl_modifier));
8595
8596   DEFVAR_LISP ("ns-input-file", ns_input_file,
8597               "The file specified in the last NS event.");
8598   ns_input_file =Qnil;
8599
8600   DEFVAR_LISP ("ns-working-text", ns_working_text,
8601               "String for visualizing working composition sequence.");
8602   ns_working_text =Qnil;
8603
8604   DEFVAR_LISP ("ns-input-font", ns_input_font,
8605               "The font specified in the last NS event.");
8606   ns_input_font =Qnil;
8607
8608   DEFVAR_LISP ("ns-input-fontsize", ns_input_fontsize,
8609               "The fontsize specified in the last NS event.");
8610   ns_input_fontsize =Qnil;
8611
8612   DEFVAR_LISP ("ns-input-line", ns_input_line,
8613                "The line specified in the last NS event.");
8614   ns_input_line =Qnil;
8615
8616   DEFVAR_LISP ("ns-input-spi-name", ns_input_spi_name,
8617                "The service name specified in the last NS event.");
8618   ns_input_spi_name =Qnil;
8619
8620   DEFVAR_LISP ("ns-input-spi-arg", ns_input_spi_arg,
8621                "The service argument specified in the last NS event.");
8622   ns_input_spi_arg =Qnil;
8623
8624   DEFVAR_LISP ("ns-alternate-modifier", ns_alternate_modifier,
8625                "This variable describes the behavior of the alternate or option key.\n\
8626 Set to the symbol control, meta, alt, super, or hyper means it is taken to be\n\
8627 that key.\n\
8628 Set to none means that the alternate / option key is not interpreted by Emacs\n\
8629 at all, allowing it to be used at a lower level for accented character entry.");
8630   ns_alternate_modifier = Qmeta;
8631
8632   DEFVAR_LISP ("ns-right-alternate-modifier", ns_right_alternate_modifier,
8633                "This variable describes the behavior of the right alternate or option key.\n\
8634 Set to the symbol control, meta, alt, super, or hyper means it is taken to be\n\
8635 that key.\n\
8636 Set to left means be the same key as `ns-alternate-modifier'.\n\
8637 Set to none means that the alternate / option key is not interpreted by Emacs\n\
8638 at all, allowing it to be used at a lower level for accented character entry.");
8639   ns_right_alternate_modifier = Qleft;
8640
8641   DEFVAR_LISP ("ns-command-modifier", ns_command_modifier,
8642                "This variable describes the behavior of the command key.\n\
8643 Set to the symbol control, meta, alt, super, or hyper means it is taken to be\n\
8644 that key.");
8645   ns_command_modifier = Qsuper;
8646
8647   DEFVAR_LISP ("ns-right-command-modifier", ns_right_command_modifier,
8648                "This variable describes the behavior of the right command key.\n\
8649 Set to the symbol control, meta, alt, super, or hyper means it is taken to be\n\
8650 that key.\n\
8651 Set to left means be the same key as `ns-command-modifier'.\n\
8652 Set to none means that the command / option key is not interpreted by Emacs\n\
8653 at all, allowing it to be used at a lower level for accented character entry.");
8654   ns_right_command_modifier = Qleft;
8655
8656   DEFVAR_LISP ("ns-control-modifier", ns_control_modifier,
8657                "This variable describes the behavior of the control key.\n\
8658 Set to the symbol control, meta, alt, super, or hyper means it is taken to be\n\
8659 that key.");
8660   ns_control_modifier = Qcontrol;
8661
8662   DEFVAR_LISP ("ns-right-control-modifier", ns_right_control_modifier,
8663                "This variable describes the behavior of the right control key.\n\
8664 Set to the symbol control, meta, alt, super, or hyper means it is taken to be\n\
8665 that key.\n\
8666 Set to left means be the same key as `ns-control-modifier'.\n\
8667 Set to none means that the control / option key is not interpreted by Emacs\n\
8668 at all, allowing it to be used at a lower level for accented character entry.");
8669   ns_right_control_modifier = Qleft;
8670
8671   DEFVAR_LISP ("ns-function-modifier", ns_function_modifier,
8672                "This variable describes the behavior of the function key (on laptops).\n\
8673 Set to the symbol control, meta, alt, super, or hyper means it is taken to be\n\
8674 that key.\n\
8675 Set to none means that the function key is not interpreted by Emacs at all,\n\
8676 allowing it to be used at a lower level for accented character entry.");
8677   ns_function_modifier = Qnone;
8678
8679   DEFVAR_LISP ("ns-antialias-text", ns_antialias_text,
8680                "Non-nil (the default) means to render text antialiased.");
8681   ns_antialias_text = Qt;
8682
8683   DEFVAR_LISP ("ns-confirm-quit", ns_confirm_quit,
8684                "Whether to confirm application quit using dialog.");
8685   ns_confirm_quit = Qnil;
8686
8687   DEFVAR_LISP ("ns-auto-hide-menu-bar", ns_auto_hide_menu_bar,
8688                doc: /* Non-nil means that the menu bar is hidden, but appears when the mouse is near.
8689 Only works on Mac OS X 10.6 or later.  */);
8690   ns_auto_hide_menu_bar = Qnil;
8691
8692   DEFVAR_BOOL ("ns-use-native-fullscreen", ns_use_native_fullscreen,
8693      doc: /*Non-nil means to use native fullscreen on Mac OS X 10.7 and later.
8694 Nil means use fullscreen the old (< 10.7) way.  The old way works better with
8695 multiple monitors, but lacks tool bar.  This variable is ignored on
8696 Mac OS X < 10.7.  Default is t for 10.7 and later, nil otherwise.  */);
8697 #ifdef HAVE_NATIVE_FS
8698   ns_use_native_fullscreen = YES;
8699 #else
8700   ns_use_native_fullscreen = NO;
8701 #endif
8702   ns_last_use_native_fullscreen = ns_use_native_fullscreen;
8703
8704   DEFVAR_BOOL ("ns-use-fullscreen-animation", ns_use_fullscreen_animation,
8705      doc: /*Non-nil means use animation on non-native fullscreen.
8706 For native fullscreen, this does nothing.
8707 Default is nil.  */);
8708   ns_use_fullscreen_animation = NO;
8709
8710   DEFVAR_BOOL ("ns-use-srgb-colorspace", ns_use_srgb_colorspace,
8711      doc: /*Non-nil means to use sRGB colorspace on Mac OS X 10.7 and later.
8712 Note that this does not apply to images.
8713 This variable is ignored on Mac OS X < 10.7 and GNUstep.  */);
8714   ns_use_srgb_colorspace = YES;
8715
8716   /* TODO: move to common code */
8717   DEFVAR_LISP ("x-toolkit-scroll-bars", Vx_toolkit_scroll_bars,
8718                doc: /* Which toolkit scroll bars Emacs uses, if any.
8719 A value of nil means Emacs doesn't use toolkit scroll bars.
8720 With the X Window system, the value is a symbol describing the
8721 X toolkit.  Possible values are: gtk, motif, xaw, or xaw3d.
8722 With MS Windows or Nextstep, the value is t.  */);
8723   Vx_toolkit_scroll_bars = Qt;
8724
8725   DEFVAR_BOOL ("x-use-underline-position-properties",
8726                x_use_underline_position_properties,
8727      doc: /*Non-nil means make use of UNDERLINE_POSITION font properties.
8728 A value of nil means ignore them.  If you encounter fonts with bogus
8729 UNDERLINE_POSITION font properties, for example 7x13 on XFree prior
8730 to 4.1, set this to nil. */);
8731   x_use_underline_position_properties = 0;
8732
8733   DEFVAR_BOOL ("x-underline-at-descent-line",
8734                x_underline_at_descent_line,
8735      doc: /* Non-nil means to draw the underline at the same place as the descent line.
8736 A value of nil means to draw the underline according to the value of the
8737 variable `x-use-underline-position-properties', which is usually at the
8738 baseline level.  The default value is nil.  */);
8739   x_underline_at_descent_line = 0;
8740
8741   /* Tell Emacs about this window system.  */
8742   Fprovide (Qns, Qnil);
8743
8744   DEFSYM (Qcocoa, "cocoa");
8745   DEFSYM (Qgnustep, "gnustep");
8746
8747 #ifdef NS_IMPL_COCOA
8748   Fprovide (Qcocoa, Qnil);
8749   syms_of_macfont ();
8750 #else
8751   Fprovide (Qgnustep, Qnil);
8752   syms_of_nsfont ();
8753 #endif
8754
8755 }