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