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 #include <setjmp.h>
  39
  40 #include <c-ctype.h>
  41 #include <c-strcase.h>
  42 #include <ftoastr.h>
  43
  44 #ifdef HAVE_FCNTL_H
  45 #include <fcntl.h>
  46 #endif
  47
  48 #include "lisp.h"
  49 #include "blockinput.h"
  50 #include "sysselect.h"
  51 #include "nsterm.h"
  52 #include "systime.h"
  53 #include "character.h"
  54 #include "fontset.h"
  55 #include "composite.h"
  56 #include "ccl.h"
  57
  58 #include "termhooks.h"
  59 #include "termopts.h"
  60 #include "termchar.h"
  61
  62 #include "window.h"
  63 #include "keyboard.h"
  64 #include "buffer.h"
  65 #include "font.h"
  66
  67 /* call tracing */
  68 #if 0
  69 int term_trace_num = 0;
  70 #define NSTRACE(x)        fprintf (stderr, "%s:%d: [%d] " #x "\n",         \
  71                                 __FILE__, __LINE__, ++term_trace_num)
  72 #else
  73 #define NSTRACE(x)
  74 #endif
  75
  76 extern NSString *NSMenuDidBeginTrackingNotification;
  77
  78 /* ==========================================================================
  79
  80     Local declarations
  81
  82    ========================================================================== */
  83
  84 /* Convert a symbol indexed with an NSxxx value to a value as defined
  85    in keyboard.c (lispy_function_key). I hope this is a correct way
  86    of doing things... */
  87 static unsigned convert_ns_to_X_keysym[] =
  88 {
  89   NSHomeFunctionKey,            0x50,
  90   NSLeftArrowFunctionKey,       0x51,
  91   NSUpArrowFunctionKey,         0x52,
  92   NSRightArrowFunctionKey,      0x53,
  93   NSDownArrowFunctionKey,       0x54,
  94   NSPageUpFunctionKey,          0x55,
  95   NSPageDownFunctionKey,        0x56,
  96   NSEndFunctionKey,             0x57,
  97   NSBeginFunctionKey,           0x58,
  98   NSSelectFunctionKey,          0x60,
  99   NSPrintFunctionKey,           0x61,
 100   NSExecuteFunctionKey,         0x62,
 101   NSInsertFunctionKey,          0x63,
 102   NSUndoFunctionKey,            0x65,
 103   NSRedoFunctionKey,            0x66,
 104   NSMenuFunctionKey,            0x67,
 105   NSFindFunctionKey,            0x68,
 106   NSHelpFunctionKey,            0x6A,
 107   NSBreakFunctionKey,           0x6B,
 108
 109   NSF1FunctionKey,              0xBE,
 110   NSF2FunctionKey,              0xBF,
 111   NSF3FunctionKey,              0xC0,
 112   NSF4FunctionKey,              0xC1,
 113   NSF5FunctionKey,              0xC2,
 114   NSF6FunctionKey,              0xC3,
 115   NSF7FunctionKey,              0xC4,
 116   NSF8FunctionKey,              0xC5,
 117   NSF9FunctionKey,              0xC6,
 118   NSF10FunctionKey,             0xC7,
 119   NSF11FunctionKey,             0xC8,
 120   NSF12FunctionKey,             0xC9,
 121   NSF13FunctionKey,             0xCA,
 122   NSF14FunctionKey,             0xCB,
 123   NSF15FunctionKey,             0xCC,
 124   NSF16FunctionKey,             0xCD,
 125   NSF17FunctionKey,             0xCE,
 126   NSF18FunctionKey,             0xCF,
 127   NSF19FunctionKey,             0xD0,
 128   NSF20FunctionKey,             0xD1,
 129   NSF21FunctionKey,             0xD2,
 130   NSF22FunctionKey,             0xD3,
 131   NSF23FunctionKey,             0xD4,
 132   NSF24FunctionKey,             0xD5,
 133
 134   NSBackspaceCharacter,         0x08,  /* 8: Not on some KBs. */
 135   NSDeleteCharacter,            0xFF,  /* 127: Big 'delete' key upper right. */
 136   NSDeleteFunctionKey,          0x9F,  /* 63272: Del forw key off main array. */
 137
 138   NSTabCharacter,               0x09,
 139   0x19,                         0x09,  /* left tab->regular since pass shift */
 140   NSCarriageReturnCharacter,    0x0D,
 141   NSNewlineCharacter,           0x0D,
 142   NSEnterCharacter,             0x8D,
 143
 144   0x1B,                         0x1B   /* escape */
 145 };
 146
 147 static Lisp_Object Qmodifier_value;
 148 Lisp_Object Qalt, Qcontrol, Qhyper, Qmeta, Qsuper;
 149 extern Lisp_Object Qcursor_color, Qcursor_type, Qns, Qleft;
 150
 151 static Lisp_Object QUTF8_STRING;
 152
 153 /* On OS X picks up the default NSGlobalDomain AppleAntiAliasingThreshold,
 154    the maximum font size to NOT antialias.  On GNUstep there is currently
 155    no way to control this behavior. */
 156 float ns_antialias_threshold;
 157
 158 /* Used to pick up AppleHighlightColor on OS X */
 159 NSString *ns_selection_color;
 160
 161 NSArray *ns_send_types =0, *ns_return_types =0, *ns_drag_types =0;
 162 NSString *ns_app_name = @"Emacs";  /* default changed later */
 163
 164 /* Display variables */
 165 struct ns_display_info *x_display_list; /* Chain of existing displays */
 166 Lisp_Object ns_display_name_list;
 167 long context_menu_value = 0;
 168
 169 /* display update */
 170 NSPoint last_mouse_motion_position;
 171 static NSRect last_mouse_glyph;
 172 static Time last_mouse_movement_time = 0;
 173 static Lisp_Object last_mouse_motion_frame;
 174 static EmacsScroller *last_mouse_scroll_bar = nil;
 175 static struct frame *ns_updating_frame;
 176 static NSView *focus_view = NULL;
 177 static int ns_window_num = 0;
 178 #ifdef NS_IMPL_GNUSTEP
 179 static NSRect uRect;
 180 #endif
 181 static BOOL gsaved = NO;
 182 BOOL ns_in_resize = NO;
 183 static BOOL ns_fake_keydown = NO;
 184 int ns_tmp_flags; /* FIXME */
 185 struct nsfont_info *ns_tmp_font; /* FIXME */
 186 static BOOL ns_menu_bar_is_hidden = NO;
 187 /*static int debug_lock = 0; */
 188
 189 /* event loop */
 190 static BOOL send_appdefined = YES;
 191 static NSEvent *last_appdefined_event = 0;
 192 static NSTimer *timed_entry = 0;
 193 static NSTimer *scroll_repeat_entry = nil;
 194 static fd_set select_readfds, select_writefds;
 195 enum { SELECT_HAVE_READ = 1, SELECT_HAVE_WRITE = 2, SELECT_HAVE_TMO = 4 };
 196 static int select_nfds = 0, select_valid = 0;
 197 static EMACS_TIME select_timeout = { 0, 0 };
 198 static int selfds[2] = { -1, -1 };
 199 static pthread_mutex_t select_mutex;
 200 static int apploopnr = 0;
 201 static NSAutoreleasePool *outerpool;
 202 static struct input_event *emacs_event = NULL;
 203 static struct input_event *q_event_ptr = NULL;
 204 static int n_emacs_events_pending = 0;
 205 static NSMutableArray *ns_pending_files, *ns_pending_service_names,
 206   *ns_pending_service_args;
 207 static BOOL ns_do_open_file = NO;
 208
 209 /* Convert modifiers in a NeXTstep event to emacs style modifiers.  */
 210 #define NS_FUNCTION_KEY_MASK 0x800000
 211 #define NSLeftControlKeyMask    (0x000001 | NSControlKeyMask)
 212 #define NSRightControlKeyMask   (0x002000 | NSControlKeyMask)
 213 #define NSLeftCommandKeyMask    (0x000008 | NSCommandKeyMask)
 214 #define NSRightCommandKeyMask   (0x000010 | NSCommandKeyMask)
 215 #define NSLeftAlternateKeyMask  (0x000020 | NSAlternateKeyMask)
 216 #define NSRightAlternateKeyMask (0x000040 | NSAlternateKeyMask)
 217 #define EV_MODIFIERS(e)                               \
 218     ((([e modifierFlags] & NSHelpKeyMask) ?           \
 219            hyper_modifier : 0)                        \
 220      | (!EQ (ns_right_alternate_modifier, Qleft) && \
 221         (([e modifierFlags] & NSRightAlternateKeyMask) \
 222          == NSRightAlternateKeyMask) ? \
 223            parse_solitary_modifier (ns_right_alternate_modifier) : 0) \
 224      | (([e modifierFlags] & NSAlternateKeyMask) ?                 \
 225            parse_solitary_modifier (ns_alternate_modifier) : 0)   \
 226      | (([e modifierFlags] & NSShiftKeyMask) ?     \
 227            shift_modifier : 0)                        \
 228      | (!EQ (ns_right_control_modifier, Qleft) && \
 229         (([e modifierFlags] & NSRightControlKeyMask) \
 230          == NSRightControlKeyMask) ? \
 231            parse_solitary_modifier (ns_right_control_modifier) : 0) \
 232      | (([e modifierFlags] & NSControlKeyMask) ?      \
 233            parse_solitary_modifier (ns_control_modifier) : 0)     \
 234      | (([e modifierFlags] & NS_FUNCTION_KEY_MASK) ?  \
 235            parse_solitary_modifier (ns_function_modifier) : 0)    \
 236      | (!EQ (ns_right_command_modifier, Qleft) && \
 237         (([e modifierFlags] & NSRightCommandKeyMask) \
 238          == NSRightCommandKeyMask) ? \
 239            parse_solitary_modifier (ns_right_command_modifier) : 0) \
 240      | (([e modifierFlags] & NSCommandKeyMask) ?      \
 241            parse_solitary_modifier (ns_command_modifier):0))
 242
 243 #define EV_UDMODIFIERS(e)                                      \
 244     ((([e type] == NSLeftMouseDown) ? down_modifier : 0)       \
 245      | (([e type] == NSRightMouseDown) ? down_modifier : 0)    \
 246      | (([e type] == NSOtherMouseDown) ? down_modifier : 0)    \
 247      | (([e type] == NSLeftMouseDragged) ? down_modifier : 0)  \
 248      | (([e type] == NSRightMouseDragged) ? down_modifier : 0) \
 249      | (([e type] == NSOtherMouseDragged) ? down_modifier : 0) \
 250      | (([e type] == NSLeftMouseUp)   ? up_modifier   : 0)     \
 251      | (([e type] == NSRightMouseUp)   ? up_modifier   : 0)    \
 252      | (([e type] == NSOtherMouseUp)   ? up_modifier   : 0))
 253
 254 #define EV_BUTTON(e)                                                         \
 255     ((([e type] == NSLeftMouseDown) || ([e type] == NSLeftMouseUp)) ? 0 :    \
 256       (([e type] == NSRightMouseDown) || ([e type] == NSRightMouseUp)) ? 2 : \
 257      [e buttonNumber] - 1)
 258
 259 /* Convert the time field to a timestamp in milliseconds. */
 260 #define EV_TIMESTAMP(e) ([e timestamp] * 1000)
 261
 262 /* This is a piece of code which is common to all the event handling
 263    methods.  Maybe it should even be a function.  */
 264 #define EV_TRAILER(e)                                                   \
 265     {                                                                   \
 266       XSETFRAME (emacs_event->frame_or_window, emacsframe);             \
 267       if (e) emacs_event->timestamp = EV_TIMESTAMP (e);                 \
 268       if (q_event_ptr)                                                  \
 269         {                                                               \
 270           n_emacs_events_pending++;                                     \
 271           kbd_buffer_store_event_hold (emacs_event, q_event_ptr);       \
 272         }                                                               \
 273       else                                                              \
 274         kbd_buffer_store_event (emacs_event);                           \
 275       EVENT_INIT (*emacs_event);                                        \
 276       ns_send_appdefined (-1);                                          \
 277     }
 278
 279 void x_set_cursor_type (struct frame *, Lisp_Object, Lisp_Object);
 280
 281 /* TODO: get rid of need for these forward declarations */
 282 static void ns_condemn_scroll_bars (struct frame *f);
 283 static void ns_judge_scroll_bars (struct frame *f);
 284 void x_set_frame_alpha (struct frame *f);
 285
 286
 287 /* ==========================================================================
 288
 289     Utilities
 290
 291    ========================================================================== */
 292
 293
 294 static Lisp_Object
 295 append2 (Lisp_Object list, Lisp_Object item)
 296 /* --------------------------------------------------------------------------
 297    Utility to append to a list
 298    -------------------------------------------------------------------------- */
 299 {
 300   Lisp_Object array[2];
 301   array[0] = list;
 302   array[1] = Fcons (item, Qnil);
 303   return Fnconc (2, &array[0]);
 304 }
 305
 306
 307 const char *
 308 ns_etc_directory (void)
 309 /* If running as a self-contained app bundle, return as a string the
 310    filename of the etc directory, if present; else nil.  */
 311 {
 312   NSBundle *bundle = [NSBundle mainBundle];
 313   NSString *resourceDir = [bundle resourcePath];
 314   NSString *resourcePath;
 315   NSFileManager *fileManager = [NSFileManager defaultManager];
 316   BOOL isDir;
 317
 318   resourcePath = [resourceDir stringByAppendingPathComponent: @"etc"];
 319   if ([fileManager fileExistsAtPath: resourcePath isDirectory: &isDir])
 320     {
 321       if (isDir) return [resourcePath UTF8String];
 322     }
 323   return NULL;
 324 }
 325
 326
 327 const char *
 328 ns_exec_path (void)
 329 /* If running as a self-contained app bundle, return as a path string
 330    the filenames of the libexec and bin directories, ie libexec:bin.
 331    Otherwise, return nil.
 332    Normally, Emacs does not add its own bin/ directory to the PATH.
 333    However, a self-contained NS build has a different layout, with
 334    bin/ and libexec/ subdirectories in the directory that contains
 335    Emacs.app itself.
 336    We put libexec first, because init_callproc_1 uses the first
 337    element to initialize exec-directory.  An alternative would be
 338    for init_callproc to check for invocation-directory/libexec.
 339 */
 340 {
 341   NSBundle *bundle = [NSBundle mainBundle];
 342   NSString *resourceDir = [bundle resourcePath];
 343   NSString *binDir = [bundle bundlePath];
 344   NSString *resourcePath, *resourcePaths;
 345   NSRange range;
 346   NSString *pathSeparator = [NSString stringWithFormat: @"%c", SEPCHAR];
 347   NSFileManager *fileManager = [NSFileManager defaultManager];
 348   NSArray *paths;
 349   NSEnumerator *pathEnum;
 350   BOOL isDir;
 351
 352   range = [resourceDir rangeOfString: @"Contents"];
 353   if (range.location != NSNotFound)
 354     {
 355       binDir = [binDir stringByAppendingPathComponent: @"Contents"];
 356 #ifdef NS_IMPL_COCOA
 357       binDir = [binDir stringByAppendingPathComponent: @"MacOS"];
 358 #endif
 359     }
 360
 361   paths = [binDir stringsByAppendingPaths:
 362                 [NSArray arrayWithObjects: @"libexec", @"bin", nil]];
 363   pathEnum = [paths objectEnumerator];
 364   resourcePaths = @"";
 365
 366   while ((resourcePath = [pathEnum nextObject]))
 367     {
 368       if ([fileManager fileExistsAtPath: resourcePath isDirectory: &isDir])
 369         if (isDir)
 370           {
 371             if ([resourcePaths length] > 0)
 372               resourcePaths
 373                 = [resourcePaths stringByAppendingString: pathSeparator];
 374             resourcePaths
 375               = [resourcePaths stringByAppendingString: resourcePath];
 376           }
 377     }
 378   if ([resourcePaths length] > 0) return [resourcePaths UTF8String];
 379
 380   return NULL;
 381 }
 382
 383
 384 const char *
 385 ns_load_path (void)
 386 /* If running as a self-contained app bundle, return as a path string
 387    the filenames of the site-lisp, lisp and leim directories.
 388    Ie, site-lisp:lisp:leim.  Otherwise, return nil.  */
 389 {
 390   NSBundle *bundle = [NSBundle mainBundle];
 391   NSString *resourceDir = [bundle resourcePath];
 392   NSString *resourcePath, *resourcePaths;
 393   NSString *pathSeparator = [NSString stringWithFormat: @"%c", SEPCHAR];
 394   NSFileManager *fileManager = [NSFileManager defaultManager];
 395   BOOL isDir;
 396   NSArray *paths = [resourceDir stringsByAppendingPaths:
 397                               [NSArray arrayWithObjects:
 398                                          @"site-lisp", @"lisp", @"leim", nil]];
 399   NSEnumerator *pathEnum = [paths objectEnumerator];
 400   resourcePaths = @"";
 401
 402   /* Hack to skip site-lisp.  */
 403   if (no_site_lisp) resourcePath = [pathEnum nextObject];
 404
 405   while ((resourcePath = [pathEnum nextObject]))
 406     {
 407       if ([fileManager fileExistsAtPath: resourcePath isDirectory: &isDir])
 408         if (isDir)
 409           {
 410             if ([resourcePaths length] > 0)
 411               resourcePaths
 412                 = [resourcePaths stringByAppendingString: pathSeparator];
 413             resourcePaths
 414               = [resourcePaths stringByAppendingString: resourcePath];
 415           }
 416     }
 417   if ([resourcePaths length] > 0) return [resourcePaths UTF8String];
 418
 419   return NULL;
 420 }
 421
 422 static void
 423 ns_timeout (int usecs)
 424 /* --------------------------------------------------------------------------
 425      Blocking timer utility used by ns_ring_bell
 426    -------------------------------------------------------------------------- */
 427 {
 428   EMACS_TIME wakeup = add_emacs_time (current_emacs_time (),
 429                                       make_emacs_time (0, usecs * 1000));
 430
 431   /* Keep waiting until past the time wakeup.  */
 432   while (1)
 433     {
 434       EMACS_TIME timeout, now = current_emacs_time ();
 435       if (EMACS_TIME_LE (wakeup, now))
 436         break;
 437       timeout = sub_emacs_time (wakeup, now);
 438
 439       /* Try to wait that long--but we might wake up sooner.  */
 440       pselect (0, NULL, NULL, NULL, &timeout, NULL);
 441     }
 442 }
 443
 444
 445 void
 446 ns_release_object (void *obj)
 447 /* --------------------------------------------------------------------------
 448     Release an object (callable from C)
 449    -------------------------------------------------------------------------- */
 450 {
 451     [(id)obj release];
 452 }
 453
 454
 455 void
 456 ns_retain_object (void *obj)
 457 /* --------------------------------------------------------------------------
 458     Retain an object (callable from C)
 459    -------------------------------------------------------------------------- */
 460 {
 461     [(id)obj retain];
 462 }
 463
 464
 465 void *
 466 ns_alloc_autorelease_pool (void)
 467 /* --------------------------------------------------------------------------
 468      Allocate a pool for temporary objects (callable from C)
 469    -------------------------------------------------------------------------- */
 470 {
 471   return [[NSAutoreleasePool alloc] init];
 472 }
 473
 474
 475 void
 476 ns_release_autorelease_pool (void *pool)
 477 /* --------------------------------------------------------------------------
 478      Free a pool and temporary objects it refers to (callable from C)
 479    -------------------------------------------------------------------------- */
 480 {
 481   ns_release_object (pool);
 482 }
 483
 484
 485
 486 /* ==========================================================================
 487
 488     Focus (clipping) and screen update
 489
 490    ========================================================================== */
 491
 492 static NSRect
 493 ns_resize_handle_rect (NSWindow *window)
 494 {
 495   NSRect r = [window frame];
 496   r.origin.x = r.size.width - RESIZE_HANDLE_SIZE;
 497   r.origin.y = 0;
 498   r.size.width = r.size.height = RESIZE_HANDLE_SIZE;
 499   return r;
 500 }
 501
 502
 503 //
 504 // Window constraining
 505 // -------------------
 506 //
 507 // To ensure that the windows are not placed under the menu bar, they
 508 // are typically moved by the call-back constrainFrameRect. However,
 509 // by overriding it, it's possible to inhibit this, leaving the window
 510 // in it's original position.
 511 //
 512 // It's possible to hide the menu bar. However, technically, it's only
 513 // possible to hide it when the application is active. To ensure that
 514 // this work properly, the menu bar and window constraining are
 515 // deferred until the application becomes active.
 516 //
 517 // Even though it's not possible to manually move a window above the
 518 // top of the screen, it is allowed if it's done programmatically,
 519 // when the menu is hidden. This allows the editable area to cover the
 520 // full screen height.
 521 //
 522 // Test cases
 523 // ----------
 524 //
 525 // Use the following extra files:
 526 //
 527 //    init.el:
 528 //       ;; Hide menu and place frame slightly above the top of the screen.
 529 //       (setq ns-auto-hide-menu-bar t)
 530 //       (set-frame-position (selected-frame) 0 -20)
 531 //
 532 // Test 1:
 533 //
 534 //    emacs -Q -l init.el
 535 //
 536 //    Result: No menu bar, and the title bar should be above the screen.
 537 //
 538 // Test 2:
 539 //
 540 //    emacs -Q
 541 //
 542 //    Result: Menu bar visible, frame placed immediately below the menu.
 543 //
 544
 545 static void
 546 ns_constrain_all_frames (void)
 547 {
 548   Lisp_Object tail, frame;
 549
 550   FOR_EACH_FRAME (tail, frame)
 551     {
 552       struct frame *f = XFRAME (frame);
 553       if (FRAME_NS_P (f))
 554         {
 555           NSView *view = FRAME_NS_VIEW (f);
 556           /* This no-op will trigger the default window placing
 557            * constraint system. */
 558           f->output_data.ns->dont_constrain = 0;
 559           [[view window] setFrameOrigin:[[view window] frame].origin];
 560         }
 561     }
 562 }
 563
 564
 565 /* True, if the menu bar should be hidden.  */
 566
 567 static BOOL
 568 ns_menu_bar_should_be_hidden (void)
 569 {
 570   return !NILP (ns_auto_hide_menu_bar)
 571     && [NSApp respondsToSelector:@selector(setPresentationOptions:)];
 572 }
 573
 574
 575 /* Show or hide the menu bar, based on user setting.  */
 576
 577 static void
 578 ns_update_auto_hide_menu_bar (void)
 579 {
 580 #ifndef MAC_OS_X_VERSION_10_6
 581 #define MAC_OS_X_VERSION_10_6 1060
 582 #endif
 583 #ifdef NS_IMPL_COCOA
 584 #if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_6
 585   BLOCK_INPUT;
 586
 587   NSTRACE (ns_update_auto_hide_menu_bar);
 588
 589   if (NSApp != nil
 590       && [NSApp isActive]
 591       && [NSApp respondsToSelector:@selector(setPresentationOptions:)])
 592     {
 593       // Note, "setPresentationOptions" triggers an error unless the
 594       // application is active.
 595       BOOL menu_bar_should_be_hidden = ns_menu_bar_should_be_hidden ();
 596
 597       if (menu_bar_should_be_hidden != ns_menu_bar_is_hidden)
 598         {
 599           NSApplicationPresentationOptions options
 600             = NSApplicationPresentationAutoHideDock;
 601
 602           if (menu_bar_should_be_hidden)
 603             options |= NSApplicationPresentationAutoHideMenuBar;
 604
 605           [NSApp setPresentationOptions: options];
 606
 607           ns_menu_bar_is_hidden = menu_bar_should_be_hidden;
 608
 609           if (!ns_menu_bar_is_hidden)
 610             {
 611               ns_constrain_all_frames ();
 612             }
 613         }
 614     }
 615
 616   UNBLOCK_INPUT;
 617 #endif
 618 #endif
 619 }
 620
 621
 622 static void
 623 ns_update_begin (struct frame *f)
 624 /* --------------------------------------------------------------------------
 625    Prepare for a grouped sequence of drawing calls
 626    external (RIF) call; whole frame, called before update_window_begin
 627    -------------------------------------------------------------------------- */
 628 {
 629   NSView *view = FRAME_NS_VIEW (f);
 630   NSRect r = [view frame];
 631   NSBezierPath *bp = [NSBezierPath bezierPath];
 632   NSTRACE (ns_update_begin);
 633
 634   ns_update_auto_hide_menu_bar ();
 635
 636   ns_updating_frame = f;
 637   [view lockFocus];
 638
 639   /* drawRect may have been called for say the minibuffer, and then clip path
 640      is for the minibuffer.  But the display engine may draw more because
 641      we have set the frame as garbaged.  So reset clip path to the whole
 642      view.  */
 643   [bp appendBezierPathWithRect: r];
 644   [bp setClip];
 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       [img drawInRect: br
2983              fromRect: NSZeroRect
2984              operation: NSCompositeSourceOver
2985               fraction: 1.0
2986            respectFlipped: YES
2987                 hints: nil];
2988 #else
2989       [img compositeToPoint: NSMakePoint (x, y + s->slice.height)
2990                   operation: NSCompositeSourceOver];
2991 #endif
2992     }
2993
2994   if (s->hl == DRAW_CURSOR)
2995     {
2996     [FRAME_CURSOR_COLOR (s->f) set];
2997     if (s->w->phys_cursor_type == FILLED_BOX_CURSOR)
2998       tdCol = ns_lookup_indexed_color (NS_FACE_BACKGROUND (face), s->f);
2999     else
3000       /* Currently on NS img->mask is always 0. Since
3001          get_window_cursor_type specifies a hollow box cursor when on
3002          a non-masked image we never reach this clause. But we put it
3003          in in anticipation of better support for image masks on
3004          NS. */
3005       tdCol = ns_lookup_indexed_color (NS_FACE_FOREGROUND (face), s->f);
3006     }
3007   else
3008     {
3009       tdCol = ns_lookup_indexed_color (NS_FACE_FOREGROUND (face), s->f);
3010     }
3011
3012   /* Draw underline, overline, strike-through. */
3013   ns_draw_text_decoration (s, face, tdCol, br.size.width, br.origin.x);
3014
3015   /* Draw relief, if requested */
3016   if (s->img->relief || s->hl ==DRAW_IMAGE_RAISED || s->hl ==DRAW_IMAGE_SUNKEN)
3017     {
3018       if (s->hl == DRAW_IMAGE_SUNKEN || s->hl == DRAW_IMAGE_RAISED)
3019         {
3020           th = tool_bar_button_relief >= 0 ?
3021             tool_bar_button_relief : DEFAULT_TOOL_BAR_BUTTON_RELIEF;
3022           raised_p = (s->hl == DRAW_IMAGE_RAISED);
3023         }
3024       else
3025         {
3026           th = abs (s->img->relief);
3027           raised_p = (s->img->relief > 0);
3028         }
3029
3030       r.origin.x = x - th;
3031       r.origin.y = y - th;
3032       r.size.width = s->slice.width + 2*th-1;
3033       r.size.height = s->slice.height + 2*th-1;
3034       ns_draw_relief (r, th, raised_p,
3035                       s->slice.y == 0,
3036                       s->slice.y + s->slice.height == s->img->height,
3037                       s->slice.x == 0,
3038                       s->slice.x + s->slice.width == s->img->width, s);
3039     }
3040
3041   /* If there is no mask, the background won't be seen,
3042      so draw a rectangle on the image for the cursor.
3043      Do this for all images, getting transparency right is not reliable.  */
3044   if (s->hl == DRAW_CURSOR)
3045     {
3046       int thickness = abs (s->img->relief);
3047       if (thickness == 0) thickness = 1;
3048       ns_draw_box (br, thickness, FRAME_CURSOR_COLOR (s->f), 1, 1);
3049     }
3050 }
3051
3052
3053 static void
3054 ns_dumpglyphs_stretch (struct glyph_string *s)
3055 {
3056   NSRect r[2];
3057   int n, i;
3058   struct face *face;
3059   NSColor *fgCol, *bgCol;
3060
3061   if (!s->background_filled_p)
3062     {
3063       n = ns_get_glyph_string_clip_rect (s, r);
3064       *r = NSMakeRect (s->x, s->y, s->background_width, s->height);
3065
3066       ns_focus (s->f, r, n);
3067
3068       if (s->hl == DRAW_MOUSE_FACE)
3069        {
3070          face = FACE_FROM_ID (s->f, MOUSE_HL_INFO (s->f)->mouse_face_face_id);
3071          if (!face)
3072            face = FACE_FROM_ID (s->f, MOUSE_FACE_ID);
3073        }
3074       else
3075        face = FACE_FROM_ID (s->f, s->first_glyph->face_id);
3076
3077       bgCol = ns_lookup_indexed_color (NS_FACE_BACKGROUND (face), s->f);
3078       fgCol = ns_lookup_indexed_color (NS_FACE_FOREGROUND (face), s->f);
3079
3080       for (i = 0; i < n; ++i)
3081         {
3082           if (!s->row->full_width_p)
3083             {
3084               int overrun, leftoverrun;
3085
3086               /* truncate to avoid overwriting fringe and/or scrollbar */
3087               overrun = max (0, (s->x + s->background_width)
3088                              - (WINDOW_BOX_RIGHT_EDGE_X (s->w)
3089                                 - WINDOW_RIGHT_FRINGE_WIDTH (s->w)));
3090               r[i].size.width -= overrun;
3091
3092               /* truncate to avoid overwriting to left of the window box */
3093               leftoverrun = (WINDOW_BOX_LEFT_EDGE_X (s->w)
3094                              + WINDOW_LEFT_FRINGE_WIDTH (s->w)) - s->x;
3095
3096               if (leftoverrun > 0)
3097                 {
3098                   r[i].origin.x += leftoverrun;
3099                   r[i].size.width -= leftoverrun;
3100                 }
3101
3102               /* XXX: Try to work between problem where a stretch glyph on
3103                  a partially-visible bottom row will clear part of the
3104                  modeline, and another where list-buffers headers and similar
3105                  rows erroneously have visible_height set to 0.  Not sure
3106                  where this is coming from as other terms seem not to show. */
3107               r[i].size.height = min (s->height, s->row->visible_height);
3108             }
3109
3110           [bgCol set];
3111
3112           /* NOTE: under NS this is NOT used to draw cursors, but we must avoid
3113              overwriting cursor (usually when cursor on a tab) */
3114           if (s->hl == DRAW_CURSOR)
3115             {
3116               CGFloat x, width;
3117
3118               x = r[i].origin.x;
3119               width = s->w->phys_cursor_width;
3120               r[i].size.width -= width;
3121               r[i].origin.x += width;
3122
3123               NSRectFill (r[i]);
3124
3125               /* Draw overlining, etc. on the cursor. */
3126               if (s->w->phys_cursor_type == FILLED_BOX_CURSOR)
3127                 ns_draw_text_decoration (s, face, bgCol, width, x);
3128               else
3129                 ns_draw_text_decoration (s, face, fgCol, width, x);
3130             }
3131           else
3132             {
3133               NSRectFill (r[i]);
3134             }
3135
3136           /* Draw overlining, etc. on the stretch glyph (or the part
3137              of the stretch glyph after the cursor). */
3138           ns_draw_text_decoration (s, face, fgCol, r[i].size.width,
3139                                    r[i].origin.x);
3140         }
3141       ns_unfocus (s->f);
3142       s->background_filled_p = 1;
3143     }
3144 }
3145
3146
3147 static void
3148 ns_draw_glyph_string (struct glyph_string *s)
3149 /* --------------------------------------------------------------------------
3150       External (RIF): Main draw-text call.
3151    -------------------------------------------------------------------------- */
3152 {
3153   /* TODO (optimize): focus for box and contents draw */
3154   NSRect r[2];
3155   int n;
3156   char box_drawn_p = 0;
3157
3158   NSTRACE (ns_draw_glyph_string);
3159
3160   if (s->next && s->right_overhang && !s->for_overlaps/*&&s->hl!=DRAW_CURSOR*/)
3161     {
3162       int width;
3163       struct glyph_string *next;
3164
3165       for (width = 0, next = s->next;
3166            next && width < s->right_overhang;
3167            width += next->width, next = next->next)
3168         if (next->first_glyph->type != IMAGE_GLYPH)
3169           {
3170             if (next->first_glyph->type != STRETCH_GLYPH)
3171               {
3172                 n = ns_get_glyph_string_clip_rect (s->next, r);
3173                 ns_focus (s->f, r, n);
3174                 ns_maybe_dumpglyphs_background (s->next, 1);
3175                 ns_unfocus (s->f);
3176               }
3177             else
3178               {
3179                 ns_dumpglyphs_stretch (s->next);
3180               }
3181             next->num_clips = 0;
3182           }
3183     }
3184
3185   if (!s->for_overlaps && s->face->box != FACE_NO_BOX
3186         && (s->first_glyph->type == CHAR_GLYPH
3187             || s->first_glyph->type == COMPOSITE_GLYPH))
3188     {
3189       n = ns_get_glyph_string_clip_rect (s, r);
3190       ns_focus (s->f, r, n);
3191       ns_maybe_dumpglyphs_background (s, 1);
3192       ns_dumpglyphs_box_or_relief (s);
3193       ns_unfocus (s->f);
3194       box_drawn_p = 1;
3195     }
3196
3197   switch (s->first_glyph->type)
3198     {
3199
3200     case IMAGE_GLYPH:
3201       n = ns_get_glyph_string_clip_rect (s, r);
3202       ns_focus (s->f, r, n);
3203       ns_dumpglyphs_image (s, r[0]);
3204       ns_unfocus (s->f);
3205       break;
3206
3207     case STRETCH_GLYPH:
3208       ns_dumpglyphs_stretch (s);
3209       break;
3210
3211     case CHAR_GLYPH:
3212     case COMPOSITE_GLYPH:
3213       n = ns_get_glyph_string_clip_rect (s, r);
3214       ns_focus (s->f, r, n);
3215
3216       if (s->for_overlaps || (s->cmp_from > 0
3217                               && ! s->first_glyph->u.cmp.automatic))
3218         s->background_filled_p = 1;
3219       else
3220         ns_maybe_dumpglyphs_background
3221           (s, s->first_glyph->type == COMPOSITE_GLYPH);
3222
3223       ns_tmp_flags = s->hl == DRAW_CURSOR ? NS_DUMPGLYPH_CURSOR :
3224                     (s->hl == DRAW_MOUSE_FACE ? NS_DUMPGLYPH_MOUSEFACE :
3225                      (s->for_overlaps ? NS_DUMPGLYPH_FOREGROUND :
3226                       NS_DUMPGLYPH_NORMAL));
3227       ns_tmp_font = (struct nsfont_info *)s->face->font;
3228       if (ns_tmp_font == NULL)
3229           ns_tmp_font = (struct nsfont_info *)FRAME_FONT (s->f);
3230
3231       if (s->hl == DRAW_CURSOR && s->w->phys_cursor_type == FILLED_BOX_CURSOR)
3232         {
3233           unsigned long tmp = NS_FACE_BACKGROUND (s->face);
3234           NS_FACE_BACKGROUND (s->face) = NS_FACE_FOREGROUND (s->face);
3235           NS_FACE_FOREGROUND (s->face) = tmp;
3236         }
3237
3238       ns_tmp_font->font.driver->draw
3239         (s, 0, s->nchars, s->x, s->y,
3240          (ns_tmp_flags == NS_DUMPGLYPH_NORMAL && !s->background_filled_p)
3241          || ns_tmp_flags == NS_DUMPGLYPH_MOUSEFACE);
3242
3243       if (s->hl == DRAW_CURSOR && s->w->phys_cursor_type == FILLED_BOX_CURSOR)
3244         {
3245           unsigned long tmp = NS_FACE_BACKGROUND (s->face);
3246           NS_FACE_BACKGROUND (s->face) = NS_FACE_FOREGROUND (s->face);
3247           NS_FACE_FOREGROUND (s->face) = tmp;
3248         }
3249
3250       ns_unfocus (s->f);
3251       break;
3252
3253     case GLYPHLESS_GLYPH:
3254       n = ns_get_glyph_string_clip_rect (s, r);
3255       ns_focus (s->f, r, n);
3256
3257       if (s->for_overlaps || (s->cmp_from > 0
3258                               && ! s->first_glyph->u.cmp.automatic))
3259         s->background_filled_p = 1;
3260       else
3261         ns_maybe_dumpglyphs_background
3262           (s, s->first_glyph->type == COMPOSITE_GLYPH);
3263       /* ... */
3264       /* Not yet implemented.  */
3265       /* ... */
3266       ns_unfocus (s->f);
3267       break;
3268
3269     default:
3270       emacs_abort ();
3271     }
3272
3273   /* Draw box if not done already. */
3274   if (!s->for_overlaps && !box_drawn_p && s->face->box != FACE_NO_BOX)
3275     {
3276       n = ns_get_glyph_string_clip_rect (s, r);
3277       ns_focus (s->f, r, n);
3278       ns_dumpglyphs_box_or_relief (s);
3279       ns_unfocus (s->f);
3280     }
3281
3282   s->num_clips = 0;
3283 }
3284
3285
3286
3287 /* ==========================================================================
3288
3289     Event loop
3290
3291    ========================================================================== */
3292
3293
3294 static void
3295 ns_send_appdefined (int value)
3296 /* --------------------------------------------------------------------------
3297     Internal: post an appdefined event which EmacsApp-sendEvent will
3298               recognize and take as a command to halt the event loop.
3299    -------------------------------------------------------------------------- */
3300 {
3301   /*NSTRACE (ns_send_appdefined); */
3302
3303   /* Only post this event if we haven't already posted one.  This will end
3304        the [NXApp run] main loop after having processed all events queued at
3305        this moment.  */
3306   if (send_appdefined)
3307     {
3308       NSEvent *nxev;
3309
3310       /* We only need one NX_APPDEFINED event to stop NXApp from running.  */
3311       send_appdefined = NO;
3312
3313       /* Don't need wakeup timer any more */
3314       if (timed_entry)
3315         {
3316           [timed_entry invalidate];
3317           [timed_entry release];
3318           timed_entry = nil;
3319         }
3320
3321       nxev = [NSEvent otherEventWithType: NSApplicationDefined
3322                                 location: NSMakePoint (0, 0)
3323                            modifierFlags: 0
3324                                timestamp: 0
3325                             windowNumber: [[NSApp mainWindow] windowNumber]
3326                                  context: [NSApp context]
3327                                  subtype: 0
3328                                    data1: value
3329                                    data2: 0];
3330
3331       /* Post an application defined event on the event queue.  When this is
3332          received the [NXApp run] will return, thus having processed all
3333          events which are currently queued.  */
3334       [NSApp postEvent: nxev atStart: NO];
3335     }
3336 }
3337
3338 static int
3339 ns_read_socket (struct terminal *terminal, int expected,
3340                 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   if (interrupt_input_blocked)
3356     {
3357       interrupt_input_pending = 1;
3358 #ifdef SYNC_INPUT
3359       pending_signals = 1;
3360 #endif
3361       return -1;
3362     }
3363
3364   interrupt_input_pending = 0;
3365 #ifdef SYNC_INPUT
3366   pending_signals = pending_atimers;
3367 #endif
3368
3369   BLOCK_INPUT;
3370   n_emacs_events_pending = 0;
3371   EVENT_INIT (ev);
3372   emacs_event = &ev;
3373   q_event_ptr = hold_quit;
3374
3375   /* we manage autorelease pools by allocate/reallocate each time around
3376      the loop; strict nesting is occasionally violated but seems not to
3377      matter.. earlier methods using full nesting caused major memory leaks */
3378   [outerpool release];
3379   outerpool = [[NSAutoreleasePool alloc] init];
3380
3381   /* If have pending open-file requests, attend to the next one of those. */
3382   if (ns_pending_files && [ns_pending_files count] != 0
3383       && [(EmacsApp *)NSApp openFile: [ns_pending_files objectAtIndex: 0]])
3384     {
3385       [ns_pending_files removeObjectAtIndex: 0];
3386     }
3387   /* Deal with pending service requests. */
3388   else if (ns_pending_service_names && [ns_pending_service_names count] != 0
3389     && [(EmacsApp *)
3390          NSApp fulfillService: [ns_pending_service_names objectAtIndex: 0]
3391                       withArg: [ns_pending_service_args objectAtIndex: 0]])
3392     {
3393       [ns_pending_service_names removeObjectAtIndex: 0];
3394       [ns_pending_service_args removeObjectAtIndex: 0];
3395     }
3396   else
3397     {
3398       /* Run and wait for events.  We must always send one NX_APPDEFINED event
3399          to ourself, otherwise [NXApp run] will never exit.  */
3400       send_appdefined = YES;
3401       ns_send_appdefined (-1);
3402
3403       if (++apploopnr != 1)
3404         {
3405           emacs_abort ();
3406         }
3407       [NSApp run];
3408       --apploopnr;
3409     }
3410
3411   nevents = n_emacs_events_pending;
3412   n_emacs_events_pending = 0;
3413   emacs_event = q_event_ptr = NULL;
3414   UNBLOCK_INPUT;
3415
3416   return nevents;
3417 }
3418
3419
3420 int
3421 ns_select (int nfds, fd_set *readfds, fd_set *writefds,
3422            fd_set *exceptfds, EMACS_TIME *timeout, sigset_t *sigmask)
3423 /* --------------------------------------------------------------------------
3424      Replacement for select, checking for events
3425    -------------------------------------------------------------------------- */
3426 {
3427   int result;
3428   NSEvent *ev;
3429   int k, nr = 0;
3430   struct input_event event;
3431   char c;
3432
3433 /*  NSTRACE (ns_select); */
3434
3435   for (k = 0; readfds && k < nfds+1; k++)
3436     if (FD_ISSET(k, readfds)) ++nr;
3437
3438   if (NSApp == nil
3439       || (timeout && timeout->tv_sec == 0 && timeout->tv_nsec == 0))
3440     return pselect (nfds, readfds, writefds, exceptfds, timeout, sigmask);
3441
3442   [outerpool release];
3443   outerpool = [[NSAutoreleasePool alloc] init];
3444
3445
3446   send_appdefined = YES;
3447   if (nr > 0)
3448     {
3449       pthread_mutex_lock (&select_mutex);
3450       select_nfds = nfds;
3451       select_valid = 0;
3452       if (readfds)
3453         {
3454           select_readfds = *readfds;
3455           select_valid += SELECT_HAVE_READ;
3456         }
3457       if (writefds)
3458         {
3459           select_writefds = *writefds;
3460           select_valid += SELECT_HAVE_WRITE;
3461         }
3462
3463       if (timeout)
3464         {
3465           select_timeout = *timeout;
3466           select_valid += SELECT_HAVE_TMO;
3467         }
3468
3469       pthread_mutex_unlock (&select_mutex);
3470
3471       /* Inform fd_handler that select should be called */
3472       c = 'g';
3473       write (selfds[1], &c, 1);
3474     }
3475   else if (nr == 0 && timeout)
3476     {
3477       /* No file descriptor, just a timeout, no need to wake fd_handler  */
3478       double time = EMACS_TIME_TO_DOUBLE (*timeout);
3479       timed_entry = [[NSTimer scheduledTimerWithTimeInterval: time
3480                                                       target: NSApp
3481                                                     selector:
3482                                   @selector (timeout_handler:)
3483                                                     userInfo: 0
3484                                                      repeats: NO]
3485                       retain];
3486     }
3487   else /* No timeout and no file descriptors, can this happen?  */
3488     {
3489       /* Send appdefined so we exit from the loop */
3490       ns_send_appdefined (-1);
3491     }
3492
3493   EVENT_INIT (event);
3494   BLOCK_INPUT;
3495   emacs_event = &event;
3496   if (++apploopnr != 1)
3497     {
3498       emacs_abort ();
3499     }
3500   [NSApp run];
3501   --apploopnr;
3502   emacs_event = NULL;
3503   if (nr > 0 && readfds)
3504     {
3505       c = 's';
3506       write (selfds[1], &c, 1);
3507     }
3508   UNBLOCK_INPUT;
3509
3510   ev = last_appdefined_event;
3511
3512   if (ev)
3513     {
3514       int t;
3515       if ([ev type] != NSApplicationDefined)
3516         emacs_abort ();
3517
3518       t = [ev data1];
3519       last_appdefined_event = 0;
3520
3521       if (t == -2)
3522         {
3523           /* The NX_APPDEFINED event we received was a timeout. */
3524           result = 0;
3525         }
3526       else if (t == -1)
3527         {
3528           /* The NX_APPDEFINED event we received was the result of
3529              at least one real input event arriving.  */
3530           errno = EINTR;
3531           result = -1;
3532         }
3533       else
3534         {
3535           /* Received back from select () in fd_handler; copy the results */
3536           pthread_mutex_lock (&select_mutex);
3537           if (readfds) *readfds = select_readfds;
3538           if (writefds) *writefds = select_writefds;
3539           if (timeout) *timeout = select_timeout;
3540           pthread_mutex_unlock (&select_mutex);
3541           result = t;
3542         }
3543     }
3544
3545   return result;
3546 }
3547
3548
3549
3550 /* ==========================================================================
3551
3552     Scrollbar handling
3553
3554    ========================================================================== */
3555
3556
3557 static void
3558 ns_set_vertical_scroll_bar (struct window *window,
3559                            int portion, int whole, int position)
3560 /* --------------------------------------------------------------------------
3561       External (hook): Update or add scrollbar
3562    -------------------------------------------------------------------------- */
3563 {
3564   Lisp_Object win;
3565   NSRect r, v;
3566   struct frame *f = XFRAME (WINDOW_FRAME (window));
3567   EmacsView *view = FRAME_NS_VIEW (f);
3568   int window_y, window_height;
3569   int top, left, height, width, sb_width, sb_left;
3570   EmacsScroller *bar;
3571   BOOL fringe_extended_p;
3572
3573   /* optimization; display engine sends WAY too many of these.. */
3574   if (!NILP (window->vertical_scroll_bar))
3575     {
3576       bar = XNS_SCROLL_BAR (window->vertical_scroll_bar);
3577       if ([bar checkSamePosition: position portion: portion whole: whole])
3578         {
3579           if (view->scrollbarsNeedingUpdate == 0)
3580             {
3581               if (!windows_or_buffers_changed)
3582                   return;
3583             }
3584           else
3585             view->scrollbarsNeedingUpdate--;
3586         }
3587     }
3588
3589   NSTRACE (ns_set_vertical_scroll_bar);
3590
3591   /* Get dimensions.  */
3592   window_box (window, -1, 0, &window_y, 0, &window_height);
3593   top = window_y;
3594   height = window_height;
3595   width = WINDOW_CONFIG_SCROLL_BAR_COLS (window) * FRAME_COLUMN_WIDTH (f);
3596   left = WINDOW_SCROLL_BAR_AREA_X (window);
3597
3598   /* allow for displaying a skinnier scrollbar than char area allotted */
3599   sb_width = (WINDOW_CONFIG_SCROLL_BAR_WIDTH (window) > 0) ?
3600     WINDOW_CONFIG_SCROLL_BAR_WIDTH (window) : width;
3601   sb_left = left;
3602
3603   r = NSMakeRect (sb_left, top, sb_width, height);
3604   /* the parent view is flipped, so we need to flip y value */
3605   v = [view frame];
3606   r.origin.y = (v.size.height - r.size.height - r.origin.y);
3607
3608   if (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (window))
3609     fringe_extended_p = (WINDOW_LEFTMOST_P (window)
3610                          && WINDOW_LEFT_FRINGE_WIDTH (window)
3611                          && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (window)
3612                              || WINDOW_LEFT_MARGIN_COLS (window) == 0));
3613   else
3614     fringe_extended_p = (WINDOW_RIGHTMOST_P (window)
3615                          && WINDOW_RIGHT_FRINGE_WIDTH (window)
3616                          && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (window)
3617                              || WINDOW_RIGHT_MARGIN_COLS (window) == 0));
3618
3619   XSETWINDOW (win, window);
3620   BLOCK_INPUT;
3621
3622   /* we want at least 5 lines to display a scrollbar */
3623   if (WINDOW_TOTAL_LINES (window) < 5)
3624     {
3625       if (!NILP (window->vertical_scroll_bar))
3626         {
3627           bar = XNS_SCROLL_BAR (window->vertical_scroll_bar);
3628           [bar removeFromSuperview];
3629           wset_vertical_scroll_bar (window, Qnil);
3630         }
3631       ns_clear_frame_area (f, sb_left, top, width, height);
3632       UNBLOCK_INPUT;
3633       return;
3634     }
3635
3636   if (NILP (window->vertical_scroll_bar))
3637     {
3638       if (width > 0 && height > 0)
3639         {
3640           if (fringe_extended_p)
3641             ns_clear_frame_area (f, sb_left, top, sb_width, height);
3642           else
3643             ns_clear_frame_area (f, left, top, width, height);
3644         }
3645
3646       bar = [[EmacsScroller alloc] initFrame: r window: win];
3647       wset_vertical_scroll_bar (window, make_save_value (bar, 0));
3648     }
3649   else
3650     {
3651       NSRect oldRect;
3652       bar = XNS_SCROLL_BAR (window->vertical_scroll_bar);
3653       oldRect = [bar frame];
3654       r.size.width = oldRect.size.width;
3655       if (FRAME_LIVE_P (f) && !NSEqualRects (oldRect, r))
3656         {
3657           if (oldRect.origin.x != r.origin.x)
3658               ns_clear_frame_area (f, sb_left, top, width, height);
3659           [bar setFrame: r];
3660         }
3661     }
3662
3663   [bar setPosition: position portion: portion whole: whole];
3664   UNBLOCK_INPUT;
3665 }
3666
3667
3668 static void
3669 ns_condemn_scroll_bars (struct frame *f)
3670 /* --------------------------------------------------------------------------
3671      External (hook): arrange for all frame's scrollbars to be removed
3672      at next call to judge_scroll_bars, except for those redeemed.
3673    -------------------------------------------------------------------------- */
3674 {
3675   int i;
3676   id view;
3677   NSArray *subviews = [[FRAME_NS_VIEW (f) superview] subviews];
3678
3679   NSTRACE (ns_condemn_scroll_bars);
3680
3681   for (i =[subviews count]-1; i >= 0; i--)
3682     {
3683       view = [subviews objectAtIndex: i];
3684       if ([view isKindOfClass: [EmacsScroller class]])
3685         [view condemn];
3686     }
3687 }
3688
3689
3690 static void
3691 ns_redeem_scroll_bar (struct window *window)
3692 /* --------------------------------------------------------------------------
3693      External (hook): arrange to spare this window's scrollbar
3694      at next call to judge_scroll_bars.
3695    -------------------------------------------------------------------------- */
3696 {
3697   id bar;
3698   NSTRACE (ns_redeem_scroll_bar);
3699   if (!NILP (window->vertical_scroll_bar))
3700     {
3701       bar = XNS_SCROLL_BAR (window->vertical_scroll_bar);
3702       [bar reprieve];
3703     }
3704 }
3705
3706
3707 static void
3708 ns_judge_scroll_bars (struct frame *f)
3709 /* --------------------------------------------------------------------------
3710      External (hook): destroy all scrollbars on frame that weren't
3711      redeemed after call to condemn_scroll_bars.
3712    -------------------------------------------------------------------------- */
3713 {
3714   int i;
3715   id view;
3716   EmacsView *eview = FRAME_NS_VIEW (f);
3717   NSArray *subviews = [[eview superview] subviews];
3718   BOOL removed = NO;
3719
3720   NSTRACE (ns_judge_scroll_bars);
3721   for (i = [subviews count]-1; i >= 0; --i)
3722     {
3723       view = [subviews objectAtIndex: i];
3724       if (![view isKindOfClass: [EmacsScroller class]]) continue;
3725       [view judge];
3726       removed = YES;
3727     }
3728
3729   if (removed)
3730     [eview updateFrameSize: NO];
3731 }
3732
3733
3734 void
3735 x_wm_set_icon_position (struct frame *f, int icon_x, int icon_y)
3736 {
3737   /* XXX irrelevant under NS */
3738 }
3739
3740
3741
3742 /* ==========================================================================
3743
3744     Initialization
3745
3746    ========================================================================== */
3747
3748 int
3749 x_display_pixel_height (struct ns_display_info *dpyinfo)
3750 {
3751   NSScreen *screen = [NSScreen mainScreen];
3752   return [screen frame].size.height;
3753 }
3754
3755 int
3756 x_display_pixel_width (struct ns_display_info *dpyinfo)
3757 {
3758   NSScreen *screen = [NSScreen mainScreen];
3759   return [screen frame].size.width;
3760 }
3761
3762
3763 static Lisp_Object ns_string_to_lispmod (const char *s)
3764 /* --------------------------------------------------------------------------
3765      Convert modifier name to lisp symbol
3766    -------------------------------------------------------------------------- */
3767 {
3768   if (!strncmp (SSDATA (SYMBOL_NAME (Qmeta)), s, 10))
3769     return Qmeta;
3770   else if (!strncmp (SSDATA (SYMBOL_NAME (Qsuper)), s, 10))
3771     return Qsuper;
3772   else if (!strncmp (SSDATA (SYMBOL_NAME (Qcontrol)), s, 10))
3773     return Qcontrol;
3774   else if (!strncmp (SSDATA (SYMBOL_NAME (Qalt)), s, 10))
3775     return Qalt;
3776   else if (!strncmp (SSDATA (SYMBOL_NAME (Qhyper)), s, 10))
3777     return Qhyper;
3778   else if (!strncmp (SSDATA (SYMBOL_NAME (Qnone)), s, 10))
3779     return Qnone;
3780   else
3781     return Qnil;
3782 }
3783
3784
3785 static void
3786 ns_default (const char *parameter, Lisp_Object *result,
3787            Lisp_Object yesval, Lisp_Object noval,
3788            BOOL is_float, BOOL is_modstring)
3789 /* --------------------------------------------------------------------------
3790       Check a parameter value in user's preferences
3791    -------------------------------------------------------------------------- */
3792 {
3793   const char *value = ns_get_defaults_value (parameter);
3794
3795   if (value)
3796     {
3797       double f;
3798       char *pos;
3799       if (c_strcasecmp (value, "YES") == 0)
3800         *result = yesval;
3801       else if (c_strcasecmp (value, "NO") == 0)
3802         *result = noval;
3803       else if (is_float && (f = strtod (value, &pos), pos != value))
3804         *result = make_float (f);
3805       else if (is_modstring && value)
3806         *result = ns_string_to_lispmod (value);
3807       else fprintf (stderr,
3808                    "Bad value for default \"%s\": \"%s\"\n", parameter, value);
3809     }
3810 }
3811
3812
3813 static void
3814 ns_initialize_display_info (struct ns_display_info *dpyinfo)
3815 /* --------------------------------------------------------------------------
3816       Initialize global info and storage for display.
3817    -------------------------------------------------------------------------- */
3818 {
3819     NSScreen *screen = [NSScreen mainScreen];
3820     NSWindowDepth depth = [screen depth];
3821     Mouse_HLInfo *hlinfo = &dpyinfo->mouse_highlight;
3822
3823     dpyinfo->resx = 72.27; /* used 75.0, but this makes pt == pixel, expected */
3824     dpyinfo->resy = 72.27;
3825     dpyinfo->color_p = ![NSDeviceWhiteColorSpace isEqualToString:
3826                                                   NSColorSpaceFromDepth (depth)]
3827                 && ![NSCalibratedWhiteColorSpace isEqualToString:
3828                                                  NSColorSpaceFromDepth (depth)];
3829     dpyinfo->n_planes = NSBitsPerPixelFromDepth (depth);
3830     dpyinfo->image_cache = make_image_cache ();
3831     dpyinfo->color_table = xmalloc (sizeof *dpyinfo->color_table);
3832     dpyinfo->color_table->colors = NULL;
3833     dpyinfo->root_window = 42; /* a placeholder.. */
3834
3835     hlinfo->mouse_face_mouse_frame = NULL;
3836     hlinfo->mouse_face_deferred_gc = 0;
3837     hlinfo->mouse_face_beg_row = hlinfo->mouse_face_beg_col = -1;
3838     hlinfo->mouse_face_end_row = hlinfo->mouse_face_end_col = -1;
3839     hlinfo->mouse_face_face_id = DEFAULT_FACE_ID;
3840     hlinfo->mouse_face_window = hlinfo->mouse_face_overlay = Qnil;
3841     hlinfo->mouse_face_hidden = 0;
3842
3843     hlinfo->mouse_face_mouse_x = hlinfo->mouse_face_mouse_y = 0;
3844     hlinfo->mouse_face_defer = 0;
3845
3846     dpyinfo->x_highlight_frame = dpyinfo->x_focus_frame = NULL;
3847
3848     dpyinfo->n_fonts = 0;
3849     dpyinfo->smallest_font_height = 1;
3850     dpyinfo->smallest_char_width = 1;
3851 }
3852
3853
3854 /* This and next define (many of the) public functions in this file. */
3855 /* x_... are generic versions in xdisp.c that we, and other terms, get away
3856          with using despite presence in the "system dependent" redisplay
3857          interface.  In addition, many of the ns_ methods have code that is
3858          shared with all terms, indicating need for further refactoring. */
3859 extern frame_parm_handler ns_frame_parm_handlers[];
3860 static struct redisplay_interface ns_redisplay_interface =
3861 {
3862   ns_frame_parm_handlers,
3863   x_produce_glyphs,
3864   x_write_glyphs,
3865   x_insert_glyphs,
3866   x_clear_end_of_line,
3867   ns_scroll_run,
3868   ns_after_update_window_line,
3869   ns_update_window_begin,
3870   ns_update_window_end,
3871   x_cursor_to,
3872   ns_flush,
3873   0, /* flush_display_optional */
3874   x_clear_window_mouse_face,
3875   x_get_glyph_overhangs,
3876   x_fix_overlapping_area,
3877   ns_draw_fringe_bitmap,
3878   0, /* define_fringe_bitmap */ /* FIXME: simplify ns_draw_fringe_bitmap */
3879   0, /* destroy_fringe_bitmap */
3880   ns_compute_glyph_string_overhangs,
3881   ns_draw_glyph_string, /* interface to nsfont.m */
3882   ns_define_frame_cursor,
3883   ns_clear_frame_area,
3884   ns_draw_window_cursor,
3885   ns_draw_vertical_window_border,
3886   ns_shift_glyphs_for_insert
3887 };
3888
3889
3890 static void
3891 ns_delete_display (struct ns_display_info *dpyinfo)
3892 {
3893   /* TODO... */
3894 }
3895
3896
3897 /* This function is called when the last frame on a display is deleted. */
3898 static void
3899 ns_delete_terminal (struct terminal *terminal)
3900 {
3901   struct ns_display_info *dpyinfo = terminal->display_info.ns;
3902
3903   /* Protect against recursive calls.  delete_frame in
3904      delete_terminal calls us back when it deletes our last frame.  */
3905   if (!terminal->name)
3906     return;
3907
3908   BLOCK_INPUT;
3909
3910   x_destroy_all_bitmaps (dpyinfo);
3911   ns_delete_display (dpyinfo);
3912   UNBLOCK_INPUT;
3913 }
3914
3915
3916 static struct terminal *
3917 ns_create_terminal (struct ns_display_info *dpyinfo)
3918 /* --------------------------------------------------------------------------
3919       Set up use of NS before we make the first connection.
3920    -------------------------------------------------------------------------- */
3921 {
3922   struct terminal *terminal;
3923
3924   NSTRACE (ns_create_terminal);
3925
3926   terminal = create_terminal ();
3927
3928   terminal->type = output_ns;
3929   terminal->display_info.ns = dpyinfo;
3930   dpyinfo->terminal = terminal;
3931
3932   terminal->rif = &ns_redisplay_interface;
3933
3934   terminal->clear_frame_hook = ns_clear_frame;
3935   terminal->ins_del_lines_hook = 0; /* XXX vestigial? */
3936   terminal->delete_glyphs_hook = 0; /* XXX vestigial? */
3937   terminal->ring_bell_hook = ns_ring_bell;
3938   terminal->reset_terminal_modes_hook = ns_reset_terminal_modes;
3939   terminal->set_terminal_modes_hook = ns_set_terminal_modes;
3940   terminal->update_begin_hook = ns_update_begin;
3941   terminal->update_end_hook = ns_update_end;
3942   terminal->set_terminal_window_hook = NULL; /* XXX vestigial? */
3943   terminal->read_socket_hook = ns_read_socket;
3944   terminal->frame_up_to_date_hook = ns_frame_up_to_date;
3945   terminal->mouse_position_hook = ns_mouse_position;
3946   terminal->frame_rehighlight_hook = ns_frame_rehighlight;
3947   terminal->frame_raise_lower_hook = ns_frame_raise_lower;
3948
3949   terminal->fullscreen_hook = 0; /* see XTfullscreen_hook */
3950
3951   terminal->set_vertical_scroll_bar_hook = ns_set_vertical_scroll_bar;
3952   terminal->condemn_scroll_bars_hook = ns_condemn_scroll_bars;
3953   terminal->redeem_scroll_bar_hook = ns_redeem_scroll_bar;
3954   terminal->judge_scroll_bars_hook = ns_judge_scroll_bars;
3955
3956   terminal->delete_frame_hook = x_destroy_window;
3957   terminal->delete_terminal_hook = ns_delete_terminal;
3958
3959   terminal->scroll_region_ok = 1;
3960   terminal->char_ins_del_ok = 1;
3961   terminal->line_ins_del_ok = 1;
3962   terminal->fast_clear_end_of_line = 1;
3963   terminal->memory_below_frame = 0;
3964
3965   return terminal;
3966 }
3967
3968
3969 struct ns_display_info *
3970 ns_term_init (Lisp_Object display_name)
3971 /* --------------------------------------------------------------------------
3972      Start the Application and get things rolling.
3973    -------------------------------------------------------------------------- */
3974 {
3975   struct terminal *terminal;
3976   struct ns_display_info *dpyinfo;
3977   static int ns_initialized = 0;
3978   Lisp_Object tmp;
3979
3980   NSTRACE (ns_term_init);
3981
3982   /* count object allocs (About, click icon); on OS X use ObjectAlloc tool */
3983   /*GSDebugAllocationActive (YES); */
3984   BLOCK_INPUT;
3985   handling_signal = 0;
3986
3987   if (!ns_initialized)
3988     {
3989       baud_rate = 38400;
3990       Fset_input_interrupt_mode (Qnil);
3991
3992       if (selfds[0] == -1)
3993         {
3994           if (pipe (selfds) == -1)
3995             {
3996               fprintf (stderr, "Failed to create pipe: %s\n",
3997                        emacs_strerror (errno));
3998               emacs_abort ();
3999             }
4000
4001           fcntl (selfds[0], F_SETFL, O_NONBLOCK|fcntl (selfds[0], F_GETFL));
4002           FD_ZERO (&select_readfds);
4003           FD_ZERO (&select_writefds);
4004           pthread_mutex_init (&select_mutex, NULL);
4005         }
4006       ns_initialized = 1;
4007     }
4008
4009   ns_pending_files = [[NSMutableArray alloc] init];
4010   ns_pending_service_names = [[NSMutableArray alloc] init];
4011   ns_pending_service_args = [[NSMutableArray alloc] init];
4012
4013 /* Start app and create the main menu, window, view.
4014      Needs to be here because ns_initialize_display_info () uses AppKit classes.
4015      The view will then ask the NSApp to stop and return to Emacs. */
4016   [EmacsApp sharedApplication];
4017   if (NSApp == nil)
4018     return NULL;
4019   [NSApp setDelegate: NSApp];
4020
4021   /* Start the select thread.  */
4022   [NSThread detachNewThreadSelector:@selector (fd_handler:)
4023                            toTarget:NSApp
4024                          withObject:nil];
4025
4026   /* debugging: log all notifications */
4027   /*   [[NSNotificationCenter defaultCenter] addObserver: NSApp
4028                                          selector: @selector (logNotification:)
4029                                              name: nil object: nil]; */
4030
4031   dpyinfo = xzalloc (sizeof *dpyinfo);
4032
4033   ns_initialize_display_info (dpyinfo);
4034   terminal = ns_create_terminal (dpyinfo);
4035
4036   terminal->kboard = xmalloc (sizeof *terminal->kboard);
4037   init_kboard (terminal->kboard);
4038   kset_window_system (terminal->kboard, Qns);
4039   terminal->kboard->next_kboard = all_kboards;
4040   all_kboards = terminal->kboard;
4041   /* Don't let the initial kboard remain current longer than necessary.
4042      That would cause problems if a file loaded on startup tries to
4043      prompt in the mini-buffer.  */
4044   if (current_kboard == initial_kboard)
4045     current_kboard = terminal->kboard;
4046   terminal->kboard->reference_count++;
4047
4048   dpyinfo->next = x_display_list;
4049   x_display_list = dpyinfo;
4050
4051   /* Put it on ns_display_name_list */
4052   ns_display_name_list = Fcons (Fcons (display_name, Qnil),
4053                                 ns_display_name_list);
4054   dpyinfo->name_list_element = XCAR (ns_display_name_list);
4055
4056   terminal->name = xstrdup (SSDATA (display_name));
4057
4058   UNBLOCK_INPUT;
4059
4060   if (!inhibit_x_resources)
4061     {
4062       ns_default ("GSFontAntiAlias", &ns_antialias_text,
4063                  Qt, Qnil, NO, NO);
4064       tmp = Qnil;
4065       /* this is a standard variable */
4066       ns_default ("AppleAntiAliasingThreshold", &tmp,
4067                  make_float (10.0), make_float (6.0), YES, NO);
4068       ns_antialias_threshold = NILP (tmp) ? 10.0 : XFLOATINT (tmp);
4069     }
4070
4071   ns_selection_color = [[NSUserDefaults standardUserDefaults]
4072                          stringForKey: @"AppleHighlightColor"];
4073   if (ns_selection_color == nil)
4074     ns_selection_color = NS_SELECTION_COLOR_DEFAULT;
4075
4076   {
4077     NSColorList *cl = [NSColorList colorListNamed: @"Emacs"];
4078
4079     if ( cl == nil )
4080       {
4081         Lisp_Object color_file, color_map, color;
4082         unsigned long c;
4083         char *name;
4084
4085         color_file = Fexpand_file_name (build_string ("rgb.txt"),
4086                          Fsymbol_value (intern ("data-directory")));
4087         if (NILP (Ffile_readable_p (color_file)))
4088           fatal ("Could not find %s.\n", SDATA (color_file));
4089
4090         color_map = Fx_load_color_file (color_file);
4091         if (NILP (color_map))
4092           fatal ("Could not read %s.\n", SDATA (color_file));
4093
4094         cl = [[NSColorList alloc] initWithName: @"Emacs"];
4095         for ( ; CONSP (color_map); color_map = XCDR (color_map))
4096           {
4097             color = XCAR (color_map);
4098             name = SSDATA (XCAR (color));
4099             c = XINT (XCDR (color));
4100             [cl setColor:
4101                   [NSColor colorWithCalibratedRed: RED_FROM_ULONG (c) / 255.0
4102                                             green: GREEN_FROM_ULONG (c) / 255.0
4103                                              blue: BLUE_FROM_ULONG (c) / 255.0
4104                                             alpha: 1.0]
4105                   forKey: [NSString stringWithUTF8String: name]];
4106           }
4107         [cl writeToFile: nil];
4108       }
4109   }
4110
4111   {
4112 #ifdef NS_IMPL_GNUSTEP
4113     Vwindow_system_version = build_string (gnustep_base_version);
4114 #else
4115     /*PSnextrelease (128, c); */
4116     char c[DBL_BUFSIZE_BOUND];
4117     int len = dtoastr (c, sizeof c, 0, 0, NSAppKitVersionNumber);
4118     Vwindow_system_version = make_unibyte_string (c, len);
4119 #endif
4120   }
4121
4122   delete_keyboard_wait_descriptor (0);
4123
4124   ns_app_name = [[NSProcessInfo processInfo] processName];
4125
4126 /* Set up OS X app menu */
4127 #ifdef NS_IMPL_COCOA
4128   {
4129     NSMenu *appMenu;
4130     NSMenuItem *item;
4131     /* set up the application menu */
4132     svcsMenu = [[EmacsMenu alloc] initWithTitle: @"Services"];
4133     [svcsMenu setAutoenablesItems: NO];
4134     appMenu = [[EmacsMenu alloc] initWithTitle: @"Emacs"];
4135     [appMenu setAutoenablesItems: NO];
4136     mainMenu = [[EmacsMenu alloc] initWithTitle: @""];
4137     dockMenu = [[EmacsMenu alloc] initWithTitle: @""];
4138
4139     [appMenu insertItemWithTitle: @"About Emacs"
4140                           action: @selector (orderFrontStandardAboutPanel:)
4141                    keyEquivalent: @""
4142                          atIndex: 0];
4143     [appMenu insertItem: [NSMenuItem separatorItem] atIndex: 1];
4144     [appMenu insertItemWithTitle: @"Preferences..."
4145                           action: @selector (showPreferencesWindow:)
4146                    keyEquivalent: @","
4147                          atIndex: 2];
4148     [appMenu insertItem: [NSMenuItem separatorItem] atIndex: 3];
4149     item = [appMenu insertItemWithTitle: @"Services"
4150                                  action: @selector (menuDown:)
4151                           keyEquivalent: @""
4152                                 atIndex: 4];
4153     [appMenu setSubmenu: svcsMenu forItem: item];
4154     [appMenu insertItem: [NSMenuItem separatorItem] atIndex: 5];
4155     [appMenu insertItemWithTitle: @"Hide Emacs"
4156                           action: @selector (hide:)
4157                    keyEquivalent: @"h"
4158                          atIndex: 6];
4159     item =  [appMenu insertItemWithTitle: @"Hide Others"
4160                           action: @selector (hideOtherApplications:)
4161                    keyEquivalent: @"h"
4162                          atIndex: 7];
4163     [item setKeyEquivalentModifierMask: NSCommandKeyMask | NSAlternateKeyMask];
4164     [appMenu insertItem: [NSMenuItem separatorItem] atIndex: 8];
4165     [appMenu insertItemWithTitle: @"Quit Emacs"
4166                           action: @selector (terminate:)
4167                    keyEquivalent: @"q"
4168                          atIndex: 9];
4169
4170     item = [mainMenu insertItemWithTitle: ns_app_name
4171                                   action: @selector (menuDown:)
4172                            keyEquivalent: @""
4173                                  atIndex: 0];
4174     [mainMenu setSubmenu: appMenu forItem: item];
4175     [dockMenu insertItemWithTitle: @"New Frame"
4176                            action: @selector (newFrame:)
4177                     keyEquivalent: @""
4178                           atIndex: 0];
4179
4180     [NSApp setMainMenu: mainMenu];
4181     [NSApp setAppleMenu: appMenu];
4182     [NSApp setServicesMenu: svcsMenu];
4183     /* Needed at least on Cocoa, to get dock menu to show windows */
4184     [NSApp setWindowsMenu: [[NSMenu alloc] init]];
4185
4186     [[NSNotificationCenter defaultCenter]
4187       addObserver: mainMenu
4188          selector: @selector (trackingNotification:)
4189              name: NSMenuDidBeginTrackingNotification object: mainMenu];
4190     [[NSNotificationCenter defaultCenter]
4191       addObserver: mainMenu
4192          selector: @selector (trackingNotification:)
4193              name: NSMenuDidEndTrackingNotification object: mainMenu];
4194   }
4195 #endif /* MAC OS X menu setup */
4196
4197   [NSApp run];
4198   ns_do_open_file = YES;
4199   return dpyinfo;
4200 }
4201
4202
4203 void
4204 ns_term_shutdown (int sig)
4205 {
4206   [[NSUserDefaults standardUserDefaults] synchronize];
4207
4208   /* code not reached in emacs.c after this is called by shut_down_emacs: */
4209   if (STRINGP (Vauto_save_list_file_name))
4210     unlink (SSDATA (Vauto_save_list_file_name));
4211
4212   if (sig == 0 || sig == SIGTERM)
4213     {
4214       [NSApp terminate: NSApp];
4215     }
4216   else // force a stack trace to happen
4217     {
4218       emacs_abort ();
4219     }
4220 }
4221
4222
4223 /* ==========================================================================
4224
4225     EmacsApp implementation
4226
4227    ========================================================================== */
4228
4229
4230 @implementation EmacsApp
4231
4232 - (void)logNotification: (NSNotification *)notification
4233 {
4234   const char *name = [[notification name] UTF8String];
4235   if (!strstr (name, "Update") && !strstr (name, "NSMenu")
4236       && !strstr (name, "WindowNumber"))
4237     NSLog (@"notification: '%@'", [notification name]);
4238 }
4239
4240
4241 - (void)sendEvent: (NSEvent *)theEvent
4242 /* --------------------------------------------------------------------------
4243      Called when NSApp is running for each event received.  Used to stop
4244      the loop when we choose, since there's no way to just run one iteration.
4245    -------------------------------------------------------------------------- */
4246 {
4247   int type = [theEvent type];
4248   NSWindow *window = [theEvent window];
4249 /*  NSTRACE (sendEvent); */
4250 /*fprintf (stderr, "received event of type %d\t%d\n", type);*/
4251
4252 #ifdef NS_IMPL_COCOA
4253   if (type == NSApplicationDefined
4254       && [theEvent data2] == NSAPP_DATA2_RUNASSCRIPT)
4255     {
4256       ns_run_ascript ();
4257       [self stop: self];
4258       return;
4259     }
4260 #endif
4261
4262   if (type == NSCursorUpdate && window == nil)
4263     {
4264       fprintf (stderr, "Dropping external cursor update event.\n");
4265       return;
4266     }
4267
4268 #ifdef NS_IMPL_COCOA
4269   /* pass mouse down in resize handle and subsequent drags directly to
4270      EmacsWindow so we can generate continuous redisplays */
4271   if (ns_in_resize)
4272     {
4273       if (type == NSLeftMouseDragged)
4274         {
4275           [window mouseDragged: theEvent];
4276           return;
4277         }
4278       else if (type == NSLeftMouseUp)
4279         {
4280           [window mouseUp: theEvent];
4281           return;
4282         }
4283     }
4284   else if (type == NSLeftMouseDown)
4285     {
4286       NSRect r = ns_resize_handle_rect (window);
4287       if (NSPointInRect ([theEvent locationInWindow], r))
4288         {
4289           ns_in_resize = YES;
4290           [window mouseDown: theEvent];
4291           return;
4292         }
4293     }
4294 #endif
4295
4296   if (type == NSApplicationDefined)
4297     {
4298       /* Events posted by ns_send_appdefined interrupt the run loop here.
4299          But, if a modal window is up, an appdefined can still come through,
4300          (e.g., from a makeKeyWindow event) but stopping self also stops the
4301          modal loop. Just defer it until later. */
4302       if ([NSApp modalWindow] == nil)
4303         {
4304           last_appdefined_event = theEvent;
4305           [self stop: self];
4306         }
4307       else
4308         {
4309           send_appdefined = YES;
4310         }
4311     }
4312
4313   [super sendEvent: theEvent];
4314 }
4315
4316
4317 - (void)showPreferencesWindow: (id)sender
4318 {
4319   struct frame *emacsframe = SELECTED_FRAME ();
4320   NSEvent *theEvent = [NSApp currentEvent];
4321
4322   if (!emacs_event)
4323     return;
4324   emacs_event->kind = NS_NONKEY_EVENT;
4325   emacs_event->code = KEY_NS_SHOW_PREFS;
4326   emacs_event->modifiers = 0;
4327   EV_TRAILER (theEvent);
4328 }
4329
4330
4331 - (void)newFrame: (id)sender
4332 {
4333   struct frame *emacsframe = SELECTED_FRAME ();
4334   NSEvent *theEvent = [NSApp currentEvent];
4335
4336   if (!emacs_event)
4337     return;
4338   emacs_event->kind = NS_NONKEY_EVENT;
4339   emacs_event->code = KEY_NS_NEW_FRAME;
4340   emacs_event->modifiers = 0;
4341   EV_TRAILER (theEvent);
4342 }
4343
4344
4345 /* Open a file (used by below, after going into queue read by ns_read_socket) */
4346 - (BOOL) openFile: (NSString *)fileName
4347 {
4348   struct frame *emacsframe = SELECTED_FRAME ();
4349   NSEvent *theEvent = [NSApp currentEvent];
4350
4351   if (!emacs_event)
4352     return NO;
4353
4354   emacs_event->kind = NS_NONKEY_EVENT;
4355   emacs_event->code = KEY_NS_OPEN_FILE_LINE;
4356   ns_input_file = append2 (ns_input_file, build_string ([fileName UTF8String]));
4357   ns_input_line = Qnil; /* can be start or cons start,end */
4358   emacs_event->modifiers =0;
4359   EV_TRAILER (theEvent);
4360
4361   return YES;
4362 }
4363
4364
4365 /* **************************************************************************
4366
4367       EmacsApp delegate implementation
4368
4369    ************************************************************************** */
4370
4371 - (void)applicationDidFinishLaunching: (NSNotification *)notification
4372 /* --------------------------------------------------------------------------
4373      When application is loaded, terminate event loop in ns_term_init
4374    -------------------------------------------------------------------------- */
4375 {
4376   NSTRACE (applicationDidFinishLaunching);
4377   [NSApp setServicesProvider: NSApp];
4378   ns_send_appdefined (-2);
4379 }
4380
4381
4382 /* Termination sequences:
4383     C-x C-c:
4384     Cmd-Q:
4385     MenuBar | File | Exit:
4386     Select Quit from App menubar:
4387         -terminate
4388         KEY_NS_POWER_OFF, (save-buffers-kill-emacs)
4389         ns_term_shutdown()
4390
4391     Select Quit from Dock menu:
4392     Logout attempt:
4393         -appShouldTerminate
4394           Cancel -> Nothing else
4395           Accept ->
4396
4397           -terminate
4398           KEY_NS_POWER_OFF, (save-buffers-kill-emacs)
4399           ns_term_shutdown()
4400
4401 */
4402
4403 - (void) terminate: (id)sender
4404 {
4405   struct frame *emacsframe = SELECTED_FRAME ();
4406
4407   if (!emacs_event)
4408     return;
4409
4410   emacs_event->kind = NS_NONKEY_EVENT;
4411   emacs_event->code = KEY_NS_POWER_OFF;
4412   emacs_event->arg = Qt; /* mark as non-key event */
4413   EV_TRAILER ((id)nil);
4414 }
4415
4416
4417 - (NSApplicationTerminateReply)applicationShouldTerminate: (id)sender
4418 {
4419   int ret;
4420
4421   if (NILP (ns_confirm_quit)) //   || ns_shutdown_properly  --> TO DO
4422     return NSTerminateNow;
4423
4424     ret = NSRunAlertPanel(ns_app_name,
4425                           @"Exit requested.  Would you like to Save Buffers and Exit, or Cancel the request?",
4426                           @"Save Buffers and Exit", @"Cancel", nil);
4427
4428     if (ret == NSAlertDefaultReturn)
4429         return NSTerminateNow;
4430     else if (ret == NSAlertAlternateReturn)
4431         return NSTerminateCancel;
4432     return NSTerminateNow;  /* just in case */
4433 }
4434
4435 static int
4436 not_in_argv (NSString *arg)
4437 {
4438   int k;
4439   const char *a = [arg UTF8String];
4440   for (k = 1; k < initial_argc; ++k)
4441     if (strcmp (a, initial_argv[k]) == 0) return 0;
4442   return 1;
4443 }
4444
4445 /*   Notification from the Workspace to open a file */
4446 - (BOOL)application: sender openFile: (NSString *)file
4447 {
4448   if (ns_do_open_file || not_in_argv (file))
4449     [ns_pending_files addObject: file];
4450   return YES;
4451 }
4452
4453
4454 /*   Open a file as a temporary file */
4455 - (BOOL)application: sender openTempFile: (NSString *)file
4456 {
4457   if (ns_do_open_file || not_in_argv (file))
4458     [ns_pending_files addObject: file];
4459   return YES;
4460 }
4461
4462
4463 /*   Notification from the Workspace to open a file noninteractively (?) */
4464 - (BOOL)application: sender openFileWithoutUI: (NSString *)file
4465 {
4466   if (ns_do_open_file || not_in_argv (file))
4467     [ns_pending_files addObject: file];
4468   return YES;
4469 }
4470
4471 /*   Notification from the Workspace to open multiple files */
4472 - (void)application: sender openFiles: (NSArray *)fileList
4473 {
4474   NSEnumerator *files = [fileList objectEnumerator];
4475   NSString *file;
4476   /* Don't open files from the command line unconditionally,
4477      Cocoa parses the command line wrong, --option value tries to open value
4478      if --option is the last option.  */
4479   while ((file = [files nextObject]) != nil)
4480     if (ns_do_open_file || not_in_argv (file))
4481       [ns_pending_files addObject: file];
4482
4483   [self replyToOpenOrPrint: NSApplicationDelegateReplySuccess];
4484
4485 }
4486
4487
4488 /* Handle dock menu requests.  */
4489 - (NSMenu *)applicationDockMenu: (NSApplication *) sender
4490 {
4491   return dockMenu;
4492 }
4493
4494
4495 /* TODO: these may help w/IO switching btwn terminal and NSApp */
4496 - (void)applicationWillBecomeActive: (NSNotification *)notification
4497 {
4498   //ns_app_active=YES;
4499 }
4500 - (void)applicationDidBecomeActive: (NSNotification *)notification
4501 {
4502   NSTRACE (applicationDidBecomeActive);
4503
4504   //ns_app_active=YES;
4505
4506   ns_update_auto_hide_menu_bar ();
4507   // No constraining takes place when the application is not active.
4508   ns_constrain_all_frames ();
4509 }
4510 - (void)applicationDidResignActive: (NSNotification *)notification
4511 {
4512   //ns_app_active=NO;
4513   ns_send_appdefined (-1);
4514 }
4515
4516
4517
4518 /* ==========================================================================
4519
4520     EmacsApp aux handlers for managing event loop
4521
4522    ========================================================================== */
4523
4524
4525 - (void)timeout_handler: (NSTimer *)timedEntry
4526 /* --------------------------------------------------------------------------
4527      The timeout specified to ns_select has passed.
4528    -------------------------------------------------------------------------- */
4529 {
4530   /*NSTRACE (timeout_handler); */
4531   ns_send_appdefined (-2);
4532 }
4533
4534 - (void)fd_handler:(id)unused
4535 /* --------------------------------------------------------------------------
4536      Check data waiting on file descriptors and terminate if so
4537    -------------------------------------------------------------------------- */
4538 {
4539   int result;
4540   int waiting = 1, nfds;
4541   char c;
4542
4543   SELECT_TYPE readfds, writefds, *wfds;
4544   EMACS_TIME timeout, *tmo;
4545   NSAutoreleasePool *pool = nil;
4546
4547   /* NSTRACE (fd_handler); */
4548
4549   for (;;)
4550     {
4551       [pool release];
4552       pool = [[NSAutoreleasePool alloc] init];
4553
4554       if (waiting)
4555         {
4556           SELECT_TYPE fds;
4557
4558           FD_SET (selfds[0], &fds);
4559           result = select (selfds[0]+1, &fds, NULL, NULL, NULL);
4560           if (result > 0)
4561             {
4562               read (selfds[0], &c, 1);
4563               if (c == 'g') waiting = 0;
4564             }
4565         }
4566       else
4567         {
4568           pthread_mutex_lock (&select_mutex);
4569           nfds = select_nfds;
4570
4571           if (select_valid & SELECT_HAVE_READ)
4572             readfds = select_readfds;
4573           else
4574             FD_ZERO (&readfds);
4575
4576           if (select_valid & SELECT_HAVE_WRITE)
4577             {
4578               writefds = select_writefds;
4579               wfds = &writefds;
4580             }
4581           else
4582             wfds = NULL;
4583           if (select_valid & SELECT_HAVE_TMO)
4584             {
4585               timeout = select_timeout;
4586               tmo = &timeout;
4587             }
4588           else
4589             tmo = NULL;
4590
4591           pthread_mutex_unlock (&select_mutex);
4592
4593           FD_SET (selfds[0], &readfds);
4594           if (selfds[0] >= nfds) nfds = selfds[0]+1;
4595
4596           result = pselect (nfds, &readfds, wfds, NULL, tmo, NULL);
4597
4598           if (result == 0)
4599             ns_send_appdefined (-2);
4600           else if (result > 0)
4601             {
4602               if (FD_ISSET (selfds[0], &readfds))
4603                 {
4604                   read (selfds[0], &c, 1);
4605                   if (c == 's') waiting = 1;
4606                 }
4607               else
4608                 {
4609                   pthread_mutex_lock (&select_mutex);
4610                   if (select_valid & SELECT_HAVE_READ)
4611                     select_readfds = readfds;
4612                   if (select_valid & SELECT_HAVE_WRITE)
4613                     select_writefds = writefds;
4614                   if (select_valid & SELECT_HAVE_TMO)
4615                     select_timeout = timeout;
4616                   pthread_mutex_unlock (&select_mutex);
4617
4618                   ns_send_appdefined (result);
4619                 }
4620             }
4621           waiting = 1;
4622         }
4623     }
4624 }
4625
4626
4627
4628 /* ==========================================================================
4629
4630     Service provision
4631
4632    ========================================================================== */
4633
4634 /* called from system: queue for next pass through event loop */
4635 - (void)requestService: (NSPasteboard *)pboard
4636               userData: (NSString *)userData
4637                  error: (NSString **)error
4638 {
4639   [ns_pending_service_names addObject: userData];
4640   [ns_pending_service_args addObject: [NSString stringWithUTF8String:
4641       SSDATA (ns_string_from_pasteboard (pboard))]];
4642 }
4643
4644
4645 /* called from ns_read_socket to clear queue */
4646 - (BOOL)fulfillService: (NSString *)name withArg: (NSString *)arg
4647 {
4648   struct frame *emacsframe = SELECTED_FRAME ();
4649   NSEvent *theEvent = [NSApp currentEvent];
4650
4651   if (!emacs_event)
4652     return NO;
4653
4654   emacs_event->kind = NS_NONKEY_EVENT;
4655   emacs_event->code = KEY_NS_SPI_SERVICE_CALL;
4656   ns_input_spi_name = build_string ([name UTF8String]);
4657   ns_input_spi_arg = build_string ([arg UTF8String]);
4658   emacs_event->modifiers = EV_MODIFIERS (theEvent);
4659   EV_TRAILER (theEvent);
4660
4661   return YES;
4662 }
4663
4664
4665 @end  /* EmacsApp */
4666
4667
4668
4669 /* ==========================================================================
4670
4671     EmacsView implementation
4672
4673    ========================================================================== */
4674
4675
4676 @implementation EmacsView
4677
4678 /* needed to inform when window closed from LISP */
4679 - (void) setWindowClosing: (BOOL)closing
4680 {
4681   windowClosing = closing;
4682 }
4683
4684
4685 - (void)dealloc
4686 {
4687   NSTRACE (EmacsView_dealloc);
4688   [toolbar release];
4689   [super dealloc];
4690 }
4691
4692
4693 /* called on font panel selection */
4694 - (void)changeFont: (id)sender
4695 {
4696   NSEvent *e =[[self window] currentEvent];
4697   struct face *face =FRAME_DEFAULT_FACE (emacsframe);
4698   id newFont;
4699   float size;
4700
4701   NSTRACE (changeFont);
4702   if (!emacs_event)
4703     return;
4704
4705   if ((newFont = [sender convertFont:
4706                            ((struct nsfont_info *)face->font)->nsfont]))
4707     {
4708       SET_FRAME_GARBAGED (emacsframe); /* now needed as of 2008/10 */
4709
4710       emacs_event->kind = NS_NONKEY_EVENT;
4711       emacs_event->modifiers = 0;
4712       emacs_event->code = KEY_NS_CHANGE_FONT;
4713
4714       size = [newFont pointSize];
4715       ns_input_fontsize = make_number (lrint (size));
4716       ns_input_font = build_string ([[newFont familyName] UTF8String]);
4717       EV_TRAILER (e);
4718     }
4719 }
4720
4721
4722 - (BOOL)acceptsFirstResponder
4723 {
4724   NSTRACE (acceptsFirstResponder);
4725   return YES;
4726 }
4727
4728
4729 - (void)resetCursorRects
4730 {
4731   NSRect visible = [self visibleRect];
4732   NSCursor *currentCursor = FRAME_POINTER_TYPE (emacsframe);
4733   NSTRACE (resetCursorRects);
4734
4735   if (currentCursor == nil)
4736     currentCursor = [NSCursor arrowCursor];
4737
4738   if (!NSIsEmptyRect (visible))
4739     [self addCursorRect: visible cursor: currentCursor];
4740   [currentCursor setOnMouseEntered: YES];
4741 }
4742
4743
4744
4745 /*****************************************************************************/
4746 /* Keyboard handling. */
4747 #define NS_KEYLOG 0
4748
4749 - (void)keyDown: (NSEvent *)theEvent
4750 {
4751   Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (emacsframe);
4752   int code;
4753   unsigned fnKeysym = 0;
4754   int flags;
4755   static NSMutableArray *nsEvArray;
4756 #if !defined (NS_IMPL_COCOA) || MAC_OS_X_VERSION_MAX_ALLOWED < MAC_OS_X_VERSION_10_6
4757   static BOOL firstTime = YES;
4758 #endif
4759   int left_is_none;
4760
4761   NSTRACE (keyDown);
4762
4763   /* Rhapsody and OS X give up and down events for the arrow keys */
4764   if (ns_fake_keydown == YES)
4765     ns_fake_keydown = NO;
4766   else if ([theEvent type] != NSKeyDown)
4767     return;
4768
4769   if (!emacs_event)
4770     return;
4771
4772  if (![[self window] isKeyWindow]
4773      && [[theEvent window] isKindOfClass: [EmacsWindow class]]
4774      /* we must avoid an infinite loop here. */
4775      && (EmacsView *)[[theEvent window] delegate] != self)
4776    {
4777      /* XXX: There is an occasional condition in which, when Emacs display
4778          updates a different frame from the current one, and temporarily
4779          selects it, then processes some interrupt-driven input
4780          (dispnew.c:3878), OS will send the event to the correct NSWindow, but
4781          for some reason that window has its first responder set to the NSView
4782          most recently updated (I guess), which is not the correct one. */
4783      [(EmacsView *)[[theEvent window] delegate] keyDown: theEvent];
4784      return;
4785    }
4786
4787   if (nsEvArray == nil)
4788     nsEvArray = [[NSMutableArray alloc] initWithCapacity: 1];
4789
4790   [NSCursor setHiddenUntilMouseMoves: YES];
4791
4792   if (hlinfo->mouse_face_hidden && INTEGERP (Vmouse_highlight))
4793     {
4794       clear_mouse_face (hlinfo);
4795       hlinfo->mouse_face_hidden = 1;
4796     }
4797
4798   if (!processingCompose)
4799     {
4800       /* When using screen sharing, no left or right information is sent,
4801          so use Left key in those cases.  */
4802       int is_left_key, is_right_key;
4803
4804       code = ([[theEvent charactersIgnoringModifiers] length] == 0) ?
4805         0 : [[theEvent charactersIgnoringModifiers] characterAtIndex: 0];
4806
4807       /* (Carbon way: [theEvent keyCode]) */
4808
4809       /* is it a "function key"? */
4810       fnKeysym = ns_convert_key (code);
4811       if (fnKeysym)
4812         {
4813           /* COUNTERHACK: map 'Delete' on upper-right main KB to 'Backspace',
4814              because Emacs treats Delete and KP-Delete same (in simple.el). */
4815           if (fnKeysym == 0xFFFF && [theEvent keyCode] == 0x33)
4816             code = 0xFF08; /* backspace */
4817           else
4818             code = fnKeysym;
4819         }
4820
4821       /* are there modifiers? */
4822       emacs_event->modifiers = 0;
4823       flags = [theEvent modifierFlags];
4824
4825       if (flags & NSHelpKeyMask)
4826           emacs_event->modifiers |= hyper_modifier;
4827
4828       if (flags & NSShiftKeyMask)
4829         emacs_event->modifiers |= shift_modifier;
4830
4831       is_right_key = (flags & NSRightCommandKeyMask) == NSRightCommandKeyMask;
4832       is_left_key = (flags & NSLeftCommandKeyMask) == NSLeftCommandKeyMask
4833         || (! is_right_key && (flags & NSCommandKeyMask) == NSCommandKeyMask);
4834
4835       if (is_right_key)
4836         emacs_event->modifiers |= parse_solitary_modifier
4837           (EQ (ns_right_command_modifier, Qleft)
4838            ? ns_command_modifier
4839            : ns_right_command_modifier);
4840
4841       if (is_left_key)
4842         {
4843           emacs_event->modifiers |= parse_solitary_modifier
4844             (ns_command_modifier);
4845
4846           /* if super (default), take input manager's word so things like
4847              dvorak / qwerty layout work */
4848           if (EQ (ns_command_modifier, Qsuper)
4849               && !fnKeysym
4850               && [[theEvent characters] length] != 0)
4851             {
4852               /* XXX: the code we get will be unshifted, so if we have
4853                  a shift modifier, must convert ourselves */
4854               if (!(flags & NSShiftKeyMask))
4855                 code = [[theEvent characters] characterAtIndex: 0];
4856 #if 0
4857               /* this is ugly and also requires linking w/Carbon framework
4858                  (for LMGetKbdType) so for now leave this rare (?) case
4859                  undealt with.. in future look into CGEvent methods */
4860               else
4861                 {
4862                   long smv = GetScriptManagerVariable (smKeyScript);
4863                   Handle uchrHandle = GetResource
4864                     ('uchr', GetScriptVariable (smv, smScriptKeys));
4865                   UInt32 dummy = 0;
4866                   UCKeyTranslate ((UCKeyboardLayout*)*uchrHandle,
4867                                  [[theEvent characters] characterAtIndex: 0],
4868                                  kUCKeyActionDisplay,
4869                                  (flags & ~NSCommandKeyMask) >> 8,
4870                                  LMGetKbdType (), kUCKeyTranslateNoDeadKeysMask,
4871                                  &dummy, 1, &dummy, &code);
4872                   code &= 0xFF;
4873                 }
4874 #endif
4875             }
4876         }
4877
4878       is_right_key = (flags & NSRightControlKeyMask) == NSRightControlKeyMask;
4879       is_left_key = (flags & NSLeftControlKeyMask) == NSLeftControlKeyMask
4880         || (! is_right_key && (flags & NSControlKeyMask) == NSControlKeyMask);
4881
4882       if (is_right_key)
4883           emacs_event->modifiers |= parse_solitary_modifier
4884               (EQ (ns_right_control_modifier, Qleft)
4885                ? ns_control_modifier
4886                : ns_right_control_modifier);
4887
4888       if (is_left_key)
4889         emacs_event->modifiers |= parse_solitary_modifier
4890           (ns_control_modifier);
4891
4892       if (flags & NS_FUNCTION_KEY_MASK && !fnKeysym)
4893           emacs_event->modifiers |=
4894             parse_solitary_modifier (ns_function_modifier);
4895
4896       left_is_none = NILP (ns_alternate_modifier)
4897         || EQ (ns_alternate_modifier, Qnone);
4898
4899       is_right_key = (flags & NSRightAlternateKeyMask)
4900         == NSRightAlternateKeyMask;
4901       is_left_key = (flags & NSLeftAlternateKeyMask) == NSLeftAlternateKeyMask
4902         || (! is_right_key
4903             && (flags & NSAlternateKeyMask) == NSAlternateKeyMask);
4904
4905       if (is_right_key)
4906         {
4907           if ((NILP (ns_right_alternate_modifier)
4908                || EQ (ns_right_alternate_modifier, Qnone)
4909                || (EQ (ns_right_alternate_modifier, Qleft) && left_is_none))
4910               && !fnKeysym)
4911             {   /* accept pre-interp alt comb */
4912               if ([[theEvent characters] length] > 0)
4913                 code = [[theEvent characters] characterAtIndex: 0];
4914               /*HACK: clear lone shift modifier to stop next if from firing */
4915               if (emacs_event->modifiers == shift_modifier)
4916                 emacs_event->modifiers = 0;
4917             }
4918           else
4919             emacs_event->modifiers |= parse_solitary_modifier
4920               (EQ (ns_right_alternate_modifier, Qleft)
4921                ? ns_alternate_modifier
4922                : ns_right_alternate_modifier);
4923         }
4924
4925       if (is_left_key) /* default = meta */
4926         {
4927           if (left_is_none && !fnKeysym)
4928             {   /* accept pre-interp alt comb */
4929               if ([[theEvent characters] length] > 0)
4930                 code = [[theEvent characters] characterAtIndex: 0];
4931               /*HACK: clear lone shift modifier to stop next if from firing */
4932               if (emacs_event->modifiers == shift_modifier)
4933                 emacs_event->modifiers = 0;
4934             }
4935           else
4936               emacs_event->modifiers |=
4937                 parse_solitary_modifier (ns_alternate_modifier);
4938         }
4939
4940   if (NS_KEYLOG)
4941     fprintf (stderr, "keyDown: code =%x\tfnKey =%x\tflags = %x\tmods = %x\n",
4942              code, fnKeysym, flags, emacs_event->modifiers);
4943
4944       /* if it was a function key or had modifiers, pass it directly to emacs */
4945       if (fnKeysym || (emacs_event->modifiers
4946                        && (emacs_event->modifiers != shift_modifier)
4947                        && [[theEvent charactersIgnoringModifiers] length] > 0))
4948 /*[[theEvent characters] length] */
4949         {
4950           emacs_event->kind = NON_ASCII_KEYSTROKE_EVENT;
4951           if (code < 0x20)
4952             code |= (1<<28)|(3<<16);
4953           else if (code == 0x7f)
4954             code |= (1<<28)|(3<<16);
4955           else if (!fnKeysym)
4956             emacs_event->kind = code > 0xFF
4957               ? MULTIBYTE_CHAR_KEYSTROKE_EVENT : ASCII_KEYSTROKE_EVENT;
4958
4959           emacs_event->code = code;
4960           EV_TRAILER (theEvent);
4961           return;
4962         }
4963     }
4964
4965
4966 #if !defined (NS_IMPL_COCOA) || MAC_OS_X_VERSION_MAX_ALLOWED < MAC_OS_X_VERSION_10_6
4967   /* if we get here we should send the key for input manager processing */
4968   if (firstTime && [[NSInputManager currentInputManager]
4969                      wantsToDelayTextChangeNotifications] == NO)
4970     fprintf (stderr,
4971           "Emacs: WARNING: TextInput mgr wants marked text to be permanent!\n");
4972   firstTime = NO;
4973 #endif
4974   if (NS_KEYLOG && !processingCompose)
4975     fprintf (stderr, "keyDown: Begin compose sequence.\n");
4976
4977   processingCompose = YES;
4978   [nsEvArray addObject: theEvent];
4979   [self interpretKeyEvents: nsEvArray];
4980   [nsEvArray removeObject: theEvent];
4981 }
4982
4983
4984 #ifdef NS_IMPL_COCOA
4985 /* Needed to pick up Ctrl-tab and possibly other events that OS X has
4986    decided not to send key-down for.
4987    See http://osdir.com/ml/editors.vim.mac/2007-10/msg00141.html
4988    This only applies on Tiger and earlier.
4989    If it matches one of these, send it on to keyDown. */
4990 -(void)keyUp: (NSEvent *)theEvent
4991 {
4992   int flags = [theEvent modifierFlags];
4993   int code = [theEvent keyCode];
4994   if (floor (NSAppKitVersionNumber) <= 824 /*NSAppKitVersionNumber10_4*/ &&
4995       code == 0x30 && (flags & NSControlKeyMask) && !(flags & NSCommandKeyMask))
4996     {
4997       if (NS_KEYLOG)
4998         fprintf (stderr, "keyUp: passed test");
4999       ns_fake_keydown = YES;
5000       [self keyDown: theEvent];
5001     }
5002 }
5003 #endif
5004
5005
5006 /* <NSTextInput> implementation (called through super interpretKeyEvents:]). */
5007
5008
5009 /* <NSTextInput>: called when done composing;
5010    NOTE: also called when we delete over working text, followed immed.
5011          by doCommandBySelector: deleteBackward: */
5012 - (void)insertText: (id)aString
5013 {
5014   int code;
5015   int len = [(NSString *)aString length];
5016   int i;
5017
5018   if (NS_KEYLOG)
5019     NSLog (@"insertText '%@'\tlen = %d", aString, len);
5020   processingCompose = NO;
5021
5022   if (!emacs_event)
5023     return;
5024
5025   /* first, clear any working text */
5026   if (workingText != nil)
5027     [self deleteWorkingText];
5028
5029   /* now insert the string as keystrokes */
5030   for (i =0; i<len; i++)
5031     {
5032       code = [aString characterAtIndex: i];
5033       /* TODO: still need this? */
5034       if (code == 0x2DC)
5035         code = '~'; /* 0x7E */
5036       if (code != 32) /* Space */
5037         emacs_event->modifiers = 0;
5038       emacs_event->kind
5039         = code > 0xFF ? MULTIBYTE_CHAR_KEYSTROKE_EVENT : ASCII_KEYSTROKE_EVENT;
5040       emacs_event->code = code;
5041       EV_TRAILER ((id)nil);
5042     }
5043 }
5044
5045
5046 /* <NSTextInput>: inserts display of composing characters */
5047 - (void)setMarkedText: (id)aString selectedRange: (NSRange)selRange
5048 {
5049   NSString *str = [aString respondsToSelector: @selector (string)] ?
5050     [aString string] : aString;
5051   if (NS_KEYLOG)
5052     NSLog (@"setMarkedText '%@' len =%d range %d from %d", str, [str length],
5053            selRange.length, selRange.location);
5054
5055   if (workingText != nil)
5056     [self deleteWorkingText];
5057   if ([str length] == 0)
5058     return;
5059
5060   if (!emacs_event)
5061     return;
5062
5063   processingCompose = YES;
5064   workingText = [str copy];
5065   ns_working_text = build_string ([workingText UTF8String]);
5066
5067   emacs_event->kind = NS_TEXT_EVENT;
5068   emacs_event->code = KEY_NS_PUT_WORKING_TEXT;
5069   EV_TRAILER ((id)nil);
5070 }
5071
5072
5073 /* delete display of composing characters [not in <NSTextInput>] */
5074 - (void)deleteWorkingText
5075 {
5076   if (workingText == nil)
5077     return;
5078   if (NS_KEYLOG)
5079     NSLog(@"deleteWorkingText len =%d\n", [workingText length]);
5080   [workingText release];
5081   workingText = nil;
5082   processingCompose = NO;
5083
5084   if (!emacs_event)
5085     return;
5086
5087   emacs_event->kind = NS_TEXT_EVENT;
5088   emacs_event->code = KEY_NS_UNPUT_WORKING_TEXT;
5089   EV_TRAILER ((id)nil);
5090 }
5091
5092
5093 - (BOOL)hasMarkedText
5094 {
5095   return workingText != nil;
5096 }
5097
5098
5099 - (NSRange)markedRange
5100 {
5101   NSRange rng = workingText != nil
5102     ? NSMakeRange (0, [workingText length]) : NSMakeRange (NSNotFound, 0);
5103   if (NS_KEYLOG)
5104     NSLog (@"markedRange request");
5105   return rng;
5106 }
5107
5108
5109 - (void)unmarkText
5110 {
5111   if (NS_KEYLOG)
5112     NSLog (@"unmark (accept) text");
5113   [self deleteWorkingText];
5114   processingCompose = NO;
5115 }
5116
5117
5118 /* used to position char selection windows, etc. */
5119 - (NSRect)firstRectForCharacterRange: (NSRange)theRange
5120 {
5121   NSRect rect;
5122   NSPoint pt;
5123   struct window *win = XWINDOW (FRAME_SELECTED_WINDOW (emacsframe));
5124   if (NS_KEYLOG)
5125     NSLog (@"firstRectForCharRange request");
5126
5127   rect.size.width = theRange.length * FRAME_COLUMN_WIDTH (emacsframe);
5128   rect.size.height = FRAME_LINE_HEIGHT (emacsframe);
5129   pt.x = WINDOW_TEXT_TO_FRAME_PIXEL_X (win, win->phys_cursor.x);
5130   pt.y = WINDOW_TO_FRAME_PIXEL_Y (win, win->phys_cursor.y
5131                                        +FRAME_LINE_HEIGHT (emacsframe));
5132
5133   pt = [self convertPoint: pt toView: nil];
5134   pt = [[self window] convertBaseToScreen: pt];
5135   rect.origin = pt;
5136   return rect;
5137 }
5138
5139
5140 - (NSInteger)conversationIdentifier
5141 {
5142   return (NSInteger)self;
5143 }
5144
5145
5146 - (void)doCommandBySelector: (SEL)aSelector
5147 {
5148   if (NS_KEYLOG)
5149     NSLog (@"doCommandBySelector: %@", NSStringFromSelector (aSelector));
5150
5151   if (aSelector == @selector (deleteBackward:))
5152     {
5153       /* happens when user backspaces over an ongoing composition:
5154          throw a 'delete' into the event queue */
5155       if (!emacs_event)
5156         return;
5157       emacs_event->kind = NON_ASCII_KEYSTROKE_EVENT;
5158       emacs_event->code = 0xFF08;
5159       EV_TRAILER ((id)nil);
5160     }
5161 }
5162
5163 - (NSArray *)validAttributesForMarkedText
5164 {
5165   static NSArray *arr = nil;
5166   if (arr == nil) arr = [NSArray new];
5167  /* [[NSArray arrayWithObject: NSUnderlineStyleAttributeName] retain]; */
5168   return arr;
5169 }
5170
5171 - (NSRange)selectedRange
5172 {
5173   if (NS_KEYLOG)
5174     NSLog (@"selectedRange request");
5175   return NSMakeRange (NSNotFound, 0);
5176 }
5177
5178 - (NSUInteger)characterIndexForPoint: (NSPoint)thePoint
5179 {
5180   if (NS_KEYLOG)
5181     NSLog (@"characterIndexForPoint request");
5182   return 0;
5183 }
5184
5185 - (NSAttributedString *)attributedSubstringFromRange: (NSRange)theRange
5186 {
5187   static NSAttributedString *str = nil;
5188   if (str == nil) str = [NSAttributedString new];
5189   if (NS_KEYLOG)
5190     NSLog (@"attributedSubstringFromRange request");
5191   return str;
5192 }
5193
5194 /* End <NSTextInput> impl. */
5195 /*****************************************************************************/
5196
5197
5198 /* This is what happens when the user presses a mouse button.  */
5199 - (void)mouseDown: (NSEvent *)theEvent
5200 {
5201   NSPoint p = [self convertPoint: [theEvent locationInWindow] fromView: nil];
5202
5203   NSTRACE (mouseDown);
5204
5205   [self deleteWorkingText];
5206
5207   if (!emacs_event)
5208     return;
5209
5210   last_mouse_frame = emacsframe;
5211   /* appears to be needed to prevent spurious movement events generated on
5212      button clicks */
5213   last_mouse_frame->mouse_moved = 0;
5214
5215   if ([theEvent type] == NSScrollWheel)
5216     {
5217       float delta = [theEvent deltaY];
5218       /* Mac notebooks send wheel events w/delta =0 when trackpad scrolling */
5219       if (delta == 0)
5220         return;
5221       emacs_event->kind = WHEEL_EVENT;
5222       emacs_event->code = 0;
5223       emacs_event->modifiers = EV_MODIFIERS (theEvent) |
5224         ((delta > 0) ? up_modifier : down_modifier);
5225     }
5226   else
5227     {
5228       emacs_event->kind = MOUSE_CLICK_EVENT;
5229       emacs_event->code = EV_BUTTON (theEvent);
5230       emacs_event->modifiers = EV_MODIFIERS (theEvent)
5231                              | EV_UDMODIFIERS (theEvent);
5232     }
5233   XSETINT (emacs_event->x, lrint (p.x));
5234   XSETINT (emacs_event->y, lrint (p.y));
5235   EV_TRAILER (theEvent);
5236 }
5237
5238
5239 - (void)rightMouseDown: (NSEvent *)theEvent
5240 {
5241   NSTRACE (rightMouseDown);
5242   [self mouseDown: theEvent];
5243 }
5244
5245
5246 - (void)otherMouseDown: (NSEvent *)theEvent
5247 {
5248   NSTRACE (otherMouseDown);
5249   [self mouseDown: theEvent];
5250 }
5251
5252
5253 - (void)mouseUp: (NSEvent *)theEvent
5254 {
5255   NSTRACE (mouseUp);
5256   [self mouseDown: theEvent];
5257 }
5258
5259
5260 - (void)rightMouseUp: (NSEvent *)theEvent
5261 {
5262   NSTRACE (rightMouseUp);
5263   [self mouseDown: theEvent];
5264 }
5265
5266
5267 - (void)otherMouseUp: (NSEvent *)theEvent
5268 {
5269   NSTRACE (otherMouseUp);
5270   [self mouseDown: theEvent];
5271 }
5272
5273
5274 - (void) scrollWheel: (NSEvent *)theEvent
5275 {
5276   NSTRACE (scrollWheel);
5277   [self mouseDown: theEvent];
5278 }
5279
5280
5281 /* Tell emacs the mouse has moved. */
5282 - (void)mouseMoved: (NSEvent *)e
5283 {
5284   Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (emacsframe);
5285   Lisp_Object frame;
5286
5287 //  NSTRACE (mouseMoved);
5288
5289   last_mouse_movement_time = EV_TIMESTAMP (e);
5290   last_mouse_motion_position
5291     = [self convertPoint: [e locationInWindow] fromView: nil];
5292
5293   /* update any mouse face */
5294   if (hlinfo->mouse_face_hidden)
5295     {
5296       hlinfo->mouse_face_hidden = 0;
5297       clear_mouse_face (hlinfo);
5298     }
5299
5300   /* tooltip handling */
5301   previous_help_echo_string = help_echo_string;
5302   help_echo_string = Qnil;
5303
5304   if (!note_mouse_movement (emacsframe, last_mouse_motion_position.x,
5305                             last_mouse_motion_position.y))
5306     help_echo_string = previous_help_echo_string;
5307
5308   XSETFRAME (frame, emacsframe);
5309   if (!NILP (help_echo_string) || !NILP (previous_help_echo_string))
5310     {
5311       /* NOTE: help_echo_{window,pos,object} are set in xdisp.c
5312          (note_mouse_highlight), which is called through the
5313          note_mouse_movement () call above */
5314       gen_help_event (help_echo_string, frame, help_echo_window,
5315                       help_echo_object, help_echo_pos);
5316     }
5317   else
5318     {
5319       help_echo_string = Qnil;
5320       gen_help_event (Qnil, frame, Qnil, Qnil, 0);
5321     }
5322
5323   if (emacsframe->mouse_moved && send_appdefined)
5324     ns_send_appdefined (-1);
5325 }
5326
5327
5328 - (void)mouseDragged: (NSEvent *)e
5329 {
5330   NSTRACE (mouseDragged);
5331   [self mouseMoved: e];
5332 }
5333
5334
5335 - (void)rightMouseDragged: (NSEvent *)e
5336 {
5337   NSTRACE (rightMouseDragged);
5338   [self mouseMoved: e];
5339 }
5340
5341
5342 - (void)otherMouseDragged: (NSEvent *)e
5343 {
5344   NSTRACE (otherMouseDragged);
5345   [self mouseMoved: e];
5346 }
5347
5348
5349 - (BOOL)windowShouldClose: (id)sender
5350 {
5351   NSEvent *e =[[self window] currentEvent];
5352
5353   NSTRACE (windowShouldClose);
5354   windowClosing = YES;
5355   if (!emacs_event)
5356     return NO;
5357   emacs_event->kind = DELETE_WINDOW_EVENT;
5358   emacs_event->modifiers = 0;
5359   emacs_event->code = 0;
5360   EV_TRAILER (e);
5361   /* Don't close this window, let this be done from lisp code.  */
5362   return NO;
5363 }
5364
5365 - (void) updateFrameSize: (BOOL) delay;
5366 {
5367   NSWindow *window = [self window];
5368   NSRect wr = [window frame];
5369 #ifdef NS_IMPL_GNUSTEP
5370   int extra = 3;
5371 #else
5372   int extra = 0;
5373 #endif
5374
5375   int oldc = cols, oldr = rows;
5376   int oldw = FRAME_PIXEL_WIDTH (emacsframe),
5377     oldh = FRAME_PIXEL_HEIGHT (emacsframe);
5378   int neww, newh;
5379
5380   cols = FRAME_PIXEL_WIDTH_TO_TEXT_COLS (emacsframe, wr.size.width + extra);
5381
5382   if (cols < MINWIDTH)
5383     cols = MINWIDTH;
5384
5385   rows = FRAME_PIXEL_HEIGHT_TO_TEXT_LINES
5386     (emacsframe, wr.size.height
5387      - FRAME_NS_TITLEBAR_HEIGHT (emacsframe) + extra
5388      - FRAME_TOOLBAR_HEIGHT (emacsframe));
5389
5390   if (rows < MINHEIGHT)
5391     rows = MINHEIGHT;
5392
5393   neww = (int)wr.size.width - emacsframe->border_width;
5394   newh = ((int)wr.size.height
5395           - FRAME_NS_TITLEBAR_HEIGHT (emacsframe)
5396           - FRAME_TOOLBAR_HEIGHT (emacsframe));
5397
5398   if (oldr != rows || oldc != cols || neww != oldw || newh != oldh)
5399     {
5400       NSView *view = FRAME_NS_VIEW (emacsframe);
5401       FRAME_PIXEL_WIDTH (emacsframe) = neww;
5402       FRAME_PIXEL_HEIGHT (emacsframe) = newh;
5403       change_frame_size (emacsframe, rows, cols, 0, delay, 0);
5404       SET_FRAME_GARBAGED (emacsframe);
5405       cancel_mouse_face (emacsframe);
5406       [view setFrame: NSMakeRect (0, 0, neww, newh)];
5407     }
5408 }
5409
5410 - (NSSize)windowWillResize: (NSWindow *)sender toSize: (NSSize)frameSize
5411 /* normalize frame to gridded text size */
5412 {
5413   NSTRACE (windowWillResize);
5414 /*fprintf (stderr,"Window will resize: %.0f x %.0f\n",frameSize.width,frameSize.height); */
5415
5416   cols = FRAME_PIXEL_WIDTH_TO_TEXT_COLS (emacsframe,
5417 #ifdef NS_IMPL_GNUSTEP
5418                                         frameSize.width + 3);
5419 #else
5420                                         frameSize.width);
5421 #endif
5422   if (cols < MINWIDTH)
5423     cols = MINWIDTH;
5424
5425   rows = FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (emacsframe, frameSize.height
5426 #ifdef NS_IMPL_GNUSTEP
5427       - FRAME_NS_TITLEBAR_HEIGHT (emacsframe) + 3
5428         - FRAME_TOOLBAR_HEIGHT (emacsframe));
5429 #else
5430       - FRAME_NS_TITLEBAR_HEIGHT (emacsframe)
5431         - FRAME_TOOLBAR_HEIGHT (emacsframe));
5432 #endif
5433   if (rows < MINHEIGHT)
5434     rows = MINHEIGHT;
5435 #ifdef NS_IMPL_COCOA
5436   {
5437     /* this sets window title to have size in it; the wm does this under GS */
5438     NSRect r = [[self window] frame];
5439     if (r.size.height == frameSize.height && r.size.width == frameSize.width)
5440       {
5441         if (old_title != 0)
5442           {
5443             xfree (old_title);
5444             old_title = 0;
5445           }
5446       }
5447     else
5448       {
5449         char *size_title;
5450         NSWindow *window = [self window];
5451         if (old_title == 0)
5452           {
5453             const char *t = [[[self window] title] UTF8String];
5454             char *pos = strstr (t, "  —  ");
5455             if (pos)
5456               *pos = '\0';
5457             old_title = xstrdup (t);
5458           }
5459         size_title = xmalloc (strlen (old_title) + 40);
5460         esprintf (size_title, "%s  —  (%d x %d)", old_title, cols, rows);
5461         [window setTitle: [NSString stringWithUTF8String: size_title]];
5462         [window display];
5463         xfree (size_title);
5464       }
5465   }
5466 #endif /* NS_IMPL_COCOA */
5467 /*fprintf (stderr,"    ...size became %.0f x %.0f  (%d x %d)\n",frameSize.width,frameSize.height,cols,rows); */
5468
5469   return frameSize;
5470 }
5471
5472
5473 - (void)windowDidResize: (NSNotification *)notification
5474 {
5475 #ifdef NS_IMPL_GNUSTEP
5476   NSWindow *theWindow = [notification object];
5477
5478    /* in GNUstep, at least currently, it's possible to get a didResize
5479       without getting a willResize.. therefore we need to act as if we got
5480       the willResize now */
5481   NSSize sz = [theWindow frame].size;
5482   sz = [self windowWillResize: theWindow toSize: sz];
5483 #endif /* NS_IMPL_GNUSTEP */
5484
5485   NSTRACE (windowDidResize);
5486 /*fprintf (stderr,"windowDidResize: %.0f\n",[theWindow frame].size.height); */
5487
5488 #ifdef NS_IMPL_COCOA
5489   if (old_title != 0)
5490     {
5491       xfree (old_title);
5492       old_title = 0;
5493     }
5494 #endif /* NS_IMPL_COCOA */
5495
5496   /* Avoid loop under GNUstep due to call at beginning of this function.
5497      (x_set_window_size causes a resize which causes
5498      a "windowDidResize" which calls x_set_window_size).  */
5499 #ifndef NS_IMPL_GNUSTEP
5500   if (cols > 0 && rows > 0)
5501     {
5502       if (ns_in_resize)
5503         x_set_window_size (emacsframe, 0, cols, rows);
5504       else
5505         {
5506           [self updateFrameSize: YES];
5507         }
5508     }
5509 #endif
5510
5511   ns_send_appdefined (-1);
5512 }
5513
5514
5515 - (void)windowDidBecomeKey: (NSNotification *)notification
5516 /* cf. x_detect_focus_change(), x_focus_changed(), x_new_focus_frame() */
5517 {
5518   struct ns_display_info *dpyinfo = FRAME_NS_DISPLAY_INFO (emacsframe);
5519   struct frame *old_focus = dpyinfo->x_focus_frame;
5520
5521   NSTRACE (windowDidBecomeKey);
5522
5523   if (emacsframe != old_focus)
5524     dpyinfo->x_focus_frame = emacsframe;
5525
5526   ns_frame_rehighlight (emacsframe);
5527
5528   if (emacs_event)
5529     {
5530       emacs_event->kind = FOCUS_IN_EVENT;
5531       EV_TRAILER ((id)nil);
5532     }
5533 }
5534
5535
5536 - (void)windowDidResignKey: (NSNotification *)notification
5537 /* cf. x_detect_focus_change(), x_focus_changed(), x_new_focus_frame() */
5538 {
5539   struct ns_display_info *dpyinfo = FRAME_NS_DISPLAY_INFO (emacsframe);
5540   NSTRACE (windowDidResignKey);
5541
5542   if (dpyinfo->x_focus_frame == emacsframe)
5543     dpyinfo->x_focus_frame = 0;
5544
5545   ns_frame_rehighlight (emacsframe);
5546
5547   /* FIXME: for some reason needed on second and subsequent clicks away
5548             from sole-frame Emacs to get hollow box to show */
5549   if (!windowClosing && [[self window] isVisible] == YES)
5550     {
5551       x_update_cursor (emacsframe, 1);
5552       x_set_frame_alpha (emacsframe);
5553     }
5554
5555   if (emacs_event)
5556     {
5557       [self deleteWorkingText];
5558       emacs_event->kind = FOCUS_IN_EVENT;
5559       EV_TRAILER ((id)nil);
5560     }
5561 }
5562
5563
5564 - (void)windowWillMiniaturize: sender
5565 {
5566   NSTRACE (windowWillMiniaturize);
5567 }
5568
5569
5570 - (BOOL)isFlipped
5571 {
5572   return YES;
5573 }
5574
5575
5576 - (BOOL)isOpaque
5577 {
5578   return NO;
5579 }
5580
5581
5582 - initFrameFromEmacs: (struct frame *)f
5583 {
5584   NSRect r, wr;
5585   Lisp_Object tem;
5586   NSWindow *win;
5587   NSButton *toggleButton;
5588   NSSize sz;
5589   NSColor *col;
5590   NSString *name;
5591
5592   NSTRACE (initFrameFromEmacs);
5593
5594   windowClosing = NO;
5595   processingCompose = NO;
5596   scrollbarsNeedingUpdate = 0;
5597
5598 /*fprintf (stderr,"init with %d, %d\n",f->text_cols, f->text_lines); */
5599
5600   ns_userRect = NSMakeRect (0, 0, 0, 0);
5601   r = NSMakeRect (0, 0, FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f, f->text_cols),
5602                  FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f, f->text_lines));
5603   [self initWithFrame: r];
5604   [self setAutoresizingMask: NSViewWidthSizable | NSViewHeightSizable];
5605
5606   FRAME_NS_VIEW (f) = self;
5607   emacsframe = f;
5608   old_title = 0;
5609
5610   win = [[EmacsWindow alloc]
5611             initWithContentRect: r
5612                       styleMask: (NSResizableWindowMask |
5613 #if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_7
5614                                   NSTitledWindowMask |
5615 #endif
5616                                   NSMiniaturizableWindowMask |
5617                                   NSClosableWindowMask)
5618                         backing: NSBackingStoreBuffered
5619                           defer: YES];
5620
5621   wr = [win frame];
5622   f->border_width = wr.size.width - r.size.width;
5623   FRAME_NS_TITLEBAR_HEIGHT (f) = wr.size.height - r.size.height;
5624
5625   [win setAcceptsMouseMovedEvents: YES];
5626   [win setDelegate: self];
5627   [win useOptimizedDrawing: YES];
5628
5629   sz.width = FRAME_COLUMN_WIDTH (f);
5630   sz.height = FRAME_LINE_HEIGHT (f);
5631   [win setResizeIncrements: sz];
5632
5633   [[win contentView] addSubview: self];
5634
5635   if (ns_drag_types)
5636     [self registerForDraggedTypes: ns_drag_types];
5637
5638   tem = f->name;
5639   name = [NSString stringWithUTF8String:
5640                    NILP (tem) ? "Emacs" : SSDATA (tem)];
5641   [win setTitle: name];
5642
5643   /* toolbar support */
5644   toolbar = [[EmacsToolbar alloc] initForView: self withIdentifier:
5645                          [NSString stringWithFormat: @"Emacs Frame %d",
5646                                    ns_window_num]];
5647   [win setToolbar: toolbar];
5648   [toolbar setVisible: NO];
5649 #ifdef NS_IMPL_COCOA
5650   toggleButton = [win standardWindowButton: NSWindowToolbarButton];
5651   [toggleButton setTarget: self];
5652   [toggleButton setAction: @selector (toggleToolbar: )];
5653 #endif
5654   FRAME_TOOLBAR_HEIGHT (f) = 0;
5655
5656   tem = f->icon_name;
5657   if (!NILP (tem))
5658     [win setMiniwindowTitle:
5659            [NSString stringWithUTF8String: SSDATA (tem)]];
5660
5661   {
5662     NSScreen *screen = [win screen];
5663
5664     if (screen != 0)
5665       [win setFrameTopLeftPoint: NSMakePoint
5666            (IN_BOUND (-SCREENMAX, f->left_pos, SCREENMAX),
5667             IN_BOUND (-SCREENMAX,
5668                      [screen frame].size.height - NS_TOP_POS (f), SCREENMAX))];
5669   }
5670
5671   [win makeFirstResponder: self];
5672
5673   col = ns_lookup_indexed_color (NS_FACE_BACKGROUND
5674                                   (FRAME_DEFAULT_FACE (emacsframe)), emacsframe);
5675   [win setBackgroundColor: col];
5676   if ([col alphaComponent] != 1.0)
5677     [win setOpaque: NO];
5678
5679   [self allocateGState];
5680
5681   [NSApp registerServicesMenuSendTypes: ns_send_types
5682                            returnTypes: nil];
5683
5684   ns_window_num++;
5685   return self;
5686 }
5687
5688
5689 - (void)windowDidMove: sender
5690 {
5691   NSWindow *win = [self window];
5692   NSRect r = [win frame];
5693   NSArray *screens = [NSScreen screens];
5694   NSScreen *screen = [screens objectAtIndex: 0];
5695
5696   NSTRACE (windowDidMove);
5697
5698   if (!emacsframe->output_data.ns)
5699     return;
5700   if (screen != nil)
5701     {
5702       emacsframe->left_pos = r.origin.x;
5703       emacsframe->top_pos =
5704         [screen frame].size.height - (r.origin.y + r.size.height);
5705     }
5706 }
5707
5708
5709 /* Called AFTER method below, but before our windowWillResize call there leads
5710    to windowDidResize -> x_set_window_size.  Update emacs' notion of frame
5711    location so set_window_size moves the frame. */
5712 - (BOOL)windowShouldZoom: (NSWindow *)sender toFrame: (NSRect)newFrame
5713 {
5714   emacsframe->output_data.ns->zooming = 1;
5715   return YES;
5716 }
5717
5718
5719 /* Override to do something slightly nonstandard, but nice.  First click on
5720    zoom button will zoom vertically.  Second will zoom completely.  Third
5721    returns to original. */
5722 - (NSRect)windowWillUseStandardFrame:(NSWindow *)sender
5723                         defaultFrame:(NSRect)defaultFrame
5724 {
5725   NSRect result = [sender frame];
5726
5727   NSTRACE (windowWillUseStandardFrame);
5728
5729   if (abs (defaultFrame.size.height - result.size.height)
5730       > FRAME_LINE_HEIGHT (emacsframe))
5731     {
5732       /* first click */
5733       ns_userRect = result;
5734       result.size.height = defaultFrame.size.height;
5735       result.origin.y = defaultFrame.origin.y;
5736     }
5737   else
5738     {
5739       if (abs (defaultFrame.size.width - result.size.width)
5740           > FRAME_COLUMN_WIDTH (emacsframe))
5741         result = defaultFrame;  /* second click */
5742       else
5743         {
5744           /* restore */
5745           result = ns_userRect.size.height ? ns_userRect : result;
5746           ns_userRect = NSMakeRect (0, 0, 0, 0);
5747         }
5748     }
5749
5750   [self windowWillResize: sender toSize: result.size];
5751   return result;
5752 }
5753
5754
5755 - (void)windowDidDeminiaturize: sender
5756 {
5757   NSTRACE (windowDidDeminiaturize);
5758   if (!emacsframe->output_data.ns)
5759     return;
5760   emacsframe->async_iconified = 0;
5761   emacsframe->async_visible   = 1;
5762   windows_or_buffers_changed++;
5763
5764   if (emacs_event)
5765     {
5766       emacs_event->kind = ICONIFY_EVENT;
5767       EV_TRAILER ((id)nil);
5768     }
5769 }
5770
5771
5772 - (void)windowDidExpose: sender
5773 {
5774   NSTRACE (windowDidExpose);
5775   if (!emacsframe->output_data.ns)
5776     return;
5777   emacsframe->async_visible = 1;
5778   SET_FRAME_GARBAGED (emacsframe);
5779
5780   if (send_appdefined)
5781     ns_send_appdefined (-1);
5782 }
5783
5784
5785 - (void)windowDidMiniaturize: sender
5786 {
5787   NSTRACE (windowDidMiniaturize);
5788   if (!emacsframe->output_data.ns)
5789     return;
5790
5791   emacsframe->async_iconified = 1;
5792   emacsframe->async_visible = 0;
5793
5794   if (emacs_event)
5795     {
5796       emacs_event->kind = ICONIFY_EVENT;
5797       EV_TRAILER ((id)nil);
5798     }
5799 }
5800
5801
5802 - (void)mouseEntered: (NSEvent *)theEvent
5803 {
5804   NSTRACE (mouseEntered);
5805   last_mouse_movement_time = EV_TIMESTAMP (theEvent);
5806 }
5807
5808
5809 - (void)mouseExited: (NSEvent *)theEvent
5810 {
5811   Mouse_HLInfo *hlinfo = emacsframe ? MOUSE_HL_INFO (emacsframe) : NULL;
5812
5813   NSTRACE (mouseExited);
5814
5815   if (!hlinfo)
5816     return;
5817
5818   last_mouse_movement_time = EV_TIMESTAMP (theEvent);
5819
5820   if (emacsframe == hlinfo->mouse_face_mouse_frame)
5821     {
5822       clear_mouse_face (hlinfo);
5823       hlinfo->mouse_face_mouse_frame = 0;
5824     }
5825 }
5826
5827
5828 - menuDown: sender
5829 {
5830   NSTRACE (menuDown);
5831   if (context_menu_value == -1)
5832     context_menu_value = [sender tag];
5833   else
5834     {
5835       NSInteger tag = [sender tag];
5836       find_and_call_menu_selection (emacsframe, emacsframe->menu_bar_items_used,
5837                                     emacsframe->menu_bar_vector,
5838                                     (void *)tag);
5839     }
5840
5841   ns_send_appdefined (-1);
5842   return self;
5843 }
5844
5845
5846 - (EmacsToolbar *)toolbar
5847 {
5848   return toolbar;
5849 }
5850
5851
5852 /* this gets called on toolbar button click */
5853 - toolbarClicked: (id)item
5854 {
5855   NSEvent *theEvent;
5856   int idx = [item tag] * TOOL_BAR_ITEM_NSLOTS;
5857
5858   NSTRACE (toolbarClicked);
5859
5860   if (!emacs_event)
5861     return self;
5862
5863   /* send first event (for some reason two needed) */
5864   theEvent = [[self window] currentEvent];
5865   emacs_event->kind = TOOL_BAR_EVENT;
5866   XSETFRAME (emacs_event->arg, emacsframe);
5867   EV_TRAILER (theEvent);
5868
5869   emacs_event->kind = TOOL_BAR_EVENT;
5870 /*   XSETINT (emacs_event->code, 0); */
5871   emacs_event->arg = AREF (emacsframe->tool_bar_items,
5872                            idx + TOOL_BAR_ITEM_KEY);
5873   emacs_event->modifiers = EV_MODIFIERS (theEvent);
5874   EV_TRAILER (theEvent);
5875   return self;
5876 }
5877
5878
5879 - toggleToolbar: (id)sender
5880 {
5881   if (!emacs_event)
5882     return self;
5883
5884   emacs_event->kind = NS_NONKEY_EVENT;
5885   emacs_event->code = KEY_NS_TOGGLE_TOOLBAR;
5886   EV_TRAILER ((id)nil);
5887   return self;
5888 }
5889
5890
5891 - (void)drawRect: (NSRect)rect
5892 {
5893   int x = NSMinX (rect), y = NSMinY (rect);
5894   int width = NSWidth (rect), height = NSHeight (rect);
5895
5896   NSTRACE (drawRect);
5897
5898   if (!emacsframe || !emacsframe->output_data.ns || ns_in_resize)
5899     return;
5900
5901   ns_clear_frame_area (emacsframe, x, y, width, height);
5902   expose_frame (emacsframe, x, y, width, height);
5903
5904   /*
5905     drawRect: may be called (at least in OS X 10.5) for invisible
5906     views as well for some reason.  Thus, do not infer visibility
5907     here.
5908
5909     emacsframe->async_visible = 1;
5910     emacsframe->async_iconified = 0;
5911   */
5912 }
5913
5914
5915 /* NSDraggingDestination protocol methods.  Actually this is not really a
5916    protocol, but a category of Object.  O well...  */
5917
5918 -(NSUInteger) draggingEntered: (id <NSDraggingInfo>) sender
5919 {
5920   NSTRACE (draggingEntered);
5921   return NSDragOperationGeneric;
5922 }
5923
5924
5925 -(BOOL)prepareForDragOperation: (id <NSDraggingInfo>) sender
5926 {
5927   return YES;
5928 }
5929
5930
5931 -(BOOL)performDragOperation: (id <NSDraggingInfo>) sender
5932 {
5933   id pb;
5934   int x, y;
5935   NSString *type;
5936   NSEvent *theEvent = [[self window] currentEvent];
5937   NSPoint position;
5938
5939   NSTRACE (performDragOperation);
5940
5941   if (!emacs_event)
5942     return NO;
5943
5944   position = [self convertPoint: [sender draggingLocation] fromView: nil];
5945   x = lrint (position.x);  y = lrint (position.y);
5946
5947   pb = [sender draggingPasteboard];
5948   type = [pb availableTypeFromArray: ns_drag_types];
5949   if (type == 0)
5950     {
5951       return NO;
5952     }
5953   else if ([type isEqualToString: NSFilenamesPboardType])
5954     {
5955       NSArray *files;
5956       NSEnumerator *fenum;
5957       NSString *file;
5958
5959       if (!(files = [pb propertyListForType: type]))
5960         return NO;
5961
5962       fenum = [files objectEnumerator];
5963       while ( (file = [fenum nextObject]) )
5964         {
5965           emacs_event->kind = NS_NONKEY_EVENT;
5966           emacs_event->code = KEY_NS_DRAG_FILE;
5967           XSETINT (emacs_event->x, x);
5968           XSETINT (emacs_event->y, y);
5969           ns_input_file = append2 (ns_input_file,
5970                                    build_string ([file UTF8String]));
5971           emacs_event->modifiers = EV_MODIFIERS (theEvent);
5972           EV_TRAILER (theEvent);
5973         }
5974       return YES;
5975     }
5976   else if ([type isEqualToString: NSURLPboardType])
5977     {
5978       NSString *file;
5979       NSURL *fileURL;
5980
5981       if (!(fileURL = [NSURL URLFromPasteboard: pb]) ||
5982           [fileURL isFileURL] == NO)
5983         return NO;
5984
5985       file = [fileURL path];
5986       emacs_event->kind = NS_NONKEY_EVENT;
5987       emacs_event->code = KEY_NS_DRAG_FILE;
5988       XSETINT (emacs_event->x, x);
5989       XSETINT (emacs_event->y, y);
5990       ns_input_file = append2 (ns_input_file, build_string ([file UTF8String]));
5991       emacs_event->modifiers = EV_MODIFIERS (theEvent);
5992       EV_TRAILER (theEvent);
5993       return YES;
5994     }
5995   else if ([type isEqualToString: NSStringPboardType]
5996            || [type isEqualToString: NSTabularTextPboardType])
5997     {
5998       NSString *data;
5999
6000       if (! (data = [pb stringForType: type]))
6001         return NO;
6002
6003       emacs_event->kind = NS_NONKEY_EVENT;
6004       emacs_event->code = KEY_NS_DRAG_TEXT;
6005       XSETINT (emacs_event->x, x);
6006       XSETINT (emacs_event->y, y);
6007       ns_input_text = build_string ([data UTF8String]);
6008       emacs_event->modifiers = EV_MODIFIERS (theEvent);
6009       EV_TRAILER (theEvent);
6010       return YES;
6011     }
6012   else if ([type isEqualToString: NSColorPboardType])
6013     {
6014       NSColor *c = [NSColor colorFromPasteboard: pb];
6015       emacs_event->kind = NS_NONKEY_EVENT;
6016       emacs_event->code = KEY_NS_DRAG_COLOR;
6017       XSETINT (emacs_event->x, x);
6018       XSETINT (emacs_event->y, y);
6019       ns_input_color = ns_color_to_lisp (c);
6020       emacs_event->modifiers = EV_MODIFIERS (theEvent);
6021       EV_TRAILER (theEvent);
6022       return YES;
6023     }
6024   else if ([type isEqualToString: NSFontPboardType])
6025     {
6026       /* impl based on GNUstep NSTextView.m */
6027       NSData *data = [pb dataForType: NSFontPboardType];
6028       NSDictionary *dict = [NSUnarchiver unarchiveObjectWithData: data];
6029       NSFont *font = [dict objectForKey: NSFontAttributeName];
6030       char fontSize[10];
6031
6032       if (font == nil)
6033         return NO;
6034
6035       emacs_event->kind = NS_NONKEY_EVENT;
6036       emacs_event->code = KEY_NS_CHANGE_FONT;
6037       XSETINT (emacs_event->x, x);
6038       XSETINT (emacs_event->y, y);
6039       ns_input_font = build_string ([[font fontName] UTF8String]);
6040       snprintf (fontSize, 10, "%f", [font pointSize]);
6041       ns_input_fontsize = build_string (fontSize);
6042       emacs_event->modifiers = EV_MODIFIERS (theEvent);
6043       EV_TRAILER (theEvent);
6044       return YES;
6045     }
6046   else
6047     {
6048       error ("Invalid data type in dragging pasteboard.");
6049       return NO;
6050     }
6051 }
6052
6053
6054 - (id) validRequestorForSendType: (NSString *)typeSent
6055                       returnType: (NSString *)typeReturned
6056 {
6057   NSTRACE (validRequestorForSendType);
6058   if (typeSent != nil && [ns_send_types indexOfObject: typeSent] != NSNotFound
6059       && typeReturned == nil)
6060     {
6061       if (! NILP (ns_get_local_selection (QPRIMARY, QUTF8_STRING)))
6062         return self;
6063     }
6064
6065   return [super validRequestorForSendType: typeSent
6066                                returnType: typeReturned];
6067 }
6068
6069
6070 /* The next two methods are part of NSServicesRequests informal protocol,
6071    supposedly called when a services menu item is chosen from this app.
6072    But this should not happen because we override the services menu with our
6073    own entries which call ns-perform-service.
6074    Nonetheless, it appeared to happen (under strange circumstances): bug#1435.
6075    So let's at least stub them out until further investigation can be done. */
6076
6077 - (BOOL) readSelectionFromPasteboard: (NSPasteboard *)pb
6078 {
6079   /* we could call ns_string_from_pasteboard(pboard) here but then it should
6080      be written into the buffer in place of the existing selection..
6081      ordinary service calls go through functions defined in ns-win.el */
6082   return NO;
6083 }
6084
6085 - (BOOL) writeSelectionToPasteboard: (NSPasteboard *)pb types: (NSArray *)types
6086 {
6087   NSArray *typesDeclared;
6088   Lisp_Object val;
6089
6090   /* We only support NSStringPboardType */
6091   if ([types containsObject:NSStringPboardType] == NO) {
6092     return NO;
6093   }
6094
6095   val = ns_get_local_selection (QPRIMARY, QUTF8_STRING);
6096   if (CONSP (val) && SYMBOLP (XCAR (val)))
6097     {
6098       val = XCDR (val);
6099       if (CONSP (val) && NILP (XCDR (val)))
6100         val = XCAR (val);
6101     }
6102   if (! STRINGP (val))
6103     return NO;
6104
6105   typesDeclared = [NSArray arrayWithObject:NSStringPboardType];
6106   [pb declareTypes:typesDeclared owner:nil];
6107   ns_string_to_pasteboard (pb, val);
6108   return YES;
6109 }
6110
6111
6112 /* setMini =YES means set from internal (gives a finder icon), NO means set nil
6113    (gives a miniaturized version of the window); currently we use the latter for
6114    frames whose active buffer doesn't correspond to any file
6115    (e.g., '*scratch*') */
6116 - setMiniwindowImage: (BOOL) setMini
6117 {
6118   id image = [[self window] miniwindowImage];
6119   NSTRACE (setMiniwindowImage);
6120
6121   /* NOTE: under Cocoa miniwindowImage always returns nil, documentation
6122      about "AppleDockIconEnabled" notwithstanding, however the set message
6123      below has its effect nonetheless. */
6124   if (image != emacsframe->output_data.ns->miniimage)
6125     {
6126       if (image && [image isKindOfClass: [EmacsImage class]])
6127         [image release];
6128       [[self window] setMiniwindowImage:
6129                        setMini ? emacsframe->output_data.ns->miniimage : nil];
6130     }
6131
6132   return self;
6133 }
6134
6135
6136 - (void) setRows: (int) r andColumns: (int) c
6137 {
6138   rows = r;
6139   cols = c;
6140 }
6141
6142 @end  /* EmacsView */
6143
6144
6145
6146 /* ==========================================================================
6147
6148     EmacsWindow implementation
6149
6150    ========================================================================== */
6151
6152 @implementation EmacsWindow
6153
6154 #ifdef NS_IMPL_COCOA
6155 - (id)accessibilityAttributeValue:(NSString *)attribute
6156 {
6157   Lisp_Object str = Qnil;
6158   struct frame *f = SELECTED_FRAME ();
6159   struct buffer *curbuf = XBUFFER (XWINDOW (f->selected_window)->buffer);
6160
6161   if ([attribute isEqualToString:NSAccessibilityRoleAttribute])
6162     return NSAccessibilityTextFieldRole;
6163
6164   if ([attribute isEqualToString:NSAccessibilitySelectedTextAttribute]
6165       && curbuf && ! NILP (BVAR (curbuf, mark_active)))
6166     {
6167       str = ns_get_local_selection (QPRIMARY, QUTF8_STRING);
6168     }
6169   else if (curbuf && [attribute isEqualToString:NSAccessibilityValueAttribute])
6170     {
6171       if (! NILP (BVAR (curbuf, mark_active)))
6172           str = ns_get_local_selection (QPRIMARY, QUTF8_STRING);
6173
6174       if (NILP (str))
6175         {
6176           ptrdiff_t start_byte = BUF_BEGV_BYTE (curbuf);
6177           ptrdiff_t byte_range = BUF_ZV_BYTE (curbuf) - start_byte;
6178           ptrdiff_t range = BUF_ZV (curbuf) - BUF_BEGV (curbuf);
6179
6180           if (! NILP (BVAR (curbuf, enable_multibyte_characters)))
6181             str = make_uninit_multibyte_string (range, byte_range);
6182           else
6183             str = make_uninit_string (range);
6184           /* To check: This returns emacs-utf-8, which is a superset of utf-8.
6185              Is this a problem?  */
6186           memcpy (SDATA (str), BYTE_POS_ADDR (start_byte), byte_range);
6187         }
6188     }
6189
6190
6191   if (! NILP (str))
6192     {
6193       if (CONSP (str) && SYMBOLP (XCAR (str)))
6194         {
6195           str = XCDR (str);
6196           if (CONSP (str) && NILP (XCDR (str)))
6197             str = XCAR (str);
6198         }
6199       if (STRINGP (str))
6200         {
6201           const char *utfStr = SSDATA (str);
6202           NSString *nsStr = [NSString stringWithUTF8String: utfStr];
6203           return nsStr;
6204         }
6205     }
6206
6207   return [super accessibilityAttributeValue:attribute];
6208 }
6209 #endif /* NS_IMPL_COCOA */
6210
6211 /* If we have multiple monitors, one above the other, we don't want to
6212    restrict the height to just one monitor.  So we override this.  */
6213 - (NSRect)constrainFrameRect:(NSRect)frameRect toScreen:(NSScreen *)screen
6214 {
6215   /* When making the frame visible for the first time or if there is just
6216      one screen, we want to constrain.  Other times not.  */
6217   NSUInteger nr_screens = [[NSScreen screens] count];
6218   struct frame *f = ((EmacsView *)[self delegate])->emacsframe;
6219   NSTRACE (constrainFrameRect);
6220
6221   if (nr_screens == 1)
6222     {
6223       NSRect r = [super constrainFrameRect:frameRect toScreen:screen];
6224       return r;
6225     }
6226
6227   if (f->output_data.ns->dont_constrain
6228       || ns_menu_bar_should_be_hidden ())
6229     return frameRect;
6230
6231   f->output_data.ns->dont_constrain = 1;
6232   return [super constrainFrameRect:frameRect toScreen:screen];
6233 }
6234
6235
6236 /* called only on resize clicks by special case in EmacsApp-sendEvent */
6237 - (void)mouseDown: (NSEvent *)theEvent
6238 {
6239   if (ns_in_resize)
6240     {
6241       NSSize size = [[theEvent window] frame].size;
6242       grabOffset = [theEvent locationInWindow];
6243       grabOffset.x = size.width - grabOffset.x;
6244     }
6245   else
6246     [super mouseDown: theEvent];
6247 }
6248
6249
6250 /* stop resizing */
6251 - (void)mouseUp: (NSEvent *)theEvent
6252 {
6253   if (ns_in_resize)
6254     {
6255       struct frame *f = ((EmacsView *)[self delegate])->emacsframe;
6256       ns_in_resize = NO;
6257       ns_set_name_as_filename (f);
6258       [self display];
6259       ns_send_appdefined (-1);
6260     }
6261   else
6262     [super mouseUp: theEvent];
6263 }
6264
6265
6266 /* send resize events */
6267 - (void)mouseDragged: (NSEvent *)theEvent
6268 {
6269   if (ns_in_resize)
6270     {
6271       NSPoint p = [theEvent locationInWindow];
6272       NSSize size, vettedSize, origSize = [self frame].size;
6273
6274       size.width = p.x + grabOffset.x;
6275       size.height = origSize.height - p.y + grabOffset.y;
6276
6277       if (size.width == origSize.width && size.height == origSize.height)
6278         return;
6279
6280       vettedSize = [[self delegate] windowWillResize: self toSize: size];
6281       [[NSNotificationCenter defaultCenter]
6282             postNotificationName: NSWindowDidResizeNotification
6283                           object: self];
6284     }
6285   else
6286     [super mouseDragged: theEvent];
6287 }
6288
6289 @end /* EmacsWindow */
6290
6291
6292 /* ==========================================================================
6293
6294     EmacsScroller implementation
6295
6296    ========================================================================== */
6297
6298
6299 @implementation EmacsScroller
6300
6301 /* for repeat button push */
6302 #define SCROLL_BAR_FIRST_DELAY 0.5
6303 #define SCROLL_BAR_CONTINUOUS_DELAY (1.0 / 15)
6304
6305 + (CGFloat) scrollerWidth
6306 {
6307   /* TODO: if we want to allow variable widths, this is the place to do it,
6308            however neither GNUstep nor Cocoa support it very well */
6309   return [NSScroller scrollerWidth];
6310 }
6311
6312
6313 - initFrame: (NSRect )r window: (Lisp_Object)nwin
6314 {
6315   NSTRACE (EmacsScroller_initFrame);
6316
6317   r.size.width = [EmacsScroller scrollerWidth];
6318   [super initWithFrame: r/*NSMakeRect (0, 0, 0, 0)*/];
6319   [self setContinuous: YES];
6320   [self setEnabled: YES];
6321
6322   /* Ensure auto resizing of scrollbars occurs within the emacs frame's view
6323      locked against the top and bottom edges, and right edge on OS X, where
6324      scrollers are on right. */
6325 #ifdef NS_IMPL_GNUSTEP
6326   [self setAutoresizingMask: NSViewMaxXMargin | NSViewHeightSizable];
6327 #else
6328   [self setAutoresizingMask: NSViewMinXMargin | NSViewHeightSizable];
6329 #endif
6330
6331   win = nwin;
6332   condemned = NO;
6333   pixel_height = NSHeight (r);
6334   if (pixel_height == 0) pixel_height = 1;
6335   min_portion = 20 / pixel_height;
6336
6337   frame = XFRAME (XWINDOW (win)->frame);
6338   if (FRAME_LIVE_P (frame))
6339     {
6340       int i;
6341       EmacsView *view = FRAME_NS_VIEW (frame);
6342       NSView *sview = [[view window] contentView];
6343       NSArray *subs = [sview subviews];
6344
6345       /* disable optimization stopping redraw of other scrollbars */
6346       view->scrollbarsNeedingUpdate = 0;
6347       for (i =[subs count]-1; i >= 0; i--)
6348         if ([[subs objectAtIndex: i] isKindOfClass: [EmacsScroller class]])
6349           view->scrollbarsNeedingUpdate++;
6350       [sview addSubview: self];
6351     }
6352
6353 /*  [self setFrame: r]; */
6354
6355   return self;
6356 }
6357
6358
6359 - (void)setFrame: (NSRect)newRect
6360 {
6361   NSTRACE (EmacsScroller_setFrame);
6362 /*  BLOCK_INPUT; */
6363   pixel_height = NSHeight (newRect);
6364   if (pixel_height == 0) pixel_height = 1;
6365   min_portion = 20 / pixel_height;
6366   [super setFrame: newRect];
6367   [self display];
6368 /*  UNBLOCK_INPUT; */
6369 }
6370
6371
6372 - (void)dealloc
6373 {
6374   NSTRACE (EmacsScroller_dealloc);
6375   if (!NILP (win))
6376     wset_vertical_scroll_bar (XWINDOW (win), Qnil);
6377   [super dealloc];
6378 }
6379
6380
6381 - condemn
6382 {
6383   NSTRACE (condemn);
6384   condemned =YES;
6385   return self;
6386 }
6387
6388
6389 - reprieve
6390 {
6391   NSTRACE (reprieve);
6392   condemned =NO;
6393   return self;
6394 }
6395
6396
6397 - judge
6398 {
6399   NSTRACE (judge);
6400   if (condemned)
6401     {
6402       EmacsView *view;
6403       BLOCK_INPUT;
6404       /* ensure other scrollbar updates after deletion */
6405       view = (EmacsView *)FRAME_NS_VIEW (frame);
6406       if (view != nil)
6407         view->scrollbarsNeedingUpdate++;
6408       [self removeFromSuperview];
6409       [self release];
6410       UNBLOCK_INPUT;
6411     }
6412   return self;
6413 }
6414
6415
6416 - (void)resetCursorRects
6417 {
6418   NSRect visible = [self visibleRect];
6419   NSTRACE (resetCursorRects);
6420
6421   if (!NSIsEmptyRect (visible))
6422     [self addCursorRect: visible cursor: [NSCursor arrowCursor]];
6423   [[NSCursor arrowCursor] setOnMouseEntered: YES];
6424 }
6425
6426
6427 - (int) checkSamePosition: (int) position portion: (int) portion
6428                     whole: (int) whole
6429 {
6430   return em_position ==position && em_portion ==portion && em_whole ==whole
6431     && portion != whole; /* needed for resize empty buf */
6432 }
6433
6434
6435 - setPosition: (int)position portion: (int)portion whole: (int)whole
6436 {
6437   NSTRACE (setPosition);
6438
6439   em_position = position;
6440   em_portion = portion;
6441   em_whole = whole;
6442
6443   if (portion >= whole)
6444     {
6445 #if defined (NS_IMPL_COCOA) && MAC_OS_X_VERSION_MAX_ALLOWED > MAC_OS_X_VERSION_10_5
6446       [self setKnobProportion: 1.0];
6447       [self setDoubleValue: 1.0];
6448 #else
6449       [self setFloatValue: 0.0 knobProportion: 1.0];
6450 #endif
6451     }
6452   else
6453     {
6454       float pos, por;
6455       portion = max ((float)whole*min_portion/pixel_height, portion);
6456       pos = (float)position / (whole - portion);
6457       por = (float)portion/whole;
6458 #if defined (NS_IMPL_COCOA) && MAC_OS_X_VERSION_MAX_ALLOWED > MAC_OS_X_VERSION_10_5
6459       [self setKnobProportion: por];
6460       [self setDoubleValue: pos];
6461 #else
6462       [self setFloatValue: pos knobProportion: por];
6463 #endif
6464     }
6465   return self;
6466 }
6467
6468 /* FIXME: unused at moment (see ns_mouse_position) at the moment because
6469      drag events will go directly to the EmacsScroller.  Leaving in for now. */
6470 -(void)getMouseMotionPart: (int *)part window: (Lisp_Object *)window
6471                         x: (Lisp_Object *)x y: ( Lisp_Object *)y
6472 {
6473   *part = last_hit_part;
6474   *window = win;
6475   XSETINT (*y, pixel_height);
6476   if ([self floatValue] > 0.999)
6477     XSETINT (*x, pixel_height);
6478   else
6479     XSETINT (*x, pixel_height * [self floatValue]);
6480 }
6481
6482
6483 /* set up emacs_event */
6484 - (void) sendScrollEventAtLoc: (float)loc fromEvent: (NSEvent *)e
6485 {
6486   if (!emacs_event)
6487     return;
6488
6489   emacs_event->part = last_hit_part;
6490   emacs_event->code = 0;
6491   emacs_event->modifiers = EV_MODIFIERS (e) | down_modifier;
6492   emacs_event->frame_or_window = win;
6493   emacs_event->timestamp = EV_TIMESTAMP (e);
6494   emacs_event->kind = SCROLL_BAR_CLICK_EVENT;
6495   emacs_event->arg = Qnil;
6496   XSETINT (emacs_event->x, loc * pixel_height);
6497   XSETINT (emacs_event->y, pixel_height-20);
6498
6499   if (q_event_ptr)
6500     {
6501       n_emacs_events_pending++;
6502       kbd_buffer_store_event_hold (emacs_event, q_event_ptr);
6503     }
6504   else
6505     kbd_buffer_store_event (emacs_event);
6506   EVENT_INIT (*emacs_event);
6507   ns_send_appdefined (-1);
6508 }
6509
6510
6511 /* called manually thru timer to implement repeated button action w/hold-down */
6512 - repeatScroll: (NSTimer *)scrollEntry
6513 {
6514   NSEvent *e = [[self window] currentEvent];
6515   NSPoint p =  [[self window] mouseLocationOutsideOfEventStream];
6516   BOOL inKnob = [self testPart: p] == NSScrollerKnob;
6517
6518   /* clear timer if need be */
6519   if (inKnob || [scroll_repeat_entry timeInterval] == SCROLL_BAR_FIRST_DELAY)
6520     {
6521         [scroll_repeat_entry invalidate];
6522         [scroll_repeat_entry release];
6523         scroll_repeat_entry = nil;
6524
6525         if (inKnob)
6526           return self;
6527
6528         scroll_repeat_entry
6529           = [[NSTimer scheduledTimerWithTimeInterval:
6530                         SCROLL_BAR_CONTINUOUS_DELAY
6531                                             target: self
6532                                           selector: @selector (repeatScroll:)
6533                                           userInfo: 0
6534                                            repeats: YES]
6535               retain];
6536     }
6537
6538   [self sendScrollEventAtLoc: 0 fromEvent: e];
6539   return self;
6540 }
6541
6542
6543 /* Asynchronous mouse tracking for scroller.  This allows us to dispatch
6544    mouseDragged events without going into a modal loop. */
6545 - (void)mouseDown: (NSEvent *)e
6546 {
6547   NSRect sr, kr;
6548   /* hitPart is only updated AFTER event is passed on */
6549   NSScrollerPart part = [self testPart: [e locationInWindow]];
6550   double inc = 0.0, loc, kloc, pos;
6551   int edge = 0;
6552
6553   NSTRACE (EmacsScroller_mouseDown);
6554
6555   switch (part)
6556     {
6557     case NSScrollerDecrementPage:
6558         last_hit_part = scroll_bar_above_handle; inc = -1.0; break;
6559     case NSScrollerIncrementPage:
6560         last_hit_part = scroll_bar_below_handle; inc = 1.0; break;
6561     case NSScrollerDecrementLine:
6562       last_hit_part = scroll_bar_up_arrow; inc = -0.1; break;
6563     case NSScrollerIncrementLine:
6564       last_hit_part = scroll_bar_down_arrow; inc = 0.1; break;
6565     case NSScrollerKnob:
6566       last_hit_part = scroll_bar_handle; break;
6567     case NSScrollerKnobSlot:  /* GNUstep-only */
6568       last_hit_part = scroll_bar_move_ratio; break;
6569     default:  /* NSScrollerNoPart? */
6570       fprintf (stderr, "EmacsScoller-mouseDown: unexpected part %ld\n",
6571                (long) part);
6572       return;
6573     }
6574
6575   if (inc != 0.0)
6576     {
6577       pos = 0;      /* ignored */
6578
6579       /* set a timer to repeat, as we can't let superclass do this modally */
6580       scroll_repeat_entry
6581         = [[NSTimer scheduledTimerWithTimeInterval: SCROLL_BAR_FIRST_DELAY
6582                                             target: self
6583                                           selector: @selector (repeatScroll:)
6584                                           userInfo: 0
6585                                            repeats: YES]
6586             retain];
6587     }
6588   else
6589     {
6590       /* handle, or on GNUstep possibly slot */
6591       NSEvent *fake_event;
6592
6593       /* compute float loc in slot and mouse offset on knob */
6594       sr = [self convertRect: [self rectForPart: NSScrollerKnobSlot]
6595                       toView: nil];
6596       loc = NSHeight (sr) - ([e locationInWindow].y - NSMinY (sr));
6597       if (loc <= 0.0)
6598         {
6599           loc = 0.0;
6600           edge = -1;
6601         }
6602       else if (loc >= NSHeight (sr))
6603         {
6604           loc = NSHeight (sr);
6605           edge = 1;
6606         }
6607
6608       if (edge)
6609         kloc = 0.5 * edge;
6610       else
6611         {
6612           kr = [self convertRect: [self rectForPart: NSScrollerKnob]
6613                           toView: nil];
6614           kloc = NSHeight (kr) - ([e locationInWindow].y - NSMinY (kr));
6615         }
6616       last_mouse_offset = kloc;
6617
6618       /* if knob, tell emacs a location offset by knob pos
6619          (to indicate top of handle) */
6620       if (part == NSScrollerKnob)
6621           pos = (loc - last_mouse_offset) / NSHeight (sr);
6622       else
6623         /* else this is a slot click on GNUstep: go straight there */
6624         pos = loc / NSHeight (sr);
6625
6626       /* send a fake mouse-up to super to preempt modal -trackKnob: mode */
6627       fake_event = [NSEvent mouseEventWithType: NSLeftMouseUp
6628                                       location: [e locationInWindow]
6629                                  modifierFlags: [e modifierFlags]
6630                                      timestamp: [e timestamp]
6631                                   windowNumber: [e windowNumber]
6632                                        context: [e context]
6633                                    eventNumber: [e eventNumber]
6634                                     clickCount: [e clickCount]
6635                                       pressure: [e pressure]];
6636       [super mouseUp: fake_event];
6637     }
6638
6639   if (part != NSScrollerKnob)
6640     [self sendScrollEventAtLoc: pos fromEvent: e];
6641 }
6642
6643
6644 /* Called as we manually track scroller drags, rather than superclass. */
6645 - (void)mouseDragged: (NSEvent *)e
6646 {
6647     NSRect sr;
6648     double loc, pos;
6649     int edge = 0;
6650
6651     NSTRACE (EmacsScroller_mouseDragged);
6652
6653       sr = [self convertRect: [self rectForPart: NSScrollerKnobSlot]
6654                       toView: nil];
6655       loc = NSHeight (sr) - ([e locationInWindow].y - NSMinY (sr));
6656
6657       if (loc <= 0.0)
6658         {
6659           loc = 0.0;
6660           edge = -1;
6661         }
6662       else if (loc >= NSHeight (sr) + last_mouse_offset)
6663         {
6664           loc = NSHeight (sr) + last_mouse_offset;
6665           edge = 1;
6666         }
6667
6668       pos = /*(edge ? loc :*/ (loc - last_mouse_offset) / NSHeight (sr);
6669       [self sendScrollEventAtLoc: pos fromEvent: e];
6670 }
6671
6672
6673 - (void)mouseUp: (NSEvent *)e
6674 {
6675   if (scroll_repeat_entry)
6676     {
6677       [scroll_repeat_entry invalidate];
6678       [scroll_repeat_entry release];
6679       scroll_repeat_entry = nil;
6680     }
6681   last_hit_part = 0;
6682 }
6683
6684
6685 /* treat scrollwheel events in the bar as though they were in the main window */
6686 - (void) scrollWheel: (NSEvent *)theEvent
6687 {
6688   EmacsView *view = (EmacsView *)FRAME_NS_VIEW (frame);
6689   [view mouseDown: theEvent];
6690 }
6691
6692 @end  /* EmacsScroller */
6693
6694
6695
6696
6697 /* ==========================================================================
6698
6699    Font-related functions; these used to be in nsfaces.m
6700
6701    ========================================================================== */
6702
6703
6704 Lisp_Object
6705 x_new_font (struct frame *f, Lisp_Object font_object, int fontset)
6706 {
6707   struct font *font = XFONT_OBJECT (font_object);
6708
6709   if (fontset < 0)
6710     fontset = fontset_from_font (font_object);
6711   FRAME_FONTSET (f) = fontset;
6712
6713   if (FRAME_FONT (f) == font)
6714     /* This font is already set in frame F.  There's nothing more to
6715        do.  */
6716     return font_object;
6717
6718   FRAME_FONT (f) = font;
6719
6720   FRAME_BASELINE_OFFSET (f) = font->baseline_offset;
6721   FRAME_COLUMN_WIDTH (f) = font->average_width;
6722   FRAME_SPACE_WIDTH (f) = font->space_width;
6723   FRAME_LINE_HEIGHT (f) = font->height;
6724
6725   compute_fringe_widths (f, 1);
6726
6727   /* Compute the scroll bar width in character columns.  */
6728   if (FRAME_CONFIG_SCROLL_BAR_WIDTH (f) > 0)
6729     {
6730       int wid = FRAME_COLUMN_WIDTH (f);
6731       FRAME_CONFIG_SCROLL_BAR_COLS (f)
6732         = (FRAME_CONFIG_SCROLL_BAR_WIDTH (f) + wid - 1) / wid;
6733     }
6734   else
6735     {
6736       int wid = FRAME_COLUMN_WIDTH (f);
6737       FRAME_CONFIG_SCROLL_BAR_COLS (f) = (14 + wid - 1) / wid;
6738     }
6739
6740   /* Now make the frame display the given font.  */
6741   if (FRAME_NS_WINDOW (f) != 0)
6742         x_set_window_size (f, 0, FRAME_COLS (f), FRAME_LINES (f));
6743
6744   return font_object;
6745 }
6746
6747
6748 /* XLFD: -foundry-family-weight-slant-swidth-adstyle-pxlsz-ptSz-resx-resy-spc-avgWidth-rgstry-encoding */
6749 /* Note: ns_font_to_xlfd and ns_fontname_to_xlfd no longer needed, removed
6750          in 1.43. */
6751
6752 const char *
6753 ns_xlfd_to_fontname (const char *xlfd)
6754 /* --------------------------------------------------------------------------
6755     Convert an X font name (XLFD) to an NS font name.
6756     Only family is used.
6757     The string returned is temporarily allocated.
6758    -------------------------------------------------------------------------- */
6759 {
6760   char *name = xmalloc (180);
6761   int i, len;
6762   const char *ret;
6763
6764   if (!strncmp (xlfd, "--", 2))
6765     sscanf (xlfd, "--%*[^-]-%[^-]179-", name);
6766   else
6767     sscanf (xlfd, "-%*[^-]-%[^-]179-", name);
6768
6769   /* stopgap for malformed XLFD input */
6770   if (strlen (name) == 0)
6771     strcpy (name, "Monaco");
6772
6773   /* undo hack in ns_fontname_to_xlfd, converting '$' to '-', '_' to ' '
6774      also uppercase after '-' or ' ' */
6775   name[0] = c_toupper (name[0]);
6776   for (len =strlen (name), i =0; i<len; i++)
6777     {
6778       if (name[i] == '$')
6779         {
6780           name[i] = '-';
6781           if (i+1<len)
6782             name[i+1] = c_toupper (name[i+1]);
6783         }
6784       else if (name[i] == '_')
6785         {
6786           name[i] = ' ';
6787           if (i+1<len)
6788             name[i+1] = c_toupper (name[i+1]);
6789         }
6790     }
6791 /*fprintf (stderr, "converted '%s' to '%s'\n",xlfd,name);  */
6792   ret = [[NSString stringWithUTF8String: name] UTF8String];
6793   xfree (name);
6794   return ret;
6795 }
6796
6797
6798 void
6799 syms_of_nsterm (void)
6800 {
6801   NSTRACE (syms_of_nsterm);
6802
6803   ns_antialias_threshold = 10.0;
6804
6805   /* from 23+ we need to tell emacs what modifiers there are.. */
6806   DEFSYM (Qmodifier_value, "modifier-value");
6807   DEFSYM (Qalt, "alt");
6808   DEFSYM (Qhyper, "hyper");
6809   DEFSYM (Qmeta, "meta");
6810   DEFSYM (Qsuper, "super");
6811   DEFSYM (Qcontrol, "control");
6812   DEFSYM (QUTF8_STRING, "UTF8_STRING");
6813
6814   Fput (Qalt, Qmodifier_value, make_number (alt_modifier));
6815   Fput (Qhyper, Qmodifier_value, make_number (hyper_modifier));
6816   Fput (Qmeta, Qmodifier_value, make_number (meta_modifier));
6817   Fput (Qsuper, Qmodifier_value, make_number (super_modifier));
6818   Fput (Qcontrol, Qmodifier_value, make_number (ctrl_modifier));
6819
6820   DEFVAR_LISP ("ns-input-file", ns_input_file,
6821               "The file specified in the last NS event.");
6822   ns_input_file =Qnil;
6823
6824   DEFVAR_LISP ("ns-input-text", ns_input_text,
6825               "The data received in the last NS text drag event.");
6826   ns_input_text =Qnil;
6827
6828   DEFVAR_LISP ("ns-working-text", ns_working_text,
6829               "String for visualizing working composition sequence.");
6830   ns_working_text =Qnil;
6831
6832   DEFVAR_LISP ("ns-input-font", ns_input_font,
6833               "The font specified in the last NS event.");
6834   ns_input_font =Qnil;
6835
6836   DEFVAR_LISP ("ns-input-fontsize", ns_input_fontsize,
6837               "The fontsize specified in the last NS event.");
6838   ns_input_fontsize =Qnil;
6839
6840   DEFVAR_LISP ("ns-input-line", ns_input_line,
6841                "The line specified in the last NS event.");
6842   ns_input_line =Qnil;
6843
6844   DEFVAR_LISP ("ns-input-color", ns_input_color,
6845                "The color specified in the last NS event.");
6846   ns_input_color =Qnil;
6847
6848   DEFVAR_LISP ("ns-input-spi-name", ns_input_spi_name,
6849                "The service name specified in the last NS event.");
6850   ns_input_spi_name =Qnil;
6851
6852   DEFVAR_LISP ("ns-input-spi-arg", ns_input_spi_arg,
6853                "The service argument specified in the last NS event.");
6854   ns_input_spi_arg =Qnil;
6855
6856   DEFVAR_LISP ("ns-alternate-modifier", ns_alternate_modifier,
6857                "This variable describes the behavior of the alternate or option key.\n\
6858 Set to control, meta, alt, super, or hyper means it is taken to be that key.\n\
6859 Set to none means that the alternate / option key is not interpreted by Emacs\n\
6860 at all, allowing it to be used at a lower level for accented character entry.");
6861   ns_alternate_modifier = Qmeta;
6862
6863   DEFVAR_LISP ("ns-right-alternate-modifier", ns_right_alternate_modifier,
6864                "This variable describes the behavior of the right alternate or option key.\n\
6865 Set to control, meta, alt, super, or hyper means it is taken to be that key.\n\
6866 Set to left means be the same key as `ns-alternate-modifier'.\n\
6867 Set to none means that the alternate / option key is not interpreted by Emacs\n\
6868 at all, allowing it to be used at a lower level for accented character entry.");
6869   ns_right_alternate_modifier = Qleft;
6870
6871   DEFVAR_LISP ("ns-command-modifier", ns_command_modifier,
6872                "This variable describes the behavior of the command key.\n\
6873 Set to control, meta, alt, super, or hyper means it is taken to be that key.");
6874   ns_command_modifier = Qsuper;
6875
6876   DEFVAR_LISP ("ns-right-command-modifier", ns_right_command_modifier,
6877                "This variable describes the behavior of the right command key.\n\
6878 Set to control, meta, alt, super, or hyper means it is taken to be that key.\n\
6879 Set to left means be the same key as `ns-command-modifier'.\n\
6880 Set to none means that the command / option key is not interpreted by Emacs\n\
6881 at all, allowing it to be used at a lower level for accented character entry.");
6882   ns_right_command_modifier = Qleft;
6883
6884   DEFVAR_LISP ("ns-control-modifier", ns_control_modifier,
6885                "This variable describes the behavior of the control key.\n\
6886 Set to control, meta, alt, super, or hyper means it is taken to be that key.");
6887   ns_control_modifier = Qcontrol;
6888
6889   DEFVAR_LISP ("ns-right-control-modifier", ns_right_control_modifier,
6890                "This variable describes the behavior of the right control key.\n\
6891 Set to control, meta, alt, super, or hyper means it is taken to be that key.\n\
6892 Set to left means be the same key as `ns-control-modifier'.\n\
6893 Set to none means that the control / option key is not interpreted by Emacs\n\
6894 at all, allowing it to be used at a lower level for accented character entry.");
6895   ns_right_control_modifier = Qleft;
6896
6897   DEFVAR_LISP ("ns-function-modifier", ns_function_modifier,
6898                "This variable describes the behavior of the function key (on laptops).\n\
6899 Set to control, meta, alt, super, or hyper means it is taken to be that key.\n\
6900 Set to none means that the function key is not interpreted by Emacs at all,\n\
6901 allowing it to be used at a lower level for accented character entry.");
6902   ns_function_modifier = Qnone;
6903
6904   DEFVAR_LISP ("ns-antialias-text", ns_antialias_text,
6905                "Non-nil (the default) means to render text antialiased. Only has an effect on OS X Panther and above.");
6906   ns_antialias_text = Qt;
6907
6908   DEFVAR_LISP ("ns-confirm-quit", ns_confirm_quit,
6909                "Whether to confirm application quit using dialog.");
6910   ns_confirm_quit = Qnil;
6911
6912   staticpro (&ns_display_name_list);
6913   ns_display_name_list = Qnil;
6914
6915   staticpro (&last_mouse_motion_frame);
6916   last_mouse_motion_frame = Qnil;
6917
6918   DEFVAR_LISP ("ns-auto-hide-menu-bar", ns_auto_hide_menu_bar,
6919                doc: /* Non-nil means that the menu bar is hidden, but appears when the mouse is near.
6920 Only works on OSX 10.6 or later.  */);
6921   ns_auto_hide_menu_bar = Qnil;
6922
6923   /* TODO: move to common code */
6924   DEFVAR_LISP ("x-toolkit-scroll-bars", Vx_toolkit_scroll_bars,
6925                doc: /* Which toolkit scroll bars Emacs uses, if any.
6926 A value of nil means Emacs doesn't use toolkit scroll bars.
6927 With the X Window system, the value is a symbol describing the
6928 X toolkit.  Possible values are: gtk, motif, xaw, or xaw3d.
6929 With MS Windows or Nextstep, the value is t.  */);
6930   Vx_toolkit_scroll_bars = Qt;
6931
6932   DEFVAR_BOOL ("x-use-underline-position-properties",
6933                x_use_underline_position_properties,
6934      doc: /*Non-nil means make use of UNDERLINE_POSITION font properties.
6935 A value of nil means ignore them.  If you encounter fonts with bogus
6936 UNDERLINE_POSITION font properties, for example 7x13 on XFree prior
6937 to 4.1, set this to nil. */);
6938   x_use_underline_position_properties = 0;
6939
6940   DEFVAR_BOOL ("x-underline-at-descent-line",
6941                x_underline_at_descent_line,
6942      doc: /* Non-nil means to draw the underline at the same place as the descent line.
6943 A value of nil means to draw the underline according to the value of the
6944 variable `x-use-underline-position-properties', which is usually at the
6945 baseline level.  The default value is nil.  */);
6946   x_underline_at_descent_line = 0;
6947
6948   /* Tell emacs about this window system. */
6949   Fprovide (intern ("ns"), Qnil);
6950 }