src/nsterm.m

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