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