code.delx.au - gnu-emacs/blob - 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_NS_TOOLBAR_HEIGHT (f) =
1142       NSHeight ([window frameRectForContentRect: NSMakeRect (0, 0, 0, 0)])
1143         - FRAME_NS_TITLEBAR_HEIGHT (f);
1144   else
1145     FRAME_NS_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_NS_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 *temp;
1521   int notFound = ns_get_color (name, &temp);
1522
1523   NSTRACE (ns_defined_color);
1524
1525   if (notFound)
1526     return 0;
1527
1528   if (makeIndex && alloc)
1529       color_def->pixel = ns_index_color(temp, f); /* [temp retain]; */
1530
1531   ns_query_color (temp, color_def, !makeIndex);
1532
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       bzero (newBimgs, max_used_fringe_bitmap * sizeof (EmacsImage *));
2167
2168       if (nBimgs)
2169         {
2170           bcopy (bimgs, newBimgs, 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   if (p->y < rowY)
2181     {
2182       /* Adjust position of "bottom aligned" bitmap on partially
2183          visible last row.  */
2184       int oldY = row->y;
2185       int oldVH = row->visible_height;
2186       row->visible_height = p->h;
2187       row->y -= rowY - p->y;
2188       ns_clip_to_row (w, row, -1, NO);
2189       row->y = oldY;
2190       row->visible_height = oldVH;
2191     }
2192   else
2193     ns_clip_to_row (w, row, -1, YES);
2194
2195   if (p->bx >= 0 && !p->overlay_p)
2196     {
2197       int yAdjust = rowY - FRAME_INTERNAL_BORDER_WIDTH (f) < 5 ?
2198         -FRAME_INTERNAL_BORDER_WIDTH (f) : 0;
2199       int yIncr = FRAME_PIXEL_HEIGHT (f) - (p->by+yAdjust + p->ny) < 5 ?
2200         FRAME_INTERNAL_BORDER_WIDTH (f) : 0;
2201       if (yAdjust)
2202         yIncr += FRAME_INTERNAL_BORDER_WIDTH (f);
2203       NSRect r = NSMakeRect (p->bx+xAdjust, p->by+yAdjust, p->nx, p->ny+yIncr);
2204       NSRectClip (r);
2205       [ns_lookup_indexed_color(face->background, f) set];
2206       NSRectFill (r);
2207     }
2208
2209   if (p->which)
2210     {
2211       NSRect r = NSMakeRect (p->x+xAdjust, p->y, p->wd, p->h);
2212       NSPoint pt = r.origin;
2213       EmacsImage *img = bimgs[p->which - 1];
2214
2215       if (!img)
2216         {
2217           unsigned short *bits = p->bits + p->dh;
2218           int len = 8 * p->h/8;
2219           int i;
2220           unsigned char *cbits = xmalloc (len);
2221
2222           for (i =0; i<len; i++)
2223             cbits[i] = ~(bits[i] & 0xff);
2224           img = [[EmacsImage alloc] initFromXBM: cbits width: 8 height: p->h
2225                                            flip: NO];
2226           bimgs[p->which - 1] = img;
2227           xfree (cbits);
2228         }
2229
2230       NSRectClip (r);
2231       /* Since we composite the bitmap instead of just blitting it, we need
2232          to erase the whole background. */
2233       [ns_lookup_indexed_color(face->background, f) set];
2234       NSRectFill (r);
2235       pt.y += p->h;
2236       [img setXBMColor: ns_lookup_indexed_color(face->foreground, f)];
2237       [img compositeToPoint: pt operation: NSCompositeSourceOver];
2238     }
2239   ns_unfocus (f);
2240 }
2241
2242
2243 void
2244 ns_draw_window_cursor (struct window *w, struct glyph_row *glyph_row,
2245                        int x, int y, int cursor_type, int cursor_width,
2246                        int on_p, int active_p)
2247 /* --------------------------------------------------------------------------
2248      External call (RIF): draw cursor
2249      (modeled after x_draw_window_cursor
2250      FIXME: cursor_width is effectively bogus -- it sometimes gets set
2251      in xdisp.c set_frame_cursor_types, sometimes left uninitialized;
2252      DON'T USE IT (no other terms do)
2253    -------------------------------------------------------------------------- */
2254 {
2255   NSRect r, s;
2256   int fx, fy, h;
2257   struct frame *f = WINDOW_XFRAME (w);
2258   struct glyph *phys_cursor_glyph;
2259   int overspill;
2260
2261   NSTRACE (dumpcursor);
2262 //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);
2263
2264   if (!on_p)
2265         return;
2266
2267   w->phys_cursor_type = cursor_type;
2268   w->phys_cursor_on_p = on_p;
2269
2270   if (cursor_type == NO_CURSOR)
2271     {
2272       w->phys_cursor_width = 0;
2273       return;
2274     }
2275
2276   if ((phys_cursor_glyph = get_phys_cursor_glyph (w)) == NULL)
2277     {
2278       if (glyph_row->exact_window_width_line_p
2279           && w->phys_cursor.hpos >= glyph_row->used[TEXT_AREA])
2280         {
2281           glyph_row->cursor_in_fringe_p = 1;
2282           draw_fringe_bitmap (w, glyph_row, 0);
2283         }
2284       return;
2285     }
2286
2287   get_phys_cursor_geometry (w, glyph_row, phys_cursor_glyph, &fx, &fy, &h);
2288
2289   r.origin.x = fx, r.origin.y = fy;
2290   r.size.height = h;
2291   r.size.width = w->phys_cursor_width;
2292
2293   /* FIXME: if we overwrite the internal border area, it does not get erased;
2294      fix by truncating cursor, but better would be to erase properly */
2295   overspill = r.origin.x + r.size.width -
2296     WINDOW_TEXT_TO_FRAME_PIXEL_X (w, WINDOW_BOX_RIGHT_EDGE_X (w)
2297       - WINDOW_TOTAL_FRINGE_WIDTH (w) - FRAME_INTERNAL_BORDER_WIDTH (f));
2298   if (overspill > 0)
2299     r.size.width -= overspill;
2300
2301   /* TODO: only needed in rare cases with last-resort font in HELLO..
2302      should we do this more efficiently? */
2303   ns_clip_to_row (w, glyph_row, -1, NO); /* do ns_focus(f, &r, 1); if remove */
2304   [FRAME_CURSOR_COLOR (f) set];
2305
2306 #ifdef NS_IMPL_COCOA
2307   /* TODO: This makes drawing of cursor plus that of phys_cursor_glyph
2308            atomic.  Cleaner ways of doing this should be investigated.
2309            One way would be to set a global variable DRAWING_CURSOR
2310            when making the call to draw_phys..(), don't focus in that
2311            case, then move the ns_unfocus() here after that call. */
2312   NSDisableScreenUpdates ();
2313 #endif
2314
2315   switch (cursor_type)
2316     {
2317     case NO_CURSOR:
2318       break;
2319     case FILLED_BOX_CURSOR:
2320       NSRectFill (r);
2321       break;
2322     case HOLLOW_BOX_CURSOR:
2323       NSRectFill (r);
2324       [FRAME_BACKGROUND_COLOR (f) set];
2325       NSRectFill (NSInsetRect (r, 1, 1));
2326       [FRAME_CURSOR_COLOR (f) set];
2327       break;
2328     case HBAR_CURSOR:
2329       s = r;
2330       s.origin.y += lrint (0.75 * s.size.height);
2331       s.size.height = lrint (s.size.height * 0.25);
2332       NSRectFill (s);
2333       break;
2334     case BAR_CURSOR:
2335       s = r;
2336       s.size.width = min (cursor_width, 2); //FIXME(see above)
2337       NSRectFill (s);
2338       break;
2339     }
2340   ns_unfocus (f);
2341
2342   /* draw the character under the cursor */
2343   if (cursor_type != NO_CURSOR)
2344     draw_phys_cursor_glyph (w, glyph_row, DRAW_CURSOR);
2345
2346 #ifdef NS_IMPL_COCOA
2347   NSEnableScreenUpdates ();
2348 #endif
2349
2350 }
2351
2352
2353 static void
2354 ns_draw_vertical_window_border (struct window *w, int x, int y0, int y1)
2355 /* --------------------------------------------------------------------------
2356      External (RIF): Draw a vertical line.
2357    -------------------------------------------------------------------------- */
2358 {
2359   struct frame *f = XFRAME (WINDOW_FRAME (w));
2360   struct face *face;
2361   NSRect r = NSMakeRect (x, y0, 1, y1-y0);
2362
2363   NSTRACE (ns_draw_vertical_window_border);
2364
2365   face = FACE_FROM_ID (f, VERTICAL_BORDER_FACE_ID);
2366   if (face)
2367       [ns_lookup_indexed_color(face->foreground, f) set];
2368
2369   ns_focus (f, &r, 1);
2370   NSRectFill(r);
2371   ns_unfocus (f);
2372 }
2373
2374
2375 void
2376 show_hourglass (struct atimer *timer)
2377 {
2378   if (hourglass_shown_p)
2379     return;
2380
2381   BLOCK_INPUT;
2382
2383   /* TODO: add NSProgressIndicator to selected frame (see macfns.c) */
2384
2385   hourglass_shown_p = 1;
2386   UNBLOCK_INPUT;
2387 }
2388
2389
2390 void
2391 hide_hourglass ()
2392 {
2393   if (!hourglass_shown_p)
2394     return;
2395
2396   BLOCK_INPUT;
2397
2398   /* TODO: remove NSProgressIndicator from all frames */
2399
2400   hourglass_shown_p = 0;
2401   UNBLOCK_INPUT;
2402 }
2403
2404
2405
2406 /* ==========================================================================
2407
2408     Glyph drawing operations
2409
2410    ========================================================================== */
2411
2412
2413 static inline NSRect
2414 ns_fix_rect_ibw (NSRect r, int fibw, int frame_pixel_width)
2415 /* --------------------------------------------------------------------------
2416     Under NS we draw internal borders inside fringes, and want full-width
2417     rendering to go all the way to edge.  This function makes that correction.
2418    -------------------------------------------------------------------------- */
2419 {
2420   if (r.origin.y <= fibw+1)
2421     {
2422       r.size.height += r.origin.y;
2423       r.origin.y = 0;
2424     }
2425   if (r.origin.x <= fibw+1)
2426     {
2427       r.size.width += r.origin.x;
2428       r.origin.x = 0;
2429     }
2430   if (frame_pixel_width - (r.origin.x+r.size.width) <= fibw+1)
2431     r.size.width += fibw;
2432
2433   return r;
2434 }
2435
2436
2437 static int
2438 ns_get_glyph_string_clip_rect (struct glyph_string *s, NativeRectangle *nr)
2439 /* --------------------------------------------------------------------------
2440     Wrapper utility to account for internal border width on full-width lines,
2441     and allow top full-width rows to hit the frame top.  nr should be pointer
2442     to two successive NSRects.  Number of rects actually used is returned.
2443    -------------------------------------------------------------------------- */
2444 {
2445   int n = get_glyph_string_clip_rects (s, nr, 2);
2446   if (s->row->full_width_p)
2447     {
2448       *nr = ns_fix_rect_ibw (*nr, FRAME_INTERNAL_BORDER_WIDTH (s->f),
2449                             FRAME_PIXEL_WIDTH (s->f));
2450       if (n == 2)
2451         *nr = ns_fix_rect_ibw (*(nr+1), FRAME_INTERNAL_BORDER_WIDTH (s->f),
2452                               FRAME_PIXEL_WIDTH (s->f));
2453     }
2454   return n;
2455 }
2456
2457
2458 static void
2459 ns_draw_box (NSRect r, float thickness, NSColor *col, char left_p, char right_p)
2460 /* --------------------------------------------------------------------------
2461     Draw an unfilled rect inside r, optionally leaving left and/or right open.
2462     Note we can't just use an NSDrawRect command, because of the possibility
2463     of some sides not being drawn, and because the rect will be filled.
2464    -------------------------------------------------------------------------- */
2465 {
2466   NSRect s = r;
2467   [col set];
2468
2469   /* top, bottom */
2470   s.size.height = thickness;
2471   NSRectFill (s);
2472   s.origin.y += r.size.height - thickness;
2473   NSRectFill (s);
2474
2475   s.size.height = r.size.height;
2476   s.origin.y = r.origin.y;
2477
2478   /* left, right (optional) */
2479   s.size.width = thickness;
2480   if (left_p)
2481     NSRectFill (s);
2482   if (right_p)
2483     {
2484       s.origin.x += r.size.width - thickness;
2485       NSRectFill (s);
2486     }
2487 }
2488
2489
2490 static void
2491 ns_draw_relief (NSRect r, int thickness, char raised_p,
2492                char top_p, char bottom_p, char left_p, char right_p,
2493                struct glyph_string *s)
2494 /* --------------------------------------------------------------------------
2495     Draw a relief rect inside r, optionally leaving some sides open.
2496     Note we can't just use an NSDrawBezel command, because of the possibility
2497     of some sides not being drawn, and because the rect will be filled.
2498    -------------------------------------------------------------------------- */
2499 {
2500   static NSColor *baseCol = nil, *lightCol = nil, *darkCol = nil;
2501   NSColor *newBaseCol = nil;
2502   NSRect sr = r;
2503
2504   NSTRACE (ns_draw_relief);
2505
2506   /* set up colors */
2507
2508   if (s->face->use_box_color_for_shadows_p)
2509     {
2510       newBaseCol = ns_lookup_indexed_color (s->face->box_color, s->f);
2511     }
2512 /*     else if (s->first_glyph->type == IMAGE_GLYPH
2513            && s->img->pixmap
2514            && !IMAGE_BACKGROUND_TRANSPARENT (s->img, s->f, 0))
2515        {
2516          newBaseCol = IMAGE_BACKGROUND  (s->img, s->f, 0);
2517        } */
2518   else
2519     {
2520       newBaseCol = ns_lookup_indexed_color (s->face->background, s->f);
2521     }
2522
2523   if (newBaseCol == nil)
2524     newBaseCol = [NSColor grayColor];
2525
2526   if (newBaseCol != baseCol)  /* TODO: better check */
2527     {
2528       [baseCol release];
2529       baseCol = [newBaseCol retain];
2530       [lightCol release];
2531       lightCol = [[baseCol highlightWithLevel: 0.2] retain];
2532       [darkCol release];
2533       darkCol = [[baseCol shadowWithLevel: 0.3] retain];
2534     }
2535
2536   [(raised_p ? lightCol : darkCol) set];
2537
2538   /* TODO: mitering. Using NSBezierPath doesn't work because of color switch. */
2539
2540   /* top */
2541   sr.size.height = thickness;
2542   if (top_p) NSRectFill (sr);
2543
2544   /* left */
2545   sr.size.height = r.size.height;
2546   sr.size.width = thickness;
2547   if (left_p) NSRectFill (sr);
2548
2549   [(raised_p ? darkCol : lightCol) set];
2550
2551   /* bottom */
2552   sr.size.width = r.size.width;
2553   sr.size.height = thickness;
2554   sr.origin.y += r.size.height - thickness;
2555   if (bottom_p) NSRectFill (sr);
2556
2557   /* right */
2558   sr.size.height = r.size.height;
2559   sr.origin.y = r.origin.y;
2560   sr.size.width = thickness;
2561   sr.origin.x += r.size.width - thickness;
2562   if (right_p) NSRectFill (sr);
2563 }
2564
2565
2566 static void
2567 ns_dumpglyphs_box_or_relief (struct glyph_string *s)
2568 /* --------------------------------------------------------------------------
2569       Function modeled after x_draw_glyph_string_box ().
2570       Sets up parameters for drawing.
2571    -------------------------------------------------------------------------- */
2572 {
2573   int right_x, last_x;
2574   char left_p, right_p;
2575   struct glyph *last_glyph;
2576   NSRect r;
2577   int thickness;
2578   struct face *face;
2579
2580   if (s->hl == DRAW_MOUSE_FACE)
2581     {
2582       face = FACE_FROM_ID
2583         (s->f, FRAME_NS_DISPLAY_INFO (s->f)->mouse_face_face_id);
2584       if (!face)
2585         face = FACE_FROM_ID (s->f, MOUSE_FACE_ID);
2586     }
2587   else
2588     face = s->face;
2589
2590   thickness = face->box_line_width;
2591
2592   NSTRACE (ns_dumpglyphs_box_or_relief);
2593
2594   last_x = ((s->row->full_width_p && !s->w->pseudo_window_p)
2595             ? WINDOW_RIGHT_EDGE_X (s->w)
2596             : window_box_right (s->w, s->area));
2597   last_glyph = (s->cmp || s->img
2598                 ? s->first_glyph : s->first_glyph + s->nchars-1);
2599
2600   right_x = ((s->row->full_width_p && s->extends_to_end_of_line_p
2601               ? last_x - 1 : min (last_x, s->x + s->background_width) - 1));
2602
2603   left_p = (s->first_glyph->left_box_line_p
2604             || (s->hl == DRAW_MOUSE_FACE
2605                 && (s->prev == NULL || s->prev->hl != s->hl)));
2606   right_p = (last_glyph->right_box_line_p
2607              || (s->hl == DRAW_MOUSE_FACE
2608                  && (s->next == NULL || s->next->hl != s->hl)));
2609
2610   r = NSMakeRect (s->x, s->y, right_x - s->x + 1, s->height);
2611
2612   /* expand full-width row over internal borders */
2613   if (s->row->full_width_p)
2614     r = ns_fix_rect_ibw (r, FRAME_INTERNAL_BORDER_WIDTH (s->f),
2615                         FRAME_PIXEL_WIDTH (s->f));
2616
2617   /* TODO: Sometimes box_color is 0 and this seems wrong; should investigate. */
2618   if (s->face->box == FACE_SIMPLE_BOX && s->face->box_color)
2619     {
2620       ns_draw_box (r, abs (thickness),
2621                    ns_lookup_indexed_color (face->box_color, s->f),
2622                   left_p, right_p);
2623     }
2624   else
2625     {
2626       ns_draw_relief (r, abs (thickness), s->face->box == FACE_RAISED_BOX,
2627                      1, 1, left_p, right_p, s);
2628     }
2629 }
2630
2631
2632 static void
2633 ns_maybe_dumpglyphs_background (struct glyph_string *s, char force_p)
2634 /* --------------------------------------------------------------------------
2635       Modeled after x_draw_glyph_string_background, which draws BG in
2636       certain cases.  Others are left to the text rendering routine.
2637    -------------------------------------------------------------------------- */
2638 {
2639   NSTRACE (ns_maybe_dumpglyphs_background);
2640
2641   if (!s->background_filled_p/* || s->hl == DRAW_MOUSE_FACE*/)
2642     {
2643       int box_line_width = max (s->face->box_line_width, 0);
2644       if (FONT_HEIGHT (s->font) < s->height - 2 * box_line_width
2645           || s->font_not_found_p || s->extends_to_end_of_line_p || force_p)
2646         {
2647           struct face *face;
2648           if (s->hl == DRAW_MOUSE_FACE)
2649             {
2650               face = FACE_FROM_ID
2651                 (s->f, FRAME_NS_DISPLAY_INFO (s->f)->mouse_face_face_id);
2652               if (!face)
2653                 face = FACE_FROM_ID (s->f, MOUSE_FACE_ID);
2654             }
2655           else
2656             face = FACE_FROM_ID (s->f, s->first_glyph->face_id);
2657           if (!face->stipple)
2658             [(NS_FACE_BACKGROUND (face) != 0
2659               ? ns_lookup_indexed_color (NS_FACE_BACKGROUND (face), s->f)
2660               : FRAME_BACKGROUND_COLOR (s->f)) set];
2661           else
2662             {
2663               struct ns_display_info *dpyinfo = FRAME_NS_DISPLAY_INFO (s->f);
2664               [[dpyinfo->bitmaps[face->stipple-1].img stippleMask] set];
2665             }
2666
2667           if (s->hl != DRAW_CURSOR)
2668             {
2669               NSRect r = NSMakeRect (s->x, s->y + box_line_width,
2670                                     s->background_width,
2671                                     s->height-2*box_line_width);
2672
2673               /* expand full-width row over internal borders */
2674               if (s->row->full_width_p)
2675                 {
2676                   int fibw = FRAME_INTERNAL_BORDER_WIDTH (s->f);
2677                   if (r.origin.y <= fibw+1 + box_line_width)
2678                     {
2679                       r.size.height += r.origin.y;
2680                       r.origin.y = 0;
2681                     }
2682                   if (r.origin.x <= fibw+1)
2683                     {
2684                       r.size.width += 2*r.origin.x;
2685                       r.origin.x = 0;
2686                     }
2687                   if (FRAME_PIXEL_WIDTH (s->f) - (r.origin.x + r.size.width)
2688                       <= fibw+1)
2689                     r.size.width += fibw;
2690                 }
2691
2692               NSRectFill (r);
2693             }
2694
2695           s->background_filled_p = 1;
2696         }
2697     }
2698 }
2699
2700
2701 static void
2702 ns_dumpglyphs_image (struct glyph_string *s, NSRect r)
2703 /* --------------------------------------------------------------------------
2704       Renders an image and associated borders.
2705    -------------------------------------------------------------------------- */
2706 {
2707   EmacsImage *img = s->img->pixmap;
2708   int box_line_vwidth = max (s->face->box_line_width, 0);
2709   int x = s->x, y = s->ybase - image_ascent (s->img, s->face, &s->slice);
2710   int bg_x, bg_y, bg_height;
2711   int th;
2712   char raised_p;
2713   NSRect br;
2714   struct face *face;
2715
2716   NSTRACE (ns_dumpglyphs_image);
2717
2718   if (s->face->box != FACE_NO_BOX
2719       && s->first_glyph->left_box_line_p && s->slice.x == 0)
2720     x += abs (s->face->box_line_width);
2721
2722   bg_x = x;
2723   bg_y =  s->slice.y == 0 ? s->y : s->y + box_line_vwidth;
2724   bg_height = s->height;
2725   /* other terms have this, but was causing problems w/tabbar mode */
2726   /* - 2 * box_line_vwidth; */
2727
2728   if (s->slice.x == 0) x += s->img->hmargin;
2729   if (s->slice.y == 0) y += s->img->vmargin;
2730
2731   /* Draw BG: if we need larger area than image itself cleared, do that,
2732      otherwise, since we composite the image under NS (instead of mucking
2733      with its background color), we must clear just the image area. */
2734   if (s->hl == DRAW_MOUSE_FACE)
2735     {
2736       face = FACE_FROM_ID
2737        (s->f, FRAME_NS_DISPLAY_INFO (s->f)->mouse_face_face_id);
2738       if (!face)
2739        face = FACE_FROM_ID (s->f, MOUSE_FACE_ID);
2740     }
2741   else
2742     face = FACE_FROM_ID (s->f, s->first_glyph->face_id);
2743
2744   [ns_lookup_indexed_color (NS_FACE_BACKGROUND (face), s->f) set];
2745
2746   if (bg_height > s->slice.height || s->img->hmargin || s->img->vmargin
2747       || s->img->mask || s->img->pixmap == 0 || s->width != s->background_width)
2748     {
2749       br = NSMakeRect (bg_x, bg_y, s->background_width, bg_height);
2750       s->background_filled_p = 1;
2751     }
2752   else
2753     {
2754       br = NSMakeRect (x, y, s->slice.width, s->slice.height);
2755     }
2756
2757   /* expand full-width row over internal borders */
2758   if (s->row->full_width_p)
2759     {
2760       int fibw = FRAME_INTERNAL_BORDER_WIDTH (s->f);
2761       if (br.origin.y <= fibw+1 + box_line_vwidth)
2762         {
2763           br.size.height += br.origin.y;
2764           br.origin.y = 0;
2765         }
2766       if (br.origin.x <= fibw+1 + box_line_vwidth)
2767         {
2768           br.size.width += br.origin.x;
2769           br.origin.x = 0;
2770         }
2771       if (FRAME_PIXEL_WIDTH (s->f) - (br.origin.x + br.size.width) <= fibw+1)
2772         br.size.width += fibw;
2773     }
2774
2775   NSRectFill (br);
2776
2777   /* Draw the image.. do we need to draw placeholder if img ==nil? */
2778   if (img != nil)
2779     [img compositeToPoint: NSMakePoint (x, y + s->slice.height)
2780                 operation: NSCompositeSourceOver];
2781
2782   /* Draw relief, if requested */
2783   if (s->img->relief || s->hl ==DRAW_IMAGE_RAISED || s->hl ==DRAW_IMAGE_SUNKEN)
2784     {
2785       if (s->hl == DRAW_IMAGE_SUNKEN || s->hl == DRAW_IMAGE_RAISED)
2786         {
2787           th = tool_bar_button_relief >= 0 ?
2788             tool_bar_button_relief : DEFAULT_TOOL_BAR_BUTTON_RELIEF;
2789           raised_p = (s->hl == DRAW_IMAGE_RAISED);
2790         }
2791       else
2792         {
2793           th = abs (s->img->relief);
2794           raised_p = (s->img->relief > 0);
2795         }
2796
2797       r.origin.x = x - th;
2798       r.origin.y = y - th;
2799       r.size.width = s->slice.width + 2*th-1;
2800       r.size.height = s->slice.height + 2*th-1;
2801       ns_draw_relief (r, th, raised_p,
2802                       s->slice.y == 0,
2803                       s->slice.y + s->slice.height == s->img->height,
2804                       s->slice.x == 0,
2805                       s->slice.x + s->slice.width == s->img->width, s);
2806     }
2807 }
2808
2809
2810 static void
2811 ns_dumpglyphs_stretch (struct glyph_string *s)
2812 {
2813   NSRect r[2];
2814   int n, i;
2815   struct face *face;
2816
2817   if (!s->background_filled_p)
2818     {
2819       n = ns_get_glyph_string_clip_rect (s, r);
2820       *r = NSMakeRect (s->x, s->y, s->background_width, s->height);
2821
2822       for (i=0; i<n; i++)
2823         {
2824           if (!s->row->full_width_p)
2825             {
2826               /* truncate to avoid overwriting fringe and/or scrollbar */
2827               int overrun = max (0, (s->x + s->background_width)
2828                                   - (WINDOW_BOX_RIGHT_EDGE_X (s->w)
2829                                     - WINDOW_RIGHT_FRINGE_WIDTH (s->w)));
2830               r[i].size.width -= overrun;
2831
2832               /* XXX: Try to work between problem where a stretch glyph on
2833                  a partially-visible bottom row will clear part of the
2834                  modeline, and another where list-buffers headers and similar
2835                  rows erroneously have visible_height set to 0.  Not sure
2836                  where this is coming from as other terms seem not to show. */
2837               r[i].size.height = min (s->height, s->row->visible_height);
2838             }
2839
2840           /* expand full-width rows over internal borders */
2841           else
2842             {
2843               r[i] = ns_fix_rect_ibw (r[i], FRAME_INTERNAL_BORDER_WIDTH (s->f),
2844                                       FRAME_PIXEL_WIDTH (s->f));
2845             }
2846
2847           /* NOTE: under NS this is NOT used to draw cursors, but we must avoid
2848              overwriting cursor (usually when cursor on a tab) */
2849           if (s->hl == DRAW_CURSOR)
2850             {
2851               r[i].origin.x += s->width;
2852               r[i].size.width -= s->width;
2853             }
2854         }
2855
2856       ns_focus (s->f, r, n);
2857
2858       if (s->hl == DRAW_MOUSE_FACE)
2859        {
2860          face = FACE_FROM_ID
2861            (s->f, FRAME_NS_DISPLAY_INFO (s->f)->mouse_face_face_id);
2862          if (!face)
2863            face = FACE_FROM_ID (s->f, MOUSE_FACE_ID);
2864        }
2865       else
2866        face = FACE_FROM_ID (s->f, s->first_glyph->face_id);
2867
2868       [ns_lookup_indexed_color (NS_FACE_BACKGROUND (face), s->f) set];
2869
2870       NSRectFill (r[0]);
2871       NSRectFill (r[1]);
2872       ns_unfocus (s->f);
2873       s->background_filled_p = 1;
2874     }
2875 }
2876
2877
2878 static void
2879 ns_draw_glyph_string (struct glyph_string *s)
2880 /* --------------------------------------------------------------------------
2881       External (RIF): Main draw-text call.
2882    -------------------------------------------------------------------------- */
2883 {
2884   /* TODO (optimize): focus for box and contents draw */
2885   NSRect r[2];
2886   int n;
2887   char box_drawn_p = 0;
2888
2889   NSTRACE (ns_draw_glyph_string);
2890
2891   if (s->next && s->right_overhang && !s->for_overlaps/*&&s->hl!=DRAW_CURSOR*/)
2892     {
2893       int width;
2894       struct glyph_string *next;
2895
2896       for (width = 0, next = s->next;
2897            next && width < s->right_overhang;
2898            width += next->width, next = next->next)
2899         if (next->first_glyph->type != IMAGE_GLYPH)
2900           {
2901             if (next->first_glyph->type != STRETCH_GLYPH)
2902               {
2903                 n = ns_get_glyph_string_clip_rect (s->next, r);
2904                 ns_focus (s->f, r, n);
2905                 ns_maybe_dumpglyphs_background (s->next, 1);
2906                 ns_unfocus (s->f);
2907               }
2908             else
2909               {
2910                 ns_dumpglyphs_stretch (s->next);
2911               }
2912             next->num_clips = 0;
2913           }
2914     }
2915
2916   if (!s->for_overlaps && s->face->box != FACE_NO_BOX
2917         && (s->first_glyph->type == CHAR_GLYPH
2918             || s->first_glyph->type == COMPOSITE_GLYPH))
2919     {
2920       n = ns_get_glyph_string_clip_rect (s, r);
2921       ns_focus (s->f, r, n);
2922       ns_maybe_dumpglyphs_background (s, 1);
2923       ns_dumpglyphs_box_or_relief (s);
2924       ns_unfocus (s->f);
2925       box_drawn_p = 1;
2926     }
2927
2928   switch (s->first_glyph->type)
2929     {
2930
2931     case IMAGE_GLYPH:
2932       n = ns_get_glyph_string_clip_rect (s, r);
2933       ns_focus (s->f, r, n);
2934       ns_dumpglyphs_image (s, r[0]);
2935       ns_unfocus (s->f);
2936       break;
2937
2938     case STRETCH_GLYPH:
2939       ns_dumpglyphs_stretch (s);
2940       break;
2941
2942     case CHAR_GLYPH:
2943     case COMPOSITE_GLYPH:
2944       n = ns_get_glyph_string_clip_rect (s, r);
2945       ns_focus (s->f, r, n);
2946
2947       if (s->for_overlaps || (s->cmp_from > 0
2948                               && ! s->first_glyph->u.cmp.automatic))
2949         s->background_filled_p = 1;
2950       else
2951         ns_maybe_dumpglyphs_background
2952           (s, s->first_glyph->type == COMPOSITE_GLYPH);
2953
2954       ns_tmp_flags = s->hl == DRAW_CURSOR ? NS_DUMPGLYPH_CURSOR :
2955                     (s->hl == DRAW_MOUSE_FACE ? NS_DUMPGLYPH_MOUSEFACE :
2956                      (s->for_overlaps ? NS_DUMPGLYPH_FOREGROUND :
2957                       NS_DUMPGLYPH_NORMAL));
2958       ns_tmp_font = (struct nsfont_info *)s->face->font;
2959       if (ns_tmp_font == NULL)
2960           ns_tmp_font = (struct nsfont_info *)FRAME_FONT (s->f);
2961
2962       ns_tmp_font->font.driver->draw
2963         (s, 0, s->nchars, s->x, s->y,
2964          (ns_tmp_flags == NS_DUMPGLYPH_NORMAL && !s->background_filled_p)
2965          || ns_tmp_flags == NS_DUMPGLYPH_MOUSEFACE);
2966
2967       ns_unfocus (s->f);
2968       break;
2969
2970     default:
2971       abort ();
2972     }
2973
2974   /* Draw box if not done already. */
2975   if (!s->for_overlaps && !box_drawn_p && s->face->box != FACE_NO_BOX)
2976     {
2977       n = ns_get_glyph_string_clip_rect (s, r);
2978       ns_focus (s->f, r, n);
2979       ns_dumpglyphs_box_or_relief (s);
2980       ns_unfocus (s->f);
2981     }
2982
2983   s->num_clips = 0;
2984 }
2985
2986
2987
2988 /* ==========================================================================
2989
2990     Event loop
2991
2992    ========================================================================== */
2993
2994
2995 static void
2996 ns_send_appdefined (int value)
2997 /* --------------------------------------------------------------------------
2998     Internal: post an appdefined event which EmacsApp-sendEvent will
2999               recognize and take as a command to halt the event loop.
3000    -------------------------------------------------------------------------- */
3001 {
3002   /*NSTRACE (ns_send_appdefined); */
3003
3004   /* Only post this event if we haven't already posted one.  This will end
3005        the [NXApp run] main loop after having processed all events queued at
3006        this moment.  */
3007   if (send_appdefined)
3008     {
3009       NSEvent *nxev;
3010
3011       /* We only need one NX_APPDEFINED event to stop NXApp from running.  */
3012       send_appdefined = NO;
3013
3014       /* Don't need wakeup timer any more */
3015       if (timed_entry)
3016         {
3017           [timed_entry invalidate];
3018           [timed_entry release];
3019           timed_entry = nil;
3020         }
3021
3022       /* Ditto for file descriptor poller */
3023       if (fd_entry)
3024         {
3025           [fd_entry invalidate];
3026           [fd_entry release];
3027           fd_entry = nil;
3028         }
3029
3030       nxev = [NSEvent otherEventWithType: NSApplicationDefined
3031                                 location: NSMakePoint (0, 0)
3032                            modifierFlags: 0
3033                                timestamp: 0
3034                             windowNumber: [[NSApp mainWindow] windowNumber]
3035                                  context: [NSApp context]
3036                                  subtype: 0
3037                                    data1: value
3038                                    data2: 0];
3039
3040       /* Post an application defined event on the event queue.  When this is
3041          received the [NXApp run] will return, thus having processed all
3042          events which are currently queued.  */
3043       [NSApp postEvent: nxev atStart: NO];
3044     }
3045 }
3046
3047
3048 static int
3049 ns_read_socket (struct terminal *terminal, int expected,
3050                 struct input_event *hold_quit)
3051 /* --------------------------------------------------------------------------
3052      External (hook): Post an event to ourself and keep reading events until
3053      we read it back again.  In effect process all events which were waiting.
3054      From 21+ we have to manage the event buffer ourselves.
3055    -------------------------------------------------------------------------- */
3056 {
3057   struct input_event ev;
3058   int nevents;
3059
3060 /* NSTRACE (ns_read_socket); */
3061
3062   if (interrupt_input_blocked)
3063     {
3064       interrupt_input_pending = 1;
3065 #ifdef SYNC_INPUT
3066       pending_signals = 1;
3067 #endif
3068       return -1;
3069     }
3070
3071   interrupt_input_pending = 0;
3072 #ifdef SYNC_INPUT
3073   pending_signals = pending_atimers;
3074 #endif
3075
3076   BLOCK_INPUT;
3077   n_emacs_events_pending = 0;
3078   EVENT_INIT (ev);
3079   emacs_event = &ev;
3080   q_event_ptr = hold_quit;
3081
3082   /* we manage autorelease pools by allocate/reallocate each time around
3083      the loop; strict nesting is occasionally violated but seems not to
3084      matter.. earlier methods using full nesting caused major memory leaks */
3085   [outerpool release];
3086   outerpool = [[NSAutoreleasePool alloc] init];
3087
3088   /* If have pending open-file requests, attend to the next one of those. */
3089   if (ns_pending_files && [ns_pending_files count] != 0
3090       && [(EmacsApp *)NSApp openFile: [ns_pending_files objectAtIndex: 0]])
3091     {
3092       [ns_pending_files removeObjectAtIndex: 0];
3093     }
3094   /* Deal with pending service requests. */
3095   else if (ns_pending_service_names && [ns_pending_service_names count] != 0
3096     && [(EmacsApp *)
3097          NSApp fulfillService: [ns_pending_service_names objectAtIndex: 0]
3098                       withArg: [ns_pending_service_args objectAtIndex: 0]])
3099     {
3100       [ns_pending_service_names removeObjectAtIndex: 0];
3101       [ns_pending_service_args removeObjectAtIndex: 0];
3102     }
3103   else
3104     {
3105       /* Run and wait for events.  We must always send one NX_APPDEFINED event
3106          to ourself, otherwise [NXApp run] will never exit.  */
3107       send_appdefined = YES;
3108
3109       /* If called via ns_select, this is called once with expected=1,
3110          because we expect either the timeout or file descriptor activity.
3111          In this case the first event through will either be real input or
3112          one of these.  read_avail_input() then calls once more with expected=0
3113          and in that case we need to return quickly if there is nothing.
3114          If we're being called outside of that, it's also OK to return quickly
3115          after one iteration through the event loop, since other terms do
3116          this and emacs expects it. */
3117       if (!(inNsSelect && expected))
3118         {
3119           /* Post an application defined event on the event queue.  When this is
3120              received the [NXApp run] will return, thus having processed all
3121              events which are currently queued, if any.  */
3122           ns_send_appdefined (-1);
3123         }
3124
3125       [NSApp run];
3126     }
3127
3128   nevents = n_emacs_events_pending;
3129   n_emacs_events_pending = 0;
3130   emacs_event = q_event_ptr = NULL;
3131   UNBLOCK_INPUT;
3132
3133   return nevents;
3134 }
3135
3136
3137 int
3138 ns_select (int nfds, fd_set *readfds, fd_set *writefds,
3139            fd_set *exceptfds, struct timeval *timeout)
3140 /* --------------------------------------------------------------------------
3141      Replacement for select, checking for events
3142    -------------------------------------------------------------------------- */
3143 {
3144   int result;
3145   double time;
3146   NSEvent *ev;
3147 /*  NSTRACE (ns_select); */
3148
3149   if (NSApp == nil || inNsSelect == 1 /* || ([NSApp isActive] == NO &&
3150                       [NSApp nextEventMatchingMask:NSAnyEventMask untilDate:nil
3151  inMode:NSDefaultRunLoopMode dequeue:NO] == nil) */)
3152     return select (nfds, readfds, writefds, exceptfds, timeout);
3153
3154   /* Save file descriptor set, which gets overwritten in calls to select ()
3155      Note, this is called from process.c, and only readfds is ever set */
3156   if (readfds)
3157     {
3158       memcpy (&select_readfds, readfds, sizeof (fd_set));
3159       select_nfds = nfds;
3160     }
3161   else
3162     select_nfds = 0;
3163
3164     /* Try an initial select for pending data on input files */
3165   select_timeout.tv_sec = select_timeout.tv_usec = 0;
3166   result = select (nfds, readfds, writefds, exceptfds, &select_timeout);
3167   if (result)
3168     return result;
3169
3170   /* if (!timeout || timed_entry || fd_entry)
3171        fprintf (stderr, "assertion failed: timeout null or timed_entry/fd_entry non-null in ns_select\n"); */
3172
3173     /* set a timeout and run the main AppKit event loop while continuing
3174        to monitor the files */
3175   time = ((double) timeout->tv_sec) + ((double) timeout->tv_usec)/1000000.0;
3176   timed_entry = [[NSTimer scheduledTimerWithTimeInterval: time
3177                                            target: NSApp
3178                                          selector: @selector (timeout_handler:)
3179                                          userInfo: 0
3180                                           repeats: YES] /* for safe removal */
3181                                                          retain];
3182
3183   /* set a periodic task to try the select () again */
3184   fd_entry = [[NSTimer scheduledTimerWithTimeInterval: 0.1
3185                                                target: NSApp
3186                                              selector: @selector (fd_handler:)
3187                                              userInfo: 0
3188                                               repeats: YES]
3189                retain];
3190
3191   /* Let Application dispatch events until it receives an event of the type
3192      NX_APPDEFINED, which should only be sent by timeout_handler.
3193      We tell read_avail_input() that input is "expected" because we do expect
3194      either the timeout or fd handler to fire, and if they don't, the original
3195      call from process.c that got us here expects us to wait until some input
3196      comes. */
3197   inNsSelect = 1;
3198   gobble_input (1);
3199   ev = last_appdefined_event;
3200   inNsSelect = 0;
3201
3202   if (ev)
3203     {
3204       int t;
3205       if ([ev type] != NSApplicationDefined)
3206         abort ();
3207
3208       t = [ev data1];
3209       last_appdefined_event = 0;
3210
3211       if (t == -2)
3212         {
3213           /* The NX_APPDEFINED event we received was a timeout. */
3214           return 0;
3215         }
3216       else if (t == -1)
3217         {
3218           /* The NX_APPDEFINED event we received was the result of
3219              at least one real input event arriving.  */
3220           errno = EINTR;
3221           return -1;
3222         }
3223       else
3224         {
3225           /* Received back from select () in fd_handler; copy the results */
3226           if (readfds)
3227             memcpy (readfds, &select_readfds, sizeof (fd_set));
3228           return t;
3229         }
3230     }
3231   /* never reached, shut compiler up */
3232   return 0;
3233 }
3234
3235
3236
3237 /* ==========================================================================
3238
3239     Scrollbar handling
3240
3241    ========================================================================== */
3242
3243
3244 static void
3245 ns_set_vertical_scroll_bar (struct window *window,
3246                            int portion, int whole, int position)
3247 /* --------------------------------------------------------------------------
3248       External (hook): Update or add scrollbar
3249    -------------------------------------------------------------------------- */
3250 {
3251   Lisp_Object win;
3252   NSRect r, v;
3253   struct frame *f = XFRAME (WINDOW_FRAME (window));
3254   EmacsView *view = FRAME_NS_VIEW (f);
3255   int window_y, window_height;
3256   BOOL barOnVeryLeft, barOnVeryRight;
3257   int top, left, height, width, sb_width, sb_left;
3258   EmacsScroller *bar;
3259 static int count = 0;
3260
3261   /* optimization; display engine sends WAY too many of these.. */
3262   if (!NILP (window->vertical_scroll_bar))
3263     {
3264       bar = XNS_SCROLL_BAR (window->vertical_scroll_bar);
3265       if ([bar checkSamePosition: position portion: portion whole: whole])
3266         {
3267           if (view->scrollbarsNeedingUpdate == 0)
3268             {
3269               if (!windows_or_buffers_changed)
3270                   return;
3271             }
3272           else
3273             view->scrollbarsNeedingUpdate--;
3274         }
3275     }
3276
3277   NSTRACE (ns_set_vertical_scroll_bar);
3278
3279   /* Get dimensions.  */
3280   window_box (window, -1, 0, &window_y, 0, &window_height);
3281   top = window_y;
3282   height = window_height;
3283   width = WINDOW_CONFIG_SCROLL_BAR_COLS (window) * FRAME_COLUMN_WIDTH (f);
3284   left = WINDOW_SCROLL_BAR_AREA_X (window);
3285
3286   if (top < 5) /* top scrollbar adjustment */
3287     {
3288       top -= FRAME_INTERNAL_BORDER_WIDTH (f);
3289       height += FRAME_INTERNAL_BORDER_WIDTH (f);
3290     }
3291
3292   /* allow for displaying a skinnier scrollbar than char area allotted */
3293   sb_width = (WINDOW_CONFIG_SCROLL_BAR_WIDTH (window) > 0) ?
3294     WINDOW_CONFIG_SCROLL_BAR_WIDTH (window) : width;
3295
3296   barOnVeryLeft = left < 5;
3297   barOnVeryRight = FRAME_PIXEL_WIDTH (f) - left - width < 5;
3298   sb_left = left + FRAME_INTERNAL_BORDER_WIDTH (f)
3299       * (barOnVeryLeft ? -1 : (barOnVeryRight ? 1 : 0));
3300
3301   r = NSMakeRect (sb_left, top, sb_width, height);
3302   /* the parent view is flipped, so we need to flip y value */
3303   v = [view frame];
3304   r.origin.y = (v.size.height - r.size.height - r.origin.y);
3305
3306   XSETWINDOW (win, window);
3307   BLOCK_INPUT;
3308
3309   /* we want at least 5 lines to display a scrollbar */
3310   if (WINDOW_TOTAL_LINES (window) < 5)
3311     {
3312       if (!NILP (window->vertical_scroll_bar))
3313         {
3314           bar = XNS_SCROLL_BAR (window->vertical_scroll_bar);
3315           [bar removeFromSuperview];
3316           window->vertical_scroll_bar = Qnil;
3317         }
3318       ns_clear_frame_area (f, sb_left, top, width, height);
3319       UNBLOCK_INPUT;
3320       return;
3321     }
3322
3323   if (NILP (window->vertical_scroll_bar))
3324     {
3325       ns_clear_frame_area (f, sb_left, top, width, height);
3326       bar = [[EmacsScroller alloc] initFrame: r window: win];
3327       window->vertical_scroll_bar = make_save_value (bar, 0);
3328     }
3329   else
3330     {
3331       NSRect oldRect;
3332       bar = XNS_SCROLL_BAR (window->vertical_scroll_bar);
3333       oldRect = [bar frame];
3334       r.size.width = oldRect.size.width;
3335       if (FRAME_LIVE_P (f) && !NSEqualRects (oldRect, r))
3336         {
3337           if (oldRect.origin.x != r.origin.x)
3338               ns_clear_frame_area (f, sb_left, top, width, height);
3339           [bar setFrame: r];
3340         }
3341     }
3342
3343   [bar setPosition: position portion: portion whole: whole];
3344   UNBLOCK_INPUT;
3345 }
3346
3347
3348 static void
3349 ns_condemn_scroll_bars (struct frame *f)
3350 /* --------------------------------------------------------------------------
3351      External (hook): arrange for all frame's scrollbars to be removed
3352      at next call to judge_scroll_bars, except for those redeemed.
3353    -------------------------------------------------------------------------- */
3354 {
3355   int i;
3356   id view;
3357   NSArray *subviews = [[FRAME_NS_VIEW (f) superview] subviews];
3358
3359   NSTRACE (ns_condemn_scroll_bars);
3360
3361   for (i =[subviews count]-1; i >= 0; i--)
3362     {
3363       view = [subviews objectAtIndex: i];
3364       if ([view isKindOfClass: [EmacsScroller class]])
3365         [view condemn];
3366     }
3367 }
3368
3369
3370 static void
3371 ns_redeem_scroll_bar (struct window *window)
3372 /* --------------------------------------------------------------------------
3373      External (hook): arrange to spare this window's scrollbar
3374      at next call to judge_scroll_bars.
3375    -------------------------------------------------------------------------- */
3376 {
3377   id bar;
3378   NSTRACE (ns_redeem_scroll_bar);
3379   if (!NILP (window->vertical_scroll_bar))
3380     {
3381       bar =XNS_SCROLL_BAR (window->vertical_scroll_bar);
3382       [bar reprieve];
3383     }
3384 }
3385
3386
3387 static void
3388 ns_judge_scroll_bars (struct frame *f)
3389 /* --------------------------------------------------------------------------
3390      External (hook): destroy all scrollbars on frame that weren't
3391      redeemed after call to condemn_scroll_bars.
3392    -------------------------------------------------------------------------- */
3393 {
3394   int i;
3395   id view;
3396   NSArray *subviews = [[FRAME_NS_VIEW (f) superview] subviews];
3397   NSTRACE (ns_judge_scroll_bars);
3398   for (i =[subviews count]-1; i >= 0; i--)
3399     {
3400       view = [subviews objectAtIndex: i];
3401       if (![view isKindOfClass: [EmacsScroller class]]) continue;
3402       [view judge];
3403     }
3404 }
3405
3406
3407 void
3408 x_wm_set_icon_position (struct frame *f, int icon_x, int icon_y)
3409 {
3410   /* XXX irrelevant under NS */
3411 }
3412
3413
3414
3415 /* ==========================================================================
3416
3417     Initialization
3418
3419    ========================================================================== */
3420
3421 int
3422 x_display_pixel_height (dpyinfo)
3423      struct ns_display_info *dpyinfo;
3424 {
3425   NSScreen *screen = [NSScreen mainScreen];
3426   return [screen frame].size.height;
3427 }
3428
3429 int
3430 x_display_pixel_width (dpyinfo)
3431      struct ns_display_info *dpyinfo;
3432 {
3433   NSScreen *screen = [NSScreen mainScreen];
3434   return [screen frame].size.width;
3435 }
3436
3437
3438 static Lisp_Object ns_string_to_lispmod (const char *s)
3439 /* --------------------------------------------------------------------------
3440      Convert modifier name to lisp symbol
3441    -------------------------------------------------------------------------- */
3442 {
3443   if (!strncmp (SDATA (SYMBOL_NAME (Qmeta)), s, 10))
3444     return Qmeta;
3445   else if (!strncmp (SDATA (SYMBOL_NAME (Qsuper)), s, 10))
3446     return Qsuper;
3447   else if (!strncmp (SDATA (SYMBOL_NAME (Qcontrol)), s, 10))
3448     return Qcontrol;
3449   else if (!strncmp (SDATA (SYMBOL_NAME (Qalt)), s, 10))
3450     return Qalt;
3451   else if (!strncmp (SDATA (SYMBOL_NAME (Qhyper)), s, 10))
3452     return Qhyper;
3453   else if (!strncmp (SDATA (SYMBOL_NAME (Qnone)), s, 10))
3454     return Qnone;
3455   else
3456     return Qnil;
3457 }
3458
3459
3460 static Lisp_Object ns_mod_to_lisp (int m)
3461 /* --------------------------------------------------------------------------
3462      Convert modifier code (see lisp.h) to lisp symbol
3463    -------------------------------------------------------------------------- */
3464 {
3465   if (m == CHAR_META)
3466     return Qmeta;
3467   else if (m == CHAR_SUPER)
3468     return Qsuper;
3469   else if (m == CHAR_CTL)
3470     return Qcontrol;
3471   else if (m == CHAR_ALT)
3472     return Qalt;
3473   else if (m == CHAR_HYPER)
3474     return Qhyper;
3475   else /* if (m == 0) */
3476     return Qnone;
3477 }
3478
3479
3480 static void
3481 ns_default (const char *parameter, Lisp_Object *result,
3482            Lisp_Object yesval, Lisp_Object noval,
3483            BOOL is_float, BOOL is_modstring)
3484 /* --------------------------------------------------------------------------
3485       Check a parameter value in user's preferences
3486    -------------------------------------------------------------------------- */
3487 {
3488   const char *value;
3489
3490   if ( (value =[[[NSUserDefaults standardUserDefaults]
3491                    stringForKey: [NSString stringWithUTF8String: parameter]]
3492                 UTF8String]) )
3493     {
3494       double f;
3495       char *pos;
3496       if (strcasecmp (value, "YES") == 0)
3497         *result = yesval;
3498       else if (strcasecmp (value, "NO") == 0)
3499         *result = noval;
3500       else if (is_float && (f = strtod (value, &pos), pos != value))
3501         *result = make_float (f);
3502       else if (is_modstring && value)
3503         *result = ns_string_to_lispmod (value);
3504       else fprintf (stderr,
3505                    "Bad value for default \"%s\": \"%s\"\n", parameter, value);
3506     }
3507 }
3508
3509
3510 void
3511 ns_initialize_display_info (struct ns_display_info *dpyinfo)
3512 /* --------------------------------------------------------------------------
3513       Initialize global info and storage for display.
3514    -------------------------------------------------------------------------- */
3515 {
3516     NSScreen *screen = [NSScreen mainScreen];
3517     NSWindowDepth depth = [screen depth];
3518
3519     dpyinfo->resx = 72.27; /* used 75.0, but this makes pt == pixel, expected */
3520     dpyinfo->resy = 72.27;
3521     dpyinfo->color_p = ![NSDeviceWhiteColorSpace isEqualToString:
3522                                                   NSColorSpaceFromDepth (depth)]
3523                 && ![NSCalibratedWhiteColorSpace isEqualToString:
3524                                                  NSColorSpaceFromDepth (depth)];
3525     dpyinfo->n_planes = NSBitsPerPixelFromDepth (depth);
3526     dpyinfo->image_cache = make_image_cache ();
3527     dpyinfo->color_table
3528       = (struct ns_color_table *)xmalloc (sizeof (struct ns_color_table));
3529     dpyinfo->color_table->colors = NULL;
3530     dpyinfo->root_window = 42; /* a placeholder.. */
3531
3532     dpyinfo->mouse_face_mouse_frame = NULL;
3533     dpyinfo->mouse_face_deferred_gc = 0;
3534     dpyinfo->mouse_face_beg_row = dpyinfo->mouse_face_beg_col = -1;
3535     dpyinfo->mouse_face_end_row = dpyinfo->mouse_face_end_col = -1;
3536     dpyinfo->mouse_face_face_id = DEFAULT_FACE_ID;
3537     dpyinfo->mouse_face_window = dpyinfo->mouse_face_overlay = Qnil;
3538     dpyinfo->mouse_face_hidden = 0;
3539
3540     dpyinfo->mouse_face_mouse_x = dpyinfo->mouse_face_mouse_y = 0;
3541     dpyinfo->mouse_face_defer = 0;
3542
3543     dpyinfo->x_highlight_frame = dpyinfo->x_focus_frame = NULL;
3544
3545     dpyinfo->n_fonts = 0;
3546     dpyinfo->smallest_font_height = 1;
3547     dpyinfo->smallest_char_width = 1;
3548 }
3549
3550
3551 /* This and next define (many of the) public functions in this file. */
3552 /* x_... are generic versions in xdisp.c that we, and other terms, get away
3553          with using despite presence in the "system dependent" redisplay
3554          interface.  In addition, many of the ns_ methods have code that is
3555          shared with all terms, indicating need for further refactoring. */
3556 extern frame_parm_handler ns_frame_parm_handlers[];
3557 static struct redisplay_interface ns_redisplay_interface =
3558 {
3559   ns_frame_parm_handlers,
3560   x_produce_glyphs,
3561   x_write_glyphs,
3562   x_insert_glyphs,
3563   x_clear_end_of_line,
3564   ns_scroll_run,
3565   ns_after_update_window_line,
3566   ns_update_window_begin,
3567   ns_update_window_end,
3568   x_cursor_to,
3569   ns_flush,
3570   0, /* flush_display_optional */
3571   x_clear_window_mouse_face,
3572   x_get_glyph_overhangs,
3573   x_fix_overlapping_area,
3574   ns_draw_fringe_bitmap,
3575   0, /* define_fringe_bitmap */ /* FIXME: simplify ns_draw_fringe_bitmap */
3576   0, /* destroy_fringe_bitmap */
3577   ns_compute_glyph_string_overhangs,
3578   ns_draw_glyph_string, /* interface to nsfont.m */
3579   ns_define_frame_cursor,
3580   ns_clear_frame_area,
3581   ns_draw_window_cursor,
3582   ns_draw_vertical_window_border,
3583   ns_shift_glyphs_for_insert
3584 };
3585
3586
3587 static void
3588 ns_delete_display (struct ns_display_info *dpyinfo)
3589 {
3590   /* TODO... */
3591 }
3592
3593
3594 /* This function is called when the last frame on a display is deleted. */
3595 static void
3596 ns_delete_terminal (struct terminal *terminal)
3597 {
3598   struct ns_display_info *dpyinfo = terminal->display_info.ns;
3599   int i;
3600
3601   /* Protect against recursive calls.  delete_frame in
3602      delete_terminal calls us back when it deletes our last frame.  */
3603   if (!terminal->name)
3604     return;
3605
3606   BLOCK_INPUT;
3607
3608   x_destroy_all_bitmaps (dpyinfo);
3609   ns_delete_display (dpyinfo);
3610   UNBLOCK_INPUT;
3611 }
3612
3613
3614 static struct terminal *
3615 ns_create_terminal (struct ns_display_info *dpyinfo)
3616 /* --------------------------------------------------------------------------
3617       Set up use of NS before we make the first connection.
3618    -------------------------------------------------------------------------- */
3619 {
3620   struct terminal *terminal;
3621
3622   NSTRACE (ns_create_terminal);
3623
3624   terminal = create_terminal ();
3625
3626   terminal->type = output_ns;
3627   terminal->display_info.ns = dpyinfo;
3628   dpyinfo->terminal = terminal;
3629
3630   terminal->rif = &ns_redisplay_interface;
3631
3632   terminal->clear_frame_hook = ns_clear_frame;
3633   terminal->ins_del_lines_hook = 0; /* XXX vestigial? */
3634   terminal->delete_glyphs_hook = 0; /* XXX vestigial? */
3635   terminal->ring_bell_hook = ns_ring_bell;
3636   terminal->reset_terminal_modes_hook = ns_reset_terminal_modes;
3637   terminal->set_terminal_modes_hook = ns_set_terminal_modes;
3638   terminal->update_begin_hook = ns_update_begin;
3639   terminal->update_end_hook = ns_update_end;
3640   terminal->set_terminal_window_hook = NULL; /* XXX vestigial? */
3641   terminal->read_socket_hook = ns_read_socket;
3642   terminal->frame_up_to_date_hook = ns_frame_up_to_date;
3643   terminal->mouse_position_hook = ns_mouse_position;
3644   terminal->frame_rehighlight_hook = ns_frame_rehighlight;
3645   terminal->frame_raise_lower_hook = ns_frame_raise_lower;
3646
3647   terminal->fullscreen_hook = 0; /* see XTfullscreen_hook */
3648
3649   terminal->set_vertical_scroll_bar_hook = ns_set_vertical_scroll_bar;
3650   terminal->condemn_scroll_bars_hook = ns_condemn_scroll_bars;
3651   terminal->redeem_scroll_bar_hook = ns_redeem_scroll_bar;
3652   terminal->judge_scroll_bars_hook = ns_judge_scroll_bars;
3653
3654   terminal->delete_frame_hook = x_destroy_window;
3655   terminal->delete_terminal_hook = ns_delete_terminal;
3656
3657   terminal->scroll_region_ok = 1;
3658   terminal->char_ins_del_ok = 1;
3659   terminal->line_ins_del_ok = 1;
3660   terminal->fast_clear_end_of_line = 1;
3661   terminal->memory_below_frame = 0;
3662
3663   return terminal;
3664 }
3665
3666
3667 struct ns_display_info *
3668 ns_term_init (Lisp_Object display_name)
3669 /* --------------------------------------------------------------------------
3670      Start the Application and get things rolling.
3671    -------------------------------------------------------------------------- */
3672 {
3673   struct terminal *terminal;
3674   struct ns_display_info *dpyinfo;
3675   static int ns_initialized = 0;
3676   Lisp_Object tmp;
3677
3678   NSTRACE (ns_term_init);
3679
3680   /* count object allocs (About, click icon); on OS X use ObjectAlloc tool */
3681   /*GSDebugAllocationActive (YES); */
3682   BLOCK_INPUT;
3683   handling_signal = 0;
3684
3685   if (!ns_initialized)
3686     {
3687       baud_rate = 38400;
3688       Fset_input_interrupt_mode (Qnil);
3689       ns_initialized = 1;
3690     }
3691
3692   ns_pending_files = [[NSMutableArray alloc] init];
3693   ns_pending_service_names = [[NSMutableArray alloc] init];
3694   ns_pending_service_args = [[NSMutableArray alloc] init];
3695
3696   /* Start app and create the main menu, window, view.
3697      Needs to be here because ns_initialize_display_info () uses AppKit classes.
3698      The view will then ask the NSApp to stop and return to Emacs. */
3699   [EmacsApp sharedApplication];
3700   if (NSApp == nil)
3701     return NULL;
3702   [NSApp setDelegate: NSApp];
3703
3704   /* debugging: log all notifications */
3705   /*   [[NSNotificationCenter defaultCenter] addObserver: NSApp
3706                                          selector: @selector (logNotification:)
3707                                              name: nil object: nil]; */
3708
3709   dpyinfo = (struct ns_display_info *)xmalloc (sizeof (struct ns_display_info));
3710   bzero (dpyinfo, sizeof (struct ns_display_info));
3711
3712   ns_initialize_display_info (dpyinfo);
3713   terminal = ns_create_terminal (dpyinfo);
3714
3715   terminal->kboard = (KBOARD *) xmalloc (sizeof (KBOARD));
3716   init_kboard (terminal->kboard);
3717   terminal->kboard->Vwindow_system = Qns;
3718   terminal->kboard->next_kboard = all_kboards;
3719   all_kboards = terminal->kboard;
3720   /* Don't let the initial kboard remain current longer than necessary.
3721      That would cause problems if a file loaded on startup tries to
3722      prompt in the mini-buffer.  */
3723   if (current_kboard == initial_kboard)
3724     current_kboard = terminal->kboard;
3725   terminal->kboard->reference_count++;
3726
3727   dpyinfo->next = x_display_list;
3728   x_display_list = dpyinfo;
3729
3730   /* Put it on ns_display_name_list */
3731   ns_display_name_list = Fcons (Fcons (display_name, Qnil),
3732                                 ns_display_name_list);
3733   dpyinfo->name_list_element = XCAR (ns_display_name_list);
3734
3735   /* Set the name of the terminal. */
3736   terminal->name = (char *) xmalloc (SBYTES (display_name) + 1);
3737   strncpy (terminal->name, SDATA (display_name), SBYTES (display_name));
3738   terminal->name[SBYTES (display_name)] = 0;
3739
3740   UNBLOCK_INPUT;
3741
3742   if (!inhibit_x_resources)
3743     {
3744       ns_default ("GSFontAntiAlias", &ns_antialias_text,
3745                  Qt, Qnil, NO, NO);
3746       tmp = Qnil;
3747       /* this is a standard variable */
3748       ns_default ("AppleAntiAliasingThreshold", &tmp,
3749                  make_float (10.0), make_float (6.0), YES, NO);
3750       ns_antialias_threshold = NILP (tmp) ? 10.0 : XFLOATINT (tmp);
3751     }
3752
3753   ns_selection_color = [[NSUserDefaults standardUserDefaults]
3754                          stringForKey: @"AppleHighlightColor"];
3755   if (ns_selection_color == nil)
3756     ns_selection_color = NS_SELECTION_COLOR_DEFAULT;
3757
3758   {
3759     NSColorList *cl = [NSColorList colorListNamed: @"Emacs"];
3760
3761     if ( cl == nil )
3762       {
3763         Lisp_Object color_file, color_map, color;
3764         int r,g,b;
3765         unsigned long c;
3766         char *name;
3767
3768         color_file = Fexpand_file_name (build_string ("rgb.txt"),
3769                          Fsymbol_value (intern ("data-directory")));
3770         if (NILP (Ffile_readable_p (color_file)))
3771           fatal ("Could not find %s.\n", SDATA (color_file));
3772
3773         color_map = Fx_load_color_file (color_file);
3774         if (NILP (color_map))
3775           fatal ("Could not read %s.\n", SDATA (color_file));
3776
3777         cl = [[NSColorList alloc] initWithName: @"Emacs"];
3778         for ( ; CONSP (color_map); color_map = XCDR (color_map))
3779           {
3780             color = XCAR (color_map);
3781             name = SDATA (XCAR (color));
3782             c = XINT (XCDR (color));
3783             [cl setColor:
3784                   [NSColor colorWithCalibratedRed: RED_FROM_ULONG (c) / 255.0
3785                                             green: GREEN_FROM_ULONG (c) / 255.0
3786                                              blue: BLUE_FROM_ULONG (c) / 255.0
3787                                             alpha: 1.0]
3788                   forKey: [NSString stringWithUTF8String: name]];
3789           }
3790         [cl writeToFile: nil];
3791       }
3792   }
3793
3794   {
3795     char c[128];
3796 #ifdef NS_IMPL_GNUSTEP
3797     strncpy (c, gnustep_base_version, sizeof (c));
3798 #else
3799     /*PSnextrelease (128, c); */
3800     snprintf (c, sizeof (c), "%g", NSAppKitVersionNumber);
3801 #endif
3802     Vwindow_system_version = build_string (c);
3803   }
3804
3805   delete_keyboard_wait_descriptor (0);
3806
3807   ns_app_name = [[NSProcessInfo processInfo] processName];
3808
3809 /* Set up OS X app menu */
3810 #ifdef NS_IMPL_COCOA
3811   {
3812     NSMenu *appMenu;
3813     NSMenuItem *item;
3814     /* set up the application menu */
3815     svcsMenu = [[EmacsMenu alloc] initWithTitle: @"Services"];
3816     [svcsMenu setAutoenablesItems: NO];
3817     appMenu = [[EmacsMenu alloc] initWithTitle: @"Emacs"];
3818     [appMenu setAutoenablesItems: NO];
3819     mainMenu = [[EmacsMenu alloc] initWithTitle: @""];
3820     dockMenu = [[EmacsMenu alloc] initWithTitle: @""];
3821
3822     [appMenu insertItemWithTitle: @"About Emacs"
3823                           action: @selector (orderFrontStandardAboutPanel:)
3824                    keyEquivalent: @""
3825                          atIndex: 0];
3826     [appMenu insertItem: [NSMenuItem separatorItem] atIndex: 1];
3827     [appMenu insertItemWithTitle: @"Preferences..."
3828                           action: @selector (showPreferencesWindow:)
3829                    keyEquivalent: @","
3830                          atIndex: 2];
3831     [appMenu insertItem: [NSMenuItem separatorItem] atIndex: 3];
3832     item = [appMenu insertItemWithTitle: @"Services"
3833                                  action: @selector (menuDown:)
3834                           keyEquivalent: @""
3835                                 atIndex: 4];
3836     [appMenu setSubmenu: svcsMenu forItem: item];
3837     [appMenu insertItem: [NSMenuItem separatorItem] atIndex: 5];
3838     [appMenu insertItemWithTitle: @"Hide Emacs"
3839                           action: @selector (hide:)
3840                    keyEquivalent: @"h"
3841                          atIndex: 6];
3842     item =  [appMenu insertItemWithTitle: @"Hide Others"
3843                           action: @selector (hideOtherApplications:)
3844                    keyEquivalent: @"h"
3845                          atIndex: 7];
3846     [item setKeyEquivalentModifierMask: NSCommandKeyMask | NSAlternateKeyMask];
3847     [appMenu insertItem: [NSMenuItem separatorItem] atIndex: 8];
3848     [appMenu insertItemWithTitle: @"Quit Emacs"
3849                           action: @selector (terminate:)
3850                    keyEquivalent: @"q"
3851                          atIndex: 9];
3852
3853     item = [mainMenu insertItemWithTitle: ns_app_name
3854                                   action: @selector (menuDown:)
3855                            keyEquivalent: @""
3856                                  atIndex: 0];
3857     [mainMenu setSubmenu: appMenu forItem: item];
3858     [dockMenu insertItemWithTitle: @"New Frame"
3859                            action: @selector (newFrame:)
3860                     keyEquivalent: @""
3861                           atIndex: 0];
3862
3863     [NSApp setMainMenu: mainMenu];
3864     [NSApp setAppleMenu: appMenu];
3865     [NSApp setServicesMenu: svcsMenu];
3866     /* Needed at least on Cocoa, to get dock menu to show windows */
3867     [NSApp setWindowsMenu: [[NSMenu alloc] init]];
3868   }
3869 #endif /* MAC OS X menu setup */
3870
3871   [NSApp run];
3872
3873   return dpyinfo;
3874 }
3875
3876
3877 extern Lisp_Object Vauto_save_list_file_name;
3878 void
3879 ns_term_shutdown (int sig)
3880 {
3881   /* code not reached in emacs.c after this is called by shut_down_emacs: */
3882   if (STRINGP (Vauto_save_list_file_name))
3883     unlink (SDATA (Vauto_save_list_file_name));
3884
3885   if (sig == 0 || sig == SIGTERM)
3886     {
3887       [NSApp terminate: NSApp];
3888     }
3889   else // force a stack trace to happen
3890     {
3891       abort();
3892     }
3893 }
3894
3895
3896 /* ==========================================================================
3897
3898     EmacsApp implementation
3899
3900    ========================================================================== */
3901
3902
3903 @implementation EmacsApp
3904
3905 - (void)logNotification: (NSNotification *)notification
3906 {
3907   const char *name = [[notification name] UTF8String];
3908   if (!strstr (name, "Update") && !strstr (name, "NSMenu")
3909       && !strstr (name, "WindowNumber"))
3910     NSLog (@"notification: '%@'", [notification name]);
3911 }
3912
3913
3914 - (void)sendEvent: (NSEvent *)theEvent
3915 /* --------------------------------------------------------------------------
3916      Called when NSApp is running for each event received.  Used to stop
3917      the loop when we choose, since there's no way to just run one iteration.
3918    -------------------------------------------------------------------------- */
3919 {
3920   int type = [theEvent type];
3921   NSWindow *window = [theEvent window];
3922 /*  NSTRACE (sendEvent); */
3923 /*fprintf (stderr, "received event of type %d\t%d\n", type);*/
3924
3925   if (type == NSCursorUpdate && window == nil)
3926     {
3927       fprintf (stderr, "Dropping external cursor update event.\n");
3928       return;
3929     }
3930
3931 #ifdef NS_IMPL_COCOA
3932   /* pass mouse down in resize handle and subsequent drags directly to
3933      EmacsWindow so we can generate continuous redisplays */
3934   if (ns_in_resize)
3935     {
3936       if (type == NSLeftMouseDragged)
3937         {
3938           [window mouseDragged: theEvent];
3939           return;
3940         }
3941       else if (type == NSLeftMouseUp)
3942         {
3943           [window mouseUp: theEvent];
3944           return;
3945         }
3946     }
3947   else if (type == NSLeftMouseDown)
3948     {
3949       NSRect r = ns_resize_handle_rect (window);
3950       if (NSPointInRect ([theEvent locationInWindow], r))
3951         {
3952           ns_in_resize = YES;
3953           [window mouseDown: theEvent];
3954           return;
3955         }
3956     }
3957 #endif
3958
3959   if (type == NSApplicationDefined)
3960     {
3961       /* Events posted by ns_send_appdefined interrupt the run loop here.
3962          But, if a modal window is up, an appdefined can still come through,
3963          (e.g., from a makeKeyWindow event) but stopping self also stops the
3964          modal loop. Just defer it until later. */
3965       if ([NSApp modalWindow] == nil)
3966         {
3967           last_appdefined_event = theEvent;
3968           [self stop: self];
3969         }
3970       else
3971         {
3972           send_appdefined = YES;
3973         }
3974     }
3975
3976   [super sendEvent: theEvent];
3977 }
3978
3979
3980 - (void)showPreferencesWindow: (id)sender
3981 {
3982   struct frame *emacsframe = SELECTED_FRAME ();
3983   NSEvent *theEvent = [NSApp currentEvent];
3984
3985   if (!emacs_event)
3986     return;
3987   emacs_event->kind = NS_NONKEY_EVENT;
3988   emacs_event->code = KEY_NS_SHOW_PREFS;
3989   emacs_event->modifiers = 0;
3990   EV_TRAILER (theEvent);
3991 }
3992
3993
3994 - (void)newFrame: (id)sender
3995 {
3996   struct frame *emacsframe = SELECTED_FRAME ();
3997   NSEvent *theEvent = [NSApp currentEvent];
3998
3999   if (!emacs_event)
4000     return;
4001   emacs_event->kind = NS_NONKEY_EVENT;
4002   emacs_event->code = KEY_NS_NEW_FRAME;
4003   emacs_event->modifiers = 0;
4004   EV_TRAILER (theEvent);
4005 }
4006
4007
4008 /* Open a file (used by below, after going into queue read by ns_read_socket) */
4009 - (BOOL) openFile: (NSString *)fileName
4010 {
4011   struct frame *emacsframe = SELECTED_FRAME ();
4012   NSEvent *theEvent = [NSApp currentEvent];
4013
4014   if (!emacs_event)
4015     return NO;
4016
4017   emacs_event->kind = NS_NONKEY_EVENT;
4018   emacs_event->code = KEY_NS_OPEN_FILE_LINE;
4019   ns_input_file = append2 (ns_input_file, build_string ([fileName UTF8String]));
4020   ns_input_line = Qnil; /* can be start or cons start,end */
4021   emacs_event->modifiers =0;
4022   EV_TRAILER (theEvent);
4023
4024   return YES;
4025 }
4026
4027
4028 /* **************************************************************************
4029
4030       EmacsApp delegate implementation
4031
4032    ************************************************************************** */
4033
4034 - (void)applicationDidFinishLaunching: (NSNotification *)notification
4035 /* --------------------------------------------------------------------------
4036      When application is loaded, terminate event loop in ns_term_init
4037    -------------------------------------------------------------------------- */
4038 {
4039   NSTRACE (applicationDidFinishLaunching);
4040   [NSApp setServicesProvider: NSApp];
4041   ns_send_appdefined (-2);
4042 }
4043
4044
4045 /* Termination sequences:
4046     C-x C-c:
4047     Cmd-Q:
4048     MenuBar | File | Exit:
4049     Select Quit from App menubar:
4050         -terminate
4051         KEY_NS_POWER_OFF, (save-buffers-kill-emacs)
4052         ns_term_shutdown()
4053
4054     Select Quit from Dock menu:
4055     Logout attempt:
4056         -appShouldTerminate
4057           Cancel -> Nothing else
4058           Accept ->
4059
4060           -terminate
4061           KEY_NS_POWER_OFF, (save-buffers-kill-emacs)
4062           ns_term_shutdown()
4063
4064 */
4065
4066 - (void) terminate: (id)sender
4067 {
4068   struct frame *emacsframe = SELECTED_FRAME ();
4069
4070   if (!emacs_event)
4071     return;
4072
4073   emacs_event->kind = NS_NONKEY_EVENT;
4074   emacs_event->code = KEY_NS_POWER_OFF;
4075   emacs_event->arg = Qt; /* mark as non-key event */
4076   EV_TRAILER ((id)nil);
4077 }
4078
4079
4080 - (NSApplicationTerminateReply)applicationShouldTerminate: (id)sender
4081 {
4082   int ret;
4083
4084   if (NILP (ns_confirm_quit)) //   || ns_shutdown_properly  --> TO DO
4085     return NSTerminateNow;
4086
4087     ret = NSRunAlertPanel(ns_app_name,
4088                           [NSString stringWithUTF8String:"Exit requested.  Would you like to Save Buffers and Exit, or Cancel the request?"],
4089                           @"Save Buffers and Exit", @"Cancel", nil);
4090
4091     if (ret == NSAlertDefaultReturn)
4092         return NSTerminateNow;
4093     else if (ret == NSAlertAlternateReturn)
4094         return NSTerminateCancel;
4095     return NSTerminateNow;  /* just in case */
4096 }
4097
4098
4099 /*   Notification from the Workspace to open a file */
4100 - (BOOL)application: sender openFile: (NSString *)file
4101 {
4102   [ns_pending_files addObject: file];
4103   return YES;
4104 }
4105
4106
4107 /*   Open a file as a temporary file */
4108 - (BOOL)application: sender openTempFile: (NSString *)file
4109 {
4110   [ns_pending_files addObject: file];
4111   return YES;
4112 }
4113
4114
4115 /*   Notification from the Workspace to open a file noninteractively (?) */
4116 - (BOOL)application: sender openFileWithoutUI: (NSString *)file
4117 {
4118   [ns_pending_files addObject: file];
4119   return YES;
4120 }
4121
4122
4123 /*   Notification from the Workspace to open multiple files */
4124 - (void)application: sender openFiles: (NSArray *)fileList
4125 {
4126   NSEnumerator *files = [fileList objectEnumerator];
4127   NSString *file;
4128   while ((file = [files nextObject]) != nil)
4129     [ns_pending_files addObject: file];
4130
4131   [self replyToOpenOrPrint: NSApplicationDelegateReplySuccess];
4132
4133 }
4134
4135
4136 /* Handle dock menu requests.  */
4137 - (NSMenu *)applicationDockMenu: (NSApplication *) sender
4138 {
4139   return dockMenu;
4140 }
4141
4142
4143 /* TODO: these may help w/IO switching btwn terminal and NSApp */
4144 - (void)applicationWillBecomeActive: (NSNotification *)notification
4145 {
4146   //ns_app_active=YES;
4147 }
4148 - (void)applicationDidBecomeActive: (NSNotification *)notification
4149 {
4150   //ns_app_active=YES;
4151 }
4152 - (void)applicationDidResignActive: (NSNotification *)notification
4153 {
4154   //ns_app_active=NO;
4155   ns_send_appdefined (-1);
4156 }
4157
4158
4159
4160 /* ==========================================================================
4161
4162     EmacsApp aux handlers for managing event loop
4163
4164    ========================================================================== */
4165
4166
4167 - (void)timeout_handler: (NSTimer *)timedEntry
4168 /* --------------------------------------------------------------------------
4169      The timeout specified to ns_select has passed.
4170    -------------------------------------------------------------------------- */
4171 {
4172   /*NSTRACE (timeout_handler); */
4173   ns_send_appdefined (-2);
4174 }
4175
4176 extern void update_window_cursor (struct window *w, int on);
4177
4178 - (void)fd_handler: (NSTimer *) fdEntry
4179 /* --------------------------------------------------------------------------
4180      Check data waiting on file descriptors and terminate if so
4181    -------------------------------------------------------------------------- */
4182 {
4183   int result;
4184   /* NSTRACE (fd_handler); */
4185
4186   if (select_nfds == 0)
4187     return;
4188
4189   memcpy (&t_readfds, &select_readfds, sizeof (fd_set));
4190
4191   select_timeout.tv_sec = select_timeout.tv_usec = 0;
4192   result = select (select_nfds, &t_readfds, (SELECT_TYPE *)0, (SELECT_TYPE *)0,
4193                   &select_timeout);
4194   if (result)
4195     {
4196       memcpy (&select_readfds, &t_readfds, sizeof (fd_set));
4197       ns_send_appdefined (result);
4198     }
4199 }
4200
4201
4202
4203 /* ==========================================================================
4204
4205     Service provision
4206
4207    ========================================================================== */
4208
4209 /* called from system: queue for next pass through event loop */
4210 - (void)requestService: (NSPasteboard *)pboard
4211               userData: (NSString *)userData
4212                  error: (NSString **)error
4213 {
4214   [ns_pending_service_names addObject: userData];
4215   [ns_pending_service_args addObject: [NSString stringWithUTF8String:
4216       SDATA (ns_string_from_pasteboard (pboard))]];
4217 }
4218
4219
4220 /* called from ns_read_socket to clear queue */
4221 - (BOOL)fulfillService: (NSString *)name withArg: (NSString *)arg
4222 {
4223   struct frame *emacsframe = SELECTED_FRAME ();
4224   NSEvent *theEvent = [NSApp currentEvent];
4225
4226   if (!emacs_event)
4227     return NO;
4228
4229   emacs_event->kind = NS_NONKEY_EVENT;
4230   emacs_event->code = KEY_NS_SPI_SERVICE_CALL;
4231   ns_input_spi_name = build_string ([name UTF8String]);
4232   ns_input_spi_arg = build_string ([arg UTF8String]);
4233   emacs_event->modifiers = EV_MODIFIERS (theEvent);
4234   EV_TRAILER (theEvent);
4235
4236   return YES;
4237 }
4238
4239
4240 @end  /* EmacsApp */
4241
4242
4243
4244 /* ==========================================================================
4245
4246     EmacsView implementation
4247
4248    ========================================================================== */
4249
4250
4251 @implementation EmacsView
4252
4253 /* needed to inform when window closed from LISP */
4254 - (void) setWindowClosing: (BOOL)closing
4255 {
4256   windowClosing = closing;
4257 }
4258
4259
4260 - (void)dealloc
4261 {
4262   NSTRACE (EmacsView_dealloc);
4263   [toolbar release];
4264   [super dealloc];
4265 }
4266
4267
4268 /* called on font panel selection */
4269 - (void)changeFont: (id)sender
4270 {
4271   NSEvent *e =[[self window] currentEvent];
4272   struct face *face =FRAME_DEFAULT_FACE (emacsframe);
4273   id newFont;
4274   float size;
4275
4276   NSTRACE (changeFont);
4277   if (!emacs_event)
4278     return;
4279
4280   if (newFont = [sender convertFont:
4281                            ((struct nsfont_info *)face->font)->nsfont])
4282     {
4283       SET_FRAME_GARBAGED (emacsframe); /* now needed as of 2008/10 */
4284
4285       emacs_event->kind = NS_NONKEY_EVENT;
4286       emacs_event->modifiers = 0;
4287       emacs_event->code = KEY_NS_CHANGE_FONT;
4288
4289       size = [newFont pointSize];
4290       ns_input_fontsize = make_number (lrint (size));
4291       ns_input_font = build_string ([[newFont familyName] UTF8String]);
4292       EV_TRAILER (e);
4293     }
4294 }
4295
4296
4297 - (BOOL)acceptsFirstResponder
4298 {
4299   NSTRACE (acceptsFirstResponder);
4300   return YES;
4301 }
4302
4303
4304 - (void)resetCursorRects
4305 {
4306   NSRect visible = [self visibleRect];
4307   NSCursor *currentCursor = FRAME_POINTER_TYPE (emacsframe);
4308   NSTRACE (resetCursorRects);
4309
4310   if (currentCursor == nil)
4311     currentCursor = [NSCursor arrowCursor];
4312
4313   if (!NSIsEmptyRect (visible))
4314     [self addCursorRect: visible cursor: currentCursor];
4315   [currentCursor setOnMouseEntered: YES];
4316 }
4317
4318
4319
4320 /*****************************************************************************/
4321 /* Keyboard handling. */
4322 #define NS_KEYLOG 0
4323
4324 - (void)keyDown: (NSEvent *)theEvent
4325 {
4326   struct ns_display_info *dpyinfo = FRAME_NS_DISPLAY_INFO (emacsframe);
4327   int code;
4328   unsigned fnKeysym = 0;
4329   int flags;
4330   static NSMutableArray *nsEvArray;
4331   static BOOL firstTime = YES;
4332
4333   NSTRACE (keyDown);
4334
4335   /* Rhapsody and OS X give up and down events for the arrow keys */
4336   if (ns_fake_keydown == YES)
4337     ns_fake_keydown = NO;
4338   else if ([theEvent type] != NSKeyDown)
4339     return;
4340
4341   if (!emacs_event)
4342     return;
4343
4344  if (![[self window] isKeyWindow]
4345      && [[theEvent window] isKindOfClass: [EmacsWindow class]]
4346      /* we must avoid an infinite loop here. */
4347      && (EmacsView *)[[theEvent window] delegate] != self)
4348    {
4349      /* XXX: There is an occasional condition in which, when Emacs display
4350          updates a different frame from the current one, and temporarily
4351          selects it, then processes some interrupt-driven input
4352          (dispnew.c:3878), OS will send the event to the correct NSWindow, but
4353          for some reason that window has its first responder set to the NSView
4354          most recently updated (I guess), which is not the correct one. */
4355      [(EmacsView *)[[theEvent window] delegate] keyDown: theEvent];
4356      return;
4357    }
4358
4359   if (nsEvArray == nil)
4360     nsEvArray = [[NSMutableArray alloc] initWithCapacity: 1];
4361
4362   [NSCursor setHiddenUntilMouseMoves: YES];
4363
4364   if (dpyinfo->mouse_face_hidden && INTEGERP (Vmouse_highlight))
4365     {
4366       clear_mouse_face (dpyinfo);
4367       dpyinfo->mouse_face_hidden = 1;
4368     }
4369
4370   if (!processingCompose)
4371     {
4372       code = ([[theEvent charactersIgnoringModifiers] length] == 0) ?
4373         0 : [[theEvent charactersIgnoringModifiers] characterAtIndex: 0];
4374       /* (Carbon way: [theEvent keyCode]) */
4375
4376       /* is it a "function key"? */
4377       fnKeysym = ns_convert_key (code);
4378       if (fnKeysym)
4379         {
4380           /* COUNTERHACK: map 'Delete' on upper-right main KB to 'Backspace',
4381              because Emacs treats Delete and KP-Delete same (in simple.el). */
4382           if (fnKeysym == 0xFFFF && [theEvent keyCode] == 0x33)
4383             code = 0xFF08; /* backspace */
4384           else
4385             code = fnKeysym;
4386         }
4387
4388       /* are there modifiers? */
4389       emacs_event->modifiers = 0;
4390       flags = [theEvent modifierFlags];
4391
4392       if (flags & NSHelpKeyMask)
4393           emacs_event->modifiers |= hyper_modifier;
4394
4395       if (flags & NSShiftKeyMask)
4396         emacs_event->modifiers |= shift_modifier;
4397
4398       if (flags & NSCommandKeyMask)
4399         {
4400           emacs_event->modifiers |= parse_solitary_modifier (ns_command_modifier);
4401           /* if super (default), take input manager's word so things like
4402              dvorak / qwerty layout work */
4403           if (EQ (ns_command_modifier, Qsuper)
4404               && !fnKeysym
4405               && [[theEvent characters] length] != 0)
4406             {
4407               /* XXX: the code we get will be unshifted, so if we have
4408                  a shift modifier, must convert ourselves */
4409               if (!(flags & NSShiftKeyMask))
4410                 code = [[theEvent characters] characterAtIndex: 0];
4411 #if 0
4412               /* this is ugly and also requires linking w/Carbon framework
4413                  (for LMGetKbdType) so for now leave this rare (?) case
4414                  undealt with.. in future look into CGEvent methods */
4415               else
4416                 {
4417                   long smv = GetScriptManagerVariable (smKeyScript);
4418                   Handle uchrHandle = GetResource
4419                     ('uchr', GetScriptVariable (smv, smScriptKeys));
4420                   UInt32 dummy = 0;
4421                   UCKeyTranslate ((UCKeyboardLayout*)*uchrHandle,
4422                                  [[theEvent characters] characterAtIndex: 0],
4423                                  kUCKeyActionDisplay,
4424                                  (flags & ~NSCommandKeyMask) >> 8,
4425                                  LMGetKbdType (), kUCKeyTranslateNoDeadKeysMask,
4426                                  &dummy, 1, &dummy, &code);
4427                   code &= 0xFF;
4428                 }
4429 #endif
4430             }
4431         }
4432
4433       if (flags & NSControlKeyMask)
4434           emacs_event->modifiers |=
4435             parse_solitary_modifier (ns_control_modifier);
4436
4437       if (flags & NS_FUNCTION_KEY_MASK && !fnKeysym)
4438           emacs_event->modifiers |=
4439             parse_solitary_modifier (ns_function_modifier);
4440
4441       if (flags & NSAlternateKeyMask) /* default = meta */
4442         {
4443           if ((NILP (ns_alternate_modifier) || EQ (ns_alternate_modifier, Qnone))
4444               && !fnKeysym)
4445             {   /* accept pre-interp alt comb */
4446               if ([[theEvent characters] length] > 0)
4447                 code = [[theEvent characters] characterAtIndex: 0];
4448               /*HACK: clear lone shift modifier to stop next if from firing */
4449               if (emacs_event->modifiers == shift_modifier)
4450                 emacs_event->modifiers = 0;
4451             }
4452           else
4453               emacs_event->modifiers |=
4454                 parse_solitary_modifier (ns_alternate_modifier);
4455         }
4456
4457   if (NS_KEYLOG)
4458     fprintf (stderr, "keyDown: code =%x\tfnKey =%x\tflags = %x\tmods = %x\n",
4459              code, fnKeysym, flags, emacs_event->modifiers);
4460
4461       /* if it was a function key or had modifiers, pass it directly to emacs */
4462       if (fnKeysym || (emacs_event->modifiers
4463                        && [[theEvent charactersIgnoringModifiers] length] > 0))
4464 /*[[theEvent characters] length] */
4465         {
4466           emacs_event->kind = NON_ASCII_KEYSTROKE_EVENT;
4467           if (code < 0x20)
4468             code |= (1<<28)|(3<<16);
4469           else if (code == 0x7f)
4470             code |= (1<<28)|(3<<16);
4471           else if (!fnKeysym)
4472             emacs_event->kind = code > 0xFF
4473               ? MULTIBYTE_CHAR_KEYSTROKE_EVENT : ASCII_KEYSTROKE_EVENT;
4474
4475           emacs_event->code = code;
4476           EV_TRAILER (theEvent);
4477           return;
4478         }
4479     }
4480
4481   /* if we get here we should send the key for input manager processing */
4482   if (firstTime && [[NSInputManager currentInputManager]
4483                      wantsToDelayTextChangeNotifications] == NO)
4484     fprintf (stderr,
4485           "Emacs: WARNING: TextInput mgr wants marked text to be permanent!\n");
4486   firstTime = NO;
4487
4488   if (NS_KEYLOG && !processingCompose)
4489     fprintf (stderr, "keyDown: Begin compose sequence.\n");
4490
4491   processingCompose = YES;
4492   [nsEvArray addObject: theEvent];
4493   [self interpretKeyEvents: nsEvArray];
4494   [nsEvArray removeObject: theEvent];
4495 }
4496
4497
4498 #ifdef NS_IMPL_COCOA
4499 /* Needed to pick up Ctrl-tab and possibly other events that OS X has
4500    decided not to send key-down for.
4501    See http://osdir.com/ml/editors.vim.mac/2007-10/msg00141.html
4502    This only applies on Tiger and earlier.
4503    If it matches one of these, send it on to keyDown. */
4504 -(void)keyUp: (NSEvent *)theEvent
4505 {
4506   int flags = [theEvent modifierFlags];
4507   int code = [theEvent keyCode];
4508   if (floor (NSAppKitVersionNumber) <= 824 /*NSAppKitVersionNumber10_4*/ &&
4509       code == 0x30 && (flags & NSControlKeyMask) && !(flags & NSCommandKeyMask))
4510     {
4511       if (NS_KEYLOG)
4512         fprintf (stderr, "keyUp: passed test");
4513       ns_fake_keydown = YES;
4514       [self keyDown: theEvent];
4515     }
4516 }
4517 #endif
4518
4519
4520 /* <NSTextInput> implementation (called through super interpretKeyEvents:]). */
4521
4522
4523 /* <NSTextInput>: called when done composing;
4524    NOTE: also called when we delete over working text, followed immed.
4525          by doCommandBySelector: deleteBackward: */
4526 - (void)insertText: (id)aString
4527 {
4528   int code;
4529   int len = [(NSString *)aString length];
4530   int i;
4531
4532   if (NS_KEYLOG)
4533     NSLog (@"insertText '%@'\tlen = %d", aString, len);
4534   processingCompose = NO;
4535
4536   if (!emacs_event)
4537     return;
4538
4539   /* first, clear any working text */
4540   if (workingText != nil)
4541     [self deleteWorkingText];
4542
4543   /* now insert the string as keystrokes */
4544   for (i =0; i<len; i++)
4545     {
4546       code = [aString characterAtIndex: i];
4547       /* TODO: still need this? */
4548       if (code == 0x2DC)
4549         code = '~'; /* 0x7E */
4550       emacs_event->modifiers = 0;
4551       emacs_event->kind
4552         = code > 0xFF ? MULTIBYTE_CHAR_KEYSTROKE_EVENT : ASCII_KEYSTROKE_EVENT;
4553       emacs_event->code = code;
4554       EV_TRAILER ((id)nil);
4555     }
4556 }
4557
4558
4559 /* <NSTextInput>: inserts display of composing characters */
4560 - (void)setMarkedText: (id)aString selectedRange: (NSRange)selRange
4561 {
4562   NSString *str = [aString respondsToSelector: @selector (string)] ?
4563     [aString string] : aString;
4564   if (NS_KEYLOG)
4565     NSLog (@"setMarkedText '%@' len =%d range %d from %d", str, [str length],
4566            selRange.length, selRange.location);
4567
4568   if (workingText != nil)
4569     [self deleteWorkingText];
4570   if ([str length] == 0)
4571     return;
4572
4573   if (!emacs_event)
4574     return;
4575
4576   processingCompose = YES;
4577   workingText = [str copy];
4578   ns_working_text = build_string ([workingText UTF8String]);
4579
4580   emacs_event->kind = NS_TEXT_EVENT;
4581   emacs_event->code = KEY_NS_PUT_WORKING_TEXT;
4582   EV_TRAILER ((id)nil);
4583 }
4584
4585
4586 /* delete display of composing characters [not in <NSTextInput>] */
4587 - (void)deleteWorkingText
4588 {
4589   if (workingText == nil)
4590     return;
4591   if (NS_KEYLOG)
4592     NSLog(@"deleteWorkingText len =%d\n", [workingText length]);
4593   [workingText release];
4594   workingText = nil;
4595   processingCompose = NO;
4596
4597   if (!emacs_event)
4598     return;
4599
4600   emacs_event->kind = NS_TEXT_EVENT;
4601   emacs_event->code = KEY_NS_UNPUT_WORKING_TEXT;
4602   EV_TRAILER ((id)nil);
4603 }
4604
4605
4606 - (BOOL)hasMarkedText
4607 {
4608   return workingText != nil;
4609 }
4610
4611
4612 - (NSRange)markedRange
4613 {
4614   NSRange rng = workingText != nil
4615     ? NSMakeRange (0, [workingText length]) : NSMakeRange (NSNotFound, 0);
4616   if (NS_KEYLOG)
4617     NSLog (@"markedRange request");
4618   return rng;
4619 }
4620
4621
4622 - (void)unmarkText
4623 {
4624   if (NS_KEYLOG)
4625     NSLog (@"unmark (accept) text");
4626   [self deleteWorkingText];
4627   processingCompose = NO;
4628 }
4629
4630
4631 /* used to position char selection windows, etc. */
4632 - (NSRect)firstRectForCharacterRange: (NSRange)theRange
4633 {
4634   NSRect rect;
4635   NSPoint pt;
4636   struct window *win = XWINDOW (FRAME_SELECTED_WINDOW (emacsframe));
4637   if (NS_KEYLOG)
4638     NSLog (@"firstRectForCharRange request");
4639
4640   rect.size.width = theRange.length * FRAME_COLUMN_WIDTH (emacsframe);
4641   rect.size.height = FRAME_LINE_HEIGHT (emacsframe);
4642   pt.x = WINDOW_TEXT_TO_FRAME_PIXEL_X (win, win->phys_cursor.x);
4643   pt.y = WINDOW_TO_FRAME_PIXEL_Y (win, win->phys_cursor.y
4644                                        +FRAME_LINE_HEIGHT (emacsframe));
4645
4646   pt = [self convertPoint: pt toView: nil];
4647   pt = [[self window] convertBaseToScreen: pt];
4648   rect.origin = pt;
4649   return rect;
4650 }
4651
4652
4653 - (long)conversationIdentifier
4654 {
4655   return (long)self;
4656 }
4657
4658
4659 - (void)doCommandBySelector: (SEL)aSelector
4660 {
4661   if (NS_KEYLOG)
4662     NSLog (@"doCommandBySelector: %@", NSStringFromSelector (aSelector));
4663
4664   if (aSelector == @selector (deleteBackward:))
4665     {
4666       /* happens when user backspaces over an ongoing composition:
4667          throw a 'delete' into the event queue */
4668       if (!emacs_event)
4669         return;
4670       emacs_event->kind = NON_ASCII_KEYSTROKE_EVENT;
4671       emacs_event->code = 0xFF08;
4672       EV_TRAILER ((id)nil);
4673     }
4674 }
4675
4676 - (NSArray *)validAttributesForMarkedText
4677 {
4678   static NSArray *arr = nil;
4679   if (arr == nil) arr = [NSArray new];
4680  /* [[NSArray arrayWithObject: NSUnderlineStyleAttributeName] retain]; */
4681   return arr;
4682 }
4683
4684 - (NSRange)selectedRange
4685 {
4686   if (NS_KEYLOG)
4687     NSLog (@"selectedRange request");
4688   return NSMakeRange (NSNotFound, 0);
4689 }
4690
4691 - (NSUInteger)characterIndexForPoint: (NSPoint)thePoint
4692 {
4693   if (NS_KEYLOG)
4694     NSLog (@"characterIndexForPoint request");
4695   return 0;
4696 }
4697
4698 - (NSAttributedString *)attributedSubstringFromRange: (NSRange)theRange
4699 {
4700   static NSAttributedString *str = nil;
4701   if (str == nil) str = [NSAttributedString new];
4702   if (NS_KEYLOG)
4703     NSLog (@"attributedSubstringFromRange request");
4704   return str;
4705 }
4706
4707 /* End <NSTextInput> impl. */
4708 /*****************************************************************************/
4709
4710
4711 /* This is what happens when the user presses a mouse button.  */
4712 - (void)mouseDown: (NSEvent *)theEvent
4713 {
4714   NSPoint p = [self convertPoint: [theEvent locationInWindow] fromView: nil];
4715   Lisp_Object window;
4716
4717   NSTRACE (mouseDown);
4718
4719   [self deleteWorkingText];
4720
4721   if (!emacs_event)
4722     return;
4723
4724   last_mouse_frame = emacsframe;
4725   /* appears to be needed to prevent spurious movement events generated on
4726      button clicks */
4727   last_mouse_frame->mouse_moved = 0;
4728
4729   if ([theEvent type] == NSScrollWheel)
4730     {
4731       float delta = [theEvent deltaY];
4732       /* Mac notebooks send wheel events w/delta =0 when trackpad scrolling */
4733       if (delta == 0)
4734         return;
4735       emacs_event->kind = WHEEL_EVENT;
4736       emacs_event->code = 0;
4737       emacs_event->modifiers = EV_MODIFIERS (theEvent) |
4738         ((delta > 0) ? up_modifier : down_modifier);
4739     }
4740   else
4741     {
4742       emacs_event->kind = MOUSE_CLICK_EVENT;
4743       emacs_event->code = EV_BUTTON (theEvent);
4744       emacs_event->modifiers = EV_MODIFIERS (theEvent)
4745                              | EV_UDMODIFIERS (theEvent);
4746     }
4747   XSETINT (emacs_event->x, lrint (p.x));
4748   XSETINT (emacs_event->y, lrint (p.y));
4749   EV_TRAILER (theEvent);
4750 }
4751
4752
4753 - (void)rightMouseDown: (NSEvent *)theEvent
4754 {
4755   NSTRACE (rightMouseDown);
4756   [self mouseDown: theEvent];
4757 }
4758
4759
4760 - (void)otherMouseDown: (NSEvent *)theEvent
4761 {
4762   NSTRACE (otherMouseDown);
4763   [self mouseDown: theEvent];
4764 }
4765
4766
4767 - (void)mouseUp: (NSEvent *)theEvent
4768 {
4769   NSTRACE (mouseUp);
4770   [self mouseDown: theEvent];
4771 }
4772
4773
4774 - (void)rightMouseUp: (NSEvent *)theEvent
4775 {
4776   NSTRACE (rightMouseUp);
4777   [self mouseDown: theEvent];
4778 }
4779
4780
4781 - (void)otherMouseUp: (NSEvent *)theEvent
4782 {
4783   NSTRACE (otherMouseUp);
4784   [self mouseDown: theEvent];
4785 }
4786
4787
4788 - (void) scrollWheel: (NSEvent *)theEvent
4789 {
4790   NSTRACE (scrollWheel);
4791   [self mouseDown: theEvent];
4792 }
4793
4794
4795 /* Tell emacs the mouse has moved. */
4796 - (void)mouseMoved: (NSEvent *)e
4797 {
4798   struct ns_display_info *dpyinfo = FRAME_NS_DISPLAY_INFO (emacsframe);
4799   Lisp_Object frame;
4800
4801 //  NSTRACE (mouseMoved);
4802
4803   last_mouse_movement_time = EV_TIMESTAMP (e);
4804   last_mouse_motion_position
4805     = [self convertPoint: [e locationInWindow] fromView: nil];
4806
4807   /* update any mouse face */
4808   if (dpyinfo->mouse_face_hidden)
4809     {
4810       dpyinfo->mouse_face_hidden = 0;
4811       clear_mouse_face (dpyinfo);
4812     }
4813
4814   /* tooltip handling */
4815   previous_help_echo_string = help_echo_string;
4816   help_echo_string = Qnil;
4817
4818   if (!note_mouse_movement (emacsframe, last_mouse_motion_position.x,
4819                             last_mouse_motion_position.y))
4820     help_echo_string = previous_help_echo_string;
4821
4822   XSETFRAME (frame, emacsframe);
4823   if (!NILP (help_echo_string) || !NILP (previous_help_echo_string))
4824     {
4825       /* NOTE: help_echo_{window,pos,object} are set in xdisp.c
4826          (note_mouse_highlight), which is called through the
4827          note_mouse_movement () call above */
4828       gen_help_event (help_echo_string, frame, help_echo_window,
4829                       help_echo_object, help_echo_pos);
4830     }
4831   else
4832     {
4833       help_echo_string = Qnil;
4834       gen_help_event (Qnil, frame, Qnil, Qnil, 0);
4835     }
4836
4837   if (emacsframe->mouse_moved && send_appdefined)
4838     ns_send_appdefined (-1);
4839 }
4840
4841
4842 - (void)mouseDragged: (NSEvent *)e
4843 {
4844   NSTRACE (mouseDragged);
4845   [self mouseMoved: e];
4846 }
4847
4848
4849 - (void)rightMouseDragged: (NSEvent *)e
4850 {
4851   NSTRACE (rightMouseDragged);
4852   [self mouseMoved: e];
4853 }
4854
4855
4856 - (void)otherMouseDragged: (NSEvent *)e
4857 {
4858   NSTRACE (otherMouseDragged);
4859   [self mouseMoved: e];
4860 }
4861
4862
4863 - (BOOL)windowShouldClose: (id)sender
4864 {
4865   NSEvent *e =[[self window] currentEvent];
4866
4867   NSTRACE (windowShouldClose);
4868   windowClosing = YES;
4869   if (!emacs_event)
4870     return NO;
4871   emacs_event->kind = DELETE_WINDOW_EVENT;
4872   emacs_event->modifiers = 0;
4873   emacs_event->code = 0;
4874   EV_TRAILER (e);
4875   /* Don't close this window, let this be done from lisp code.  */
4876   return NO;
4877 }
4878
4879
4880 - (NSSize)windowWillResize: (NSWindow *)sender toSize: (NSSize)frameSize
4881 /* normalize frame to gridded text size */
4882 {
4883   NSTRACE (windowWillResize);
4884 /*fprintf (stderr,"Window will resize: %.0f x %.0f\n",frameSize.width,frameSize.height); */
4885
4886   cols = FRAME_PIXEL_WIDTH_TO_TEXT_COLS (emacsframe,
4887 #ifdef NS_IMPL_GNUSTEP
4888                                         frameSize.width + 3);
4889 #else
4890                                         frameSize.width);
4891 #endif
4892   if (cols < MINWIDTH)
4893     cols = MINWIDTH;
4894   frameSize.width = FRAME_TEXT_COLS_TO_PIXEL_WIDTH (emacsframe, cols);
4895
4896   rows = FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (emacsframe, frameSize.height
4897 #ifdef NS_IMPL_GNUSTEP
4898       - FRAME_NS_TITLEBAR_HEIGHT (emacsframe) + 3
4899         - FRAME_NS_TOOLBAR_HEIGHT (emacsframe));
4900 #else
4901       - FRAME_NS_TITLEBAR_HEIGHT (emacsframe)
4902         - FRAME_NS_TOOLBAR_HEIGHT (emacsframe));
4903 #endif
4904   if (rows < MINHEIGHT)
4905     rows = MINHEIGHT;
4906   frameSize.height = FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (emacsframe, rows)
4907                        + FRAME_NS_TITLEBAR_HEIGHT (emacsframe)
4908                        + FRAME_NS_TOOLBAR_HEIGHT (emacsframe);
4909 #ifdef NS_IMPL_COCOA
4910   {
4911     /* this sets window title to have size in it; the wm does this under GS */
4912     NSRect r = [[self window] frame];
4913     if (r.size.height == frameSize.height && r.size.width == frameSize.width)
4914       {
4915         if (old_title != 0)
4916           {
4917             xfree (old_title);
4918             old_title = 0;
4919           }
4920       }
4921     else
4922       {
4923         char *size_title;
4924         NSWindow *window = [self window];
4925         if (old_title == 0)
4926           {
4927             const char *t = [[[self window] title] UTF8String];
4928             char *pos = strstr (t, "  —  ");
4929             if (pos)
4930               *pos = '\0';
4931             old_title = (char *) xmalloc (strlen (t) + 1);
4932             strcpy (old_title, t);
4933           }
4934         size_title = xmalloc (strlen (old_title) + 40);
4935         sprintf (size_title, "%s  —  (%d x %d)", old_title, cols, rows);
4936         [window setTitle: [NSString stringWithUTF8String: size_title]];
4937         [window display];
4938         xfree (size_title);
4939       }
4940   }
4941 #endif /* NS_IMPL_COCOA */
4942 /*fprintf (stderr,"    ...size became %.0f x %.0f  (%d x %d)\n",frameSize.width,frameSize.height,cols,rows); */
4943
4944   return frameSize;
4945 }
4946
4947
4948 - (void)windowDidResize: (NSNotification *)notification
4949 {
4950   NSWindow *theWindow = [notification object];
4951
4952 #ifdef NS_IMPL_GNUSTEP
4953    /* in GNUstep, at least currently, it's possible to get a didResize
4954       without getting a willResize.. therefore we need to act as if we got
4955       the willResize now */
4956   NSSize sz = [theWindow frame].size;
4957   sz = [self windowWillResize: theWindow toSize: sz];
4958 #endif /* NS_IMPL_GNUSTEP */
4959
4960   NSTRACE (windowDidResize);
4961 /*fprintf (stderr,"windowDidResize: %.0f\n",[theWindow frame].size.height); */
4962
4963 #ifdef NS_IMPL_COCOA
4964   if (old_title != 0)
4965     {
4966       xfree (old_title);
4967       old_title = 0;
4968     }
4969 #endif /* NS_IMPL_COCOA */
4970
4971   /* Avoid loop under GNUstep due to call at beginning of this function.
4972      (x_set_window_size causes a resize which causes
4973      a "windowDidResize" which calls x_set_window_size).  */
4974 #ifndef NS_IMPL_GNUSTEP
4975   if (cols > 0 && rows > 0)
4976      x_set_window_size (emacsframe, 0, cols, rows);
4977 #endif
4978
4979   ns_send_appdefined (-1);
4980 }
4981
4982
4983 - (void)windowDidBecomeKey: (NSNotification *)notification
4984 /* cf. x_detect_focus_change(), x_focus_changed(), x_new_focus_frame() */
4985 {
4986   struct ns_display_info *dpyinfo = FRAME_NS_DISPLAY_INFO (emacsframe);
4987   struct frame *old_focus = dpyinfo->x_focus_frame;
4988
4989   NSTRACE (windowDidBecomeKey);
4990
4991   if (emacsframe != old_focus)
4992     dpyinfo->x_focus_frame = emacsframe;
4993
4994   ns_frame_rehighlight (emacsframe);
4995
4996   if (emacs_event)
4997     {
4998       emacs_event->kind = FOCUS_IN_EVENT;
4999       EV_TRAILER ((id)nil);
5000     }
5001 }
5002
5003
5004 - (void)windowDidResignKey: (NSNotification *)notification
5005 /* cf. x_detect_focus_change(), x_focus_changed(), x_new_focus_frame() */
5006 {
5007   struct ns_display_info *dpyinfo = FRAME_NS_DISPLAY_INFO (emacsframe);
5008   NSTRACE (windowDidResignKey);
5009
5010   if (dpyinfo->x_focus_frame == emacsframe)
5011     dpyinfo->x_focus_frame = 0;
5012
5013   ns_frame_rehighlight (emacsframe);
5014
5015   /* FIXME: for some reason needed on second and subsequent clicks away
5016             from sole-frame Emacs to get hollow box to show */
5017   if (!windowClosing && [[self window] isVisible] == YES)
5018     {
5019       x_update_cursor (emacsframe, 1);
5020       x_set_frame_alpha (emacsframe);
5021     }
5022
5023   if (emacs_event)
5024     {
5025       [self deleteWorkingText];
5026       emacs_event->kind = FOCUS_IN_EVENT;
5027       EV_TRAILER ((id)nil);
5028     }
5029 }
5030
5031
5032 - (void)windowWillMiniaturize: sender
5033 {
5034   NSTRACE (windowWillMiniaturize);
5035 }
5036
5037
5038 - (BOOL)isFlipped
5039 {
5040   return YES;
5041 }
5042
5043
5044 - (BOOL)isOpaque
5045 {
5046   return NO;
5047 }
5048
5049
5050 - initFrameFromEmacs: (struct frame *)f
5051 {
5052   NSRect r, wr;
5053   Lisp_Object tem;
5054   NSWindow *win;
5055   NSButton *toggleButton;
5056   int vbextra = NS_SCROLL_BAR_WIDTH (f);
5057   NSSize sz;
5058   NSColor *col;
5059   NSString *name;
5060
5061   NSTRACE (initFrameFromEmacs);
5062
5063   windowClosing = NO;
5064   processingCompose = NO;
5065   scrollbarsNeedingUpdate = 0;
5066
5067 /*fprintf (stderr,"init with %d, %d\n",f->text_cols, f->text_lines); */
5068
5069   r = NSMakeRect (0, 0, FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f, f->text_cols),
5070                  FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f, f->text_lines));
5071   [self initWithFrame: r];
5072   [self setAutoresizingMask: NSViewWidthSizable | NSViewHeightSizable];
5073
5074   FRAME_NS_VIEW (f) = self;
5075   emacsframe = f;
5076   old_title = 0;
5077
5078   win = [[EmacsWindow alloc]
5079             initWithContentRect: r
5080                       styleMask: (NSResizableWindowMask |
5081                                   NSMiniaturizableWindowMask |
5082                                   NSClosableWindowMask)
5083                         backing: NSBackingStoreBuffered
5084                           defer: YES];
5085
5086   wr = [win frame];
5087   f->border_width = wr.size.width - r.size.width;
5088   FRAME_NS_TITLEBAR_HEIGHT (f) = wr.size.height - r.size.height;
5089
5090   [win setAcceptsMouseMovedEvents: YES];
5091   [win setDelegate: self];
5092   [win useOptimizedDrawing: YES];
5093
5094   sz.width = FRAME_COLUMN_WIDTH (f);
5095   sz.height = FRAME_LINE_HEIGHT (f);
5096   [win setResizeIncrements: sz];
5097
5098   [[win contentView] addSubview: self];
5099
5100   if (ns_drag_types)
5101     [self registerForDraggedTypes: ns_drag_types];
5102
5103   tem = f->name;
5104   name = [NSString stringWithUTF8String:
5105                    NILP (tem) ? (unsigned char *)"Emacs" : SDATA (tem)];
5106   [win setTitle: name];
5107
5108   /* toolbar support */
5109   toolbar = [[EmacsToolbar alloc] initForView: self withIdentifier:
5110                          [NSString stringWithFormat: @"Emacs Frame %d",
5111                                    ns_window_num]];
5112   [win setToolbar: toolbar];
5113   [toolbar setVisible: NO];
5114 #ifdef NS_IMPL_COCOA
5115   toggleButton = [win standardWindowButton: NSWindowToolbarButton];
5116   [toggleButton setTarget: self];
5117   [toggleButton setAction: @selector (toggleToolbar: )];
5118 #endif
5119   FRAME_NS_TOOLBAR_HEIGHT (f) = 0;
5120
5121   tem = f->icon_name;
5122   if (!NILP (tem))
5123     [win setMiniwindowTitle:
5124            [NSString stringWithUTF8String: SDATA (tem)]];
5125
5126   {
5127     NSScreen *screen = [win screen];
5128
5129     if (screen != 0)
5130       [win setFrameTopLeftPoint: NSMakePoint
5131            (IN_BOUND (-SCREENMAX, f->left_pos, SCREENMAX),
5132             IN_BOUND (-SCREENMAX,
5133                      [screen frame].size.height - NS_TOP_POS (f), SCREENMAX))];
5134   }
5135
5136   [win makeFirstResponder: self];
5137
5138   col = ns_lookup_indexed_color (NS_FACE_BACKGROUND
5139                                   (FRAME_DEFAULT_FACE (emacsframe)), emacsframe);
5140   [win setBackgroundColor: col];
5141   if ([col alphaComponent] != 1.0)
5142     [win setOpaque: NO];
5143
5144   [self allocateGState];
5145
5146   ns_window_num++;
5147   return self;
5148 }
5149
5150
5151 - (void)windowDidMove: sender
5152 {
5153   NSWindow *win = [self window];
5154   NSRect r = [win frame];
5155   NSScreen *screen = [win screen];
5156
5157   NSTRACE (windowDidMove);
5158
5159   if (!emacsframe->output_data.ns)
5160     return;
5161   if (screen != nil)
5162     {
5163       emacsframe->left_pos = r.origin.x;
5164       emacsframe->top_pos =
5165         [screen frame].size.height - (r.origin.y + r.size.height);
5166     }
5167 }
5168
5169
5170 /* Called AFTER method below, but before our windowWillResize call there leads
5171    to windowDidResize -> x_set_window_size.  Update emacs' notion of frame
5172    location so set_window_size moves the frame. */
5173 - (BOOL)windowShouldZoom: (NSWindow *)sender toFrame: (NSRect)newFrame
5174 {
5175   NSTRACE (windowShouldZoom);
5176   emacsframe->left_pos = (int)newFrame.origin.x;
5177   emacsframe->top_pos = [[sender screen] frame].size.height
5178                             - (newFrame.origin.y+newFrame.size.height);
5179   return YES;
5180 }
5181
5182
5183 /* Override to do something slightly nonstandard, but nice.  First click on
5184    zoom button will zoom vertically.  Second will zoom completely.  Third
5185    returns to original. */
5186 - (NSRect)windowWillUseStandardFrame:(NSWindow *)sender
5187                         defaultFrame:(NSRect)defaultFrame
5188 {
5189   NSRect result = [sender frame];
5190   static NSRect ns_userRect = { 0, 0, 0, 0 };
5191
5192   NSTRACE (windowWillUseStandardFrame);
5193
5194   if (abs (defaultFrame.size.height - result.size.height)
5195       > FRAME_LINE_HEIGHT (emacsframe))
5196     {
5197       /* first click */
5198       ns_userRect = result;
5199       result.size.height = defaultFrame.size.height;
5200       result.origin.y = defaultFrame.origin.y;
5201     }
5202   else
5203     {
5204       if (abs (defaultFrame.size.width - result.size.width)
5205           > FRAME_COLUMN_WIDTH (emacsframe))
5206         result = defaultFrame;  /* second click */
5207       else
5208         result = ns_userRect.size.height ? ns_userRect : result;  /* restore */
5209     }
5210
5211   [self windowWillResize: sender toSize: result.size];
5212   return result;
5213 }
5214
5215
5216 - (void)windowDidDeminiaturize: sender
5217 {
5218   NSTRACE (windowDidDeminiaturize);
5219   if (!emacsframe->output_data.ns)
5220     return;
5221   emacsframe->async_iconified = 0;
5222   emacsframe->async_visible   = 1;
5223   windows_or_buffers_changed++;
5224
5225   if (emacs_event)
5226     {
5227       emacs_event->kind = ICONIFY_EVENT;
5228       EV_TRAILER ((id)nil);
5229     }
5230 }
5231
5232
5233 - (void)windowDidExpose: sender
5234 {
5235   NSTRACE (windowDidExpose);
5236   if (!emacsframe->output_data.ns)
5237     return;
5238   emacsframe->async_visible = 1;
5239   SET_FRAME_GARBAGED (emacsframe);
5240
5241   if (send_appdefined)
5242     ns_send_appdefined (-1);
5243 }
5244
5245
5246 - (void)windowDidMiniaturize: sender
5247 {
5248   NSTRACE (windowDidMiniaturize);
5249   if (!emacsframe->output_data.ns)
5250     return;
5251
5252   emacsframe->async_iconified = 1;
5253   emacsframe->async_visible = 0;
5254
5255   if (emacs_event)
5256     {
5257       emacs_event->kind = ICONIFY_EVENT;
5258       EV_TRAILER ((id)nil);
5259     }
5260 }
5261
5262
5263 - (void)mouseEntered: (NSEvent *)theEvent
5264 {
5265   NSPoint p = [self convertPoint: [theEvent locationInWindow] fromView: nil];
5266   struct ns_display_info *dpyinfo = FRAME_NS_DISPLAY_INFO (emacsframe);
5267   NSTRACE (mouseEntered);
5268
5269   last_mouse_movement_time = EV_TIMESTAMP (theEvent);
5270 }
5271
5272
5273 - (void)mouseExited: (NSEvent *)theEvent
5274 {
5275   NSPoint p = [self convertPoint: [theEvent locationInWindow] fromView: nil];
5276   NSRect r;
5277   struct ns_display_info *dpyinfo
5278     = emacsframe ? FRAME_NS_DISPLAY_INFO (emacsframe) : NULL;
5279
5280   NSTRACE (mouseExited);
5281
5282   if (dpyinfo || !emacsframe)
5283     return;
5284
5285   last_mouse_movement_time = EV_TIMESTAMP (theEvent);
5286
5287   if (emacsframe == dpyinfo->mouse_face_mouse_frame)
5288     {
5289       clear_mouse_face (dpyinfo);
5290       dpyinfo->mouse_face_mouse_frame = 0;
5291     }
5292 }
5293
5294
5295 - menuDown: sender
5296 {
5297   NSTRACE (menuDown);
5298   if (context_menu_value == -1)
5299     context_menu_value = [sender tag];
5300   else
5301     find_and_call_menu_selection (emacsframe, emacsframe->menu_bar_items_used,
5302                                   emacsframe->menu_bar_vector,
5303                                   (void *)[sender tag]);
5304   ns_send_appdefined (-1);
5305   return self;
5306 }
5307
5308
5309 - (EmacsToolbar *)toolbar
5310 {
5311   return toolbar;
5312 }
5313
5314
5315 /* this gets called on toolbar button click */
5316 - toolbarClicked: (id)item
5317 {
5318   NSEvent *theEvent;
5319   int idx = [item tag] * TOOL_BAR_ITEM_NSLOTS;
5320
5321   NSTRACE (toolbarClicked);
5322
5323   if (!emacs_event)
5324     return self;
5325
5326   /* send first event (for some reason two needed) */
5327   theEvent = [[self window] currentEvent];
5328   emacs_event->kind = TOOL_BAR_EVENT;
5329   XSETFRAME (emacs_event->arg, emacsframe);
5330   EV_TRAILER (theEvent);
5331
5332   emacs_event->kind = TOOL_BAR_EVENT;
5333 /*   XSETINT (emacs_event->code, 0); */
5334   emacs_event->arg = AREF (emacsframe->tool_bar_items,
5335                           idx + TOOL_BAR_ITEM_KEY);
5336   emacs_event->modifiers = EV_MODIFIERS (theEvent);
5337   EV_TRAILER (theEvent);
5338   return self;
5339 }
5340
5341
5342 - toggleToolbar: (id)sender
5343 {
5344   if (!emacs_event)
5345     return self;
5346
5347   emacs_event->kind = NS_NONKEY_EVENT;
5348   emacs_event->code = KEY_NS_TOGGLE_TOOLBAR;
5349   EV_TRAILER ((id)nil);
5350   return self;
5351 }
5352
5353
5354 - (void)drawRect: (NSRect)rect
5355 {
5356   int x = NSMinX (rect), y = NSMinY (rect);
5357   int width = NSWidth (rect), height = NSHeight (rect);
5358
5359   NSTRACE (drawRect);
5360
5361   if (!emacsframe || !emacsframe->output_data.ns || ns_in_resize)
5362     return;
5363
5364   ns_clear_frame_area (emacsframe, x, y, width, height);
5365   expose_frame (emacsframe, x, y, width, height);
5366
5367   /*
5368     drawRect: may be called (at least in OS X 10.5) for invisible
5369     views as well for some reason.  Thus, do not infer visibility
5370     here.
5371
5372     emacsframe->async_visible = 1;
5373     emacsframe->async_iconified = 0;
5374   */
5375 }
5376
5377
5378 /* NSDraggingDestination protocol methods.  Actually this is not really a
5379    protocol, but a category of Object.  O well...  */
5380
5381 -(NSUInteger) draggingEntered: (id <NSDraggingInfo>) sender
5382 {
5383   NSTRACE (draggingEntered);
5384   return NSDragOperationGeneric;
5385 }
5386
5387
5388 -(BOOL)prepareForDragOperation: (id <NSDraggingInfo>) sender
5389 {
5390   return YES;
5391 }
5392
5393
5394 -(BOOL)performDragOperation: (id <NSDraggingInfo>) sender
5395 {
5396   id pb;
5397   int x, y;
5398   NSString *type;
5399   NSEvent *theEvent = [[self window] currentEvent];
5400   NSPoint position;
5401
5402   NSTRACE (performDragOperation);
5403
5404   if (!emacs_event)
5405     return;
5406
5407   position = [self convertPoint: [sender draggingLocation] fromView: nil];
5408   x = lrint (position.x);  y = lrint (position.y);
5409
5410   pb = [sender draggingPasteboard];
5411   type = [pb availableTypeFromArray: ns_drag_types];
5412   if (type == 0)
5413     {
5414       return NO;
5415     }
5416   else if ([type isEqualToString: NSFilenamesPboardType])
5417     {
5418       NSArray *files;
5419       NSEnumerator *fenum;
5420       NSString *file;
5421
5422       if (!(files = [pb propertyListForType: type]))
5423         return NO;
5424
5425       fenum = [files objectEnumerator];
5426       while ( (file = [fenum nextObject]) )
5427         {
5428           emacs_event->kind = NS_NONKEY_EVENT;
5429           emacs_event->code = KEY_NS_DRAG_FILE;
5430           XSETINT (emacs_event->x, x);
5431           XSETINT (emacs_event->y, y);
5432           ns_input_file = append2 (ns_input_file,
5433                                    build_string ([file UTF8String]));
5434           emacs_event->modifiers = EV_MODIFIERS (theEvent);
5435           EV_TRAILER (theEvent);
5436         }
5437       return YES;
5438     }
5439   else if ([type isEqualToString: NSURLPboardType])
5440     {
5441       NSString *file;
5442       NSURL *fileURL;
5443
5444       if (!(fileURL = [NSURL URLFromPasteboard: pb]) ||
5445           [fileURL isFileURL] == NO)
5446         return NO;
5447
5448       file = [fileURL path];
5449       emacs_event->kind = NS_NONKEY_EVENT;
5450       emacs_event->code = KEY_NS_DRAG_FILE;
5451       XSETINT (emacs_event->x, x);
5452       XSETINT (emacs_event->y, y);
5453       ns_input_file = append2 (ns_input_file, build_string ([file UTF8String]));
5454       emacs_event->modifiers = EV_MODIFIERS (theEvent);
5455       EV_TRAILER (theEvent);
5456       return YES;
5457     }
5458   else if ([type isEqualToString: NSStringPboardType]
5459            || [type isEqualToString: NSTabularTextPboardType])
5460     {
5461       NSString *data;
5462
5463       if (! (data = [pb stringForType: type]))
5464         return NO;
5465
5466       emacs_event->kind = NS_NONKEY_EVENT;
5467       emacs_event->code = KEY_NS_DRAG_TEXT;
5468       XSETINT (emacs_event->x, x);
5469       XSETINT (emacs_event->y, y);
5470       ns_input_text = build_string ([data UTF8String]);
5471       emacs_event->modifiers = EV_MODIFIERS (theEvent);
5472       EV_TRAILER (theEvent);
5473       return YES;
5474     }
5475   else if ([type isEqualToString: NSColorPboardType])
5476     {
5477       NSColor *c = [NSColor colorFromPasteboard: pb];
5478       emacs_event->kind = NS_NONKEY_EVENT;
5479       emacs_event->code = KEY_NS_DRAG_COLOR;
5480       XSETINT (emacs_event->x, x);
5481       XSETINT (emacs_event->y, y);
5482       ns_input_color = ns_color_to_lisp (c);
5483       emacs_event->modifiers = EV_MODIFIERS (theEvent);
5484       EV_TRAILER (theEvent);
5485       return YES;
5486     }
5487   else if ([type isEqualToString: NSFontPboardType])
5488     {
5489       /* impl based on GNUstep NSTextView.m */
5490       NSData *data = [pb dataForType: NSFontPboardType];
5491       NSDictionary *dict = [NSUnarchiver unarchiveObjectWithData: data];
5492       NSFont *font = [dict objectForKey: NSFontAttributeName];
5493       char fontSize[10];
5494
5495       if (font == nil)
5496         return NO;
5497
5498       emacs_event->kind = NS_NONKEY_EVENT;
5499       emacs_event->code = KEY_NS_CHANGE_FONT;
5500       XSETINT (emacs_event->x, x);
5501       XSETINT (emacs_event->y, y);
5502       ns_input_font = build_string ([[font fontName] UTF8String]);
5503       snprintf (fontSize, 10, "%f", [font pointSize]);
5504       ns_input_fontsize = build_string (fontSize);
5505       emacs_event->modifiers = EV_MODIFIERS (theEvent);
5506       EV_TRAILER (theEvent);
5507       return YES;
5508     }
5509   else
5510     {
5511       error ("Invalid data type in dragging pasteboard.");
5512       return NO;
5513     }
5514 }
5515
5516
5517 - validRequestorForSendType: (NSString *)typeSent
5518                  returnType: (NSString *)typeReturned
5519 {
5520   NSTRACE (validRequestorForSendType);
5521   if ([ns_send_types indexOfObjectIdenticalTo: typeSent] != NSNotFound &&
5522       [ns_return_types indexOfObjectIdenticalTo: typeSent] != NSNotFound)
5523     return self;
5524
5525   return [super validRequestorForSendType: typeSent
5526                                returnType: typeReturned];
5527 }
5528
5529
5530 /* The next two methods are part of NSServicesRequests informal protocol,
5531    supposedly called when a services menu item is chosen from this app.
5532    But this should not happen because we override the services menu with our
5533    own entries which call ns-perform-service.
5534    Nonetheless, it appeared to happen (under strange circumstances): bug#1435.
5535    So let's at least stub them out until further investigation can be done. */
5536
5537 - (BOOL) readSelectionFromPasteboard: (NSPasteboard *)pb
5538 {
5539   /* we could call ns_string_from_pasteboard(pboard) here but then it should
5540      be written into the buffer in place of the existing selection..
5541      ordinary service calls go through functions defined in ns-win.el */
5542   return NO;
5543 }
5544
5545 - (BOOL) writeSelectionToPasteboard: (NSPasteboard *)pb types: (NSArray *)types
5546 {
5547   /* supposed to write for as many of types as we are able */
5548   return NO;
5549 }
5550
5551
5552 /* setMini =YES means set from internal (gives a finder icon), NO means set nil
5553    (gives a miniaturized version of the window); currently we use the latter for
5554    frames whose active buffer doesn't correspond to any file
5555    (e.g., '*scratch*') */
5556 - setMiniwindowImage: (BOOL) setMini
5557 {
5558   id image = [[self window] miniwindowImage];
5559   NSTRACE (setMiniwindowImage);
5560
5561   /* NOTE: under Cocoa miniwindowImage always returns nil, documentation
5562      about "AppleDockIconEnabled" notwithstanding, however the set message
5563      below has its effect nonetheless. */
5564   if (image != emacsframe->output_data.ns->miniimage)
5565     {
5566       if (image && [image isKindOfClass: [EmacsImage class]])
5567         [image release];
5568       [[self window] setMiniwindowImage:
5569                        setMini ? emacsframe->output_data.ns->miniimage : nil];
5570     }
5571
5572   return self;
5573 }
5574
5575
5576 - (void) setRows: (int) r andColumns: (int) c
5577 {
5578   rows = r;
5579   cols = c;
5580 }
5581
5582 @end  /* EmacsView */
5583
5584
5585
5586 /* ==========================================================================
5587
5588     EmacsWindow implementation
5589
5590    ========================================================================== */
5591
5592 @implementation EmacsWindow
5593
5594 /* called only on resize clicks by special case in EmacsApp-sendEvent */
5595 - (void)mouseDown: (NSEvent *)theEvent
5596 {
5597   if (ns_in_resize)
5598     {
5599       NSSize size = [[theEvent window] frame].size;
5600       grabOffset = [theEvent locationInWindow];
5601       grabOffset.x = size.width - grabOffset.x;
5602     }
5603   else
5604     [super mouseDown: theEvent];
5605 }
5606
5607
5608 /* stop resizing */
5609 - (void)mouseUp: (NSEvent *)theEvent
5610 {
5611   if (ns_in_resize)
5612     {
5613       struct frame *f = ((EmacsView *)[self delegate])->emacsframe;
5614       ns_in_resize = NO;
5615       ns_set_name_as_filename (f);
5616       [self display];
5617       ns_send_appdefined (-1);
5618     }
5619   else
5620     [super mouseUp: theEvent];
5621 }
5622
5623
5624 /* send resize events */
5625 - (void)mouseDragged: (NSEvent *)theEvent
5626 {
5627   if (ns_in_resize)
5628     {
5629       NSPoint p = [theEvent locationInWindow];
5630       NSSize size, vettedSize, origSize = [self frame].size;
5631
5632       size.width = p.x + grabOffset.x;
5633       size.height = origSize.height - p.y + grabOffset.y;
5634
5635       if (size.width == origSize.width && size.height == origSize.height)
5636         return;
5637
5638       vettedSize = [[self delegate] windowWillResize: self toSize: size];
5639       if (vettedSize.width != size.width || vettedSize.height != size.height)
5640         {
5641           [[NSNotificationCenter defaultCenter]
5642             postNotificationName: NSWindowDidResizeNotification
5643                           object: self];
5644         }
5645     }
5646   else
5647     [super mouseDragged: theEvent];
5648 }
5649
5650 @end /* EmacsWindow */
5651
5652
5653 /* ==========================================================================
5654
5655     EmacsScroller implementation
5656
5657    ========================================================================== */
5658
5659
5660 @implementation EmacsScroller
5661
5662 /* for repeat button push */
5663 #define SCROLL_BAR_FIRST_DELAY 0.5
5664 #define SCROLL_BAR_CONTINUOUS_DELAY (1.0 / 15)
5665
5666 + (CGFloat) scrollerWidth
5667 {
5668   /* TODO: if we want to allow variable widths, this is the place to do it,
5669            however neither GNUstep nor Cocoa support it very well */
5670   return [NSScroller scrollerWidth];
5671 }
5672
5673
5674 - initFrame: (NSRect )r window: (Lisp_Object)nwin
5675 {
5676   NSTRACE (EmacsScroller_initFrame);
5677
5678   r.size.width = [EmacsScroller scrollerWidth];
5679   [super initWithFrame: r/*NSMakeRect (0, 0, 0, 0)*/];
5680   [self setContinuous: YES];
5681   [self setEnabled: YES];
5682
5683   /* Ensure auto resizing of scrollbars occurs within the emacs frame's view
5684      locked against the top and bottom edges, and right edge on OS X, where
5685      scrollers are on right. */
5686 #ifdef NS_IMPL_GNUSTEP
5687   [self setAutoresizingMask: NSViewMaxXMargin | NSViewHeightSizable];
5688 #else
5689   [self setAutoresizingMask: NSViewMinXMargin | NSViewHeightSizable];
5690 #endif
5691
5692   win = nwin;
5693   condemned = NO;
5694   pixel_height = NSHeight (r);
5695   min_portion = 20 / pixel_height;
5696
5697   frame = XFRAME (XWINDOW (win)->frame);
5698   if (FRAME_LIVE_P (frame))
5699     {
5700       int i;
5701       EmacsView *view = FRAME_NS_VIEW (frame);
5702       NSView *sview = [[view window] contentView];
5703       NSArray *subs = [sview subviews];
5704
5705       /* disable optimization stopping redraw of other scrollbars */
5706       view->scrollbarsNeedingUpdate = 0;
5707       for (i =[subs count]-1; i >= 0; i--)
5708         if ([[subs objectAtIndex: i] isKindOfClass: [EmacsScroller class]])
5709           view->scrollbarsNeedingUpdate++;
5710       [sview addSubview: self];
5711     }
5712
5713 /*  [self setFrame: r]; */
5714
5715   return self;
5716 }
5717
5718
5719 - (void)setFrame: (NSRect)newRect
5720 {
5721   NSTRACE (EmacsScroller_setFrame);
5722 /*  BLOCK_INPUT; */
5723   pixel_height = NSHeight (newRect);
5724   min_portion = 20 / pixel_height;
5725   [super setFrame: newRect];
5726   [self display];
5727 /*  UNBLOCK_INPUT; */
5728 }
5729
5730
5731 - (void)dealloc
5732 {
5733   NSTRACE (EmacsScroller_dealloc);
5734   if (!NILP (win))
5735     XWINDOW (win)->vertical_scroll_bar = Qnil;
5736   [super dealloc];
5737 }
5738
5739
5740 - condemn
5741 {
5742   NSTRACE (condemn);
5743   condemned =YES;
5744   return self;
5745 }
5746
5747
5748 - reprieve
5749 {
5750   NSTRACE (reprieve);
5751   condemned =NO;
5752   return self;
5753 }
5754
5755
5756 - judge
5757 {
5758   NSTRACE (judge);
5759   if (condemned)
5760     {
5761       BLOCK_INPUT;
5762       /* ensure other scrollbar updates after deletion */
5763       EmacsView *view = (EmacsView *)FRAME_NS_VIEW (frame);
5764       if (view != nil)
5765         view->scrollbarsNeedingUpdate++;
5766       [self removeFromSuperview];
5767       [self release];
5768       UNBLOCK_INPUT;
5769     }
5770   return self;
5771 }
5772
5773
5774 - (void)resetCursorRects
5775 {
5776   NSRect visible = [self visibleRect];
5777   NSTRACE (resetCursorRects);
5778
5779   if (!NSIsEmptyRect (visible))
5780     [self addCursorRect: visible cursor: [NSCursor arrowCursor]];
5781   [[NSCursor arrowCursor] setOnMouseEntered: YES];
5782 }
5783
5784
5785 - (int) checkSamePosition: (int) position portion: (int) portion
5786                     whole: (int) whole
5787 {
5788   return em_position ==position && em_portion ==portion && em_whole ==whole
5789     && portion != whole; /* needed for resize empty buf */
5790 }
5791
5792
5793 - setPosition: (int)position portion: (int)portion whole: (int)whole
5794 {
5795   NSTRACE (setPosition);
5796
5797   em_position = position;
5798   em_portion = portion;
5799   em_whole = whole;
5800
5801   if (portion >= whole)
5802     [self setFloatValue: 0.0 knobProportion: 1.0];
5803   else
5804     {
5805       float pos, por;
5806       portion = max ((float)whole*min_portion/pixel_height, portion);
5807       pos = (float)position / (whole - portion);
5808       por = (float)portion/whole;
5809       [self setFloatValue: pos knobProportion: por];
5810     }
5811   return self;
5812 }
5813
5814 /* FIXME: unused at moment (see ns_mouse_position) at the moment because
5815      drag events will go directly to the EmacsScroller.  Leaving in for now. */
5816 -(void)getMouseMotionPart: (int *)part window: (Lisp_Object *)window
5817                         x: (Lisp_Object *)x y: ( Lisp_Object *)y
5818 {
5819   *part = last_hit_part;
5820   *window = win;
5821   XSETINT (*y, pixel_height);
5822   if ([self floatValue] > 0.999)
5823     XSETINT (*x, pixel_height);
5824   else
5825     XSETINT (*x, pixel_height * [self floatValue]);
5826 }
5827
5828
5829 /* set up emacs_event */
5830 - (void) sendScrollEventAtLoc: (float)loc fromEvent: (NSEvent *)e
5831 {
5832   if (!emacs_event)
5833     return;
5834
5835   emacs_event->part = last_hit_part;
5836   emacs_event->code = 0;
5837   emacs_event->modifiers = EV_MODIFIERS (e) | down_modifier;
5838   emacs_event->frame_or_window = win;
5839   emacs_event->timestamp = EV_TIMESTAMP (e);
5840   emacs_event->kind = SCROLL_BAR_CLICK_EVENT;
5841   emacs_event->arg = Qnil;
5842   XSETINT (emacs_event->x, loc * pixel_height);
5843   XSETINT (emacs_event->y, pixel_height-20);
5844
5845   n_emacs_events_pending++;
5846   kbd_buffer_store_event_hold (emacs_event, q_event_ptr);
5847   EVENT_INIT (*emacs_event);
5848   ns_send_appdefined (-1);
5849 }
5850
5851
5852 /* called manually thru timer to implement repeated button action w/hold-down */
5853 - repeatScroll: (NSTimer *)scrollEntry
5854 {
5855   NSEvent *e = [[self window] currentEvent];
5856   NSPoint p =  [[self window] mouseLocationOutsideOfEventStream];
5857   BOOL inKnob = [self testPart: p] == NSScrollerKnob;
5858
5859   /* clear timer if need be */
5860   if (inKnob || [scroll_repeat_entry timeInterval] == SCROLL_BAR_FIRST_DELAY)
5861     {
5862         [scroll_repeat_entry invalidate];
5863         [scroll_repeat_entry release];
5864         scroll_repeat_entry = nil;
5865
5866         if (inKnob)
5867           return self;
5868
5869         scroll_repeat_entry
5870           = [[NSTimer scheduledTimerWithTimeInterval:
5871                         SCROLL_BAR_CONTINUOUS_DELAY
5872                                             target: self
5873                                           selector: @selector (repeatScroll:)
5874                                           userInfo: 0
5875                                            repeats: YES]
5876               retain];
5877     }
5878
5879   [self sendScrollEventAtLoc: 0 fromEvent: e];
5880   return self;
5881 }
5882
5883
5884 /* Asynchronous mouse tracking for scroller.  This allows us to dispatch
5885    mouseDragged events without going into a modal loop. */
5886 - (void)mouseDown: (NSEvent *)e
5887 {
5888   NSRect sr, kr;
5889   /* hitPart is only updated AFTER event is passed on */
5890   NSScrollerPart part = [self testPart: [e locationInWindow]];
5891   double inc = 0.0, loc, kloc, pos;
5892   int edge = 0;
5893
5894   NSTRACE (EmacsScroller_mouseDown);
5895
5896   switch (part)
5897     {
5898     case NSScrollerDecrementPage:
5899         last_hit_part = scroll_bar_above_handle; inc = -1.0; break;
5900     case NSScrollerIncrementPage:
5901         last_hit_part = scroll_bar_below_handle; inc = 1.0; break;
5902     case NSScrollerDecrementLine:
5903       last_hit_part = scroll_bar_up_arrow; inc = -0.1; break;
5904     case NSScrollerIncrementLine:
5905       last_hit_part = scroll_bar_down_arrow; inc = 0.1; break;
5906     case NSScrollerKnob:
5907       last_hit_part = scroll_bar_handle; break;
5908     case NSScrollerKnobSlot:  /* GNUstep-only */
5909       last_hit_part = scroll_bar_move_ratio; break;
5910     default:  /* NSScrollerNoPart? */
5911       fprintf (stderr, "EmacsScoller-mouseDown: unexpected part %ld\n",
5912                (long) part);
5913       return;
5914     }
5915
5916   if (inc != 0.0)
5917     {
5918       pos = 0;      /* ignored */
5919
5920       /* set a timer to repeat, as we can't let superclass do this modally */
5921       scroll_repeat_entry
5922         = [[NSTimer scheduledTimerWithTimeInterval: SCROLL_BAR_FIRST_DELAY
5923                                             target: self
5924                                           selector: @selector (repeatScroll:)
5925                                           userInfo: 0
5926                                            repeats: YES]
5927             retain];
5928     }
5929   else
5930     {
5931       /* handle, or on GNUstep possibly slot */
5932       NSEvent *fake_event;
5933
5934       /* compute float loc in slot and mouse offset on knob */
5935       sr = [self convertRect: [self rectForPart: NSScrollerKnobSlot]
5936                       toView: nil];
5937       loc = NSHeight (sr) - ([e locationInWindow].y - NSMinY (sr));
5938       if (loc <= 0.0)
5939         {
5940           loc = 0.0;
5941           edge = -1;
5942         }
5943       else if (loc >= NSHeight (sr))
5944         {
5945           loc = NSHeight (sr);
5946           edge = 1;
5947         }
5948
5949       if (edge)
5950         kloc = 0.5 * edge;
5951       else
5952         {
5953           kr = [self convertRect: [self rectForPart: NSScrollerKnob]
5954                           toView: nil];
5955           kloc = NSHeight (kr) - ([e locationInWindow].y - NSMinY (kr));
5956         }
5957       last_mouse_offset = kloc;
5958
5959       /* if knob, tell emacs a location offset by knob pos
5960          (to indicate top of handle) */
5961       if (part == NSScrollerKnob)
5962           pos = (loc - last_mouse_offset) / NSHeight (sr);
5963       else
5964         /* else this is a slot click on GNUstep: go straight there */
5965         pos = loc / NSHeight (sr);
5966
5967       /* send a fake mouse-up to super to preempt modal -trackKnob: mode */
5968       fake_event = [NSEvent mouseEventWithType: NSLeftMouseUp
5969                                       location: [e locationInWindow]
5970                                  modifierFlags: [e modifierFlags]
5971                                      timestamp: [e timestamp]
5972                                   windowNumber: [e windowNumber]
5973                                        context: [e context]
5974                                    eventNumber: [e eventNumber]
5975                                     clickCount: [e clickCount]
5976                                       pressure: [e pressure]];
5977       [super mouseUp: fake_event];
5978     }
5979
5980   if (part != NSScrollerKnob)
5981     [self sendScrollEventAtLoc: pos fromEvent: e];
5982 }
5983
5984
5985 /* Called as we manually track scroller drags, rather than superclass. */
5986 - (void)mouseDragged: (NSEvent *)e
5987 {
5988     NSRect sr;
5989     double loc, pos;
5990     int edge = 0;
5991
5992     NSTRACE (EmacsScroller_mouseDragged);
5993
5994       sr = [self convertRect: [self rectForPart: NSScrollerKnobSlot]
5995                       toView: nil];
5996       loc = NSHeight (sr) - ([e locationInWindow].y - NSMinY (sr));
5997
5998       if (loc <= 0.0)
5999         {
6000           loc = 0.0;
6001           edge = -1;
6002         }
6003       else if (loc >= NSHeight (sr) + last_mouse_offset)
6004         {
6005           loc = NSHeight (sr) + last_mouse_offset;
6006           edge = 1;
6007         }
6008
6009       pos = /*(edge ? loc :*/ (loc - last_mouse_offset) / NSHeight (sr);
6010       [self sendScrollEventAtLoc: pos fromEvent: e];
6011 }
6012
6013
6014 - (void)mouseUp: (NSEvent *)e
6015 {
6016   if (scroll_repeat_entry)
6017     {
6018       [scroll_repeat_entry invalidate];
6019       [scroll_repeat_entry release];
6020       scroll_repeat_entry = nil;
6021     }
6022   last_hit_part = 0;
6023 }
6024
6025
6026 /* treat scrollwheel events in the bar as though they were in the main window */
6027 - (void) scrollWheel: (NSEvent *)theEvent
6028 {
6029   EmacsView *view = (EmacsView *)FRAME_NS_VIEW (frame);
6030   [view mouseDown: theEvent];
6031 }
6032
6033 @end  /* EmacsScroller */
6034
6035
6036
6037
6038 /* ==========================================================================
6039
6040    Font-related functions; these used to be in nsfaces.m
6041
6042    ========================================================================== */
6043
6044
6045 Lisp_Object
6046 x_new_font (struct frame *f, Lisp_Object font_object, int fontset)
6047 {
6048   struct font *font = XFONT_OBJECT (font_object);
6049
6050   if (fontset < 0)
6051     fontset = fontset_from_font (font_object);
6052   FRAME_FONTSET (f) = fontset;
6053
6054   if (FRAME_FONT (f) == font)
6055     /* This font is already set in frame F.  There's nothing more to
6056        do.  */
6057     return font_object;
6058
6059   FRAME_FONT (f) = font;
6060
6061   FRAME_BASELINE_OFFSET (f) = font->baseline_offset;
6062   FRAME_COLUMN_WIDTH (f) = font->average_width;
6063   FRAME_SPACE_WIDTH (f) = font->space_width;
6064   FRAME_LINE_HEIGHT (f) = font->height;
6065
6066   compute_fringe_widths (f, 1);
6067
6068   /* Compute the scroll bar width in character columns.  */
6069   if (FRAME_CONFIG_SCROLL_BAR_WIDTH (f) > 0)
6070     {
6071       int wid = FRAME_COLUMN_WIDTH (f);
6072       FRAME_CONFIG_SCROLL_BAR_COLS (f)
6073         = (FRAME_CONFIG_SCROLL_BAR_WIDTH (f) + wid - 1) / wid;
6074     }
6075   else
6076     {
6077       int wid = FRAME_COLUMN_WIDTH (f);
6078       FRAME_CONFIG_SCROLL_BAR_COLS (f) = (14 + wid - 1) / wid;
6079     }
6080
6081   /* Now make the frame display the given font.  */
6082   if (FRAME_NS_WINDOW (f) != 0)
6083         x_set_window_size (f, 0, FRAME_COLS (f), FRAME_LINES (f));
6084
6085   return font_object;
6086 }
6087
6088
6089 /* XLFD: -foundry-family-weight-slant-swidth-adstyle-pxlsz-ptSz-resx-resy-spc-avgWidth-rgstry-encoding */
6090 /* Note: ns_font_to_xlfd and ns_fontname_to_xlfd no longer needed, removed
6091          in 1.43. */
6092
6093 const char *
6094 ns_xlfd_to_fontname (const char *xlfd)
6095 /* --------------------------------------------------------------------------
6096     Convert an X font name (XLFD) to an NS font name.
6097     Only family is used.
6098     The string returned is temporarily allocated.
6099    -------------------------------------------------------------------------- */
6100 {
6101   char *name = xmalloc (180);
6102   int i, len;
6103   const char *ret;
6104
6105   if (!strncmp (xlfd, "--", 2))
6106     sscanf (xlfd, "--%*[^-]-%[^-]179-", name);
6107   else
6108     sscanf (xlfd, "-%*[^-]-%[^-]179-", name);
6109
6110   /* stopgap for malformed XLFD input */
6111   if (strlen (name) == 0)
6112     strcpy (name, "Monaco");
6113
6114   /* undo hack in ns_fontname_to_xlfd, converting '$' to '-', '_' to ' '
6115      also uppercase after '-' or ' ' */
6116   name[0] = toupper (name[0]);
6117   for (len =strlen (name), i =0; i<len; i++)
6118     {
6119       if (name[i] == '$')
6120         {
6121           name[i] = '-';
6122           if (i+1<len)
6123             name[i+1] = toupper (name[i+1]);
6124         }
6125       else if (name[i] == '_')
6126         {
6127           name[i] = ' ';
6128           if (i+1<len)
6129             name[i+1] = toupper (name[i+1]);
6130         }
6131     }
6132 /*fprintf (stderr, "converted '%s' to '%s'\n",xlfd,name);  */
6133   ret = [[NSString stringWithUTF8String: name] UTF8String];
6134   xfree (name);
6135   return ret;
6136 }
6137
6138
6139 void
6140 syms_of_nsterm ()
6141 {
6142   NSTRACE (syms_of_nsterm);
6143
6144   ns_antialias_threshold = 10.0;
6145
6146   /* from 23+ we need to tell emacs what modifiers there are.. */
6147   DEFSYM (Qmodifier_value, "modifier-value");
6148   DEFSYM (Qalt, "alt");
6149   DEFSYM (Qhyper, "hyper");
6150   DEFSYM (Qmeta, "meta");
6151   DEFSYM (Qsuper, "super");
6152   DEFSYM (Qcontrol, "control");
6153   DEFSYM (Qnone, "none");
6154   Fput (Qalt, Qmodifier_value, make_number (alt_modifier));
6155   Fput (Qhyper, Qmodifier_value, make_number (hyper_modifier));
6156   Fput (Qmeta, Qmodifier_value, make_number (meta_modifier));
6157   Fput (Qsuper, Qmodifier_value, make_number (super_modifier));
6158   Fput (Qcontrol, Qmodifier_value, make_number (ctrl_modifier));
6159
6160   DEFVAR_LISP ("ns-input-file", &ns_input_file,
6161               "The file specified in the last NS event.");
6162   ns_input_file =Qnil;
6163
6164   DEFVAR_LISP ("ns-input-text", &ns_input_text,
6165               "The data received in the last NS text drag event.");
6166   ns_input_text =Qnil;
6167
6168   DEFVAR_LISP ("ns-working-text", &ns_working_text,
6169               "String for visualizing working composition sequence.");
6170   ns_working_text =Qnil;
6171
6172   DEFVAR_LISP ("ns-input-font", &ns_input_font,
6173               "The font specified in the last NS event.");
6174   ns_input_font =Qnil;
6175
6176   DEFVAR_LISP ("ns-input-fontsize", &ns_input_fontsize,
6177               "The fontsize specified in the last NS event.");
6178   ns_input_fontsize =Qnil;
6179
6180   DEFVAR_LISP ("ns-input-line", &ns_input_line,
6181                "The line specified in the last NS event.");
6182   ns_input_line =Qnil;
6183
6184   DEFVAR_LISP ("ns-input-color", &ns_input_color,
6185                "The color specified in the last NS event.");
6186   ns_input_color =Qnil;
6187
6188   DEFVAR_LISP ("ns-input-spi-name", &ns_input_spi_name,
6189                "The service name specified in the last NS event.");
6190   ns_input_spi_name =Qnil;
6191
6192   DEFVAR_LISP ("ns-input-spi-arg", &ns_input_spi_arg,
6193                "The service argument specified in the last NS event.");
6194   ns_input_spi_arg =Qnil;
6195
6196   DEFVAR_LISP ("ns-alternate-modifier", &ns_alternate_modifier,
6197                "This variable describes the behavior of the alternate or option key.\n\
6198 Set to control, meta, alt, super, or hyper means it is taken to be that key.\n\
6199 Set to none means that the alternate / option key is not interpreted by Emacs\n\
6200 at all, allowing it to be used at a lower level for accented character entry.");
6201   ns_alternate_modifier = Qmeta;
6202
6203   DEFVAR_LISP ("ns-command-modifier", &ns_command_modifier,
6204                "This variable describes the behavior of the command key.\n\
6205 Set to control, meta, alt, super, or hyper means it is taken to be that key.");
6206   ns_command_modifier = Qsuper;
6207
6208   DEFVAR_LISP ("ns-control-modifier", &ns_control_modifier,
6209                "This variable describes the behavior of the control key.\n\
6210 Set to control, meta, alt, super, or hyper means it is taken to be that key.");
6211   ns_control_modifier = Qcontrol;
6212
6213   DEFVAR_LISP ("ns-function-modifier", &ns_function_modifier,
6214                "This variable describes the behavior of the function key (on laptops).\n\
6215 Set to control, meta, alt, super, or hyper means it is taken to be that key.\n\
6216 Set to none means that the function key is not interpreted by Emacs at all,\n\
6217 allowing it to be used at a lower level for accented character entry.");
6218   ns_function_modifier = Qnone;
6219
6220   DEFVAR_LISP ("ns-antialias-text", &ns_antialias_text,
6221                "Non-nil (the default) means to render text antialiased. Only has an effect on OS X Panther and above.");
6222   ns_antialias_text = Qt;
6223
6224   DEFVAR_LISP ("ns-confirm-quit", &ns_confirm_quit,
6225                "Whether to confirm application quit using dialog.");
6226   ns_confirm_quit = Qnil;
6227
6228   staticpro (&ns_display_name_list);
6229   ns_display_name_list = Qnil;
6230
6231   staticpro (&last_mouse_motion_frame);
6232   last_mouse_motion_frame = Qnil;
6233
6234   /* TODO: move to common code */
6235   DEFVAR_LISP ("x-toolkit-scroll-bars", &Vx_toolkit_scroll_bars,
6236                doc: /* If not nil, Emacs uses toolkit scroll bars.  */);
6237 #ifdef USE_TOOLKIT_SCROLL_BARS
6238   Vx_toolkit_scroll_bars = Qt;
6239 #else
6240   Vx_toolkit_scroll_bars = Qnil;
6241 #endif
6242
6243   /* these are unsupported but we need the declarations to avoid whining
6244      messages from cus-start.el */
6245   DEFVAR_BOOL ("x-use-underline-position-properties",
6246                &x_use_underline_position_properties,
6247      doc: /* NOT SUPPORTED UNDER NS.
6248 *Non-nil means make use of UNDERLINE_POSITION font properties.
6249 A value of nil means ignore them.  If you encounter fonts with bogus
6250 UNDERLINE_POSITION font properties, for example 7x13 on XFree prior
6251 to 4.1, set this to nil.
6252
6253 NOTE: Not supported on Mac yet.  */);
6254   x_use_underline_position_properties = 0;
6255
6256   DEFVAR_BOOL ("x-underline-at-descent-line",
6257                &x_underline_at_descent_line,
6258      doc: /* NOT SUPPORTED UNDER NS.
6259 *Non-nil means to draw the underline at the same place as the descent line.
6260 A value of nil means to draw the underline according to the value of the
6261 variable `x-use-underline-position-properties', which is usually at the
6262 baseline level.  The default value is nil.  */);
6263   x_underline_at_descent_line = 0;
6264
6265   /* Tell emacs about this window system. */
6266   Fprovide (intern ("ns"), Qnil);
6267 }
6268
6269
6270 // arch-tag: 6eaa8f7d-a69b-4e1c-b43d-ab31defbe0d2