src/nsterm.m

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