src/nsterm.m

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