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