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