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