code.delx.au - gnu-emacs/blob - src/nsterm.m

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