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