src/nsterm.m

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