src/nsterm.m

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