src/nsterm.m

   1 /* NeXT/Open/GNUstep / MacOSX communication module.
   2
   3 Copyright (C) 1989, 1993-1994, 2005-2006, 2008-2013
   4   Free Software Foundation, Inc.
   5
   6 This file is part of GNU Emacs.
   7
   8 GNU Emacs is free software: you can redistribute it and/or modify
   9 it under the terms of the GNU General Public License as published by
  10 the Free Software Foundation, either version 3 of the License, or
  11 (at your option) any later version.
  12
  13 GNU Emacs is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
  20
  21 /*
  22 Originally by Carl Edman
  23 Updated by Christian Limpach (chris@nice.ch)
  24 OpenStep/Rhapsody port by Scott Bender (sbender@harmony-ds.com)
  25 MacOSX/Aqua port by Christophe de Dinechin (descubes@earthlink.net)
  26 GNUstep port and post-20 update by Adrian Robert (arobert@cogsci.ucsd.edu)
  27 */
  28
  29 /* This should be the first include, as it may set up #defines affecting
  30    interpretation of even the system includes. */
  31 #include <config.h>
  32
  33 #include <fcntl.h>
  34 #include <math.h>
  35 #include <pthread.h>
  36 #include <sys/types.h>
  37 #include <time.h>
  38 #include <signal.h>
  39 #include <unistd.h>
  40
  41 #include <c-ctype.h>
  42 #include <c-strcase.h>
  43 #include <ftoastr.h>
  44
  45 #include "lisp.h"
  46 #include "blockinput.h"
  47 #include "sysselect.h"
  48 #include "nsterm.h"
  49 #include "systime.h"
  50 #include "character.h"
  51 #include "fontset.h"
  52 #include "composite.h"
  53 #include "ccl.h"
  54
  55 #include "termhooks.h"
  56 #include "termchar.h"
  57
  58 #include "window.h"
  59 #include "keyboard.h"
  60 #include "buffer.h"
  61 #include "font.h"
  62
  63 #ifdef NS_IMPL_GNUSTEP
  64 #include "process.h"
  65 #endif
  66
  67 #ifdef NS_IMPL_COCOA
  68 #if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5
  69 #include "macfont.h"
  70 #endif
  71 #endif
  72
  73 /* call tracing */
  74 #if 0
  75 int term_trace_num = 0;
  76 #define NSTRACE(x)        fprintf (stderr, "%s:%d: [%d] " #x "\n",         \
  77                                 __FILE__, __LINE__, ++term_trace_num)
  78 #else
  79 #define NSTRACE(x)
  80 #endif
  81
  82 extern NSString *NSMenuDidBeginTrackingNotification;
  83
  84 /* ==========================================================================
  85
  86     Local declarations
  87
  88    ========================================================================== */
  89
  90 /* Convert a symbol indexed with an NSxxx value to a value as defined
  91    in keyboard.c (lispy_function_key). I hope this is a correct way
  92    of doing things... */
  93 static unsigned convert_ns_to_X_keysym[] =
  94 {
  95   NSHomeFunctionKey,            0x50,
  96   NSLeftArrowFunctionKey,       0x51,
  97   NSUpArrowFunctionKey,         0x52,
  98   NSRightArrowFunctionKey,      0x53,
  99   NSDownArrowFunctionKey,       0x54,
 100   NSPageUpFunctionKey,          0x55,
 101   NSPageDownFunctionKey,        0x56,
 102   NSEndFunctionKey,             0x57,
 103   NSBeginFunctionKey,           0x58,
 104   NSSelectFunctionKey,          0x60,
 105   NSPrintFunctionKey,           0x61,
 106   NSClearLineFunctionKey,       0x0B,
 107   NSExecuteFunctionKey,         0x62,
 108   NSInsertFunctionKey,          0x63,
 109   NSUndoFunctionKey,            0x65,
 110   NSRedoFunctionKey,            0x66,
 111   NSMenuFunctionKey,            0x67,
 112   NSFindFunctionKey,            0x68,
 113   NSHelpFunctionKey,            0x6A,
 114   NSBreakFunctionKey,           0x6B,
 115
 116   NSF1FunctionKey,              0xBE,
 117   NSF2FunctionKey,              0xBF,
 118   NSF3FunctionKey,              0xC0,
 119   NSF4FunctionKey,              0xC1,
 120   NSF5FunctionKey,              0xC2,
 121   NSF6FunctionKey,              0xC3,
 122   NSF7FunctionKey,              0xC4,
 123   NSF8FunctionKey,              0xC5,
 124   NSF9FunctionKey,              0xC6,
 125   NSF10FunctionKey,             0xC7,
 126   NSF11FunctionKey,             0xC8,
 127   NSF12FunctionKey,             0xC9,
 128   NSF13FunctionKey,             0xCA,
 129   NSF14FunctionKey,             0xCB,
 130   NSF15FunctionKey,             0xCC,
 131   NSF16FunctionKey,             0xCD,
 132   NSF17FunctionKey,             0xCE,
 133   NSF18FunctionKey,             0xCF,
 134   NSF19FunctionKey,             0xD0,
 135   NSF20FunctionKey,             0xD1,
 136   NSF21FunctionKey,             0xD2,
 137   NSF22FunctionKey,             0xD3,
 138   NSF23FunctionKey,             0xD4,
 139   NSF24FunctionKey,             0xD5,
 140
 141   NSBackspaceCharacter,         0x08,  /* 8: Not on some KBs. */
 142   NSDeleteCharacter,            0xFF,  /* 127: Big 'delete' key upper right. */
 143   NSDeleteFunctionKey,          0x9F,  /* 63272: Del forw key off main array. */
 144
 145   NSTabCharacter,               0x09,
 146   0x19,                         0x09,  /* left tab->regular since pass shift */
 147   NSCarriageReturnCharacter,    0x0D,
 148   NSNewlineCharacter,           0x0D,
 149   NSEnterCharacter,             0x8D,
 150
 151   0x41|NSNumericPadKeyMask,     0xAE,  /* KP_Decimal */
 152   0x43|NSNumericPadKeyMask,     0xAA,  /* KP_Multiply */
 153   0x45|NSNumericPadKeyMask,     0xAB,  /* KP_Add */
 154   0x4B|NSNumericPadKeyMask,     0xAF,  /* KP_Divide */
 155   0x4E|NSNumericPadKeyMask,     0xAD,  /* KP_Subtract */
 156   0x51|NSNumericPadKeyMask,     0xBD,  /* KP_Equal */
 157   0x52|NSNumericPadKeyMask,     0xB0,  /* KP_0 */
 158   0x53|NSNumericPadKeyMask,     0xB1,  /* KP_1 */
 159   0x54|NSNumericPadKeyMask,     0xB2,  /* KP_2 */
 160   0x55|NSNumericPadKeyMask,     0xB3,  /* KP_3 */
 161   0x56|NSNumericPadKeyMask,     0xB4,  /* KP_4 */
 162   0x57|NSNumericPadKeyMask,     0xB5,  /* KP_5 */
 163   0x58|NSNumericPadKeyMask,     0xB6,  /* KP_6 */
 164   0x59|NSNumericPadKeyMask,     0xB7,  /* KP_7 */
 165   0x5B|NSNumericPadKeyMask,     0xB8,  /* KP_8 */
 166   0x5C|NSNumericPadKeyMask,     0xB9,  /* KP_9 */
 167
 168   0x1B,                         0x1B   /* escape */
 169 };
 170
 171 static Lisp_Object Qmodifier_value;
 172 Lisp_Object Qalt, Qcontrol, Qhyper, Qmeta, Qsuper;
 173 extern Lisp_Object Qcursor_color, Qcursor_type, Qns, Qleft;
 174
 175 static Lisp_Object QUTF8_STRING;
 176 static Lisp_Object Qcocoa, Qgnustep;
 177
 178 /* On OS X picks up the default NSGlobalDomain AppleAntiAliasingThreshold,
 179    the maximum font size to NOT antialias.  On GNUstep there is currently
 180    no way to control this behavior. */
 181 float ns_antialias_threshold;
 182
 183 NSArray *ns_send_types =0, *ns_return_types =0, *ns_drag_types =0;
 184 NSString *ns_app_name = @"Emacs";  /* default changed later */
 185
 186 /* Display variables */
 187 struct ns_display_info *x_display_list; /* Chain of existing displays */
 188 long context_menu_value = 0;
 189
 190 /* display update */
 191 static struct frame *ns_updating_frame;
 192 static NSView *focus_view = NULL;
 193 static int ns_window_num = 0;
 194 #ifdef NS_IMPL_GNUSTEP
 195 static NSRect uRect;
 196 #endif
 197 static BOOL gsaved = NO;
 198 static BOOL ns_fake_keydown = NO;
 199 #ifdef NS_IMPL_COCOA
 200 static BOOL ns_menu_bar_is_hidden = NO;
 201 #endif
 202 /*static int debug_lock = 0; */
 203
 204 /* event loop */
 205 static BOOL send_appdefined = YES;
 206 #define NO_APPDEFINED_DATA (-8)
 207 static int last_appdefined_event_data = NO_APPDEFINED_DATA;
 208 static NSTimer *timed_entry = 0;
 209 static NSTimer *scroll_repeat_entry = nil;
 210 static fd_set select_readfds, select_writefds;
 211 enum { SELECT_HAVE_READ = 1, SELECT_HAVE_WRITE = 2, SELECT_HAVE_TMO = 4 };
 212 static int select_nfds = 0, select_valid = 0;
 213 static struct timespec select_timeout = { 0, 0 };
 214 static int selfds[2] = { -1, -1 };
 215 static pthread_mutex_t select_mutex;
 216 static int apploopnr = 0;
 217 static NSAutoreleasePool *outerpool;
 218 static struct input_event *emacs_event = NULL;
 219 static struct input_event *q_event_ptr = NULL;
 220 static int n_emacs_events_pending = 0;
 221 static NSMutableArray *ns_pending_files, *ns_pending_service_names,
 222   *ns_pending_service_args;
 223 static BOOL ns_do_open_file = NO;
 224 static BOOL ns_last_use_native_fullscreen;
 225
 226 static struct {
 227   struct input_event *q;
 228   int nr, cap;
 229 } hold_event_q = {
 230   NULL, 0, 0
 231 };
 232
 233 #ifdef NS_IMPL_COCOA
 234 /*
 235  * State for pending menu activation:
 236  * MENU_NONE     Normal state
 237  * MENU_PENDING  A menu has been clicked on, but has been canceled so we can
 238  *               run lisp to update the menu.
 239  * MENU_OPENING  Menu is up to date, and the click event is redone so the menu
 240  *               will open.
 241  */
 242 #define MENU_NONE 0
 243 #define MENU_PENDING 1
 244 #define MENU_OPENING 2
 245 static int menu_will_open_state = MENU_NONE;
 246
 247 /* Saved position for menu click.  */
 248 static CGPoint menu_mouse_point;
 249 #endif
 250
 251 /* Convert modifiers in a NeXTstep event to emacs style modifiers.  */
 252 #define NS_FUNCTION_KEY_MASK 0x800000
 253 #define NSLeftControlKeyMask    (0x000001 | NSControlKeyMask)
 254 #define NSRightControlKeyMask   (0x002000 | NSControlKeyMask)
 255 #define NSLeftCommandKeyMask    (0x000008 | NSCommandKeyMask)
 256 #define NSRightCommandKeyMask   (0x000010 | NSCommandKeyMask)
 257 #define NSLeftAlternateKeyMask  (0x000020 | NSAlternateKeyMask)
 258 #define NSRightAlternateKeyMask (0x000040 | NSAlternateKeyMask)
 259 #define EV_MODIFIERS(e)                               \
 260     ((([e modifierFlags] & NSHelpKeyMask) ?           \
 261            hyper_modifier : 0)                        \
 262      | (!EQ (ns_right_alternate_modifier, Qleft) && \
 263         (([e modifierFlags] & NSRightAlternateKeyMask) \
 264          == NSRightAlternateKeyMask) ? \
 265            parse_solitary_modifier (ns_right_alternate_modifier) : 0) \
 266      | (([e modifierFlags] & NSAlternateKeyMask) ?                 \
 267            parse_solitary_modifier (ns_alternate_modifier) : 0)   \
 268      | (([e modifierFlags] & NSShiftKeyMask) ?     \
 269            shift_modifier : 0)                        \
 270      | (!EQ (ns_right_control_modifier, Qleft) && \
 271         (([e modifierFlags] & NSRightControlKeyMask) \
 272          == NSRightControlKeyMask) ? \
 273            parse_solitary_modifier (ns_right_control_modifier) : 0) \
 274      | (([e modifierFlags] & NSControlKeyMask) ?      \
 275            parse_solitary_modifier (ns_control_modifier) : 0)     \
 276      | (([e modifierFlags] & NS_FUNCTION_KEY_MASK) ?  \
 277            parse_solitary_modifier (ns_function_modifier) : 0)    \
 278      | (!EQ (ns_right_command_modifier, Qleft) && \
 279         (([e modifierFlags] & NSRightCommandKeyMask) \
 280          == NSRightCommandKeyMask) ? \
 281            parse_solitary_modifier (ns_right_command_modifier) : 0) \
 282      | (([e modifierFlags] & NSCommandKeyMask) ?      \
 283            parse_solitary_modifier (ns_command_modifier):0))
 284
 285 #define EV_UDMODIFIERS(e)                                      \
 286     ((([e type] == NSLeftMouseDown) ? down_modifier : 0)       \
 287      | (([e type] == NSRightMouseDown) ? down_modifier : 0)    \
 288      | (([e type] == NSOtherMouseDown) ? down_modifier : 0)    \
 289      | (([e type] == NSLeftMouseDragged) ? down_modifier : 0)  \
 290      | (([e type] == NSRightMouseDragged) ? down_modifier : 0) \
 291      | (([e type] == NSOtherMouseDragged) ? down_modifier : 0) \
 292      | (([e type] == NSLeftMouseUp)   ? up_modifier   : 0)     \
 293      | (([e type] == NSRightMouseUp)   ? up_modifier   : 0)    \
 294      | (([e type] == NSOtherMouseUp)   ? up_modifier   : 0))
 295
 296 #define EV_BUTTON(e)                                                         \
 297     ((([e type] == NSLeftMouseDown) || ([e type] == NSLeftMouseUp)) ? 0 :    \
 298       (([e type] == NSRightMouseDown) || ([e type] == NSRightMouseUp)) ? 2 : \
 299      [e buttonNumber] - 1)
 300
 301 /* Convert the time field to a timestamp in milliseconds. */
 302 #define EV_TIMESTAMP(e) ([e timestamp] * 1000)
 303
 304 /* This is a piece of code which is common to all the event handling
 305    methods.  Maybe it should even be a function.  */
 306 #define EV_TRAILER(e)                                                   \
 307   {                                                                     \
 308     XSETFRAME (emacs_event->frame_or_window, emacsframe);               \
 309     EV_TRAILER2 (e);                                                    \
 310   }
 311
 312 #define EV_TRAILER2(e)                                                  \
 313   {                                                                     \
 314       if (e) emacs_event->timestamp = EV_TIMESTAMP (e);                 \
 315       if (q_event_ptr)                                                  \
 316         {                                                               \
 317           n_emacs_events_pending++;                                     \
 318           kbd_buffer_store_event_hold (emacs_event, q_event_ptr);       \
 319         }                                                               \
 320       else                                                              \
 321         hold_event (emacs_event);                                       \
 322       EVENT_INIT (*emacs_event);                                        \
 323       ns_send_appdefined (-1);                                          \
 324     }
 325
 326 /* TODO: get rid of need for these forward declarations */
 327 static void ns_condemn_scroll_bars (struct frame *f);
 328 static void ns_judge_scroll_bars (struct frame *f);
 329 void x_set_frame_alpha (struct frame *f);
 330
 331
 332 /* ==========================================================================
 333
 334     Utilities
 335
 336    ========================================================================== */
 337
 338 static void
 339 hold_event (struct input_event *event)
 340 {
 341   if (hold_event_q.nr == hold_event_q.cap)
 342     {
 343       if (hold_event_q.cap == 0) hold_event_q.cap = 10;
 344       else hold_event_q.cap *= 2;
 345       hold_event_q.q =
 346         xrealloc (hold_event_q.q, hold_event_q.cap * sizeof *hold_event_q.q);
 347     }
 348
 349   hold_event_q.q[hold_event_q.nr++] = *event;
 350   /* Make sure ns_read_socket is called, i.e. we have input.  */
 351   raise (SIGIO);
 352   send_appdefined = YES;
 353 }
 354
 355 static Lisp_Object
 356 append2 (Lisp_Object list, Lisp_Object item)
 357 /* --------------------------------------------------------------------------
 358    Utility to append to a list
 359    -------------------------------------------------------------------------- */
 360 {
 361   Lisp_Object array[2];
 362   array[0] = list;
 363   array[1] = list1 (item);
 364   return Fnconc (2, &array[0]);
 365 }
 366
 367
 368 const char *
 369 ns_etc_directory (void)
 370 /* If running as a self-contained app bundle, return as a string the
 371    filename of the etc directory, if present; else nil.  */
 372 {
 373   NSBundle *bundle = [NSBundle mainBundle];
 374   NSString *resourceDir = [bundle resourcePath];
 375   NSString *resourcePath;
 376   NSFileManager *fileManager = [NSFileManager defaultManager];
 377   BOOL isDir;
 378
 379   resourcePath = [resourceDir stringByAppendingPathComponent: @"etc"];
 380   if ([fileManager fileExistsAtPath: resourcePath isDirectory: &isDir])
 381     {
 382       if (isDir) return [resourcePath UTF8String];
 383     }
 384   return NULL;
 385 }
 386
 387
 388 const char *
 389 ns_exec_path (void)
 390 /* If running as a self-contained app bundle, return as a path string
 391    the filenames of the libexec and bin directories, ie libexec:bin.
 392    Otherwise, return nil.
 393    Normally, Emacs does not add its own bin/ directory to the PATH.
 394    However, a self-contained NS build has a different layout, with
 395    bin/ and libexec/ subdirectories in the directory that contains
 396    Emacs.app itself.
 397    We put libexec first, because init_callproc_1 uses the first
 398    element to initialize exec-directory.  An alternative would be
 399    for init_callproc to check for invocation-directory/libexec.
 400 */
 401 {
 402   NSBundle *bundle = [NSBundle mainBundle];
 403   NSString *resourceDir = [bundle resourcePath];
 404   NSString *binDir = [bundle bundlePath];
 405   NSString *resourcePath, *resourcePaths;
 406   NSRange range;
 407   NSString *pathSeparator = [NSString stringWithFormat: @"%c", SEPCHAR];
 408   NSFileManager *fileManager = [NSFileManager defaultManager];
 409   NSArray *paths;
 410   NSEnumerator *pathEnum;
 411   BOOL isDir;
 412
 413   range = [resourceDir rangeOfString: @"Contents"];
 414   if (range.location != NSNotFound)
 415     {
 416       binDir = [binDir stringByAppendingPathComponent: @"Contents"];
 417 #ifdef NS_IMPL_COCOA
 418       binDir = [binDir stringByAppendingPathComponent: @"MacOS"];
 419 #endif
 420     }
 421
 422   paths = [binDir stringsByAppendingPaths:
 423                 [NSArray arrayWithObjects: @"libexec", @"bin", nil]];
 424   pathEnum = [paths objectEnumerator];
 425   resourcePaths = @"";
 426
 427   while ((resourcePath = [pathEnum nextObject]))
 428     {
 429       if ([fileManager fileExistsAtPath: resourcePath isDirectory: &isDir])
 430         if (isDir)
 431           {
 432             if ([resourcePaths length] > 0)
 433               resourcePaths
 434                 = [resourcePaths stringByAppendingString: pathSeparator];
 435             resourcePaths
 436               = [resourcePaths stringByAppendingString: resourcePath];
 437           }
 438     }
 439   if ([resourcePaths length] > 0) return [resourcePaths UTF8String];
 440
 441   return NULL;
 442 }
 443
 444
 445 const char *
 446 ns_load_path (void)
 447 /* If running as a self-contained app bundle, return as a path string
 448    the filenames of the site-lisp and lisp directories.
 449    Ie, site-lisp:lisp.  Otherwise, return nil.  */
 450 {
 451   NSBundle *bundle = [NSBundle mainBundle];
 452   NSString *resourceDir = [bundle resourcePath];
 453   NSString *resourcePath, *resourcePaths;
 454   NSString *pathSeparator = [NSString stringWithFormat: @"%c", SEPCHAR];
 455   NSFileManager *fileManager = [NSFileManager defaultManager];
 456   BOOL isDir;
 457   NSArray *paths = [resourceDir stringsByAppendingPaths:
 458                               [NSArray arrayWithObjects:
 459                                          @"site-lisp", @"lisp", nil]];
 460   NSEnumerator *pathEnum = [paths objectEnumerator];
 461   resourcePaths = @"";
 462
 463   /* Hack to skip site-lisp.  */
 464   if (no_site_lisp) resourcePath = [pathEnum nextObject];
 465
 466   while ((resourcePath = [pathEnum nextObject]))
 467     {
 468       if ([fileManager fileExistsAtPath: resourcePath isDirectory: &isDir])
 469         if (isDir)
 470           {
 471             if ([resourcePaths length] > 0)
 472               resourcePaths
 473                 = [resourcePaths stringByAppendingString: pathSeparator];
 474             resourcePaths
 475               = [resourcePaths stringByAppendingString: resourcePath];
 476           }
 477     }
 478   if ([resourcePaths length] > 0) return [resourcePaths UTF8String];
 479
 480   return NULL;
 481 }
 482
 483 static void
 484 ns_timeout (int usecs)
 485 /* --------------------------------------------------------------------------
 486      Blocking timer utility used by ns_ring_bell
 487    -------------------------------------------------------------------------- */
 488 {
 489   struct timespec wakeup = timespec_add (current_timespec (),
 490                                          make_timespec (0, usecs * 1000));
 491
 492   /* Keep waiting until past the time wakeup.  */
 493   while (1)
 494     {
 495       struct timespec timeout, now = current_timespec ();
 496       if (timespec_cmp (wakeup, now) <= 0)
 497         break;
 498       timeout = timespec_sub (wakeup, now);
 499
 500       /* Try to wait that long--but we might wake up sooner.  */
 501       pselect (0, NULL, NULL, NULL, &timeout, NULL);
 502     }
 503 }
 504
 505
 506 void
 507 ns_release_object (void *obj)
 508 /* --------------------------------------------------------------------------
 509     Release an object (callable from C)
 510    -------------------------------------------------------------------------- */
 511 {
 512     [(id)obj release];
 513 }
 514
 515
 516 void
 517 ns_retain_object (void *obj)
 518 /* --------------------------------------------------------------------------
 519     Retain an object (callable from C)
 520    -------------------------------------------------------------------------- */
 521 {
 522     [(id)obj retain];
 523 }
 524
 525
 526 void *
 527 ns_alloc_autorelease_pool (void)
 528 /* --------------------------------------------------------------------------
 529      Allocate a pool for temporary objects (callable from C)
 530    -------------------------------------------------------------------------- */
 531 {
 532   return [[NSAutoreleasePool alloc] init];
 533 }
 534
 535
 536 void
 537 ns_release_autorelease_pool (void *pool)
 538 /* --------------------------------------------------------------------------
 539      Free a pool and temporary objects it refers to (callable from C)
 540    -------------------------------------------------------------------------- */
 541 {
 542   ns_release_object (pool);
 543 }
 544
 545
 546
 547 /* ==========================================================================
 548
 549     Focus (clipping) and screen update
 550
 551    ========================================================================== */
 552
 553 //
 554 // Window constraining
 555 // -------------------
 556 //
 557 // To ensure that the windows are not placed under the menu bar, they
 558 // are typically moved by the call-back constrainFrameRect. However,
 559 // by overriding it, it's possible to inhibit this, leaving the window
 560 // in it's original position.
 561 //
 562 // It's possible to hide the menu bar. However, technically, it's only
 563 // possible to hide it when the application is active. To ensure that
 564 // this work properly, the menu bar and window constraining are
 565 // deferred until the application becomes active.
 566 //
 567 // Even though it's not possible to manually move a window above the
 568 // top of the screen, it is allowed if it's done programmatically,
 569 // when the menu is hidden. This allows the editable area to cover the
 570 // full screen height.
 571 //
 572 // Test cases
 573 // ----------
 574 //
 575 // Use the following extra files:
 576 //
 577 //    init.el:
 578 //       ;; Hide menu and place frame slightly above the top of the screen.
 579 //       (setq ns-auto-hide-menu-bar t)
 580 //       (set-frame-position (selected-frame) 0 -20)
 581 //
 582 // Test 1:
 583 //
 584 //    emacs -Q -l init.el
 585 //
 586 //    Result: No menu bar, and the title bar should be above the screen.
 587 //
 588 // Test 2:
 589 //
 590 //    emacs -Q
 591 //
 592 //    Result: Menu bar visible, frame placed immediately below the menu.
 593 //
 594
 595 static void
 596 ns_constrain_all_frames (void)
 597 {
 598   Lisp_Object tail, frame;
 599
 600   FOR_EACH_FRAME (tail, frame)
 601     {
 602       struct frame *f = XFRAME (frame);
 603       if (FRAME_NS_P (f))
 604         {
 605           NSView *view = FRAME_NS_VIEW (f);
 606           /* This no-op will trigger the default window placing
 607            * constraint system. */
 608           f->output_data.ns->dont_constrain = 0;
 609           [[view window] setFrameOrigin:[[view window] frame].origin];
 610         }
 611     }
 612 }
 613
 614
 615 /* True, if the menu bar should be hidden.  */
 616
 617 static BOOL
 618 ns_menu_bar_should_be_hidden (void)
 619 {
 620   return !NILP (ns_auto_hide_menu_bar)
 621     && [NSApp respondsToSelector:@selector(setPresentationOptions:)];
 622 }
 623
 624
 625 /* Show or hide the menu bar, based on user setting.  */
 626
 627 static void
 628 ns_update_auto_hide_menu_bar (void)
 629 {
 630 #ifdef NS_IMPL_COCOA
 631 #if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_6
 632   block_input ();
 633
 634   NSTRACE (ns_update_auto_hide_menu_bar);
 635
 636   if (NSApp != nil && [NSApp isActive])
 637     {
 638       // Note, "setPresentationOptions" triggers an error unless the
 639       // application is active.
 640       BOOL menu_bar_should_be_hidden = ns_menu_bar_should_be_hidden ();
 641
 642       if (menu_bar_should_be_hidden != ns_menu_bar_is_hidden)
 643         {
 644           NSApplicationPresentationOptions options
 645             = NSApplicationPresentationDefault;
 646
 647           if (menu_bar_should_be_hidden)
 648             options |= NSApplicationPresentationAutoHideMenuBar
 649               | NSApplicationPresentationAutoHideDock;
 650
 651           [NSApp setPresentationOptions: options];
 652
 653           ns_menu_bar_is_hidden = menu_bar_should_be_hidden;
 654
 655           if (!ns_menu_bar_is_hidden)
 656             {
 657               ns_constrain_all_frames ();
 658             }
 659         }
 660     }
 661
 662   unblock_input ();
 663 #endif
 664 #endif
 665 }
 666
 667
 668 static void
 669 ns_update_begin (struct frame *f)
 670 /* --------------------------------------------------------------------------
 671    Prepare for a grouped sequence of drawing calls
 672    external (RIF) call; whole frame, called before update_window_begin
 673    -------------------------------------------------------------------------- */
 674 {
 675   EmacsView *view = FRAME_NS_VIEW (f);
 676   NSTRACE (ns_update_begin);
 677
 678   ns_update_auto_hide_menu_bar ();
 679
 680 #ifdef NS_IMPL_COCOA
 681   if ([view isFullscreen] && [view fsIsNative])
 682   {
 683     // Fix reappearing tool bar in fullscreen for OSX 10.7
 684     BOOL tbar_visible = FRAME_EXTERNAL_TOOL_BAR (f) ? YES : NO;
 685     NSToolbar *toolbar = [FRAME_NS_VIEW (f) toolbar];
 686     if (! tbar_visible != ! [toolbar isVisible])
 687       [toolbar setVisible: tbar_visible];
 688   }
 689 #endif
 690
 691   ns_updating_frame = f;
 692   [view lockFocus];
 693
 694   /* drawRect may have been called for say the minibuffer, and then clip path
 695      is for the minibuffer.  But the display engine may draw more because
 696      we have set the frame as garbaged.  So reset clip path to the whole
 697      view.  */
 698 #ifdef NS_IMPL_COCOA
 699   {
 700     NSBezierPath *bp;
 701     NSRect r = [view frame];
 702     NSRect cr = [[view window] frame];
 703     /* If a large frame size is set, r may be larger than the window frame
 704        before constrained.  In that case don't change the clip path, as we
 705        will clear in to the tool bar and title bar.  */
 706     if (r.size.height
 707         + FRAME_NS_TITLEBAR_HEIGHT (f)
 708         + FRAME_TOOLBAR_HEIGHT (f) <= cr.size.height)
 709       {
 710         bp = [[NSBezierPath bezierPathWithRect: r] retain];
 711         [bp setClip];
 712         [bp release];
 713       }
 714   }
 715 #endif
 716
 717 #ifdef NS_IMPL_GNUSTEP
 718   uRect = NSMakeRect (0, 0, 0, 0);
 719 #endif
 720 }
 721
 722
 723 static void
 724 ns_update_window_begin (struct window *w)
 725 /* --------------------------------------------------------------------------
 726    Prepare for a grouped sequence of drawing calls
 727    external (RIF) call; for one window, called after update_begin
 728    -------------------------------------------------------------------------- */
 729 {
 730   struct frame *f = XFRAME (WINDOW_FRAME (w));
 731   Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (f);
 732
 733   NSTRACE (ns_update_window_begin);
 734   w->output_cursor = w->cursor;
 735
 736   block_input ();
 737
 738   if (f == hlinfo->mouse_face_mouse_frame)
 739     {
 740       /* Don't do highlighting for mouse motion during the update.  */
 741       hlinfo->mouse_face_defer = 1;
 742
 743         /* If the frame needs to be redrawn,
 744            simply forget about any prior mouse highlighting.  */
 745       if (FRAME_GARBAGED_P (f))
 746         hlinfo->mouse_face_window = Qnil;
 747
 748       /* (further code for mouse faces ifdef'd out in other terms elided) */
 749     }
 750
 751   unblock_input ();
 752 }
 753
 754
 755 static void
 756 ns_update_window_end (struct window *w, bool cursor_on_p,
 757                       bool mouse_face_overwritten_p)
 758 /* --------------------------------------------------------------------------
 759    Finished a grouped sequence of drawing calls
 760    external (RIF) call; for one window called before update_end
 761    -------------------------------------------------------------------------- */
 762 {
 763   /* note: this fn is nearly identical in all terms */
 764   if (!w->pseudo_window_p)
 765     {
 766       block_input ();
 767
 768       if (cursor_on_p)
 769         display_and_set_cursor (w, 1,
 770                                 w->output_cursor.hpos, w->output_cursor.vpos,
 771                                 w->output_cursor.x, w->output_cursor.y);
 772
 773       if (draw_window_fringes (w, 1))
 774         {
 775           if (WINDOW_RIGHT_DIVIDER_WIDTH (w))
 776             x_draw_right_divider (w);
 777           else
 778             x_draw_vertical_border (w);
 779         }
 780
 781       unblock_input ();
 782     }
 783
 784   /* If a row with mouse-face was overwritten, arrange for
 785      frame_up_to_date to redisplay the mouse highlight.  */
 786   if (mouse_face_overwritten_p)
 787     reset_mouse_highlight (MOUSE_HL_INFO (XFRAME (w->frame)));
 788
 789   NSTRACE (update_window_end);
 790 }
 791
 792
 793 static void
 794 ns_update_end (struct frame *f)
 795 /* --------------------------------------------------------------------------
 796    Finished a grouped sequence of drawing calls
 797    external (RIF) call; for whole frame, called after update_window_end
 798    -------------------------------------------------------------------------- */
 799 {
 800   EmacsView *view = FRAME_NS_VIEW (f);
 801
 802 /*   if (f == MOUSE_HL_INFO (f)->mouse_face_mouse_frame) */
 803   MOUSE_HL_INFO (f)->mouse_face_defer = 0;
 804
 805   block_input ();
 806
 807   [view unlockFocus];
 808   [[view window] flushWindow];
 809
 810   unblock_input ();
 811   ns_updating_frame = NULL;
 812   NSTRACE (ns_update_end);
 813 }
 814
 815 static void
 816 ns_focus (struct frame *f, NSRect *r, int n)
 817 /* --------------------------------------------------------------------------
 818    Internal: Focus on given frame.  During small local updates this is used to
 819      draw, however during large updates, ns_update_begin and ns_update_end are
 820      called to wrap the whole thing, in which case these calls are stubbed out.
 821      Except, on GNUstep, we accumulate the rectangle being drawn into, because
 822      the back end won't do this automatically, and will just end up flushing
 823      the entire window.
 824    -------------------------------------------------------------------------- */
 825 {
 826 //  NSTRACE (ns_focus);
 827 /* static int c =0;
 828    fprintf (stderr, "focus: %d", c++);
 829    if (r) fprintf (stderr, " (%.0f, %.0f : %.0f x %.0f)", r->origin.x, r->origin.y, r->size.width, r->size.height);
 830    fprintf (stderr, "\n"); */
 831
 832   if (f != ns_updating_frame)
 833     {
 834       NSView *view = FRAME_NS_VIEW (f);
 835       if (view != focus_view)
 836         {
 837           if (focus_view != NULL)
 838             {
 839               [focus_view unlockFocus];
 840               [[focus_view window] flushWindow];
 841 /*debug_lock--; */
 842             }
 843
 844           if (view)
 845             [view lockFocus];
 846           focus_view = view;
 847 /*if (view) debug_lock++; */
 848         }
 849     }
 850
 851   /* clipping */
 852   if (r)
 853     {
 854       [[NSGraphicsContext currentContext] saveGraphicsState];
 855       if (n == 2)
 856         NSRectClipList (r, 2);
 857       else
 858         NSRectClip (*r);
 859       gsaved = YES;
 860     }
 861 }
 862
 863
 864 static void
 865 ns_unfocus (struct frame *f)
 866 /* --------------------------------------------------------------------------
 867      Internal: Remove focus on given frame
 868    -------------------------------------------------------------------------- */
 869 {
 870 //  NSTRACE (ns_unfocus);
 871
 872   if (gsaved)
 873     {
 874       [[NSGraphicsContext currentContext] restoreGraphicsState];
 875       gsaved = NO;
 876     }
 877
 878   if (f != ns_updating_frame)
 879     {
 880       if (focus_view != NULL)
 881         {
 882           [focus_view unlockFocus];
 883           [[focus_view window] flushWindow];
 884           focus_view = NULL;
 885 /*debug_lock--; */
 886         }
 887     }
 888 }
 889
 890
 891 static void
 892 ns_clip_to_row (struct window *w, struct glyph_row *row,
 893                 enum glyph_row_area area, BOOL gc)
 894 /* --------------------------------------------------------------------------
 895      Internal (but parallels other terms): Focus drawing on given row
 896    -------------------------------------------------------------------------- */
 897 {
 898   struct frame *f = XFRAME (WINDOW_FRAME (w));
 899   NSRect clip_rect;
 900   int window_x, window_y, window_width;
 901
 902   window_box (w, area, &window_x, &window_y, &window_width, 0);
 903
 904   clip_rect.origin.x = window_x;
 905   clip_rect.origin.y = WINDOW_TO_FRAME_PIXEL_Y (w, max (0, row->y));
 906   clip_rect.origin.y = max (clip_rect.origin.y, window_y);
 907   clip_rect.size.width = window_width;
 908   clip_rect.size.height = row->visible_height;
 909
 910   ns_focus (f, &clip_rect, 1);
 911 }
 912
 913
 914 static void
 915 ns_ring_bell (struct frame *f)
 916 /* --------------------------------------------------------------------------
 917      "Beep" routine
 918    -------------------------------------------------------------------------- */
 919 {
 920   NSTRACE (ns_ring_bell);
 921   if (visible_bell)
 922     {
 923       NSAutoreleasePool *pool;
 924       struct frame *frame = SELECTED_FRAME ();
 925       NSView *view;
 926
 927       block_input ();
 928       pool = [[NSAutoreleasePool alloc] init];
 929
 930       view = FRAME_NS_VIEW (frame);
 931       if (view != nil)
 932         {
 933           NSRect r, surr;
 934           NSPoint dim = NSMakePoint (128, 128);
 935
 936           r = [view bounds];
 937           r.origin.x += (r.size.width - dim.x) / 2;
 938           r.origin.y += (r.size.height - dim.y) / 2;
 939           r.size.width = dim.x;
 940           r.size.height = dim.y;
 941           surr = NSInsetRect (r, -2, -2);
 942           ns_focus (frame, &surr, 1);
 943           [[view window] cacheImageInRect: [view convertRect: surr toView:nil]];
 944           [ns_lookup_indexed_color (NS_FACE_FOREGROUND
 945                                       (FRAME_DEFAULT_FACE (frame)), frame) set];
 946           NSRectFill (r);
 947           [[view window] flushWindow];
 948           ns_timeout (150000);
 949           [[view window] restoreCachedImage];
 950           [[view window] flushWindow];
 951           ns_unfocus (frame);
 952         }
 953       [pool release];
 954       unblock_input ();
 955     }
 956   else
 957     {
 958       NSBeep ();
 959     }
 960 }
 961
 962 /* ==========================================================================
 963
 964     Frame / window manager related functions
 965
 966    ========================================================================== */
 967
 968
 969 static void
 970 ns_raise_frame (struct frame *f)
 971 /* --------------------------------------------------------------------------
 972      Bring window to foreground and make it active
 973    -------------------------------------------------------------------------- */
 974 {
 975   NSView *view;
 976   check_window_system (f);
 977   view = FRAME_NS_VIEW (f);
 978   block_input ();
 979   if (FRAME_VISIBLE_P (f))
 980     [[view window] makeKeyAndOrderFront: NSApp];
 981   unblock_input ();
 982 }
 983
 984
 985 static void
 986 ns_lower_frame (struct frame *f)
 987 /* --------------------------------------------------------------------------
 988      Send window to back
 989    -------------------------------------------------------------------------- */
 990 {
 991   NSView *view;
 992   check_window_system (f);
 993   view = FRAME_NS_VIEW (f);
 994   block_input ();
 995   [[view window] orderBack: NSApp];
 996   unblock_input ();
 997 }
 998
 999
1000 static void
1001 ns_frame_raise_lower (struct frame *f, int raise)
1002 /* --------------------------------------------------------------------------
1003      External (hook)
1004    -------------------------------------------------------------------------- */
1005 {
1006   NSTRACE (ns_frame_raise_lower);
1007
1008   if (raise)
1009     ns_raise_frame (f);
1010   else
1011     ns_lower_frame (f);
1012 }
1013
1014
1015 static void
1016 ns_frame_rehighlight (struct frame *frame)
1017 /* --------------------------------------------------------------------------
1018      External (hook): called on things like window switching within frame
1019    -------------------------------------------------------------------------- */
1020 {
1021   struct ns_display_info *dpyinfo = FRAME_DISPLAY_INFO (frame);
1022   struct frame *old_highlight = dpyinfo->x_highlight_frame;
1023
1024   NSTRACE (ns_frame_rehighlight);
1025   if (dpyinfo->x_focus_frame)
1026     {
1027       dpyinfo->x_highlight_frame
1028         = (FRAMEP (FRAME_FOCUS_FRAME (dpyinfo->x_focus_frame))
1029            ? XFRAME (FRAME_FOCUS_FRAME (dpyinfo->x_focus_frame))
1030            : dpyinfo->x_focus_frame);
1031       if (!FRAME_LIVE_P (dpyinfo->x_highlight_frame))
1032         {
1033           fset_focus_frame (dpyinfo->x_focus_frame, Qnil);
1034           dpyinfo->x_highlight_frame = dpyinfo->x_focus_frame;
1035         }
1036     }
1037   else
1038       dpyinfo->x_highlight_frame = 0;
1039
1040   if (dpyinfo->x_highlight_frame &&
1041          dpyinfo->x_highlight_frame != old_highlight)
1042     {
1043       if (old_highlight)
1044         {
1045           x_update_cursor (old_highlight, 1);
1046           x_set_frame_alpha (old_highlight);
1047         }
1048       if (dpyinfo->x_highlight_frame)
1049         {
1050           x_update_cursor (dpyinfo->x_highlight_frame, 1);
1051           x_set_frame_alpha (dpyinfo->x_highlight_frame);
1052         }
1053     }
1054 }
1055
1056
1057 void
1058 x_make_frame_visible (struct frame *f)
1059 /* --------------------------------------------------------------------------
1060      External: Show the window (X11 semantics)
1061    -------------------------------------------------------------------------- */
1062 {
1063   NSTRACE (x_make_frame_visible);
1064   /* XXX: at some points in past this was not needed, as the only place that
1065      called this (frame.c:Fraise_frame ()) also called raise_lower;
1066      if this ends up the case again, comment this out again. */
1067   if (!FRAME_VISIBLE_P (f))
1068     {
1069       EmacsView *view = (EmacsView *)FRAME_NS_VIEW (f);
1070
1071       SET_FRAME_VISIBLE (f, 1);
1072       ns_raise_frame (f);
1073
1074       /* Making a new frame from a fullscreen frame will make the new frame
1075          fullscreen also.  So skip handleFS as this will print an error.  */
1076       if ([view fsIsNative] && f->want_fullscreen == FULLSCREEN_BOTH
1077           && [view isFullscreen])
1078         return;
1079
1080       if (f->want_fullscreen != FULLSCREEN_NONE)
1081         {
1082           block_input ();
1083           [view handleFS];
1084           unblock_input ();
1085         }
1086     }
1087 }
1088
1089
1090 void
1091 x_make_frame_invisible (struct frame *f)
1092 /* --------------------------------------------------------------------------
1093      External: Hide the window (X11 semantics)
1094    -------------------------------------------------------------------------- */
1095 {
1096   NSView *view;
1097   NSTRACE (x_make_frame_invisible);
1098   check_window_system (f);
1099   view = FRAME_NS_VIEW (f);
1100   [[view window] orderOut: NSApp];
1101   SET_FRAME_VISIBLE (f, 0);
1102   SET_FRAME_ICONIFIED (f, 0);
1103 }
1104
1105
1106 void
1107 x_iconify_frame (struct frame *f)
1108 /* --------------------------------------------------------------------------
1109      External: Iconify window
1110    -------------------------------------------------------------------------- */
1111 {
1112   NSView *view;
1113   struct ns_display_info *dpyinfo;
1114
1115   NSTRACE (x_iconify_frame);
1116   check_window_system (f);
1117   view = FRAME_NS_VIEW (f);
1118   dpyinfo = FRAME_DISPLAY_INFO (f);
1119
1120   if (dpyinfo->x_highlight_frame == f)
1121     dpyinfo->x_highlight_frame = 0;
1122
1123   if ([[view window] windowNumber] <= 0)
1124     {
1125       /* the window is still deferred.  Make it very small, bring it
1126          on screen and order it out. */
1127       NSRect s = { { 100, 100}, {0, 0} };
1128       NSRect t;
1129       t = [[view window] frame];
1130       [[view window] setFrame: s display: NO];
1131       [[view window] orderBack: NSApp];
1132       [[view window] orderOut: NSApp];
1133       [[view window] setFrame: t display: NO];
1134     }
1135   [[view window] miniaturize: NSApp];
1136 }
1137
1138 /* Free X resources of frame F.  */
1139
1140 void
1141 x_free_frame_resources (struct frame *f)
1142 {
1143   NSView *view;
1144   struct ns_display_info *dpyinfo;
1145   Mouse_HLInfo *hlinfo;
1146
1147   NSTRACE (x_free_frame_resources);
1148   check_window_system (f);
1149   view = FRAME_NS_VIEW (f);
1150   dpyinfo = FRAME_DISPLAY_INFO (f);
1151   hlinfo = MOUSE_HL_INFO (f);
1152
1153   [(EmacsView *)view setWindowClosing: YES]; /* may not have been informed */
1154
1155   block_input ();
1156
1157   free_frame_menubar (f);
1158
1159   if (FRAME_FACE_CACHE (f))
1160     free_frame_faces (f);
1161
1162   if (f == dpyinfo->x_focus_frame)
1163     dpyinfo->x_focus_frame = 0;
1164   if (f == dpyinfo->x_highlight_frame)
1165     dpyinfo->x_highlight_frame = 0;
1166   if (f == hlinfo->mouse_face_mouse_frame)
1167     reset_mouse_highlight (hlinfo);
1168
1169   if (f->output_data.ns->miniimage != nil)
1170     [f->output_data.ns->miniimage release];
1171
1172   [[view window] close];
1173   [view release];
1174
1175   xfree (f->output_data.ns);
1176
1177   unblock_input ();
1178 }
1179
1180 void
1181 x_destroy_window (struct frame *f)
1182 /* --------------------------------------------------------------------------
1183      External: Delete the window
1184    -------------------------------------------------------------------------- */
1185 {
1186   NSTRACE (x_destroy_window);
1187   check_window_system (f);
1188   x_free_frame_resources (f);
1189   ns_window_num--;
1190 }
1191
1192
1193 void
1194 x_set_offset (struct frame *f, int xoff, int yoff, int change_grav)
1195 /* --------------------------------------------------------------------------
1196      External: Position the window
1197    -------------------------------------------------------------------------- */
1198 {
1199   NSView *view = FRAME_NS_VIEW (f);
1200   NSArray *screens = [NSScreen screens];
1201   NSScreen *fscreen = [screens objectAtIndex: 0];
1202   NSScreen *screen = [[view window] screen];
1203
1204   NSTRACE (x_set_offset);
1205
1206   block_input ();
1207
1208   f->left_pos = xoff;
1209   f->top_pos = yoff;
1210
1211   if (view != nil && screen && fscreen)
1212     {
1213       f->left_pos = f->size_hint_flags & XNegative
1214         ? [screen visibleFrame].size.width + f->left_pos - FRAME_PIXEL_WIDTH (f)
1215         : f->left_pos;
1216       /* We use visibleFrame here to take menu bar into account.
1217          Ideally we should also adjust left/top with visibleFrame.origin.  */
1218
1219       f->top_pos = f->size_hint_flags & YNegative
1220         ? ([screen visibleFrame].size.height + f->top_pos
1221            - FRAME_PIXEL_HEIGHT (f) - FRAME_NS_TITLEBAR_HEIGHT (f)
1222            - FRAME_TOOLBAR_HEIGHT (f))
1223         : f->top_pos;
1224 #ifdef NS_IMPL_GNUSTEP
1225       if (f->left_pos < 100)
1226         f->left_pos = 100;  /* don't overlap menu */
1227 #endif
1228       /* Constrain the setFrameTopLeftPoint so we don't move behind the
1229          menu bar.  */
1230       f->output_data.ns->dont_constrain = 0;
1231       [[view window] setFrameTopLeftPoint:
1232                        NSMakePoint (SCREENMAXBOUND (f->left_pos),
1233                                     SCREENMAXBOUND ([fscreen frame].size.height
1234                                                     - NS_TOP_POS (f)))];
1235       f->size_hint_flags &= ~(XNegative|YNegative);
1236     }
1237
1238   unblock_input ();
1239 }
1240
1241
1242 void
1243 x_set_window_size (struct frame *f, int change_grav, int cols, int rows, bool pixelwise)
1244 /* --------------------------------------------------------------------------
1245      Adjust window pixel size based on given character grid size
1246      Impl is a bit more complex than other terms, need to do some
1247      internal clipping.
1248    -------------------------------------------------------------------------- */
1249 {
1250   EmacsView *view = FRAME_NS_VIEW (f);
1251   NSWindow *window = [view window];
1252   NSRect wr = [window frame];
1253   int tb = FRAME_EXTERNAL_TOOL_BAR (f);
1254   int pixelwidth, pixelheight;
1255
1256   NSTRACE (x_set_window_size);
1257
1258   if (view == nil)
1259     return;
1260
1261 /*fprintf (stderr, "\tsetWindowSize: %d x %d, font size %d x %d\n", cols, rows, FRAME_COLUMN_WIDTH (f), FRAME_LINE_HEIGHT (f)); */
1262
1263   block_input ();
1264
1265   check_frame_size (f, &cols, &rows, 0);
1266
1267   f->scroll_bar_actual_width = NS_SCROLL_BAR_WIDTH (f);
1268   compute_fringe_widths (f, 0);
1269
1270   pixelwidth =  FRAME_TEXT_COLS_TO_PIXEL_WIDTH   (f, cols);
1271   pixelheight = FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f, rows);
1272
1273   /* If we have a toolbar, take its height into account. */
1274   if (tb && ! [view isFullscreen])
1275     {
1276     /* NOTE: previously this would generate wrong result if toolbar not
1277              yet displayed and fixing toolbar_height=32 helped, but
1278              now (200903) seems no longer needed */
1279     FRAME_TOOLBAR_HEIGHT (f) =
1280       NSHeight ([window frameRectForContentRect: NSMakeRect (0, 0, 0, 0)])
1281         - FRAME_NS_TITLEBAR_HEIGHT (f);
1282 #ifdef NS_IMPL_GNUSTEP
1283       FRAME_TOOLBAR_HEIGHT (f) -= 3;
1284 #endif
1285     }
1286   else
1287     FRAME_TOOLBAR_HEIGHT (f) = 0;
1288
1289   wr.size.width = pixelwidth + f->border_width;
1290   wr.size.height = pixelheight;
1291   if (! [view isFullscreen])
1292     wr.size.height += FRAME_NS_TITLEBAR_HEIGHT (f)
1293       + FRAME_TOOLBAR_HEIGHT (f);
1294
1295   /* Do not try to constrain to this screen.  We may have multiple
1296      screens, and want Emacs to span those.  Constraining to screen
1297      prevents that, and that is not nice to the user.  */
1298  if (f->output_data.ns->zooming)
1299    f->output_data.ns->zooming = 0;
1300  else
1301    wr.origin.y += FRAME_PIXEL_HEIGHT (f) - pixelheight;
1302
1303   [view setRows: rows andColumns: cols];
1304   [window setFrame: wr display: YES];
1305
1306 /*fprintf (stderr, "\tx_set_window_size %d, %d\t%d, %d\n", cols, rows, pixelwidth, pixelheight); */
1307
1308   /* This is a trick to compensate for Emacs' managing the scrollbar area
1309      as a fixed number of standard character columns.  Instead of leaving
1310      blank space for the extra, we chopped it off above.  Now for
1311      left-hand scrollbars, we shift all rendering to the left by the
1312      difference between the real width and Emacs' imagined one.  For
1313      right-hand bars, don't worry about it since the extra is never used.
1314      (Obviously doesn't work for vertically split windows tho..) */
1315   {
1316     NSPoint origin = FRAME_HAS_VERTICAL_SCROLL_BARS_ON_LEFT (f)
1317       ? NSMakePoint (FRAME_SCROLL_BAR_COLS (f) * FRAME_COLUMN_WIDTH (f)
1318                      - NS_SCROLL_BAR_WIDTH (f), 0)
1319       : NSMakePoint (0, 0);
1320     [view setFrame: NSMakeRect (0, 0, pixelwidth, pixelheight)];
1321     [view setBoundsOrigin: origin];
1322   }
1323
1324   change_frame_size (f, cols, rows, 0, 1, 0, 0); /* pretend, delay, safe */
1325   FRAME_PIXEL_WIDTH (f) = pixelwidth;
1326   FRAME_PIXEL_HEIGHT (f) = pixelheight;
1327 /*  SET_FRAME_GARBAGED (f); // this short-circuits expose call in drawRect */
1328
1329   mark_window_cursors_off (XWINDOW (f->root_window));
1330   cancel_mouse_face (f);
1331
1332   unblock_input ();
1333 }
1334
1335
1336 static void
1337 ns_fullscreen_hook (struct frame *f)
1338 {
1339   EmacsView *view = (EmacsView *)FRAME_NS_VIEW (f);
1340
1341   if (!FRAME_VISIBLE_P (f))
1342     return;
1343
1344    if (! [view fsIsNative] && f->want_fullscreen == FULLSCREEN_BOTH)
1345     {
1346       /* Old style fs don't initiate correctly if created from
1347          init/default-frame alist, so use a timer (not nice...).
1348       */
1349       [NSTimer scheduledTimerWithTimeInterval: 0.5 target: view
1350                                      selector: @selector (handleFS)
1351                                      userInfo: nil repeats: NO];
1352       return;
1353     }
1354
1355   block_input ();
1356   [view handleFS];
1357   unblock_input ();
1358 }
1359
1360 /* ==========================================================================
1361
1362     Color management
1363
1364    ========================================================================== */
1365
1366
1367 NSColor *
1368 ns_lookup_indexed_color (unsigned long idx, struct frame *f)
1369 {
1370   struct ns_color_table *color_table = FRAME_DISPLAY_INFO (f)->color_table;
1371   if (idx < 1 || idx >= color_table->avail)
1372     return nil;
1373   return color_table->colors[idx];
1374 }
1375
1376
1377 unsigned long
1378 ns_index_color (NSColor *color, struct frame *f)
1379 {
1380   struct ns_color_table *color_table = FRAME_DISPLAY_INFO (f)->color_table;
1381   ptrdiff_t idx;
1382   ptrdiff_t i;
1383
1384   if (!color_table->colors)
1385     {
1386       color_table->size = NS_COLOR_CAPACITY;
1387       color_table->avail = 1; /* skip idx=0 as marker */
1388       color_table->colors = xmalloc (color_table->size * sizeof (NSColor *));
1389       color_table->colors[0] = nil;
1390       color_table->empty_indices = [[NSMutableSet alloc] init];
1391     }
1392
1393   /* Do we already have this color?  */
1394   for (i = 1; i < color_table->avail; i++)
1395     if (color_table->colors[i] && [color_table->colors[i] isEqual: color])
1396       return i;
1397
1398   if ([color_table->empty_indices count] > 0)
1399     {
1400       NSNumber *index = [color_table->empty_indices anyObject];
1401       [color_table->empty_indices removeObject: index];
1402       idx = [index unsignedLongValue];
1403     }
1404   else
1405     {
1406       if (color_table->avail == color_table->size)
1407         color_table->colors =
1408           xpalloc (color_table->colors, &color_table->size, 1,
1409                    min (ULONG_MAX, PTRDIFF_MAX), sizeof *color_table->colors);
1410       idx = color_table->avail++;
1411     }
1412
1413   color_table->colors[idx] = color;
1414   [color retain];
1415 /*fprintf(stderr, "color_table: allocated %d\n",idx);*/
1416   return idx;
1417 }
1418
1419
1420 void
1421 ns_free_indexed_color (unsigned long idx, struct frame *f)
1422 {
1423   struct ns_color_table *color_table;
1424   NSColor *color;
1425   NSNumber *index;
1426
1427   if (!f)
1428     return;
1429
1430   color_table = FRAME_DISPLAY_INFO (f)->color_table;
1431
1432   if (idx <= 0 || idx >= color_table->size) {
1433     message1 ("ns_free_indexed_color: Color index out of range.\n");
1434     return;
1435   }
1436
1437   index = [NSNumber numberWithUnsignedInt: idx];
1438   if ([color_table->empty_indices containsObject: index]) {
1439     message1 ("ns_free_indexed_color: attempt to free already freed color.\n");
1440     return;
1441   }
1442
1443   color = color_table->colors[idx];
1444   [color release];
1445   color_table->colors[idx] = nil;
1446   [color_table->empty_indices addObject: index];
1447 /*fprintf(stderr, "color_table: FREED %d\n",idx);*/
1448 }
1449
1450
1451 static int
1452 ns_get_color (const char *name, NSColor **col)
1453 /* --------------------------------------------------------------------------
1454      Parse a color name
1455    -------------------------------------------------------------------------- */
1456 /* On *Step, we attempt to mimic the X11 platform here, down to installing an
1457    X11 rgb.txt-compatible color list in Emacs.clr (see ns_term_init()).
1458    See: http://thread.gmane.org/gmane.emacs.devel/113050/focus=113272). */
1459 {
1460   NSColor *new = nil;
1461   static char hex[20];
1462   int scaling;
1463   float r = -1.0, g, b;
1464   NSString *nsname = [NSString stringWithUTF8String: name];
1465
1466 /*fprintf (stderr, "ns_get_color: '%s'\n", name); */
1467   block_input ();
1468
1469   if ([nsname isEqualToString: @"ns_selection_bg_color"])
1470     {
1471 #ifdef NS_IMPL_COCOA
1472       NSString *defname = [[NSUserDefaults standardUserDefaults]
1473                             stringForKey: @"AppleHighlightColor"];
1474       if (defname != nil)
1475         nsname = defname;
1476       else
1477 #endif
1478       if ((new = [NSColor selectedTextBackgroundColor]) != nil)
1479         {
1480           *col = [new colorUsingColorSpaceName: NSCalibratedRGBColorSpace];
1481           unblock_input ();
1482           return 0;
1483         }
1484       else
1485         nsname = NS_SELECTION_BG_COLOR_DEFAULT;
1486
1487       name = [nsname UTF8String];
1488     }
1489   else if ([nsname isEqualToString: @"ns_selection_fg_color"])
1490     {
1491       /* NOTE: OSX applications normally don't set foreground selection, but
1492          text may be unreadable if we don't.
1493       */
1494       if ((new = [NSColor selectedTextColor]) != nil)
1495         {
1496           *col = [new colorUsingColorSpaceName: NSCalibratedRGBColorSpace];
1497           unblock_input ();
1498           return 0;
1499         }
1500
1501       nsname = NS_SELECTION_FG_COLOR_DEFAULT;
1502       name = [nsname UTF8String];
1503     }
1504
1505   /* First, check for some sort of numeric specification. */
1506   hex[0] = '\0';
1507
1508   if (name[0] == '0' || name[0] == '1' || name[0] == '.')  /* RGB decimal */
1509     {
1510       NSScanner *scanner = [NSScanner scannerWithString: nsname];
1511       [scanner scanFloat: &r];
1512       [scanner scanFloat: &g];
1513       [scanner scanFloat: &b];
1514     }
1515   else if (!strncmp(name, "rgb:", 4))  /* A newer X11 format -- rgb:r/g/b */
1516     scaling = (snprintf (hex, sizeof hex, "%s", name + 4) - 2) / 3;
1517   else if (name[0] == '#')        /* An old X11 format; convert to newer */
1518     {
1519       int len = (strlen(name) - 1);
1520       int start = (len % 3 == 0) ? 1 : len / 4 + 1;
1521       int i;
1522       scaling = strlen(name+start) / 3;
1523       for (i = 0; i < 3; i++)
1524         sprintf (hex + i * (scaling + 1), "%.*s/", scaling,
1525                  name + start + i * scaling);
1526       hex[3 * (scaling + 1) - 1] = '\0';
1527     }
1528
1529   if (hex[0])
1530     {
1531       int rr, gg, bb;
1532       float fscale = scaling == 4 ? 65535.0 : (scaling == 2 ? 255.0 : 15.0);
1533       if (sscanf (hex, "%x/%x/%x", &rr, &gg, &bb))
1534         {
1535           r = rr / fscale;
1536           g = gg / fscale;
1537           b = bb / fscale;
1538         }
1539     }
1540
1541   if (r >= 0.0F)
1542     {
1543       *col = [NSColor colorWithCalibratedRed: r green: g blue: b alpha: 1.0];
1544       unblock_input ();
1545       return 0;
1546     }
1547
1548   /* Otherwise, color is expected to be from a list */
1549   {
1550     NSEnumerator *lenum, *cenum;
1551     NSString *name;
1552     NSColorList *clist;
1553
1554 #ifdef NS_IMPL_GNUSTEP
1555     /* XXX: who is wrong, the requestor or the implementation? */
1556     if ([nsname compare: @"Highlight" options: NSCaseInsensitiveSearch]
1557         == NSOrderedSame)
1558       nsname = @"highlightColor";
1559 #endif
1560
1561     lenum = [[NSColorList availableColorLists] objectEnumerator];
1562     while ( (clist = [lenum nextObject]) && new == nil)
1563       {
1564         cenum = [[clist allKeys] objectEnumerator];
1565         while ( (name = [cenum nextObject]) && new == nil )
1566           {
1567             if ([name compare: nsname
1568                       options: NSCaseInsensitiveSearch] == NSOrderedSame )
1569               new = [clist colorWithKey: name];
1570           }
1571       }
1572   }
1573
1574   if (new)
1575     *col = [new colorUsingColorSpaceName: NSCalibratedRGBColorSpace];
1576   unblock_input ();
1577   return new ? 0 : 1;
1578 }
1579
1580
1581 int
1582 ns_lisp_to_color (Lisp_Object color, NSColor **col)
1583 /* --------------------------------------------------------------------------
1584      Convert a Lisp string object to a NS color
1585    -------------------------------------------------------------------------- */
1586 {
1587   NSTRACE (ns_lisp_to_color);
1588   if (STRINGP (color))
1589     return ns_get_color (SSDATA (color), col);
1590   else if (SYMBOLP (color))
1591     return ns_get_color (SSDATA (SYMBOL_NAME (color)), col);
1592   return 1;
1593 }
1594
1595
1596 Lisp_Object
1597 ns_color_to_lisp (NSColor *col)
1598 /* --------------------------------------------------------------------------
1599      Convert a color to a lisp string with the RGB equivalent
1600    -------------------------------------------------------------------------- */
1601 {
1602   EmacsCGFloat red, green, blue, alpha, gray;
1603   char buf[1024];
1604   const char *str;
1605   NSTRACE (ns_color_to_lisp);
1606
1607   block_input ();
1608   if ([[col colorSpaceName] isEqualToString: NSNamedColorSpace])
1609
1610       if ((str =[[col colorNameComponent] UTF8String]))
1611         {
1612           unblock_input ();
1613           return build_string ((char *)str);
1614         }
1615
1616     [[col colorUsingColorSpaceName: NSCalibratedRGBColorSpace]
1617         getRed: &red green: &green blue: &blue alpha: &alpha];
1618   if (red ==green && red ==blue)
1619     {
1620       [[col colorUsingColorSpaceName: NSCalibratedWhiteColorSpace]
1621             getWhite: &gray alpha: &alpha];
1622       snprintf (buf, sizeof (buf), "#%2.2lx%2.2lx%2.2lx",
1623                 lrint (gray * 0xff), lrint (gray * 0xff), lrint (gray * 0xff));
1624       unblock_input ();
1625       return build_string (buf);
1626     }
1627
1628   snprintf (buf, sizeof (buf), "#%2.2lx%2.2lx%2.2lx",
1629             lrint (red*0xff), lrint (green*0xff), lrint (blue*0xff));
1630
1631   unblock_input ();
1632   return build_string (buf);
1633 }
1634
1635
1636 void
1637 ns_query_color(void *col, XColor *color_def, int setPixel)
1638 /* --------------------------------------------------------------------------
1639          Get ARGB values out of NSColor col and put them into color_def.
1640          If setPixel, set the pixel to a concatenated version.
1641          and set color_def pixel to the resulting index.
1642    -------------------------------------------------------------------------- */
1643 {
1644   EmacsCGFloat r, g, b, a;
1645
1646   [((NSColor *)col) getRed: &r green: &g blue: &b alpha: &a];
1647   color_def->red   = r * 65535;
1648   color_def->green = g * 65535;
1649   color_def->blue  = b * 65535;
1650
1651   if (setPixel == YES)
1652     color_def->pixel
1653       = ARGB_TO_ULONG((int)(a*255),
1654                       (int)(r*255), (int)(g*255), (int)(b*255));
1655 }
1656
1657
1658 bool
1659 ns_defined_color (struct frame *f,
1660                   const char *name,
1661                   XColor *color_def,
1662                   bool alloc,
1663                   bool makeIndex)
1664 /* --------------------------------------------------------------------------
1665          Return true if named color found, and set color_def rgb accordingly.
1666          If makeIndex and alloc are nonzero put the color in the color_table,
1667          and set color_def pixel to the resulting index.
1668          If makeIndex is zero, set color_def pixel to ARGB.
1669          Return false if not found
1670    -------------------------------------------------------------------------- */
1671 {
1672   NSColor *col;
1673   NSTRACE (ns_defined_color);
1674
1675   block_input ();
1676   if (ns_get_color (name, &col) != 0) /* Color not found  */
1677     {
1678       unblock_input ();
1679       return 0;
1680     }
1681   if (makeIndex && alloc)
1682     color_def->pixel = ns_index_color (col, f);
1683   ns_query_color (col, color_def, !makeIndex);
1684   unblock_input ();
1685   return 1;
1686 }
1687
1688
1689 void
1690 x_set_frame_alpha (struct frame *f)
1691 /* --------------------------------------------------------------------------
1692      change the entire-frame transparency
1693    -------------------------------------------------------------------------- */
1694 {
1695   struct ns_display_info *dpyinfo = FRAME_DISPLAY_INFO (f);
1696   double alpha = 1.0;
1697   double alpha_min = 1.0;
1698
1699   if (dpyinfo->x_highlight_frame == f)
1700     alpha = f->alpha[0];
1701   else
1702     alpha = f->alpha[1];
1703
1704   if (FLOATP (Vframe_alpha_lower_limit))
1705     alpha_min = XFLOAT_DATA (Vframe_alpha_lower_limit);
1706   else if (INTEGERP (Vframe_alpha_lower_limit))
1707     alpha_min = (XINT (Vframe_alpha_lower_limit)) / 100.0;
1708
1709   if (alpha < 0.0)
1710     return;
1711   else if (1.0 < alpha)
1712     alpha = 1.0;
1713   else if (0.0 <= alpha && alpha < alpha_min && alpha_min <= 1.0)
1714     alpha = alpha_min;
1715
1716 #ifdef NS_IMPL_COCOA
1717   {
1718     EmacsView *view = FRAME_NS_VIEW (f);
1719   [[view window] setAlphaValue: alpha];
1720   }
1721 #endif
1722 }
1723
1724
1725 /* ==========================================================================
1726
1727     Mouse handling
1728
1729    ========================================================================== */
1730
1731
1732 void
1733 x_set_mouse_pixel_position (struct frame *f, int pix_x, int pix_y)
1734 /* --------------------------------------------------------------------------
1735      Programmatically reposition mouse pointer in pixel coordinates
1736    -------------------------------------------------------------------------- */
1737 {
1738   NSTRACE (x_set_mouse_pixel_position);
1739   ns_raise_frame (f);
1740 #if 0
1741   /* FIXME: this does not work, and what about GNUstep? */
1742 #ifdef NS_IMPL_COCOA
1743   [FRAME_NS_VIEW (f) lockFocus];
1744   PSsetmouse ((float)pix_x, (float)pix_y);
1745   [FRAME_NS_VIEW (f) unlockFocus];
1746 #endif
1747 #endif
1748 }
1749
1750
1751 void
1752 x_set_mouse_position (struct frame *f, int h, int v)
1753 /* --------------------------------------------------------------------------
1754      Programmatically reposition mouse pointer in character coordinates
1755    -------------------------------------------------------------------------- */
1756 {
1757   int pix_x, pix_y;
1758
1759   pix_x = FRAME_COL_TO_PIXEL_X (f, h) + FRAME_COLUMN_WIDTH (f) / 2;
1760   pix_y = FRAME_LINE_TO_PIXEL_Y (f, v) + FRAME_LINE_HEIGHT (f) / 2;
1761
1762   if (pix_x < 0) pix_x = 0;
1763   if (pix_x > FRAME_PIXEL_WIDTH (f)) pix_x = FRAME_PIXEL_WIDTH (f);
1764
1765   if (pix_y < 0) pix_y = 0;
1766   if (pix_y > FRAME_PIXEL_HEIGHT (f)) pix_y = FRAME_PIXEL_HEIGHT (f);
1767
1768   x_set_mouse_pixel_position (f, pix_x, pix_y);
1769 }
1770
1771
1772 static int
1773 note_mouse_movement (struct frame *frame, CGFloat x, CGFloat y)
1774 /*   ------------------------------------------------------------------------
1775      Called by EmacsView on mouseMovement events.  Passes on
1776      to emacs mainstream code if we moved off of a rect of interest
1777      known as last_mouse_glyph.
1778      ------------------------------------------------------------------------ */
1779 {
1780   struct ns_display_info *dpyinfo = FRAME_DISPLAY_INFO (frame);
1781   NSRect *r;
1782
1783 //  NSTRACE (note_mouse_movement);
1784
1785   dpyinfo->last_mouse_motion_frame = frame;
1786   r = &dpyinfo->last_mouse_glyph;
1787
1788   /* Note, this doesn't get called for enter/leave, since we don't have a
1789      position.  Those are taken care of in the corresponding NSView methods. */
1790
1791   /* has movement gone beyond last rect we were tracking? */
1792   if (x < r->origin.x || x >= r->origin.x + r->size.width
1793       || y < r->origin.y || y >= r->origin.y + r->size.height)
1794     {
1795       ns_update_begin (frame);
1796       frame->mouse_moved = 1;
1797       note_mouse_highlight (frame, x, y);
1798       remember_mouse_glyph (frame, x, y, r);
1799       ns_update_end (frame);
1800       return 1;
1801     }
1802
1803   return 0;
1804 }
1805
1806
1807 static void
1808 ns_mouse_position (struct frame **fp, int insist, Lisp_Object *bar_window,
1809                    enum scroll_bar_part *part, Lisp_Object *x, Lisp_Object *y,
1810                    Time *time)
1811 /* --------------------------------------------------------------------------
1812     External (hook): inform emacs about mouse position and hit parts.
1813     If a scrollbar is being dragged, set bar_window, part, x, y, time.
1814     x & y should be position in the scrollbar (the whole bar, not the handle)
1815     and length of scrollbar respectively
1816    -------------------------------------------------------------------------- */
1817 {
1818   id view;
1819   NSPoint position;
1820   Lisp_Object frame, tail;
1821   struct frame *f;
1822   struct ns_display_info *dpyinfo;
1823
1824   NSTRACE (ns_mouse_position);
1825
1826   if (*fp == NULL)
1827     {
1828       fprintf (stderr, "Warning: ns_mouse_position () called with null *fp.\n");
1829       return;
1830     }
1831
1832   dpyinfo = FRAME_DISPLAY_INFO (*fp);
1833
1834   block_input ();
1835
1836   if (dpyinfo->last_mouse_scroll_bar != nil && insist == 0)
1837     {
1838       /* TODO: we do not use this path at the moment because drag events will
1839            go directly to the EmacsScroller.  Leaving code in for now. */
1840       [dpyinfo->last_mouse_scroll_bar
1841           getMouseMotionPart: (int *)part window: bar_window x: x y: y];
1842       if (time)
1843         *time = dpyinfo->last_mouse_movement_time;
1844       dpyinfo->last_mouse_scroll_bar = nil;
1845     }
1846   else
1847     {
1848       /* Clear the mouse-moved flag for every frame on this display.  */
1849       FOR_EACH_FRAME (tail, frame)
1850         if (FRAME_NS_P (XFRAME (frame))
1851             && FRAME_NS_DISPLAY (XFRAME (frame)) == FRAME_NS_DISPLAY (*fp))
1852           XFRAME (frame)->mouse_moved = 0;
1853
1854       dpyinfo->last_mouse_scroll_bar = nil;
1855       if (dpyinfo->last_mouse_frame
1856           && FRAME_LIVE_P (dpyinfo->last_mouse_frame))
1857         f = dpyinfo->last_mouse_frame;
1858       else
1859         f = dpyinfo->x_focus_frame ? dpyinfo->x_focus_frame
1860                                     : SELECTED_FRAME ();
1861
1862       if (f && FRAME_NS_P (f))
1863         {
1864           view = FRAME_NS_VIEW (*fp);
1865
1866           position = [[view window] mouseLocationOutsideOfEventStream];
1867           position = [view convertPoint: position fromView: nil];
1868           remember_mouse_glyph (f, position.x, position.y,
1869                                 &dpyinfo->last_mouse_glyph);
1870 /*fprintf (stderr, "ns_mouse_position: %.0f, %.0f\n", position.x, position.y); */
1871
1872           if (bar_window) *bar_window = Qnil;
1873           if (part) *part = 0; /*scroll_bar_handle; */
1874
1875           if (x) XSETINT (*x, lrint (position.x));
1876           if (y) XSETINT (*y, lrint (position.y));
1877           if (time)
1878             *time = dpyinfo->last_mouse_movement_time;
1879           *fp = f;
1880         }
1881     }
1882
1883   unblock_input ();
1884 }
1885
1886
1887 static void
1888 ns_frame_up_to_date (struct frame *f)
1889 /* --------------------------------------------------------------------------
1890     External (hook): Fix up mouse highlighting right after a full update.
1891     Can't use FRAME_MOUSE_UPDATE due to ns_frame_begin and ns_frame_end calls.
1892    -------------------------------------------------------------------------- */
1893 {
1894   NSTRACE (ns_frame_up_to_date);
1895
1896   if (FRAME_NS_P (f))
1897     {
1898       Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (f);
1899       if (f == hlinfo->mouse_face_mouse_frame)
1900         {
1901           block_input ();
1902           ns_update_begin(f);
1903           note_mouse_highlight (hlinfo->mouse_face_mouse_frame,
1904                                 hlinfo->mouse_face_mouse_x,
1905                                 hlinfo->mouse_face_mouse_y);
1906           ns_update_end(f);
1907           unblock_input ();
1908         }
1909     }
1910 }
1911
1912
1913 static void
1914 ns_define_frame_cursor (struct frame *f, Cursor cursor)
1915 /* --------------------------------------------------------------------------
1916     External (RIF): set frame mouse pointer type.
1917    -------------------------------------------------------------------------- */
1918 {
1919   NSTRACE (ns_define_frame_cursor);
1920   if (FRAME_POINTER_TYPE (f) != cursor)
1921     {
1922       EmacsView *view = FRAME_NS_VIEW (f);
1923       FRAME_POINTER_TYPE (f) = cursor;
1924       [[view window] invalidateCursorRectsForView: view];
1925       /* Redisplay assumes this function also draws the changed frame
1926          cursor, but this function doesn't, so do it explicitly.  */
1927       x_update_cursor (f, 1);
1928     }
1929 }
1930
1931
1932
1933 /* ==========================================================================
1934
1935     Keyboard handling
1936
1937    ========================================================================== */
1938
1939
1940 static unsigned
1941 ns_convert_key (unsigned code)
1942 /* --------------------------------------------------------------------------
1943     Internal call used by NSView-keyDown.
1944    -------------------------------------------------------------------------- */
1945 {
1946   const unsigned last_keysym = (sizeof (convert_ns_to_X_keysym)
1947                                 / sizeof (convert_ns_to_X_keysym[0]));
1948   unsigned keysym;
1949   /* An array would be faster, but less easy to read. */
1950   for (keysym = 0; keysym < last_keysym; keysym += 2)
1951     if (code == convert_ns_to_X_keysym[keysym])
1952       return 0xFF00 | convert_ns_to_X_keysym[keysym+1];
1953   return 0;
1954 /* if decide to use keyCode and Carbon table, use this line:
1955      return code > 0xff ? 0 : 0xFF00 | ns_keycode_to_xkeysym_table[code]; */
1956 }
1957
1958
1959 char *
1960 x_get_keysym_name (int keysym)
1961 /* --------------------------------------------------------------------------
1962     Called by keyboard.c.  Not sure if the return val is important, except
1963     that it be unique.
1964    -------------------------------------------------------------------------- */
1965 {
1966   static char value[16];
1967   NSTRACE (x_get_keysym_name);
1968   sprintf (value, "%d", keysym);
1969   return value;
1970 }
1971
1972
1973
1974 /* ==========================================================================
1975
1976     Block drawing operations
1977
1978    ========================================================================== */
1979
1980
1981 static void
1982 ns_redraw_scroll_bars (struct frame *f)
1983 {
1984   int i;
1985   id view;
1986   NSArray *subviews = [[FRAME_NS_VIEW (f) superview] subviews];
1987   NSTRACE (ns_redraw_scroll_bars);
1988   for (i =[subviews count]-1; i >= 0; i--)
1989     {
1990       view = [subviews objectAtIndex: i];
1991       if (![view isKindOfClass: [EmacsScroller class]]) continue;
1992       [view display];
1993     }
1994 }
1995
1996
1997 void
1998 ns_clear_frame (struct frame *f)
1999 /* --------------------------------------------------------------------------
2000       External (hook): Erase the entire frame
2001    -------------------------------------------------------------------------- */
2002 {
2003   NSView *view = FRAME_NS_VIEW (f);
2004   NSRect r;
2005
2006   NSTRACE (ns_clear_frame);
2007
2008  /* comes on initial frame because we have
2009     after-make-frame-functions = select-frame */
2010  if (!FRAME_DEFAULT_FACE (f))
2011    return;
2012
2013   mark_window_cursors_off (XWINDOW (FRAME_ROOT_WINDOW (f)));
2014
2015   r = [view bounds];
2016
2017   block_input ();
2018   ns_focus (f, &r, 1);
2019   [ns_lookup_indexed_color (NS_FACE_BACKGROUND (FRAME_DEFAULT_FACE (f)), f) set];
2020   NSRectFill (r);
2021   ns_unfocus (f);
2022
2023   /* as of 2006/11 or so this is now needed */
2024   ns_redraw_scroll_bars (f);
2025   unblock_input ();
2026 }
2027
2028
2029 static void
2030 ns_clear_frame_area (struct frame *f, int x, int y, int width, int height)
2031 /* --------------------------------------------------------------------------
2032     External (RIF):  Clear section of frame
2033    -------------------------------------------------------------------------- */
2034 {
2035   NSRect r = NSMakeRect (x, y, width, height);
2036   NSView *view = FRAME_NS_VIEW (f);
2037   struct face *face = FRAME_DEFAULT_FACE (f);
2038
2039   if (!view || !face)
2040     return;
2041
2042   NSTRACE (ns_clear_frame_area);
2043
2044   r = NSIntersectionRect (r, [view frame]);
2045   ns_focus (f, &r, 1);
2046   [ns_lookup_indexed_color (NS_FACE_BACKGROUND (face), f) set];
2047
2048   NSRectFill (r);
2049
2050   ns_unfocus (f);
2051   return;
2052 }
2053
2054
2055 static void
2056 ns_scroll_run (struct window *w, struct run *run)
2057 /* --------------------------------------------------------------------------
2058     External (RIF):  Insert or delete n lines at line vpos
2059    -------------------------------------------------------------------------- */
2060 {
2061   struct frame *f = XFRAME (w->frame);
2062   int x, y, width, height, from_y, to_y, bottom_y;
2063
2064   NSTRACE (ns_scroll_run);
2065
2066   /* begin copy from other terms */
2067   /* Get frame-relative bounding box of the text display area of W,
2068      without mode lines.  Include in this box the left and right
2069      fringe of W.  */
2070   window_box (w, ANY_AREA, &x, &y, &width, &height);
2071
2072   from_y = WINDOW_TO_FRAME_PIXEL_Y (w, run->current_y);
2073   to_y = WINDOW_TO_FRAME_PIXEL_Y (w, run->desired_y);
2074   bottom_y = y + height;
2075
2076   if (to_y < from_y)
2077     {
2078       /* Scrolling up.  Make sure we don't copy part of the mode
2079          line at the bottom.  */
2080       if (from_y + run->height > bottom_y)
2081         height = bottom_y - from_y;
2082       else
2083         height = run->height;
2084     }
2085   else
2086     {
2087       /* Scrolling down.  Make sure we don't copy over the mode line.
2088          at the bottom.  */
2089       if (to_y + run->height > bottom_y)
2090         height = bottom_y - to_y;
2091       else
2092         height = run->height;
2093     }
2094   /* end copy from other terms */
2095
2096   if (height == 0)
2097       return;
2098
2099   block_input ();
2100
2101   x_clear_cursor (w);
2102
2103   {
2104     NSRect srcRect = NSMakeRect (x, from_y, width, height);
2105     NSRect dstRect = NSMakeRect (x, to_y, width, height);
2106     NSPoint dstOrigin = NSMakePoint (x, to_y);
2107
2108     ns_focus (f, &dstRect, 1);
2109     NSCopyBits (0, srcRect , dstOrigin);
2110     ns_unfocus (f);
2111   }
2112
2113   unblock_input ();
2114 }
2115
2116
2117 static void
2118 ns_after_update_window_line (struct window *w, struct glyph_row *desired_row)
2119 /* --------------------------------------------------------------------------
2120     External (RIF): preparatory to fringe update after text was updated
2121    -------------------------------------------------------------------------- */
2122 {
2123   struct frame *f;
2124   int width, height;
2125
2126   NSTRACE (ns_after_update_window_line);
2127
2128   /* begin copy from other terms */
2129   eassert (w);
2130
2131   if (!desired_row->mode_line_p && !w->pseudo_window_p)
2132     desired_row->redraw_fringe_bitmaps_p = 1;
2133
2134   /* When a window has disappeared, make sure that no rest of
2135      full-width rows stays visible in the internal border.  */
2136   if (windows_or_buffers_changed
2137       && desired_row->full_width_p
2138       && (f = XFRAME (w->frame),
2139           width = FRAME_INTERNAL_BORDER_WIDTH (f),
2140           width != 0)
2141       && (height = desired_row->visible_height,
2142           height > 0))
2143     {
2144       int y = WINDOW_TO_FRAME_PIXEL_Y (w, max (0, desired_row->y));
2145
2146       block_input ();
2147       ns_clear_frame_area (f, 0, y, width, height);
2148       ns_clear_frame_area (f,
2149                            FRAME_PIXEL_WIDTH (f) - width,
2150                            y, width, height);
2151       unblock_input ();
2152     }
2153 }
2154
2155
2156 static void
2157 ns_shift_glyphs_for_insert (struct frame *f,
2158                            int x, int y, int width, int height,
2159                            int shift_by)
2160 /* --------------------------------------------------------------------------
2161     External (RIF): copy an area horizontally, don't worry about clearing src
2162    -------------------------------------------------------------------------- */
2163 {
2164   NSRect srcRect = NSMakeRect (x, y, width, height);
2165   NSRect dstRect = NSMakeRect (x+shift_by, y, width, height);
2166   NSPoint dstOrigin = dstRect.origin;
2167
2168   NSTRACE (ns_shift_glyphs_for_insert);
2169
2170   ns_focus (f, &dstRect, 1);
2171   NSCopyBits (0, srcRect, dstOrigin);
2172   ns_unfocus (f);
2173 }
2174
2175
2176
2177 /* ==========================================================================
2178
2179     Character encoding and metrics
2180
2181    ========================================================================== */
2182
2183
2184 static void
2185 ns_compute_glyph_string_overhangs (struct glyph_string *s)
2186 /* --------------------------------------------------------------------------
2187      External (RIF); compute left/right overhang of whole string and set in s
2188    -------------------------------------------------------------------------- */
2189 {
2190   struct font *font = s->font;
2191
2192   if (s->char2b)
2193     {
2194       struct font_metrics metrics;
2195       unsigned int codes[2];
2196       codes[0] = *(s->char2b);
2197       codes[1] = *(s->char2b + s->nchars - 1);
2198
2199       font->driver->text_extents (font, codes, 2, &metrics);
2200       s->left_overhang = -metrics.lbearing;
2201       s->right_overhang
2202         = metrics.rbearing > metrics.width
2203         ? metrics.rbearing - metrics.width : 0;
2204     }
2205   else
2206     {
2207       s->left_overhang = 0;
2208       if (EQ (font->driver->type, Qns))
2209         s->right_overhang = ((struct nsfont_info *)font)->ital ?
2210           FONT_HEIGHT (font) * 0.2 : 0;
2211       else
2212         s->right_overhang = 0;
2213     }
2214 }
2215
2216
2217
2218 /* ==========================================================================
2219
2220     Fringe and cursor drawing
2221
2222    ========================================================================== */
2223
2224
2225 extern int max_used_fringe_bitmap;
2226 static void
2227 ns_draw_fringe_bitmap (struct window *w, struct glyph_row *row,
2228                       struct draw_fringe_bitmap_params *p)
2229 /* --------------------------------------------------------------------------
2230     External (RIF); fringe-related
2231    -------------------------------------------------------------------------- */
2232 {
2233   struct frame *f = XFRAME (WINDOW_FRAME (w));
2234   struct face *face = p->face;
2235   static EmacsImage **bimgs = NULL;
2236   static int nBimgs = 0;
2237
2238   /* grow bimgs if needed */
2239   if (nBimgs < max_used_fringe_bitmap)
2240     {
2241       bimgs = xrealloc (bimgs, max_used_fringe_bitmap * sizeof *bimgs);
2242       memset (bimgs + nBimgs, 0,
2243               (max_used_fringe_bitmap - nBimgs) * sizeof *bimgs);
2244       nBimgs = max_used_fringe_bitmap;
2245     }
2246
2247   /* Must clip because of partially visible lines.  */
2248   ns_clip_to_row (w, row, ANY_AREA, YES);
2249
2250   if (!p->overlay_p)
2251     {
2252       int bx = p->bx, by = p->by, nx = p->nx, ny = p->ny;
2253
2254       /* If the fringe is adjacent to the left (right) scroll bar of a
2255          leftmost (rightmost, respectively) window, then extend its
2256          background to the gap between the fringe and the bar.  */
2257       if ((WINDOW_LEFTMOST_P (w)
2258            && WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w))
2259           || (WINDOW_RIGHTMOST_P (w)
2260               && WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_RIGHT (w)))
2261         {
2262           int sb_width = WINDOW_CONFIG_SCROLL_BAR_WIDTH (w);
2263
2264           if (sb_width > 0)
2265             {
2266               int bar_area_x = WINDOW_SCROLL_BAR_AREA_X (w);
2267               int bar_area_width = (WINDOW_CONFIG_SCROLL_BAR_COLS (w)
2268                                     * FRAME_COLUMN_WIDTH (f));
2269
2270               if (bx < 0)
2271                 {
2272                   /* Bitmap fills the fringe.  */
2273                   if (bar_area_x + bar_area_width == p->x)
2274                     bx = bar_area_x + sb_width;
2275                   else if (p->x + p->wd == bar_area_x)
2276                     bx = bar_area_x;
2277                   if (bx >= 0)
2278                     {
2279                       int header_line_height = WINDOW_HEADER_LINE_HEIGHT (w);
2280
2281                       nx = bar_area_width - sb_width;
2282                       by = WINDOW_TO_FRAME_PIXEL_Y (w, max (header_line_height,
2283                                                             row->y));
2284                       ny = row->visible_height;
2285                     }
2286                 }
2287               else
2288                 {
2289                   if (bar_area_x + bar_area_width == bx)
2290                     {
2291                       bx = bar_area_x + sb_width;
2292                       nx += bar_area_width - sb_width;
2293                     }
2294                   else if (bx + nx == bar_area_x)
2295                     nx += bar_area_width - sb_width;
2296                 }
2297             }
2298         }
2299
2300       if (bx >= 0 && nx > 0)
2301         {
2302           NSRect r = NSMakeRect (bx, by, nx, ny);
2303           NSRectClip (r);
2304           [ns_lookup_indexed_color (face->background, f) set];
2305           NSRectFill (r);
2306         }
2307     }
2308
2309   if (p->which)
2310     {
2311       NSRect r = NSMakeRect (p->x, p->y, p->wd, p->h);
2312       EmacsImage *img = bimgs[p->which - 1];
2313
2314       if (!img)
2315         {
2316           unsigned short *bits = p->bits + p->dh;
2317           int len = p->h;
2318           int i;
2319           unsigned char *cbits = xmalloc (len);
2320
2321           for (i = 0; i < len; i++)
2322             cbits[i] = ~(bits[i] & 0xff);
2323           img = [[EmacsImage alloc] initFromXBM: cbits width: 8 height: p->h
2324                                            flip: NO];
2325           bimgs[p->which - 1] = img;
2326           xfree (cbits);
2327         }
2328
2329       NSRectClip (r);
2330       /* Since we composite the bitmap instead of just blitting it, we need
2331          to erase the whole background. */
2332       [ns_lookup_indexed_color(face->background, f) set];
2333       NSRectFill (r);
2334       [img setXBMColor: ns_lookup_indexed_color(face->foreground, f)];
2335 #if defined (NS_IMPL_COCOA) && MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_6
2336       [img drawInRect: r
2337               fromRect: NSZeroRect
2338              operation: NSCompositeSourceOver
2339               fraction: 1.0
2340            respectFlipped: YES
2341                 hints: nil];
2342 #else
2343       {
2344         NSPoint pt = r.origin;
2345         pt.y += p->h;
2346         [img compositeToPoint: pt operation: NSCompositeSourceOver];
2347       }
2348 #endif
2349     }
2350   ns_unfocus (f);
2351 }
2352
2353
2354 static void
2355 ns_draw_window_cursor (struct window *w, struct glyph_row *glyph_row,
2356                        int x, int y, enum text_cursor_kinds cursor_type,
2357                        int cursor_width, bool on_p, bool active_p)
2358 /* --------------------------------------------------------------------------
2359      External call (RIF): draw cursor.
2360      Note that CURSOR_WIDTH is meaningful only for (h)bar cursors.
2361    -------------------------------------------------------------------------- */
2362 {
2363   NSRect r, s;
2364   int fx, fy, h, cursor_height;
2365   struct frame *f = WINDOW_XFRAME (w);
2366   struct glyph *phys_cursor_glyph;
2367   struct glyph *cursor_glyph;
2368   struct face *face;
2369   NSColor *hollow_color = FRAME_BACKGROUND_COLOR (f);
2370
2371   /* If cursor is out of bounds, don't draw garbage.  This can happen
2372      in mini-buffer windows when switching between echo area glyphs
2373      and mini-buffer.  */
2374
2375   NSTRACE (dumpcursor);
2376
2377   if (!on_p)
2378     return;
2379
2380   w->phys_cursor_type = cursor_type;
2381   w->phys_cursor_on_p = on_p;
2382
2383   if (cursor_type == NO_CURSOR)
2384     {
2385       w->phys_cursor_width = 0;
2386       return;
2387     }
2388
2389   if ((phys_cursor_glyph = get_phys_cursor_glyph (w)) == NULL)
2390     {
2391       if (glyph_row->exact_window_width_line_p
2392           && w->phys_cursor.hpos >= glyph_row->used[TEXT_AREA])
2393         {
2394           glyph_row->cursor_in_fringe_p = 1;
2395           draw_fringe_bitmap (w, glyph_row, 0);
2396         }
2397       return;
2398     }
2399
2400   /* We draw the cursor (with NSRectFill), then draw the glyph on top
2401      (other terminals do it the other way round).  We must set
2402      w->phys_cursor_width to the cursor width.  For bar cursors, that
2403      is CURSOR_WIDTH; for box cursors, it is the glyph width.  */
2404   get_phys_cursor_geometry (w, glyph_row, phys_cursor_glyph, &fx, &fy, &h);
2405
2406   /* The above get_phys_cursor_geometry call set w->phys_cursor_width
2407      to the glyph width; replace with CURSOR_WIDTH for (V)BAR cursors. */
2408   if (cursor_type == BAR_CURSOR)
2409     {
2410       if (cursor_width < 1)
2411         cursor_width = max (FRAME_CURSOR_WIDTH (f), 1);
2412       w->phys_cursor_width = cursor_width;
2413     }
2414   /* If we have an HBAR, "cursor_width" MAY specify height. */
2415   else if (cursor_type == HBAR_CURSOR)
2416     {
2417       cursor_height = (cursor_width < 1) ? lrint (0.25 * h) : cursor_width;
2418       fy += h - cursor_height;
2419       h = cursor_height;
2420     }
2421
2422   r.origin.x = fx, r.origin.y = fy;
2423   r.size.height = h;
2424   r.size.width = w->phys_cursor_width;
2425
2426   /* TODO: only needed in rare cases with last-resort font in HELLO..
2427      should we do this more efficiently? */
2428   ns_clip_to_row (w, glyph_row, ANY_AREA, NO); /* do ns_focus(f, &r, 1); if remove */
2429
2430
2431   face = FACE_FROM_ID (f, phys_cursor_glyph->face_id);
2432   if (face && NS_FACE_BACKGROUND (face)
2433       == ns_index_color (FRAME_CURSOR_COLOR (f), f))
2434     {
2435       [ns_lookup_indexed_color (NS_FACE_FOREGROUND (face), f) set];
2436       hollow_color = FRAME_CURSOR_COLOR (f);
2437     }
2438   else
2439     [FRAME_CURSOR_COLOR (f) set];
2440
2441 #ifdef NS_IMPL_COCOA
2442   /* TODO: This makes drawing of cursor plus that of phys_cursor_glyph
2443            atomic.  Cleaner ways of doing this should be investigated.
2444            One way would be to set a global variable DRAWING_CURSOR
2445            when making the call to draw_phys..(), don't focus in that
2446            case, then move the ns_unfocus() here after that call. */
2447   NSDisableScreenUpdates ();
2448 #endif
2449
2450   switch (cursor_type)
2451     {
2452     case NO_CURSOR:
2453       break;
2454     case FILLED_BOX_CURSOR:
2455       NSRectFill (r);
2456       break;
2457     case HOLLOW_BOX_CURSOR:
2458       NSRectFill (r);
2459       [hollow_color set];
2460       NSRectFill (NSInsetRect (r, 1, 1));
2461       [FRAME_CURSOR_COLOR (f) set];
2462       break;
2463     case HBAR_CURSOR:
2464       NSRectFill (r);
2465       break;
2466     case BAR_CURSOR:
2467       s = r;
2468       /* If the character under cursor is R2L, draw the bar cursor
2469          on the right of its glyph, rather than on the left.  */
2470       cursor_glyph = get_phys_cursor_glyph (w);
2471       if ((cursor_glyph->resolved_level & 1) != 0)
2472         s.origin.x += cursor_glyph->pixel_width - s.size.width;
2473
2474       NSRectFill (s);
2475       break;
2476     }
2477   ns_unfocus (f);
2478
2479   /* draw the character under the cursor */
2480   if (cursor_type != NO_CURSOR)
2481     draw_phys_cursor_glyph (w, glyph_row, DRAW_CURSOR);
2482
2483 #ifdef NS_IMPL_COCOA
2484   NSEnableScreenUpdates ();
2485 #endif
2486
2487 }
2488
2489
2490 static void
2491 ns_draw_vertical_window_border (struct window *w, int x, int y0, int y1)
2492 /* --------------------------------------------------------------------------
2493      External (RIF): Draw a vertical line.
2494    -------------------------------------------------------------------------- */
2495 {
2496   struct frame *f = XFRAME (WINDOW_FRAME (w));
2497   struct face *face;
2498   NSRect r = NSMakeRect (x, y0, 1, y1-y0);
2499
2500   NSTRACE (ns_draw_vertical_window_border);
2501
2502   face = FACE_FROM_ID (f, VERTICAL_BORDER_FACE_ID);
2503   if (face)
2504       [ns_lookup_indexed_color(face->foreground, f) set];
2505
2506   ns_focus (f, &r, 1);
2507   NSRectFill(r);
2508   ns_unfocus (f);
2509 }
2510
2511
2512 static void
2513 ns_draw_window_divider (struct window *w, int x0, int x1, int y0, int y1)
2514 /* --------------------------------------------------------------------------
2515      External (RIF): Draw a window divider.
2516    -------------------------------------------------------------------------- */
2517 {
2518   struct frame *f = XFRAME (WINDOW_FRAME (w));
2519   struct face *face;
2520   NSRect r = NSMakeRect (x0, y0, x1-x0, y1-y0);
2521
2522   NSTRACE (ns_draw_window_divider);
2523
2524   face = FACE_FROM_ID (f, WINDOW_DIVIDER_FACE_ID);
2525   if (face)
2526       [ns_lookup_indexed_color(face->foreground, f) set];
2527
2528   ns_focus (f, &r, 1);
2529   NSRectFill(r);
2530   ns_unfocus (f);
2531 }
2532
2533
2534 void
2535 show_hourglass (struct atimer *timer)
2536 {
2537   if (hourglass_shown_p)
2538     return;
2539
2540   block_input ();
2541
2542   /* TODO: add NSProgressIndicator to selected frame (see macfns.c) */
2543
2544   hourglass_shown_p = 1;
2545   unblock_input ();
2546 }
2547
2548
2549 void
2550 hide_hourglass (void)
2551 {
2552   if (!hourglass_shown_p)
2553     return;
2554
2555   block_input ();
2556
2557   /* TODO: remove NSProgressIndicator from all frames */
2558
2559   hourglass_shown_p = 0;
2560   unblock_input ();
2561 }
2562
2563
2564
2565 /* ==========================================================================
2566
2567     Glyph drawing operations
2568
2569    ========================================================================== */
2570
2571 static int
2572 ns_get_glyph_string_clip_rect (struct glyph_string *s, NativeRectangle *nr)
2573 /* --------------------------------------------------------------------------
2574     Wrapper utility to account for internal border width on full-width lines,
2575     and allow top full-width rows to hit the frame top.  nr should be pointer
2576     to two successive NSRects.  Number of rects actually used is returned.
2577    -------------------------------------------------------------------------- */
2578 {
2579   int n = get_glyph_string_clip_rects (s, nr, 2);
2580   return n;
2581 }
2582
2583 /* --------------------------------------------------------------------
2584    Draw a wavy line under glyph string s. The wave fills wave_height
2585    pixels from y.
2586
2587                     x          wave_length = 2
2588                                  --
2589                 y    *   *   *   *   *
2590                      |* * * * * * * * *
2591     wave_height = 3  | *   *   *   *
2592   --------------------------------------------------------------------- */
2593
2594 static void
2595 ns_draw_underwave (struct glyph_string *s, EmacsCGFloat width, EmacsCGFloat x)
2596 {
2597   int wave_height = 3, wave_length = 2;
2598   int y, dx, dy, odd, xmax;
2599   NSPoint a, b;
2600   NSRect waveClip;
2601
2602   dx = wave_length;
2603   dy = wave_height - 1;
2604   y =  s->ybase - wave_height + 3;
2605   xmax = x + width;
2606
2607   /* Find and set clipping rectangle */
2608   waveClip = NSMakeRect (x, y, width, wave_height);
2609   [[NSGraphicsContext currentContext] saveGraphicsState];
2610   NSRectClip (waveClip);
2611
2612   /* Draw the waves */
2613   a.x = x - ((int)(x) % dx) + (EmacsCGFloat) 0.5;
2614   b.x = a.x + dx;
2615   odd = (int)(a.x/dx) % 2;
2616   a.y = b.y = y + 0.5;
2617
2618   if (odd)
2619     a.y += dy;
2620   else
2621     b.y += dy;
2622
2623   while (a.x <= xmax)
2624     {
2625       [NSBezierPath strokeLineFromPoint:a toPoint:b];
2626       a.x = b.x, a.y = b.y;
2627       b.x += dx, b.y = y + 0.5 + odd*dy;
2628       odd = !odd;
2629     }
2630
2631   /* Restore previous clipping rectangle(s) */
2632   [[NSGraphicsContext currentContext] restoreGraphicsState];
2633 }
2634
2635
2636
2637 void
2638 ns_draw_text_decoration (struct glyph_string *s, struct face *face,
2639                          NSColor *defaultCol, CGFloat width, CGFloat x)
2640 /* --------------------------------------------------------------------------
2641    Draw underline, overline, and strike-through on glyph string s.
2642    -------------------------------------------------------------------------- */
2643 {
2644   if (s->for_overlaps)
2645     return;
2646
2647   /* Do underline. */
2648   if (face->underline_p)
2649     {
2650       if (s->face->underline_type == FACE_UNDER_WAVE)
2651         {
2652           if (face->underline_defaulted_p)
2653             [defaultCol set];
2654           else
2655             [ns_lookup_indexed_color (face->underline_color, s->f) set];
2656
2657           ns_draw_underwave (s, width, x);
2658         }
2659       else if (s->face->underline_type == FACE_UNDER_LINE)
2660         {
2661
2662           NSRect r;
2663           unsigned long thickness, position;
2664
2665           /* If the prev was underlined, match its appearance. */
2666           if (s->prev && s->prev->face->underline_p
2667               && s->prev->face->underline_type == FACE_UNDER_LINE
2668               && s->prev->underline_thickness > 0)
2669             {
2670               thickness = s->prev->underline_thickness;
2671               position = s->prev->underline_position;
2672             }
2673           else
2674             {
2675               struct font *font;
2676               unsigned long descent;
2677
2678               font=s->font;
2679               descent = s->y + s->height - s->ybase;
2680
2681               /* Use underline thickness of font, defaulting to 1. */
2682               thickness = (font && font->underline_thickness > 0)
2683                 ? font->underline_thickness : 1;
2684
2685               /* Determine the offset of underlining from the baseline. */
2686               if (x_underline_at_descent_line)
2687                 position = descent - thickness;
2688               else if (x_use_underline_position_properties
2689                        && font && font->underline_position >= 0)
2690                 position = font->underline_position;
2691               else if (font)
2692                 position = lround (font->descent / 2);
2693               else
2694                 position = underline_minimum_offset;
2695
2696               position = max (position, underline_minimum_offset);
2697
2698               /* Ensure underlining is not cropped. */
2699               if (descent <= position)
2700                 {
2701                   position = descent - 1;
2702                   thickness = 1;
2703                 }
2704               else if (descent < position + thickness)
2705                 thickness = 1;
2706             }
2707
2708           s->underline_thickness = thickness;
2709           s->underline_position = position;
2710
2711           r = NSMakeRect (x, s->ybase + position, width, thickness);
2712
2713           if (face->underline_defaulted_p)
2714             [defaultCol set];
2715           else
2716             [ns_lookup_indexed_color (face->underline_color, s->f) set];
2717           NSRectFill (r);
2718         }
2719     }
2720   /* Do overline. We follow other terms in using a thickness of 1
2721      and ignoring overline_margin. */
2722   if (face->overline_p)
2723     {
2724       NSRect r;
2725       r = NSMakeRect (x, s->y, width, 1);
2726
2727       if (face->overline_color_defaulted_p)
2728         [defaultCol set];
2729       else
2730         [ns_lookup_indexed_color (face->overline_color, s->f) set];
2731       NSRectFill (r);
2732     }
2733
2734   /* Do strike-through.  We follow other terms for thickness and
2735      vertical position.*/
2736   if (face->strike_through_p)
2737     {
2738       NSRect r;
2739       unsigned long dy;
2740
2741       dy = lrint ((s->height - 1) / 2);
2742       r = NSMakeRect (x, s->y + dy, width, 1);
2743
2744       if (face->strike_through_color_defaulted_p)
2745         [defaultCol set];
2746       else
2747         [ns_lookup_indexed_color (face->strike_through_color, s->f) set];
2748       NSRectFill (r);
2749     }
2750 }
2751
2752 static void
2753 ns_draw_box (NSRect r, CGFloat thickness, NSColor *col,
2754              char left_p, char right_p)
2755 /* --------------------------------------------------------------------------
2756     Draw an unfilled rect inside r, optionally leaving left and/or right open.
2757     Note we can't just use an NSDrawRect command, because of the possibility
2758     of some sides not being drawn, and because the rect will be filled.
2759    -------------------------------------------------------------------------- */
2760 {
2761   NSRect s = r;
2762   [col set];
2763
2764   /* top, bottom */
2765   s.size.height = thickness;
2766   NSRectFill (s);
2767   s.origin.y += r.size.height - thickness;
2768   NSRectFill (s);
2769
2770   s.size.height = r.size.height;
2771   s.origin.y = r.origin.y;
2772
2773   /* left, right (optional) */
2774   s.size.width = thickness;
2775   if (left_p)
2776     NSRectFill (s);
2777   if (right_p)
2778     {
2779       s.origin.x += r.size.width - thickness;
2780       NSRectFill (s);
2781     }
2782 }
2783
2784
2785 static void
2786 ns_draw_relief (NSRect r, int thickness, char raised_p,
2787                char top_p, char bottom_p, char left_p, char right_p,
2788                struct glyph_string *s)
2789 /* --------------------------------------------------------------------------
2790     Draw a relief rect inside r, optionally leaving some sides open.
2791     Note we can't just use an NSDrawBezel command, because of the possibility
2792     of some sides not being drawn, and because the rect will be filled.
2793    -------------------------------------------------------------------------- */
2794 {
2795   static NSColor *baseCol = nil, *lightCol = nil, *darkCol = nil;
2796   NSColor *newBaseCol = nil;
2797   NSRect sr = r;
2798
2799   NSTRACE (ns_draw_relief);
2800
2801   /* set up colors */
2802
2803   if (s->face->use_box_color_for_shadows_p)
2804     {
2805       newBaseCol = ns_lookup_indexed_color (s->face->box_color, s->f);
2806     }
2807 /*     else if (s->first_glyph->type == IMAGE_GLYPH
2808            && s->img->pixmap
2809            && !IMAGE_BACKGROUND_TRANSPARENT (s->img, s->f, 0))
2810        {
2811          newBaseCol = IMAGE_BACKGROUND  (s->img, s->f, 0);
2812        } */
2813   else
2814     {
2815       newBaseCol = ns_lookup_indexed_color (s->face->background, s->f);
2816     }
2817
2818   if (newBaseCol == nil)
2819     newBaseCol = [NSColor grayColor];
2820
2821   if (newBaseCol != baseCol)  /* TODO: better check */
2822     {
2823       [baseCol release];
2824       baseCol = [newBaseCol retain];
2825       [lightCol release];
2826       lightCol = [[baseCol highlightWithLevel: 0.2] retain];
2827       [darkCol release];
2828       darkCol = [[baseCol shadowWithLevel: 0.3] retain];
2829     }
2830
2831   [(raised_p ? lightCol : darkCol) set];
2832
2833   /* TODO: mitering. Using NSBezierPath doesn't work because of color switch. */
2834
2835   /* top */
2836   sr.size.height = thickness;
2837   if (top_p) NSRectFill (sr);
2838
2839   /* left */
2840   sr.size.height = r.size.height;
2841   sr.size.width = thickness;
2842   if (left_p) NSRectFill (sr);
2843
2844   [(raised_p ? darkCol : lightCol) set];
2845
2846   /* bottom */
2847   sr.size.width = r.size.width;
2848   sr.size.height = thickness;
2849   sr.origin.y += r.size.height - thickness;
2850   if (bottom_p) NSRectFill (sr);
2851
2852   /* right */
2853   sr.size.height = r.size.height;
2854   sr.origin.y = r.origin.y;
2855   sr.size.width = thickness;
2856   sr.origin.x += r.size.width - thickness;
2857   if (right_p) NSRectFill (sr);
2858 }
2859
2860
2861 static void
2862 ns_dumpglyphs_box_or_relief (struct glyph_string *s)
2863 /* --------------------------------------------------------------------------
2864       Function modeled after x_draw_glyph_string_box ().
2865       Sets up parameters for drawing.
2866    -------------------------------------------------------------------------- */
2867 {
2868   int right_x, last_x;
2869   char left_p, right_p;
2870   struct glyph *last_glyph;
2871   NSRect r;
2872   int thickness;
2873   struct face *face;
2874
2875   if (s->hl == DRAW_MOUSE_FACE)
2876     {
2877       face = FACE_FROM_ID (s->f, MOUSE_HL_INFO (s->f)->mouse_face_face_id);
2878       if (!face)
2879         face = FACE_FROM_ID (s->f, MOUSE_FACE_ID);
2880     }
2881   else
2882     face = s->face;
2883
2884   thickness = face->box_line_width;
2885
2886   NSTRACE (ns_dumpglyphs_box_or_relief);
2887
2888   last_x = ((s->row->full_width_p && !s->w->pseudo_window_p)
2889             ? WINDOW_RIGHT_EDGE_X (s->w)
2890             : window_box_right (s->w, s->area));
2891   last_glyph = (s->cmp || s->img
2892                 ? s->first_glyph : s->first_glyph + s->nchars-1);
2893
2894   right_x = ((s->row->full_width_p && s->extends_to_end_of_line_p
2895               ? last_x - 1 : min (last_x, s->x + s->background_width) - 1));
2896
2897   left_p = (s->first_glyph->left_box_line_p
2898             || (s->hl == DRAW_MOUSE_FACE
2899                 && (s->prev == NULL || s->prev->hl != s->hl)));
2900   right_p = (last_glyph->right_box_line_p
2901              || (s->hl == DRAW_MOUSE_FACE
2902                  && (s->next == NULL || s->next->hl != s->hl)));
2903
2904   r = NSMakeRect (s->x, s->y, right_x - s->x + 1, s->height);
2905
2906   /* TODO: Sometimes box_color is 0 and this seems wrong; should investigate. */
2907   if (s->face->box == FACE_SIMPLE_BOX && s->face->box_color)
2908     {
2909       ns_draw_box (r, abs (thickness),
2910                    ns_lookup_indexed_color (face->box_color, s->f),
2911                   left_p, right_p);
2912     }
2913   else
2914     {
2915       ns_draw_relief (r, abs (thickness), s->face->box == FACE_RAISED_BOX,
2916                      1, 1, left_p, right_p, s);
2917     }
2918 }
2919
2920
2921 static void
2922 ns_maybe_dumpglyphs_background (struct glyph_string *s, char force_p)
2923 /* --------------------------------------------------------------------------
2924       Modeled after x_draw_glyph_string_background, which draws BG in
2925       certain cases.  Others are left to the text rendering routine.
2926    -------------------------------------------------------------------------- */
2927 {
2928   NSTRACE (ns_maybe_dumpglyphs_background);
2929
2930   if (!s->background_filled_p/* || s->hl == DRAW_MOUSE_FACE*/)
2931     {
2932       int box_line_width = max (s->face->box_line_width, 0);
2933       if (FONT_HEIGHT (s->font) < s->height - 2 * box_line_width
2934           || s->font_not_found_p || s->extends_to_end_of_line_p || force_p)
2935         {
2936           struct face *face;
2937           if (s->hl == DRAW_MOUSE_FACE)
2938             {
2939               face = FACE_FROM_ID (s->f,
2940                                    MOUSE_HL_INFO (s->f)->mouse_face_face_id);
2941               if (!face)
2942                 face = FACE_FROM_ID (s->f, MOUSE_FACE_ID);
2943             }
2944           else
2945             face = FACE_FROM_ID (s->f, s->first_glyph->face_id);
2946           if (!face->stipple)
2947             [(NS_FACE_BACKGROUND (face) != 0
2948               ? ns_lookup_indexed_color (NS_FACE_BACKGROUND (face), s->f)
2949               : FRAME_BACKGROUND_COLOR (s->f)) set];
2950           else
2951             {
2952               struct ns_display_info *dpyinfo = FRAME_DISPLAY_INFO (s->f);
2953               [[dpyinfo->bitmaps[face->stipple-1].img stippleMask] set];
2954             }
2955
2956           if (s->hl != DRAW_CURSOR)
2957             {
2958               NSRect r = NSMakeRect (s->x, s->y + box_line_width,
2959                                     s->background_width,
2960                                     s->height-2*box_line_width);
2961               NSRectFill (r);
2962             }
2963
2964           s->background_filled_p = 1;
2965         }
2966     }
2967 }
2968
2969
2970 static void
2971 ns_dumpglyphs_image (struct glyph_string *s, NSRect r)
2972 /* --------------------------------------------------------------------------
2973       Renders an image and associated borders.
2974    -------------------------------------------------------------------------- */
2975 {
2976   EmacsImage *img = s->img->pixmap;
2977   int box_line_vwidth = max (s->face->box_line_width, 0);
2978   int x = s->x, y = s->ybase - image_ascent (s->img, s->face, &s->slice);
2979   int bg_x, bg_y, bg_height;
2980   int th;
2981   char raised_p;
2982   NSRect br;
2983   struct face *face;
2984   NSColor *tdCol;
2985
2986   NSTRACE (ns_dumpglyphs_image);
2987
2988   if (s->face->box != FACE_NO_BOX
2989       && s->first_glyph->left_box_line_p && s->slice.x == 0)
2990     x += abs (s->face->box_line_width);
2991
2992   bg_x = x;
2993   bg_y =  s->slice.y == 0 ? s->y : s->y + box_line_vwidth;
2994   bg_height = s->height;
2995   /* other terms have this, but was causing problems w/tabbar mode */
2996   /* - 2 * box_line_vwidth; */
2997
2998   if (s->slice.x == 0) x += s->img->hmargin;
2999   if (s->slice.y == 0) y += s->img->vmargin;
3000
3001   /* Draw BG: if we need larger area than image itself cleared, do that,
3002      otherwise, since we composite the image under NS (instead of mucking
3003      with its background color), we must clear just the image area. */
3004   if (s->hl == DRAW_MOUSE_FACE)
3005     {
3006       face = FACE_FROM_ID (s->f, MOUSE_HL_INFO (s->f)->mouse_face_face_id);
3007       if (!face)
3008        face = FACE_FROM_ID (s->f, MOUSE_FACE_ID);
3009     }
3010   else
3011     face = FACE_FROM_ID (s->f, s->first_glyph->face_id);
3012
3013   [ns_lookup_indexed_color (NS_FACE_BACKGROUND (face), s->f) set];
3014
3015   if (bg_height > s->slice.height || s->img->hmargin || s->img->vmargin
3016       || s->img->mask || s->img->pixmap == 0 || s->width != s->background_width)
3017     {
3018       br = NSMakeRect (bg_x, bg_y, s->background_width, bg_height);
3019       s->background_filled_p = 1;
3020     }
3021   else
3022     {
3023       br = NSMakeRect (x, y, s->slice.width, s->slice.height);
3024     }
3025
3026   NSRectFill (br);
3027
3028   /* Draw the image.. do we need to draw placeholder if img ==nil? */
3029   if (img != nil)
3030     {
3031 #if defined (NS_IMPL_COCOA) && MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_6
3032       NSRect dr = NSMakeRect (x, y, s->slice.width, s->slice.height);
3033       NSRect ir = NSMakeRect (s->slice.x, s->slice.y,
3034                               s->slice.width, s->slice.height);
3035       [img drawInRect: dr
3036              fromRect: ir
3037              operation: NSCompositeSourceOver
3038               fraction: 1.0
3039            respectFlipped: YES
3040                 hints: nil];
3041 #else
3042       [img compositeToPoint: NSMakePoint (x, y + s->slice.height)
3043                   operation: NSCompositeSourceOver];
3044 #endif
3045     }
3046
3047   if (s->hl == DRAW_CURSOR)
3048     {
3049     [FRAME_CURSOR_COLOR (s->f) set];
3050     if (s->w->phys_cursor_type == FILLED_BOX_CURSOR)
3051       tdCol = ns_lookup_indexed_color (NS_FACE_BACKGROUND (face), s->f);
3052     else
3053       /* Currently on NS img->mask is always 0. Since
3054          get_window_cursor_type specifies a hollow box cursor when on
3055          a non-masked image we never reach this clause. But we put it
3056          in in anticipation of better support for image masks on
3057          NS. */
3058       tdCol = ns_lookup_indexed_color (NS_FACE_FOREGROUND (face), s->f);
3059     }
3060   else
3061     {
3062       tdCol = ns_lookup_indexed_color (NS_FACE_FOREGROUND (face), s->f);
3063     }
3064
3065   /* Draw underline, overline, strike-through. */
3066   ns_draw_text_decoration (s, face, tdCol, br.size.width, br.origin.x);
3067
3068   /* Draw relief, if requested */
3069   if (s->img->relief || s->hl ==DRAW_IMAGE_RAISED || s->hl ==DRAW_IMAGE_SUNKEN)
3070     {
3071       if (s->hl == DRAW_IMAGE_SUNKEN || s->hl == DRAW_IMAGE_RAISED)
3072         {
3073           th = tool_bar_button_relief >= 0 ?
3074             tool_bar_button_relief : DEFAULT_TOOL_BAR_BUTTON_RELIEF;
3075           raised_p = (s->hl == DRAW_IMAGE_RAISED);
3076         }
3077       else
3078         {
3079           th = abs (s->img->relief);
3080           raised_p = (s->img->relief > 0);
3081         }
3082
3083       r.origin.x = x - th;
3084       r.origin.y = y - th;
3085       r.size.width = s->slice.width + 2*th-1;
3086       r.size.height = s->slice.height + 2*th-1;
3087       ns_draw_relief (r, th, raised_p,
3088                       s->slice.y == 0,
3089                       s->slice.y + s->slice.height == s->img->height,
3090                       s->slice.x == 0,
3091                       s->slice.x + s->slice.width == s->img->width, s);
3092     }
3093
3094   /* If there is no mask, the background won't be seen,
3095      so draw a rectangle on the image for the cursor.
3096      Do this for all images, getting transparency right is not reliable.  */
3097   if (s->hl == DRAW_CURSOR)
3098     {
3099       int thickness = abs (s->img->relief);
3100       if (thickness == 0) thickness = 1;
3101       ns_draw_box (br, thickness, FRAME_CURSOR_COLOR (s->f), 1, 1);
3102     }
3103 }
3104
3105
3106 static void
3107 ns_dumpglyphs_stretch (struct glyph_string *s)
3108 {
3109   NSRect r[2];
3110   int n, i;
3111   struct face *face;
3112   NSColor *fgCol, *bgCol;
3113
3114   if (!s->background_filled_p)
3115     {
3116       n = ns_get_glyph_string_clip_rect (s, r);
3117       *r = NSMakeRect (s->x, s->y, s->background_width, s->height);
3118
3119       ns_focus (s->f, r, n);
3120
3121       if (s->hl == DRAW_MOUSE_FACE)
3122        {
3123          face = FACE_FROM_ID (s->f, MOUSE_HL_INFO (s->f)->mouse_face_face_id);
3124          if (!face)
3125            face = FACE_FROM_ID (s->f, MOUSE_FACE_ID);
3126        }
3127       else
3128        face = FACE_FROM_ID (s->f, s->first_glyph->face_id);
3129
3130       bgCol = ns_lookup_indexed_color (NS_FACE_BACKGROUND (face), s->f);
3131       fgCol = ns_lookup_indexed_color (NS_FACE_FOREGROUND (face), s->f);
3132
3133       for (i = 0; i < n; ++i)
3134         {
3135           if (!s->row->full_width_p)
3136             {
3137               int overrun, leftoverrun;
3138
3139               /* truncate to avoid overwriting fringe and/or scrollbar */
3140               overrun = max (0, (s->x + s->background_width)
3141                              - (WINDOW_BOX_RIGHT_EDGE_X (s->w)
3142                                 - WINDOW_RIGHT_FRINGE_WIDTH (s->w)));
3143               r[i].size.width -= overrun;
3144
3145               /* truncate to avoid overwriting to left of the window box */
3146               leftoverrun = (WINDOW_BOX_LEFT_EDGE_X (s->w)
3147                              + WINDOW_LEFT_FRINGE_WIDTH (s->w)) - s->x;
3148
3149               if (leftoverrun > 0)
3150                 {
3151                   r[i].origin.x += leftoverrun;
3152                   r[i].size.width -= leftoverrun;
3153                 }
3154
3155               /* XXX: Try to work between problem where a stretch glyph on
3156                  a partially-visible bottom row will clear part of the
3157                  modeline, and another where list-buffers headers and similar
3158                  rows erroneously have visible_height set to 0.  Not sure
3159                  where this is coming from as other terms seem not to show. */
3160               r[i].size.height = min (s->height, s->row->visible_height);
3161             }
3162
3163           [bgCol set];
3164
3165           /* NOTE: under NS this is NOT used to draw cursors, but we must avoid
3166              overwriting cursor (usually when cursor on a tab) */
3167           if (s->hl == DRAW_CURSOR)
3168             {
3169               CGFloat x, width;
3170
3171               x = r[i].origin.x;
3172               width = s->w->phys_cursor_width;
3173               r[i].size.width -= width;
3174               r[i].origin.x += width;
3175
3176               NSRectFill (r[i]);
3177
3178               /* Draw overlining, etc. on the cursor. */
3179               if (s->w->phys_cursor_type == FILLED_BOX_CURSOR)
3180                 ns_draw_text_decoration (s, face, bgCol, width, x);
3181               else
3182                 ns_draw_text_decoration (s, face, fgCol, width, x);
3183             }
3184           else
3185             {
3186               NSRectFill (r[i]);
3187             }
3188
3189           /* Draw overlining, etc. on the stretch glyph (or the part
3190              of the stretch glyph after the cursor). */
3191           ns_draw_text_decoration (s, face, fgCol, r[i].size.width,
3192                                    r[i].origin.x);
3193         }
3194       ns_unfocus (s->f);
3195       s->background_filled_p = 1;
3196     }
3197 }
3198
3199
3200 static void
3201 ns_draw_glyph_string (struct glyph_string *s)
3202 /* --------------------------------------------------------------------------
3203       External (RIF): Main draw-text call.
3204    -------------------------------------------------------------------------- */
3205 {
3206   /* TODO (optimize): focus for box and contents draw */
3207   NSRect r[2];
3208   int n, flags;
3209   char box_drawn_p = 0;
3210   struct font *font = s->face->font;
3211   if (! font) font = FRAME_FONT (s->f);
3212
3213   NSTRACE (ns_draw_glyph_string);
3214
3215   if (s->next && s->right_overhang && !s->for_overlaps/*&&s->hl!=DRAW_CURSOR*/)
3216     {
3217       int width;
3218       struct glyph_string *next;
3219
3220       for (width = 0, next = s->next;
3221            next && width < s->right_overhang;
3222            width += next->width, next = next->next)
3223         if (next->first_glyph->type != IMAGE_GLYPH)
3224           {
3225             if (next->first_glyph->type != STRETCH_GLYPH)
3226               {
3227                 n = ns_get_glyph_string_clip_rect (s->next, r);
3228                 ns_focus (s->f, r, n);
3229                 ns_maybe_dumpglyphs_background (s->next, 1);
3230                 ns_unfocus (s->f);
3231               }
3232             else
3233               {
3234                 ns_dumpglyphs_stretch (s->next);
3235               }
3236             next->num_clips = 0;
3237           }
3238     }
3239
3240   if (!s->for_overlaps && s->face->box != FACE_NO_BOX
3241         && (s->first_glyph->type == CHAR_GLYPH
3242             || s->first_glyph->type == COMPOSITE_GLYPH))
3243     {
3244       n = ns_get_glyph_string_clip_rect (s, r);
3245       ns_focus (s->f, r, n);
3246       ns_maybe_dumpglyphs_background (s, 1);
3247       ns_dumpglyphs_box_or_relief (s);
3248       ns_unfocus (s->f);
3249       box_drawn_p = 1;
3250     }
3251
3252   switch (s->first_glyph->type)
3253     {
3254
3255     case IMAGE_GLYPH:
3256       n = ns_get_glyph_string_clip_rect (s, r);
3257       ns_focus (s->f, r, n);
3258       ns_dumpglyphs_image (s, r[0]);
3259       ns_unfocus (s->f);
3260       break;
3261
3262     case STRETCH_GLYPH:
3263       ns_dumpglyphs_stretch (s);
3264       break;
3265
3266     case CHAR_GLYPH:
3267     case COMPOSITE_GLYPH:
3268       n = ns_get_glyph_string_clip_rect (s, r);
3269       ns_focus (s->f, r, n);
3270
3271       if (s->for_overlaps || (s->cmp_from > 0
3272                               && ! s->first_glyph->u.cmp.automatic))
3273         s->background_filled_p = 1;
3274       else
3275         ns_maybe_dumpglyphs_background
3276           (s, s->first_glyph->type == COMPOSITE_GLYPH);
3277
3278       flags = s->hl == DRAW_CURSOR ? NS_DUMPGLYPH_CURSOR :
3279         (s->hl == DRAW_MOUSE_FACE ? NS_DUMPGLYPH_MOUSEFACE :
3280          (s->for_overlaps ? NS_DUMPGLYPH_FOREGROUND :
3281           NS_DUMPGLYPH_NORMAL));
3282
3283       if (s->hl == DRAW_CURSOR && s->w->phys_cursor_type == FILLED_BOX_CURSOR)
3284         {
3285           unsigned long tmp = NS_FACE_BACKGROUND (s->face);
3286           NS_FACE_BACKGROUND (s->face) = NS_FACE_FOREGROUND (s->face);
3287           NS_FACE_FOREGROUND (s->face) = tmp;
3288         }
3289
3290       font->driver->draw
3291         (s, 0, s->nchars, s->x, s->y,
3292          (flags == NS_DUMPGLYPH_NORMAL && !s->background_filled_p)
3293          || flags == NS_DUMPGLYPH_MOUSEFACE);
3294
3295       {
3296         NSColor *col = (NS_FACE_FOREGROUND (s->face) != 0
3297                         ? ns_lookup_indexed_color (NS_FACE_FOREGROUND (s->face),
3298                                                    s->f)
3299                         : FRAME_FOREGROUND_COLOR (s->f));
3300         [col set];
3301
3302         /* Draw underline, overline, strike-through. */
3303         ns_draw_text_decoration (s, s->face, col, s->width, s->x);
3304       }
3305
3306       if (s->hl == DRAW_CURSOR && s->w->phys_cursor_type == FILLED_BOX_CURSOR)
3307         {
3308           unsigned long tmp = NS_FACE_BACKGROUND (s->face);
3309           NS_FACE_BACKGROUND (s->face) = NS_FACE_FOREGROUND (s->face);
3310           NS_FACE_FOREGROUND (s->face) = tmp;
3311         }
3312
3313       ns_unfocus (s->f);
3314       break;
3315
3316     case GLYPHLESS_GLYPH:
3317       n = ns_get_glyph_string_clip_rect (s, r);
3318       ns_focus (s->f, r, n);
3319
3320       if (s->for_overlaps || (s->cmp_from > 0
3321                               && ! s->first_glyph->u.cmp.automatic))
3322         s->background_filled_p = 1;
3323       else
3324         ns_maybe_dumpglyphs_background
3325           (s, s->first_glyph->type == COMPOSITE_GLYPH);
3326       /* ... */
3327       /* Not yet implemented.  */
3328       /* ... */
3329       ns_unfocus (s->f);
3330       break;
3331
3332     default:
3333       emacs_abort ();
3334     }
3335
3336   /* Draw box if not done already. */
3337   if (!s->for_overlaps && !box_drawn_p && s->face->box != FACE_NO_BOX)
3338     {
3339       n = ns_get_glyph_string_clip_rect (s, r);
3340       ns_focus (s->f, r, n);
3341       ns_dumpglyphs_box_or_relief (s);
3342       ns_unfocus (s->f);
3343     }
3344
3345   s->num_clips = 0;
3346 }
3347
3348
3349
3350 /* ==========================================================================
3351
3352     Event loop
3353
3354    ========================================================================== */
3355
3356
3357 static void
3358 ns_send_appdefined (int value)
3359 /* --------------------------------------------------------------------------
3360     Internal: post an appdefined event which EmacsApp-sendEvent will
3361               recognize and take as a command to halt the event loop.
3362    -------------------------------------------------------------------------- */
3363 {
3364   /*NSTRACE (ns_send_appdefined); */
3365
3366 #ifdef NS_IMPL_GNUSTEP
3367   // GNUStep needs postEvent to happen on the main thread.
3368   if (! [[NSThread currentThread] isMainThread])
3369     {
3370       EmacsApp *app = (EmacsApp *)NSApp;
3371       app->nextappdefined = value;
3372       [app performSelectorOnMainThread:@selector (sendFromMainThread:)
3373                             withObject:nil
3374                          waitUntilDone:YES];
3375       return;
3376     }
3377 #endif
3378
3379   /* Only post this event if we haven't already posted one.  This will end
3380        the [NXApp run] main loop after having processed all events queued at
3381        this moment.  */
3382   if (send_appdefined)
3383     {
3384       NSEvent *nxev;
3385
3386       /* We only need one NX_APPDEFINED event to stop NXApp from running.  */
3387       send_appdefined = NO;
3388
3389       /* Don't need wakeup timer any more */
3390       if (timed_entry)
3391         {
3392           [timed_entry invalidate];
3393           [timed_entry release];
3394           timed_entry = nil;
3395         }
3396
3397       nxev = [NSEvent otherEventWithType: NSApplicationDefined
3398                                 location: NSMakePoint (0, 0)
3399                            modifierFlags: 0
3400                                timestamp: 0
3401                             windowNumber: [[NSApp mainWindow] windowNumber]
3402                                  context: [NSApp context]
3403                                  subtype: 0
3404                                    data1: value
3405                                    data2: 0];
3406
3407       /* Post an application defined event on the event queue.  When this is
3408          received the [NXApp run] will return, thus having processed all
3409          events which are currently queued.  */
3410       [NSApp postEvent: nxev atStart: NO];
3411     }
3412 }
3413
3414 #ifdef HAVE_NATIVE_FS
3415 static void
3416 check_native_fs ()
3417 {
3418   Lisp_Object frame, tail;
3419
3420   if (ns_last_use_native_fullscreen == ns_use_native_fullscreen)
3421     return;
3422
3423   ns_last_use_native_fullscreen = ns_use_native_fullscreen;
3424
3425   FOR_EACH_FRAME (tail, frame)
3426     {
3427       struct frame *f = XFRAME (frame);
3428       if (FRAME_NS_P (f))
3429         {
3430           EmacsView *view = FRAME_NS_VIEW (f);
3431           [view updateCollectionBehaviour];
3432         }
3433     }
3434 }
3435 #endif
3436
3437 /* GNUStep and OSX <= 10.4 does not have cancelTracking.  */
3438 #if defined (NS_IMPL_COCOA) && \
3439   MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5
3440 /* Check if menu open should be cancelled or continued as normal.  */
3441 void
3442 ns_check_menu_open (NSMenu *menu)
3443 {
3444   /* Click in menu bar? */
3445   NSArray *a = [[NSApp mainMenu] itemArray];
3446   int i;
3447   BOOL found = NO;
3448
3449   if (menu == nil) // Menu tracking ended.
3450     {
3451       if (menu_will_open_state == MENU_OPENING)
3452         menu_will_open_state = MENU_NONE;
3453       return;
3454     }
3455
3456   for (i = 0; ! found && i < [a count]; i++)
3457     found = menu == [[a objectAtIndex:i] submenu];
3458   if (found)
3459     {
3460       if (menu_will_open_state == MENU_NONE && emacs_event)
3461         {
3462           NSEvent *theEvent = [NSApp currentEvent];
3463           struct frame *emacsframe = SELECTED_FRAME ();
3464
3465           [menu cancelTracking];
3466           menu_will_open_state = MENU_PENDING;
3467           emacs_event->kind = MENU_BAR_ACTIVATE_EVENT;
3468           EV_TRAILER (theEvent);
3469
3470           CGEventRef ourEvent = CGEventCreate (NULL);
3471           menu_mouse_point = CGEventGetLocation (ourEvent);
3472           CFRelease (ourEvent);
3473         }
3474       else if (menu_will_open_state == MENU_OPENING)
3475         {
3476           menu_will_open_state = MENU_NONE;
3477         }
3478     }
3479 }
3480
3481 /* Redo saved menu click if state is MENU_PENDING.  */
3482 void
3483 ns_check_pending_open_menu ()
3484 {
3485   if (menu_will_open_state == MENU_PENDING)
3486     {
3487       CGEventSourceRef source
3488         = CGEventSourceCreate (kCGEventSourceStateHIDSystemState);
3489
3490       CGEventRef event = CGEventCreateMouseEvent (source,
3491                                                   kCGEventLeftMouseDown,
3492                                                   menu_mouse_point,
3493                                                   kCGMouseButtonLeft);
3494       CGEventSetType (event, kCGEventLeftMouseDown);
3495       CGEventPost (kCGHIDEventTap, event);
3496       CFRelease (event);
3497       CFRelease (source);
3498
3499       menu_will_open_state = MENU_OPENING;
3500     }
3501 }
3502 #endif /* NS_IMPL_COCOA) && >= MAC_OS_X_VERSION_10_5 */
3503
3504 static int
3505 ns_read_socket (struct terminal *terminal, struct input_event *hold_quit)
3506 /* --------------------------------------------------------------------------
3507      External (hook): Post an event to ourself and keep reading events until
3508      we read it back again.  In effect process all events which were waiting.
3509      From 21+ we have to manage the event buffer ourselves.
3510    -------------------------------------------------------------------------- */
3511 {
3512   struct input_event ev;
3513   int nevents;
3514
3515 /* NSTRACE (ns_read_socket); */
3516
3517 #ifdef HAVE_NATIVE_FS
3518   check_native_fs ();
3519 #endif
3520
3521   if ([NSApp modalWindow] != nil)
3522     return -1;
3523
3524   if (hold_event_q.nr > 0)
3525     {
3526       int i;
3527       for (i = 0; i < hold_event_q.nr; ++i)
3528         kbd_buffer_store_event_hold (&hold_event_q.q[i], hold_quit);
3529       hold_event_q.nr = 0;
3530       return i;
3531     }
3532
3533   block_input ();
3534   n_emacs_events_pending = 0;
3535   EVENT_INIT (ev);
3536   emacs_event = &ev;
3537   q_event_ptr = hold_quit;
3538
3539   /* we manage autorelease pools by allocate/reallocate each time around
3540      the loop; strict nesting is occasionally violated but seems not to
3541      matter.. earlier methods using full nesting caused major memory leaks */
3542   [outerpool release];
3543   outerpool = [[NSAutoreleasePool alloc] init];
3544
3545   /* If have pending open-file requests, attend to the next one of those. */
3546   if (ns_pending_files && [ns_pending_files count] != 0
3547       && [(EmacsApp *)NSApp openFile: [ns_pending_files objectAtIndex: 0]])
3548     {
3549       [ns_pending_files removeObjectAtIndex: 0];
3550     }
3551   /* Deal with pending service requests. */
3552   else if (ns_pending_service_names && [ns_pending_service_names count] != 0
3553     && [(EmacsApp *)
3554          NSApp fulfillService: [ns_pending_service_names objectAtIndex: 0]
3555                       withArg: [ns_pending_service_args objectAtIndex: 0]])
3556     {
3557       [ns_pending_service_names removeObjectAtIndex: 0];
3558       [ns_pending_service_args removeObjectAtIndex: 0];
3559     }
3560   else
3561     {
3562       /* Run and wait for events.  We must always send one NX_APPDEFINED event
3563          to ourself, otherwise [NXApp run] will never exit.  */
3564       send_appdefined = YES;
3565       ns_send_appdefined (-1);
3566
3567       if (++apploopnr != 1)
3568         {
3569           emacs_abort ();
3570         }
3571       [NSApp run];
3572       --apploopnr;
3573     }
3574
3575   nevents = n_emacs_events_pending;
3576   n_emacs_events_pending = 0;
3577   emacs_event = q_event_ptr = NULL;
3578   unblock_input ();
3579
3580   return nevents;
3581 }
3582
3583
3584 int
3585 ns_select (int nfds, fd_set *readfds, fd_set *writefds,
3586            fd_set *exceptfds, struct timespec const *timeout,
3587            sigset_t const *sigmask)
3588 /* --------------------------------------------------------------------------
3589      Replacement for select, checking for events
3590    -------------------------------------------------------------------------- */
3591 {
3592   int result;
3593   int t, k, nr = 0;
3594   struct input_event event;
3595   char c;
3596
3597 /*  NSTRACE (ns_select); */
3598
3599 #ifdef HAVE_NATIVE_FS
3600   check_native_fs ();
3601 #endif
3602
3603   if (hold_event_q.nr > 0)
3604     {
3605       /* We already have events pending. */
3606       raise (SIGIO);
3607       errno = EINTR;
3608       return -1;
3609     }
3610
3611   for (k = 0; k < nfds+1; k++)
3612     {
3613       if (readfds && FD_ISSET(k, readfds)) ++nr;
3614       if (writefds && FD_ISSET(k, writefds)) ++nr;
3615     }
3616
3617   if (NSApp == nil
3618       || (timeout && timeout->tv_sec == 0 && timeout->tv_nsec == 0))
3619     return pselect (nfds, readfds, writefds, exceptfds, timeout, sigmask);
3620
3621   [outerpool release];
3622   outerpool = [[NSAutoreleasePool alloc] init];
3623
3624
3625   send_appdefined = YES;
3626   if (nr > 0)
3627     {
3628       pthread_mutex_lock (&select_mutex);
3629       select_nfds = nfds;
3630       select_valid = 0;
3631       if (readfds)
3632         {
3633           select_readfds = *readfds;
3634           select_valid += SELECT_HAVE_READ;
3635         }
3636       if (writefds)
3637         {
3638           select_writefds = *writefds;
3639           select_valid += SELECT_HAVE_WRITE;
3640         }
3641
3642       if (timeout)
3643         {
3644           select_timeout = *timeout;
3645           select_valid += SELECT_HAVE_TMO;
3646         }
3647
3648       pthread_mutex_unlock (&select_mutex);
3649
3650       /* Inform fd_handler that select should be called */
3651       c = 'g';
3652       emacs_write_sig (selfds[1], &c, 1);
3653     }
3654   else if (nr == 0 && timeout)
3655     {
3656       /* No file descriptor, just a timeout, no need to wake fd_handler  */
3657       double time = timespectod (*timeout);
3658       timed_entry = [[NSTimer scheduledTimerWithTimeInterval: time
3659                                                       target: NSApp
3660                                                     selector:
3661                                   @selector (timeout_handler:)
3662                                                     userInfo: 0
3663                                                      repeats: NO]
3664                       retain];
3665     }
3666   else /* No timeout and no file descriptors, can this happen?  */
3667     {
3668       /* Send appdefined so we exit from the loop */
3669       ns_send_appdefined (-1);
3670     }
3671
3672   EVENT_INIT (event);
3673   block_input ();
3674   emacs_event = &event;
3675   if (++apploopnr != 1)
3676     {
3677       emacs_abort ();
3678     }
3679   [NSApp run];
3680   --apploopnr;
3681   emacs_event = NULL;
3682   if (nr > 0 && readfds)
3683     {
3684       c = 's';
3685       emacs_write_sig (selfds[1], &c, 1);
3686     }
3687   unblock_input ();
3688
3689   t = last_appdefined_event_data;
3690
3691   if (t != NO_APPDEFINED_DATA)
3692     {
3693       last_appdefined_event_data = NO_APPDEFINED_DATA;
3694
3695       if (t == -2)
3696         {
3697           /* The NX_APPDEFINED event we received was a timeout. */
3698           result = 0;
3699         }
3700       else if (t == -1)
3701         {
3702           /* The NX_APPDEFINED event we received was the result of
3703              at least one real input event arriving.  */
3704           errno = EINTR;
3705           result = -1;
3706         }
3707       else
3708         {
3709           /* Received back from select () in fd_handler; copy the results */
3710           pthread_mutex_lock (&select_mutex);
3711           if (readfds) *readfds = select_readfds;
3712           if (writefds) *writefds = select_writefds;
3713           pthread_mutex_unlock (&select_mutex);
3714           result = t;
3715         }
3716     }
3717   else
3718     {
3719       errno = EINTR;
3720       result = -1;
3721     }
3722
3723   return result;
3724 }
3725
3726
3727
3728 /* ==========================================================================
3729
3730     Scrollbar handling
3731
3732    ========================================================================== */
3733
3734
3735 static void
3736 ns_set_vertical_scroll_bar (struct window *window,
3737                            int portion, int whole, int position)
3738 /* --------------------------------------------------------------------------
3739       External (hook): Update or add scrollbar
3740    -------------------------------------------------------------------------- */
3741 {
3742   Lisp_Object win;
3743   NSRect r, v;
3744   struct frame *f = XFRAME (WINDOW_FRAME (window));
3745   EmacsView *view = FRAME_NS_VIEW (f);
3746   int window_y, window_height;
3747   int top, left, height, width, sb_width, sb_left;
3748   EmacsScroller *bar;
3749   BOOL fringe_extended_p;
3750
3751   /* optimization; display engine sends WAY too many of these.. */
3752   if (!NILP (window->vertical_scroll_bar))
3753     {
3754       bar = XNS_SCROLL_BAR (window->vertical_scroll_bar);
3755       if ([bar checkSamePosition: position portion: portion whole: whole])
3756         {
3757           if (view->scrollbarsNeedingUpdate == 0)
3758             {
3759               if (!windows_or_buffers_changed)
3760                   return;
3761             }
3762           else
3763             view->scrollbarsNeedingUpdate--;
3764         }
3765     }
3766
3767   NSTRACE (ns_set_vertical_scroll_bar);
3768
3769   /* Get dimensions.  */
3770   window_box (window, ANY_AREA, 0, &window_y, 0, &window_height);
3771   top = window_y;
3772   height = window_height;
3773   width = WINDOW_CONFIG_SCROLL_BAR_COLS (window) * FRAME_COLUMN_WIDTH (f);
3774   left = WINDOW_SCROLL_BAR_AREA_X (window);
3775
3776   /* allow for displaying a skinnier scrollbar than char area allotted */
3777   sb_width = (WINDOW_CONFIG_SCROLL_BAR_WIDTH (window) > 0) ?
3778     WINDOW_CONFIG_SCROLL_BAR_WIDTH (window) : width;
3779   sb_left = left;
3780
3781   r = NSMakeRect (sb_left, top, sb_width, height);
3782   /* the parent view is flipped, so we need to flip y value */
3783   v = [view frame];
3784   r.origin.y = (v.size.height - r.size.height - r.origin.y);
3785
3786   fringe_extended_p = WINDOW_FRINGE_EXTENDED_P (window);
3787
3788   XSETWINDOW (win, window);
3789   block_input ();
3790
3791   /* we want at least 5 lines to display a scrollbar */
3792   if (WINDOW_TOTAL_LINES (window) < 5)
3793     {
3794       if (!NILP (window->vertical_scroll_bar))
3795         {
3796           bar = XNS_SCROLL_BAR (window->vertical_scroll_bar);
3797           [bar removeFromSuperview];
3798           wset_vertical_scroll_bar (window, Qnil);
3799         }
3800       ns_clear_frame_area (f, sb_left, top, width, height);
3801       unblock_input ();
3802       return;
3803     }
3804
3805   if (NILP (window->vertical_scroll_bar))
3806     {
3807       if (width > 0 && height > 0)
3808         {
3809           if (fringe_extended_p)
3810             ns_clear_frame_area (f, sb_left, top, sb_width, height);
3811           else
3812             ns_clear_frame_area (f, left, top, width, height);
3813         }
3814
3815       bar = [[EmacsScroller alloc] initFrame: r window: win];
3816       wset_vertical_scroll_bar (window, make_save_ptr (bar));
3817     }
3818   else
3819     {
3820       NSRect oldRect;
3821       bar = XNS_SCROLL_BAR (window->vertical_scroll_bar);
3822       oldRect = [bar frame];
3823       r.size.width = oldRect.size.width;
3824       if (FRAME_LIVE_P (f) && !NSEqualRects (oldRect, r))
3825         {
3826           if (oldRect.origin.x != r.origin.x)
3827               ns_clear_frame_area (f, sb_left, top, width, height);
3828           [bar setFrame: r];
3829         }
3830     }
3831
3832   [bar setPosition: position portion: portion whole: whole];
3833   unblock_input ();
3834 }
3835
3836
3837 static void
3838 ns_condemn_scroll_bars (struct frame *f)
3839 /* --------------------------------------------------------------------------
3840      External (hook): arrange for all frame's scrollbars to be removed
3841      at next call to judge_scroll_bars, except for those redeemed.
3842    -------------------------------------------------------------------------- */
3843 {
3844   int i;
3845   id view;
3846   NSArray *subviews = [[FRAME_NS_VIEW (f) superview] subviews];
3847
3848   NSTRACE (ns_condemn_scroll_bars);
3849
3850   for (i =[subviews count]-1; i >= 0; i--)
3851     {
3852       view = [subviews objectAtIndex: i];
3853       if ([view isKindOfClass: [EmacsScroller class]])
3854         [view condemn];
3855     }
3856 }
3857
3858
3859 static void
3860 ns_redeem_scroll_bar (struct window *window)
3861 /* --------------------------------------------------------------------------
3862      External (hook): arrange to spare this window's scrollbar
3863      at next call to judge_scroll_bars.
3864    -------------------------------------------------------------------------- */
3865 {
3866   id bar;
3867   NSTRACE (ns_redeem_scroll_bar);
3868   if (!NILP (window->vertical_scroll_bar))
3869     {
3870       bar = XNS_SCROLL_BAR (window->vertical_scroll_bar);
3871       [bar reprieve];
3872     }
3873 }
3874
3875
3876 static void
3877 ns_judge_scroll_bars (struct frame *f)
3878 /* --------------------------------------------------------------------------
3879      External (hook): destroy all scrollbars on frame that weren't
3880      redeemed after call to condemn_scroll_bars.
3881    -------------------------------------------------------------------------- */
3882 {
3883   int i;
3884   id view;
3885   EmacsView *eview = FRAME_NS_VIEW (f);
3886   NSArray *subviews = [[eview superview] subviews];
3887   BOOL removed = NO;
3888
3889   NSTRACE (ns_judge_scroll_bars);
3890   for (i = [subviews count]-1; i >= 0; --i)
3891     {
3892       view = [subviews objectAtIndex: i];
3893       if (![view isKindOfClass: [EmacsScroller class]]) continue;
3894       [view judge];
3895       removed = YES;
3896     }
3897
3898   if (removed)
3899     [eview updateFrameSize: NO];
3900 }
3901
3902 /* ==========================================================================
3903
3904     Initialization
3905
3906    ========================================================================== */
3907
3908 int
3909 x_display_pixel_height (struct ns_display_info *dpyinfo)
3910 {
3911   NSArray *screens = [NSScreen screens];
3912   NSEnumerator *enumerator = [screens objectEnumerator];
3913   NSScreen *screen;
3914   NSRect frame;
3915
3916   frame = NSZeroRect;
3917   while ((screen = [enumerator nextObject]) != nil)
3918     frame = NSUnionRect (frame, [screen frame]);
3919
3920   return NSHeight (frame);
3921 }
3922
3923 int
3924 x_display_pixel_width (struct ns_display_info *dpyinfo)
3925 {
3926   NSArray *screens = [NSScreen screens];
3927   NSEnumerator *enumerator = [screens objectEnumerator];
3928   NSScreen *screen;
3929   NSRect frame;
3930
3931   frame = NSZeroRect;
3932   while ((screen = [enumerator nextObject]) != nil)
3933     frame = NSUnionRect (frame, [screen frame]);
3934
3935   return NSWidth (frame);
3936 }
3937
3938
3939 static Lisp_Object ns_string_to_lispmod (const char *s)
3940 /* --------------------------------------------------------------------------
3941      Convert modifier name to lisp symbol
3942    -------------------------------------------------------------------------- */
3943 {
3944   if (!strncmp (SSDATA (SYMBOL_NAME (Qmeta)), s, 10))
3945     return Qmeta;
3946   else if (!strncmp (SSDATA (SYMBOL_NAME (Qsuper)), s, 10))
3947     return Qsuper;
3948   else if (!strncmp (SSDATA (SYMBOL_NAME (Qcontrol)), s, 10))
3949     return Qcontrol;
3950   else if (!strncmp (SSDATA (SYMBOL_NAME (Qalt)), s, 10))
3951     return Qalt;
3952   else if (!strncmp (SSDATA (SYMBOL_NAME (Qhyper)), s, 10))
3953     return Qhyper;
3954   else if (!strncmp (SSDATA (SYMBOL_NAME (Qnone)), s, 10))
3955     return Qnone;
3956   else
3957     return Qnil;
3958 }
3959
3960
3961 static void
3962 ns_default (const char *parameter, Lisp_Object *result,
3963            Lisp_Object yesval, Lisp_Object noval,
3964            BOOL is_float, BOOL is_modstring)
3965 /* --------------------------------------------------------------------------
3966       Check a parameter value in user's preferences
3967    -------------------------------------------------------------------------- */
3968 {
3969   const char *value = ns_get_defaults_value (parameter);
3970
3971   if (value)
3972     {
3973       double f;
3974       char *pos;
3975       if (c_strcasecmp (value, "YES") == 0)
3976         *result = yesval;
3977       else if (c_strcasecmp (value, "NO") == 0)
3978         *result = noval;
3979       else if (is_float && (f = strtod (value, &pos), pos != value))
3980         *result = make_float (f);
3981       else if (is_modstring && value)
3982         *result = ns_string_to_lispmod (value);
3983       else fprintf (stderr,
3984                    "Bad value for default \"%s\": \"%s\"\n", parameter, value);
3985     }
3986 }
3987
3988
3989 static void
3990 ns_initialize_display_info (struct ns_display_info *dpyinfo)
3991 /* --------------------------------------------------------------------------
3992       Initialize global info and storage for display.
3993    -------------------------------------------------------------------------- */
3994 {
3995     NSScreen *screen = [NSScreen mainScreen];
3996     NSWindowDepth depth = [screen depth];
3997
3998     dpyinfo->resx = 72.27; /* used 75.0, but this makes pt == pixel, expected */
3999     dpyinfo->resy = 72.27;
4000     dpyinfo->color_p = ![NSDeviceWhiteColorSpace isEqualToString:
4001                                                   NSColorSpaceFromDepth (depth)]
4002                 && ![NSCalibratedWhiteColorSpace isEqualToString:
4003                                                  NSColorSpaceFromDepth (depth)];
4004     dpyinfo->n_planes = NSBitsPerPixelFromDepth (depth);
4005     dpyinfo->color_table = xmalloc (sizeof *dpyinfo->color_table);
4006     dpyinfo->color_table->colors = NULL;
4007     dpyinfo->root_window = 42; /* a placeholder.. */
4008     dpyinfo->x_highlight_frame = dpyinfo->x_focus_frame = NULL;
4009     dpyinfo->n_fonts = 0;
4010     dpyinfo->smallest_font_height = 1;
4011     dpyinfo->smallest_char_width = 1;
4012
4013     reset_mouse_highlight (&dpyinfo->mouse_highlight);
4014 }
4015
4016
4017 /* This and next define (many of the) public functions in this file. */
4018 /* x_... are generic versions in xdisp.c that we, and other terms, get away
4019          with using despite presence in the "system dependent" redisplay
4020          interface.  In addition, many of the ns_ methods have code that is
4021          shared with all terms, indicating need for further refactoring. */
4022 extern frame_parm_handler ns_frame_parm_handlers[];
4023 static struct redisplay_interface ns_redisplay_interface =
4024 {
4025   ns_frame_parm_handlers,
4026   x_produce_glyphs,
4027   x_write_glyphs,
4028   x_insert_glyphs,
4029   x_clear_end_of_line,
4030   ns_scroll_run,
4031   ns_after_update_window_line,
4032   ns_update_window_begin,
4033   ns_update_window_end,
4034   0, /* flush_display */
4035   x_clear_window_mouse_face,
4036   x_get_glyph_overhangs,
4037   x_fix_overlapping_area,
4038   ns_draw_fringe_bitmap,
4039   0, /* define_fringe_bitmap */ /* FIXME: simplify ns_draw_fringe_bitmap */
4040   0, /* destroy_fringe_bitmap */
4041   ns_compute_glyph_string_overhangs,
4042   ns_draw_glyph_string,
4043   ns_define_frame_cursor,
4044   ns_clear_frame_area,
4045   ns_draw_window_cursor,
4046   ns_draw_vertical_window_border,
4047   ns_draw_window_divider,
4048   ns_shift_glyphs_for_insert
4049 };
4050
4051
4052 static void
4053 ns_delete_display (struct ns_display_info *dpyinfo)
4054 {
4055   /* TODO... */
4056 }
4057
4058
4059 /* This function is called when the last frame on a display is deleted. */
4060 static void
4061 ns_delete_terminal (struct terminal *terminal)
4062 {
4063   struct ns_display_info *dpyinfo = terminal->display_info.ns;
4064
4065   /* Protect against recursive calls.  delete_frame in
4066      delete_terminal calls us back when it deletes our last frame.  */
4067   if (!terminal->name)
4068     return;
4069
4070   block_input ();
4071
4072   x_destroy_all_bitmaps (dpyinfo);
4073   ns_delete_display (dpyinfo);
4074   unblock_input ();
4075 }
4076
4077
4078 static struct terminal *
4079 ns_create_terminal (struct ns_display_info *dpyinfo)
4080 /* --------------------------------------------------------------------------
4081       Set up use of NS before we make the first connection.
4082    -------------------------------------------------------------------------- */
4083 {
4084   struct terminal *terminal;
4085
4086   NSTRACE (ns_create_terminal);
4087
4088   terminal = create_terminal ();
4089
4090   terminal->type = output_ns;
4091   terminal->display_info.ns = dpyinfo;
4092   dpyinfo->terminal = terminal;
4093
4094   terminal->rif = &ns_redisplay_interface;
4095
4096   terminal->clear_frame_hook = ns_clear_frame;
4097   terminal->ins_del_lines_hook = 0; /* XXX vestigial? */
4098   terminal->delete_glyphs_hook = 0; /* XXX vestigial? */
4099   terminal->ring_bell_hook = ns_ring_bell;
4100   terminal->reset_terminal_modes_hook = NULL;
4101   terminal->set_terminal_modes_hook = NULL;
4102   terminal->update_begin_hook = ns_update_begin;
4103   terminal->update_end_hook = ns_update_end;
4104   terminal->set_terminal_window_hook = NULL; /* XXX vestigial? */
4105   terminal->read_socket_hook = ns_read_socket;
4106   terminal->frame_up_to_date_hook = ns_frame_up_to_date;
4107   terminal->mouse_position_hook = ns_mouse_position;
4108   terminal->frame_rehighlight_hook = ns_frame_rehighlight;
4109   terminal->frame_raise_lower_hook = ns_frame_raise_lower;
4110
4111   terminal->fullscreen_hook = ns_fullscreen_hook;
4112
4113   terminal->set_vertical_scroll_bar_hook = ns_set_vertical_scroll_bar;
4114   terminal->condemn_scroll_bars_hook = ns_condemn_scroll_bars;
4115   terminal->redeem_scroll_bar_hook = ns_redeem_scroll_bar;
4116   terminal->judge_scroll_bars_hook = ns_judge_scroll_bars;
4117
4118   terminal->delete_frame_hook = x_destroy_window;
4119   terminal->delete_terminal_hook = ns_delete_terminal;
4120
4121   return terminal;
4122 }
4123
4124
4125 struct ns_display_info *
4126 ns_term_init (Lisp_Object display_name)
4127 /* --------------------------------------------------------------------------
4128      Start the Application and get things rolling.
4129    -------------------------------------------------------------------------- */
4130 {
4131   struct terminal *terminal;
4132   struct ns_display_info *dpyinfo;
4133   static int ns_initialized = 0;
4134   Lisp_Object tmp;
4135
4136   if (ns_initialized) return x_display_list;
4137   ns_initialized = 1;
4138
4139   NSTRACE (ns_term_init);
4140
4141   [outerpool release];
4142   outerpool = [[NSAutoreleasePool alloc] init];
4143
4144   /* count object allocs (About, click icon); on OS X use ObjectAlloc tool */
4145   /*GSDebugAllocationActive (YES); */
4146   block_input ();
4147
4148   baud_rate = 38400;
4149   Fset_input_interrupt_mode (Qnil);
4150
4151   if (selfds[0] == -1)
4152     {
4153       if (emacs_pipe (selfds) != 0)
4154         {
4155           fprintf (stderr, "Failed to create pipe: %s\n",
4156                    emacs_strerror (errno));
4157           emacs_abort ();
4158         }
4159
4160       fcntl (selfds[0], F_SETFL, O_NONBLOCK|fcntl (selfds[0], F_GETFL));
4161       FD_ZERO (&select_readfds);
4162       FD_ZERO (&select_writefds);
4163       pthread_mutex_init (&select_mutex, NULL);
4164     }
4165
4166   ns_pending_files = [[NSMutableArray alloc] init];
4167   ns_pending_service_names = [[NSMutableArray alloc] init];
4168   ns_pending_service_args = [[NSMutableArray alloc] init];
4169
4170 /* Start app and create the main menu, window, view.
4171      Needs to be here because ns_initialize_display_info () uses AppKit classes.
4172      The view will then ask the NSApp to stop and return to Emacs. */
4173   [EmacsApp sharedApplication];
4174   if (NSApp == nil)
4175     return NULL;
4176   [NSApp setDelegate: NSApp];
4177
4178   /* Start the select thread.  */
4179   [NSThread detachNewThreadSelector:@selector (fd_handler:)
4180                            toTarget:NSApp
4181                          withObject:nil];
4182
4183   /* debugging: log all notifications */
4184   /*   [[NSNotificationCenter defaultCenter] addObserver: NSApp
4185                                          selector: @selector (logNotification:)
4186                                              name: nil object: nil]; */
4187
4188   dpyinfo = xzalloc (sizeof *dpyinfo);
4189
4190   ns_initialize_display_info (dpyinfo);
4191   terminal = ns_create_terminal (dpyinfo);
4192
4193   terminal->kboard = allocate_kboard (Qns);
4194   /* Don't let the initial kboard remain current longer than necessary.
4195      That would cause problems if a file loaded on startup tries to
4196      prompt in the mini-buffer.  */
4197   if (current_kboard == initial_kboard)
4198     current_kboard = terminal->kboard;
4199   terminal->kboard->reference_count++;
4200
4201   dpyinfo->next = x_display_list;
4202   x_display_list = dpyinfo;
4203
4204   dpyinfo->name_list_element = Fcons (display_name, Qnil);
4205
4206   terminal->name = xstrdup (SSDATA (display_name));
4207
4208   unblock_input ();
4209
4210   if (!inhibit_x_resources)
4211     {
4212       ns_default ("GSFontAntiAlias", &ns_antialias_text,
4213                  Qt, Qnil, NO, NO);
4214       tmp = Qnil;
4215       /* this is a standard variable */
4216       ns_default ("AppleAntiAliasingThreshold", &tmp,
4217                  make_float (10.0), make_float (6.0), YES, NO);
4218       ns_antialias_threshold = NILP (tmp) ? 10.0 : XFLOATINT (tmp);
4219     }
4220
4221   {
4222     NSColorList *cl = [NSColorList colorListNamed: @"Emacs"];
4223
4224     if ( cl == nil )
4225       {
4226         Lisp_Object color_file, color_map, color;
4227         unsigned long c;
4228         char *name;
4229
4230         color_file = Fexpand_file_name (build_string ("rgb.txt"),
4231                          Fsymbol_value (intern ("data-directory")));
4232
4233         color_map = Fx_load_color_file (color_file);
4234         if (NILP (color_map))
4235           fatal ("Could not read %s.\n", SDATA (color_file));
4236
4237         cl = [[NSColorList alloc] initWithName: @"Emacs"];
4238         for ( ; CONSP (color_map); color_map = XCDR (color_map))
4239           {
4240             color = XCAR (color_map);
4241             name = SSDATA (XCAR (color));
4242             c = XINT (XCDR (color));
4243             [cl setColor:
4244                   [NSColor colorWithCalibratedRed: RED_FROM_ULONG (c) / 255.0
4245                                             green: GREEN_FROM_ULONG (c) / 255.0
4246                                              blue: BLUE_FROM_ULONG (c) / 255.0
4247                                             alpha: 1.0]
4248                   forKey: [NSString stringWithUTF8String: name]];
4249           }
4250         [cl writeToFile: nil];
4251       }
4252   }
4253
4254   {
4255 #ifdef NS_IMPL_GNUSTEP
4256     Vwindow_system_version = build_string (gnustep_base_version);
4257 #else
4258     /*PSnextrelease (128, c); */
4259     char c[DBL_BUFSIZE_BOUND];
4260     int len = dtoastr (c, sizeof c, 0, 0, NSAppKitVersionNumber);
4261     Vwindow_system_version = make_unibyte_string (c, len);
4262 #endif
4263   }
4264
4265   delete_keyboard_wait_descriptor (0);
4266
4267   ns_app_name = [[NSProcessInfo processInfo] processName];
4268
4269 /* Set up OS X app menu */
4270 #ifdef NS_IMPL_COCOA
4271   {
4272     NSMenu *appMenu;
4273     NSMenuItem *item;
4274     /* set up the application menu */
4275     svcsMenu = [[EmacsMenu alloc] initWithTitle: @"Services"];
4276     [svcsMenu setAutoenablesItems: NO];
4277     appMenu = [[EmacsMenu alloc] initWithTitle: @"Emacs"];
4278     [appMenu setAutoenablesItems: NO];
4279     mainMenu = [[EmacsMenu alloc] initWithTitle: @""];
4280     dockMenu = [[EmacsMenu alloc] initWithTitle: @""];
4281
4282     [appMenu insertItemWithTitle: @"About Emacs"
4283                           action: @selector (orderFrontStandardAboutPanel:)
4284                    keyEquivalent: @""
4285                          atIndex: 0];
4286     [appMenu insertItem: [NSMenuItem separatorItem] atIndex: 1];
4287     [appMenu insertItemWithTitle: @"Preferences..."
4288                           action: @selector (showPreferencesWindow:)
4289                    keyEquivalent: @","
4290                          atIndex: 2];
4291     [appMenu insertItem: [NSMenuItem separatorItem] atIndex: 3];
4292     item = [appMenu insertItemWithTitle: @"Services"
4293                                  action: @selector (menuDown:)
4294                           keyEquivalent: @""
4295                                 atIndex: 4];
4296     [appMenu setSubmenu: svcsMenu forItem: item];
4297     [appMenu insertItem: [NSMenuItem separatorItem] atIndex: 5];
4298     [appMenu insertItemWithTitle: @"Hide Emacs"
4299                           action: @selector (hide:)
4300                    keyEquivalent: @"h"
4301                          atIndex: 6];
4302     item =  [appMenu insertItemWithTitle: @"Hide Others"
4303                           action: @selector (hideOtherApplications:)
4304                    keyEquivalent: @"h"
4305                          atIndex: 7];
4306     [item setKeyEquivalentModifierMask: NSCommandKeyMask | NSAlternateKeyMask];
4307     [appMenu insertItem: [NSMenuItem separatorItem] atIndex: 8];
4308     [appMenu insertItemWithTitle: @"Quit Emacs"
4309                           action: @selector (terminate:)
4310                    keyEquivalent: @"q"
4311                          atIndex: 9];
4312
4313     item = [mainMenu insertItemWithTitle: ns_app_name
4314                                   action: @selector (menuDown:)
4315                            keyEquivalent: @""
4316                                  atIndex: 0];
4317     [mainMenu setSubmenu: appMenu forItem: item];
4318     [dockMenu insertItemWithTitle: @"New Frame"
4319                            action: @selector (newFrame:)
4320                     keyEquivalent: @""
4321                           atIndex: 0];
4322
4323     [NSApp setMainMenu: mainMenu];
4324     [NSApp setAppleMenu: appMenu];
4325     [NSApp setServicesMenu: svcsMenu];
4326     /* Needed at least on Cocoa, to get dock menu to show windows */
4327     [NSApp setWindowsMenu: [[NSMenu alloc] init]];
4328
4329     [[NSNotificationCenter defaultCenter]
4330       addObserver: mainMenu
4331          selector: @selector (trackingNotification:)
4332              name: NSMenuDidBeginTrackingNotification object: mainMenu];
4333     [[NSNotificationCenter defaultCenter]
4334       addObserver: mainMenu
4335          selector: @selector (trackingNotification:)
4336              name: NSMenuDidEndTrackingNotification object: mainMenu];
4337   }
4338 #endif /* MAC OS X menu setup */
4339
4340   /* Register our external input/output types, used for determining
4341      applicable services and also drag/drop eligibility. */
4342   ns_send_types = [[NSArray arrayWithObjects: NSStringPboardType, nil] retain];
4343   ns_return_types = [[NSArray arrayWithObjects: NSStringPboardType, nil]
4344                       retain];
4345   ns_drag_types = [[NSArray arrayWithObjects:
4346                             NSStringPboardType,
4347                             NSTabularTextPboardType,
4348                             NSFilenamesPboardType,
4349                             NSURLPboardType,
4350                             NSColorPboardType,
4351                             NSFontPboardType, nil] retain];
4352
4353   /* If fullscreen is in init/default-frame-alist, focus isn't set
4354      right for fullscreen windows, so set this.  */
4355   [NSApp activateIgnoringOtherApps:YES];
4356
4357   [NSApp run];
4358   ns_do_open_file = YES;
4359
4360 #ifdef NS_IMPL_GNUSTEP
4361   /* GNUstep steals SIGCHLD for use in NSTask, but we don't use NSTask.
4362      We must re-catch it so subprocess works.  */
4363   catch_child_signal ();
4364 #endif
4365   return dpyinfo;
4366 }
4367
4368
4369 void
4370 ns_term_shutdown (int sig)
4371 {
4372   [[NSUserDefaults standardUserDefaults] synchronize];
4373
4374   /* code not reached in emacs.c after this is called by shut_down_emacs: */
4375   if (STRINGP (Vauto_save_list_file_name))
4376     unlink (SSDATA (Vauto_save_list_file_name));
4377
4378   if (sig == 0 || sig == SIGTERM)
4379     {
4380       [NSApp terminate: NSApp];
4381     }
4382   else // force a stack trace to happen
4383     {
4384       emacs_abort ();
4385     }
4386 }
4387
4388
4389 /* ==========================================================================
4390
4391     EmacsApp implementation
4392
4393    ========================================================================== */
4394
4395
4396 @implementation EmacsApp
4397
4398 #if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_9
4399 - (id)init
4400 {
4401   if (self = [super init])
4402     self->isFirst = YES;
4403
4404   return self;
4405 }
4406
4407 - (void)run
4408 {
4409     NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
4410
4411     if (isFirst) [self finishLaunching];
4412     isFirst = NO;
4413
4414     shouldKeepRunning = YES;
4415     do
4416       {
4417         [pool release];
4418         pool = [[NSAutoreleasePool alloc] init];
4419
4420         NSEvent *event =
4421           [self nextEventMatchingMask:NSAnyEventMask
4422                             untilDate:[NSDate distantFuture]
4423                                inMode:NSDefaultRunLoopMode
4424                               dequeue:YES];
4425         [self sendEvent:event];
4426         [self updateWindows];
4427     } while (shouldKeepRunning);
4428
4429     [pool release];
4430 }
4431
4432 - (void)stop: (id)sender
4433 {
4434     shouldKeepRunning = NO;
4435     // Stop possible dialog also.  Noop if no dialog present.
4436     // The file dialog still leaks 7k - 10k on 10.9 though.
4437     [super stop:sender];
4438 }
4439 #endif
4440
4441 - (void)logNotification: (NSNotification *)notification
4442 {
4443   const char *name = [[notification name] UTF8String];
4444   if (!strstr (name, "Update") && !strstr (name, "NSMenu")
4445       && !strstr (name, "WindowNumber"))
4446     NSLog (@"notification: '%@'", [notification name]);
4447 }
4448
4449
4450 - (void)sendEvent: (NSEvent *)theEvent
4451 /* --------------------------------------------------------------------------
4452      Called when NSApp is running for each event received.  Used to stop
4453      the loop when we choose, since there's no way to just run one iteration.
4454    -------------------------------------------------------------------------- */
4455 {
4456   int type = [theEvent type];
4457   NSWindow *window = [theEvent window];
4458
4459 /*  NSTRACE (sendEvent); */
4460 /*fprintf (stderr, "received event of type %d\t%d\n", type);*/
4461
4462 #ifdef NS_IMPL_GNUSTEP
4463   // Keyboard events aren't propagated to file dialogs for some reason.
4464   if ([NSApp modalWindow] != nil &&
4465       (type == NSKeyDown || type == NSKeyUp || type == NSFlagsChanged))
4466     {
4467       [[NSApp modalWindow] sendEvent: theEvent];
4468       return;
4469     }
4470 #endif
4471
4472   if (type == NSApplicationDefined)
4473     {
4474       switch ([theEvent data2])
4475         {
4476 #ifdef NS_IMPL_COCOA
4477         case NSAPP_DATA2_RUNASSCRIPT:
4478           ns_run_ascript ();
4479           [self stop: self];
4480           return;
4481 #endif
4482         case NSAPP_DATA2_RUNFILEDIALOG:
4483           ns_run_file_dialog ();
4484           [self stop: self];
4485           return;
4486         }
4487     }
4488
4489   if (type == NSCursorUpdate && window == nil)
4490     {
4491       fprintf (stderr, "Dropping external cursor update event.\n");
4492       return;
4493     }
4494
4495   if (type == NSApplicationDefined)
4496     {
4497       /* Events posted by ns_send_appdefined interrupt the run loop here.
4498          But, if a modal window is up, an appdefined can still come through,
4499          (e.g., from a makeKeyWindow event) but stopping self also stops the
4500          modal loop. Just defer it until later. */
4501       if ([NSApp modalWindow] == nil)
4502         {
4503           last_appdefined_event_data = [theEvent data1];
4504           [self stop: self];
4505         }
4506       else
4507         {
4508           send_appdefined = YES;
4509         }
4510     }
4511
4512
4513 #ifdef NS_IMPL_COCOA
4514   /* If no dialog and none of our frames have focus and it is a move, skip it.
4515      It is a mouse move in an auxiliary menu, i.e. on the top right on OSX,
4516      such as Wifi, sound, date or similar.
4517      This prevents "spooky" highlighting in the frame under the menu.  */
4518   if (type == NSMouseMoved && [NSApp modalWindow] == nil)
4519     {
4520       struct ns_display_info *di;
4521       BOOL has_focus = NO;
4522       for (di = x_display_list; ! has_focus && di; di = di->next)
4523         has_focus = di->x_focus_frame != 0;
4524       if (! has_focus)
4525         return;
4526     }
4527 #endif
4528
4529   [super sendEvent: theEvent];
4530 }
4531
4532
4533 - (void)showPreferencesWindow: (id)sender
4534 {
4535   struct frame *emacsframe = SELECTED_FRAME ();
4536   NSEvent *theEvent = [NSApp currentEvent];
4537
4538   if (!emacs_event)
4539     return;
4540   emacs_event->kind = NS_NONKEY_EVENT;
4541   emacs_event->code = KEY_NS_SHOW_PREFS;
4542   emacs_event->modifiers = 0;
4543   EV_TRAILER (theEvent);
4544 }
4545
4546
4547 - (void)newFrame: (id)sender
4548 {
4549   struct frame *emacsframe = SELECTED_FRAME ();
4550   NSEvent *theEvent = [NSApp currentEvent];
4551
4552   if (!emacs_event)
4553     return;
4554   emacs_event->kind = NS_NONKEY_EVENT;
4555   emacs_event->code = KEY_NS_NEW_FRAME;
4556   emacs_event->modifiers = 0;
4557   EV_TRAILER (theEvent);
4558 }
4559
4560
4561 /* Open a file (used by below, after going into queue read by ns_read_socket) */
4562 - (BOOL) openFile: (NSString *)fileName
4563 {
4564   struct frame *emacsframe = SELECTED_FRAME ();
4565   NSEvent *theEvent = [NSApp currentEvent];
4566
4567   if (!emacs_event)
4568     return NO;
4569
4570   emacs_event->kind = NS_NONKEY_EVENT;
4571   emacs_event->code = KEY_NS_OPEN_FILE_LINE;
4572   ns_input_file = append2 (ns_input_file, build_string ([fileName UTF8String]));
4573   ns_input_line = Qnil; /* can be start or cons start,end */
4574   emacs_event->modifiers =0;
4575   EV_TRAILER (theEvent);
4576
4577   return YES;
4578 }
4579
4580
4581 /* **************************************************************************
4582
4583       EmacsApp delegate implementation
4584
4585    ************************************************************************** */
4586
4587 - (void)applicationDidFinishLaunching: (NSNotification *)notification
4588 /* --------------------------------------------------------------------------
4589      When application is loaded, terminate event loop in ns_term_init
4590    -------------------------------------------------------------------------- */
4591 {
4592   NSTRACE (applicationDidFinishLaunching);
4593   [NSApp setServicesProvider: NSApp];
4594   ns_send_appdefined (-2);
4595 }
4596
4597
4598 /* Termination sequences:
4599     C-x C-c:
4600     Cmd-Q:
4601     MenuBar | File | Exit:
4602     Select Quit from App menubar:
4603         -terminate
4604         KEY_NS_POWER_OFF, (save-buffers-kill-emacs)
4605         ns_term_shutdown()
4606
4607     Select Quit from Dock menu:
4608     Logout attempt:
4609         -appShouldTerminate
4610           Cancel -> Nothing else
4611           Accept ->
4612
4613           -terminate
4614           KEY_NS_POWER_OFF, (save-buffers-kill-emacs)
4615           ns_term_shutdown()
4616
4617 */
4618
4619 - (void) terminate: (id)sender
4620 {
4621   struct frame *emacsframe = SELECTED_FRAME ();
4622
4623   if (!emacs_event)
4624     return;
4625
4626   emacs_event->kind = NS_NONKEY_EVENT;
4627   emacs_event->code = KEY_NS_POWER_OFF;
4628   emacs_event->arg = Qt; /* mark as non-key event */
4629   EV_TRAILER ((id)nil);
4630 }
4631
4632
4633 - (NSApplicationTerminateReply)applicationShouldTerminate: (id)sender
4634 {
4635   int ret;
4636
4637   if (NILP (ns_confirm_quit)) //   || ns_shutdown_properly  --> TO DO
4638     return NSTerminateNow;
4639
4640     ret = NSRunAlertPanel(ns_app_name,
4641                           @"Exit requested.  Would you like to Save Buffers and Exit, or Cancel the request?",
4642                           @"Save Buffers and Exit", @"Cancel", nil);
4643
4644     if (ret == NSAlertDefaultReturn)
4645         return NSTerminateNow;
4646     else if (ret == NSAlertAlternateReturn)
4647         return NSTerminateCancel;
4648     return NSTerminateNow;  /* just in case */
4649 }
4650
4651 static int
4652 not_in_argv (NSString *arg)
4653 {
4654   int k;
4655   const char *a = [arg UTF8String];
4656   for (k = 1; k < initial_argc; ++k)
4657     if (strcmp (a, initial_argv[k]) == 0) return 0;
4658   return 1;
4659 }
4660
4661 /*   Notification from the Workspace to open a file */
4662 - (BOOL)application: sender openFile: (NSString *)file
4663 {
4664   if (ns_do_open_file || not_in_argv (file))
4665     [ns_pending_files addObject: file];
4666   return YES;
4667 }
4668
4669
4670 /*   Open a file as a temporary file */
4671 - (BOOL)application: sender openTempFile: (NSString *)file
4672 {
4673   if (ns_do_open_file || not_in_argv (file))
4674     [ns_pending_files addObject: file];
4675   return YES;
4676 }
4677
4678
4679 /*   Notification from the Workspace to open a file noninteractively (?) */
4680 - (BOOL)application: sender openFileWithoutUI: (NSString *)file
4681 {
4682   if (ns_do_open_file || not_in_argv (file))
4683     [ns_pending_files addObject: file];
4684   return YES;
4685 }
4686
4687 /*   Notification from the Workspace to open multiple files */
4688 - (void)application: sender openFiles: (NSArray *)fileList
4689 {
4690   NSEnumerator *files = [fileList objectEnumerator];
4691   NSString *file;
4692   /* Don't open files from the command line unconditionally,
4693      Cocoa parses the command line wrong, --option value tries to open value
4694      if --option is the last option.  */
4695   while ((file = [files nextObject]) != nil)
4696     if (ns_do_open_file || not_in_argv (file))
4697       [ns_pending_files addObject: file];
4698
4699   [self replyToOpenOrPrint: NSApplicationDelegateReplySuccess];
4700
4701 }
4702
4703
4704 /* Handle dock menu requests.  */
4705 - (NSMenu *)applicationDockMenu: (NSApplication *) sender
4706 {
4707   return dockMenu;
4708 }
4709
4710
4711 /* TODO: these may help w/IO switching btwn terminal and NSApp */
4712 - (void)applicationWillBecomeActive: (NSNotification *)notification
4713 {
4714   //ns_app_active=YES;
4715 }
4716 - (void)applicationDidBecomeActive: (NSNotification *)notification
4717 {
4718   NSTRACE (applicationDidBecomeActive);
4719
4720   //ns_app_active=YES;
4721
4722   ns_update_auto_hide_menu_bar ();
4723   // No constraining takes place when the application is not active.
4724   ns_constrain_all_frames ();
4725 }
4726 - (void)applicationDidResignActive: (NSNotification *)notification
4727 {
4728   //ns_app_active=NO;
4729   ns_send_appdefined (-1);
4730 }
4731
4732
4733
4734 /* ==========================================================================
4735
4736     EmacsApp aux handlers for managing event loop
4737
4738    ========================================================================== */
4739
4740
4741 - (void)timeout_handler: (NSTimer *)timedEntry
4742 /* --------------------------------------------------------------------------
4743      The timeout specified to ns_select has passed.
4744    -------------------------------------------------------------------------- */
4745 {
4746   /*NSTRACE (timeout_handler); */
4747   ns_send_appdefined (-2);
4748 }
4749
4750 #ifdef NS_IMPL_GNUSTEP
4751 - (void)sendFromMainThread:(id)unused
4752 {
4753   ns_send_appdefined (nextappdefined);
4754 }
4755 #endif
4756
4757 - (void)fd_handler:(id)unused
4758 /* --------------------------------------------------------------------------
4759      Check data waiting on file descriptors and terminate if so
4760    -------------------------------------------------------------------------- */
4761 {
4762   int result;
4763   int waiting = 1, nfds;
4764   char c;
4765
4766   fd_set readfds, writefds, *wfds;
4767   struct timespec timeout, *tmo;
4768   NSAutoreleasePool *pool = nil;
4769
4770   /* NSTRACE (fd_handler); */
4771
4772   for (;;)
4773     {
4774       [pool release];
4775       pool = [[NSAutoreleasePool alloc] init];
4776
4777       if (waiting)
4778         {
4779           fd_set fds;
4780           FD_ZERO (&fds);
4781           FD_SET (selfds[0], &fds);
4782           result = select (selfds[0]+1, &fds, NULL, NULL, NULL);
4783           if (result > 0 && read (selfds[0], &c, 1) == 1 && c == 'g')
4784             waiting = 0;
4785         }
4786       else
4787         {
4788           pthread_mutex_lock (&select_mutex);
4789           nfds = select_nfds;
4790
4791           if (select_valid & SELECT_HAVE_READ)
4792             readfds = select_readfds;
4793           else
4794             FD_ZERO (&readfds);
4795
4796           if (select_valid & SELECT_HAVE_WRITE)
4797             {
4798               writefds = select_writefds;
4799               wfds = &writefds;
4800             }
4801           else
4802             wfds = NULL;
4803           if (select_valid & SELECT_HAVE_TMO)
4804             {
4805               timeout = select_timeout;
4806               tmo = &timeout;
4807             }
4808           else
4809             tmo = NULL;
4810
4811           pthread_mutex_unlock (&select_mutex);
4812
4813           FD_SET (selfds[0], &readfds);
4814           if (selfds[0] >= nfds) nfds = selfds[0]+1;
4815
4816           result = pselect (nfds, &readfds, wfds, NULL, tmo, NULL);
4817
4818           if (result == 0)
4819             ns_send_appdefined (-2);
4820           else if (result > 0)
4821             {
4822               if (FD_ISSET (selfds[0], &readfds))
4823                 {
4824                   if (read (selfds[0], &c, 1) == 1 && c == 's')
4825                     waiting = 1;
4826                 }
4827               else
4828                 {
4829                   pthread_mutex_lock (&select_mutex);
4830                   if (select_valid & SELECT_HAVE_READ)
4831                     select_readfds = readfds;
4832                   if (select_valid & SELECT_HAVE_WRITE)
4833                     select_writefds = writefds;
4834                   if (select_valid & SELECT_HAVE_TMO)
4835                     select_timeout = timeout;
4836                   pthread_mutex_unlock (&select_mutex);
4837
4838                   ns_send_appdefined (result);
4839                 }
4840             }
4841           waiting = 1;
4842         }
4843     }
4844 }
4845
4846
4847
4848 /* ==========================================================================
4849
4850     Service provision
4851
4852    ========================================================================== */
4853
4854 /* called from system: queue for next pass through event loop */
4855 - (void)requestService: (NSPasteboard *)pboard
4856               userData: (NSString *)userData
4857                  error: (NSString **)error
4858 {
4859   [ns_pending_service_names addObject: userData];
4860   [ns_pending_service_args addObject: [NSString stringWithUTF8String:
4861       SSDATA (ns_string_from_pasteboard (pboard))]];
4862 }
4863
4864
4865 /* called from ns_read_socket to clear queue */
4866 - (BOOL)fulfillService: (NSString *)name withArg: (NSString *)arg
4867 {
4868   struct frame *emacsframe = SELECTED_FRAME ();
4869   NSEvent *theEvent = [NSApp currentEvent];
4870
4871   if (!emacs_event)
4872     return NO;
4873
4874   emacs_event->kind = NS_NONKEY_EVENT;
4875   emacs_event->code = KEY_NS_SPI_SERVICE_CALL;
4876   ns_input_spi_name = build_string ([name UTF8String]);
4877   ns_input_spi_arg = build_string ([arg UTF8String]);
4878   emacs_event->modifiers = EV_MODIFIERS (theEvent);
4879   EV_TRAILER (theEvent);
4880
4881   return YES;
4882 }
4883
4884
4885 @end  /* EmacsApp */
4886
4887
4888
4889 /* ==========================================================================
4890
4891     EmacsView implementation
4892
4893    ========================================================================== */
4894
4895
4896 @implementation EmacsView
4897
4898 /* needed to inform when window closed from LISP */
4899 - (void) setWindowClosing: (BOOL)closing
4900 {
4901   windowClosing = closing;
4902 }
4903
4904
4905 - (void)dealloc
4906 {
4907   NSTRACE (EmacsView_dealloc);
4908   [toolbar release];
4909   if (fs_state == FULLSCREEN_BOTH)
4910     [nonfs_window release];
4911   [super dealloc];
4912 }
4913
4914
4915 /* called on font panel selection */
4916 - (void)changeFont: (id)sender
4917 {
4918   NSEvent *e = [[self window] currentEvent];
4919   struct face *face = FRAME_DEFAULT_FACE (emacsframe);
4920   struct font *font = face->font;
4921   id newFont;
4922   CGFloat size;
4923   NSFont *nsfont;
4924
4925   NSTRACE (changeFont);
4926
4927   if (!emacs_event)
4928     return;
4929
4930   if (EQ (font->driver->type, Qns))
4931     nsfont = ((struct nsfont_info *)font)->nsfont;
4932 #if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5
4933   else
4934     nsfont = (NSFont *) macfont_get_nsctfont (font);
4935 #endif
4936
4937   if ((newFont = [sender convertFont: nsfont]))
4938     {
4939       SET_FRAME_GARBAGED (emacsframe); /* now needed as of 2008/10 */
4940
4941       emacs_event->kind = NS_NONKEY_EVENT;
4942       emacs_event->modifiers = 0;
4943       emacs_event->code = KEY_NS_CHANGE_FONT;
4944
4945       size = [newFont pointSize];
4946       ns_input_fontsize = make_number (lrint (size));
4947       ns_input_font = build_string ([[newFont familyName] UTF8String]);
4948       EV_TRAILER (e);
4949     }
4950 }
4951
4952
4953 - (BOOL)acceptsFirstResponder
4954 {
4955   NSTRACE (acceptsFirstResponder);
4956   return YES;
4957 }
4958
4959
4960 - (void)resetCursorRects
4961 {
4962   NSRect visible = [self visibleRect];
4963   NSCursor *currentCursor = FRAME_POINTER_TYPE (emacsframe);
4964   NSTRACE (resetCursorRects);
4965
4966   if (currentCursor == nil)
4967     currentCursor = [NSCursor arrowCursor];
4968
4969   if (!NSIsEmptyRect (visible))
4970     [self addCursorRect: visible cursor: currentCursor];
4971   [currentCursor setOnMouseEntered: YES];
4972 }
4973
4974
4975
4976 /*****************************************************************************/
4977 /* Keyboard handling. */
4978 #define NS_KEYLOG 0
4979
4980 - (void)keyDown: (NSEvent *)theEvent
4981 {
4982   Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (emacsframe);
4983   int code;
4984   unsigned fnKeysym = 0;
4985   static NSMutableArray *nsEvArray;
4986 #if !defined (NS_IMPL_COCOA) || MAC_OS_X_VERSION_MAX_ALLOWED < MAC_OS_X_VERSION_10_6
4987   static BOOL firstTime = YES;
4988 #endif
4989   int left_is_none;
4990   unsigned int flags = [theEvent modifierFlags];
4991
4992   NSTRACE (keyDown);
4993
4994   /* Rhapsody and OS X give up and down events for the arrow keys */
4995   if (ns_fake_keydown == YES)
4996     ns_fake_keydown = NO;
4997   else if ([theEvent type] != NSKeyDown)
4998     return;
4999
5000   if (!emacs_event)
5001     return;
5002
5003  if (![[self window] isKeyWindow]
5004      && [[theEvent window] isKindOfClass: [EmacsWindow class]]
5005      /* we must avoid an infinite loop here. */
5006      && (EmacsView *)[[theEvent window] delegate] != self)
5007    {
5008      /* XXX: There is an occasional condition in which, when Emacs display
5009          updates a different frame from the current one, and temporarily
5010          selects it, then processes some interrupt-driven input
5011          (dispnew.c:3878), OS will send the event to the correct NSWindow, but
5012          for some reason that window has its first responder set to the NSView
5013          most recently updated (I guess), which is not the correct one. */
5014      [(EmacsView *)[[theEvent window] delegate] keyDown: theEvent];
5015      return;
5016    }
5017
5018   if (nsEvArray == nil)
5019     nsEvArray = [[NSMutableArray alloc] initWithCapacity: 1];
5020
5021   [NSCursor setHiddenUntilMouseMoves: YES];
5022
5023   if (hlinfo->mouse_face_hidden && INTEGERP (Vmouse_highlight))
5024     {
5025       clear_mouse_face (hlinfo);
5026       hlinfo->mouse_face_hidden = 1;
5027     }
5028
5029   if (!processingCompose)
5030     {
5031       /* When using screen sharing, no left or right information is sent,
5032          so use Left key in those cases.  */
5033       int is_left_key, is_right_key;
5034
5035       code = ([[theEvent charactersIgnoringModifiers] length] == 0) ?
5036         0 : [[theEvent charactersIgnoringModifiers] characterAtIndex: 0];
5037
5038       /* (Carbon way: [theEvent keyCode]) */
5039
5040       /* is it a "function key"? */
5041       fnKeysym = (code < 0x00ff && (flags&NSNumericPadKeyMask))
5042         ? ns_convert_key ([theEvent keyCode] | NSNumericPadKeyMask)
5043         : ns_convert_key (code);
5044
5045       if (fnKeysym)
5046         {
5047           /* COUNTERHACK: map 'Delete' on upper-right main KB to 'Backspace',
5048              because Emacs treats Delete and KP-Delete same (in simple.el). */
5049           if ((fnKeysym == 0xFFFF && [theEvent keyCode] == 0x33)
5050 #ifdef NS_IMPL_GNUSTEP
5051               /*  GNUstep uses incompatible keycodes, even for those that are
5052                   supposed to be hardware independent.  Just check for delete.
5053                   Keypad delete does not have keysym 0xFFFF.
5054                   See http://savannah.gnu.org/bugs/?25395
5055               */
5056               || (fnKeysym == 0xFFFF && code == 127)
5057 #endif
5058             )
5059             code = 0xFF08; /* backspace */
5060           else
5061             code = fnKeysym;
5062         }
5063
5064       /* are there modifiers? */
5065       emacs_event->modifiers = 0;
5066
5067       if (flags & NSHelpKeyMask)
5068           emacs_event->modifiers |= hyper_modifier;
5069
5070       if (flags & NSShiftKeyMask)
5071         emacs_event->modifiers |= shift_modifier;
5072
5073       is_right_key = (flags & NSRightCommandKeyMask) == NSRightCommandKeyMask;
5074       is_left_key = (flags & NSLeftCommandKeyMask) == NSLeftCommandKeyMask
5075         || (! is_right_key && (flags & NSCommandKeyMask) == NSCommandKeyMask);
5076
5077       if (is_right_key)
5078         emacs_event->modifiers |= parse_solitary_modifier
5079           (EQ (ns_right_command_modifier, Qleft)
5080            ? ns_command_modifier
5081            : ns_right_command_modifier);
5082
5083       if (is_left_key)
5084         {
5085           emacs_event->modifiers |= parse_solitary_modifier
5086             (ns_command_modifier);
5087
5088           /* if super (default), take input manager's word so things like
5089              dvorak / qwerty layout work */
5090           if (EQ (ns_command_modifier, Qsuper)
5091               && !fnKeysym
5092               && [[theEvent characters] length] != 0)
5093             {
5094               /* XXX: the code we get will be unshifted, so if we have
5095                  a shift modifier, must convert ourselves */
5096               if (!(flags & NSShiftKeyMask))
5097                 code = [[theEvent characters] characterAtIndex: 0];
5098 #if 0
5099               /* this is ugly and also requires linking w/Carbon framework
5100                  (for LMGetKbdType) so for now leave this rare (?) case
5101                  undealt with.. in future look into CGEvent methods */
5102               else
5103                 {
5104                   long smv = GetScriptManagerVariable (smKeyScript);
5105                   Handle uchrHandle = GetResource
5106                     ('uchr', GetScriptVariable (smv, smScriptKeys));
5107                   UInt32 dummy = 0;
5108                   UCKeyTranslate ((UCKeyboardLayout*)*uchrHandle,
5109                                  [[theEvent characters] characterAtIndex: 0],
5110                                  kUCKeyActionDisplay,
5111                                  (flags & ~NSCommandKeyMask) >> 8,
5112                                  LMGetKbdType (), kUCKeyTranslateNoDeadKeysMask,
5113                                  &dummy, 1, &dummy, &code);
5114                   code &= 0xFF;
5115                 }
5116 #endif
5117             }
5118         }
5119
5120       is_right_key = (flags & NSRightControlKeyMask) == NSRightControlKeyMask;
5121       is_left_key = (flags & NSLeftControlKeyMask) == NSLeftControlKeyMask
5122         || (! is_right_key && (flags & NSControlKeyMask) == NSControlKeyMask);
5123
5124       if (is_right_key)
5125           emacs_event->modifiers |= parse_solitary_modifier
5126               (EQ (ns_right_control_modifier, Qleft)
5127                ? ns_control_modifier
5128                : ns_right_control_modifier);
5129
5130       if (is_left_key)
5131         emacs_event->modifiers |= parse_solitary_modifier
5132           (ns_control_modifier);
5133
5134       if (flags & NS_FUNCTION_KEY_MASK && !fnKeysym)
5135           emacs_event->modifiers |=
5136             parse_solitary_modifier (ns_function_modifier);
5137
5138       left_is_none = NILP (ns_alternate_modifier)
5139         || EQ (ns_alternate_modifier, Qnone);
5140
5141       is_right_key = (flags & NSRightAlternateKeyMask)
5142         == NSRightAlternateKeyMask;
5143       is_left_key = (flags & NSLeftAlternateKeyMask) == NSLeftAlternateKeyMask
5144         || (! is_right_key
5145             && (flags & NSAlternateKeyMask) == NSAlternateKeyMask);
5146
5147       if (is_right_key)
5148         {
5149           if ((NILP (ns_right_alternate_modifier)
5150                || EQ (ns_right_alternate_modifier, Qnone)
5151                || (EQ (ns_right_alternate_modifier, Qleft) && left_is_none))
5152               && !fnKeysym)
5153             {   /* accept pre-interp alt comb */
5154               if ([[theEvent characters] length] > 0)
5155                 code = [[theEvent characters] characterAtIndex: 0];
5156               /*HACK: clear lone shift modifier to stop next if from firing */
5157               if (emacs_event->modifiers == shift_modifier)
5158                 emacs_event->modifiers = 0;
5159             }
5160           else
5161             emacs_event->modifiers |= parse_solitary_modifier
5162               (EQ (ns_right_alternate_modifier, Qleft)
5163                ? ns_alternate_modifier
5164                : ns_right_alternate_modifier);
5165         }
5166
5167       if (is_left_key) /* default = meta */
5168         {
5169           if (left_is_none && !fnKeysym)
5170             {   /* accept pre-interp alt comb */
5171               if ([[theEvent characters] length] > 0)
5172                 code = [[theEvent characters] characterAtIndex: 0];
5173               /*HACK: clear lone shift modifier to stop next if from firing */
5174               if (emacs_event->modifiers == shift_modifier)
5175                 emacs_event->modifiers = 0;
5176             }
5177           else
5178               emacs_event->modifiers |=
5179                 parse_solitary_modifier (ns_alternate_modifier);
5180         }
5181
5182   if (NS_KEYLOG)
5183     fprintf (stderr, "keyDown: code =%x\tfnKey =%x\tflags = %x\tmods = %x\n",
5184              code, fnKeysym, flags, emacs_event->modifiers);
5185
5186       /* if it was a function key or had modifiers, pass it directly to emacs */
5187       if (fnKeysym || (emacs_event->modifiers
5188                        && (emacs_event->modifiers != shift_modifier)
5189                        && [[theEvent charactersIgnoringModifiers] length] > 0))
5190 /*[[theEvent characters] length] */
5191         {
5192           emacs_event->kind = NON_ASCII_KEYSTROKE_EVENT;
5193           if (code < 0x20)
5194             code |= (1<<28)|(3<<16);
5195           else if (code == 0x7f)
5196             code |= (1<<28)|(3<<16);
5197           else if (!fnKeysym)
5198             emacs_event->kind = code > 0xFF
5199               ? MULTIBYTE_CHAR_KEYSTROKE_EVENT : ASCII_KEYSTROKE_EVENT;
5200
5201           emacs_event->code = code;
5202           EV_TRAILER (theEvent);
5203           processingCompose = NO;
5204           return;
5205         }
5206     }
5207
5208
5209 #if !defined (NS_IMPL_COCOA) || MAC_OS_X_VERSION_MAX_ALLOWED < MAC_OS_X_VERSION_10_6
5210   /* if we get here we should send the key for input manager processing */
5211   /* Disable warning, there is nothing a user can do about it anyway, and
5212      it does not seem to matter.  */
5213 #if 0
5214   if (firstTime && [[NSInputManager currentInputManager]
5215                      wantsToDelayTextChangeNotifications] == NO)
5216     fprintf (stderr,
5217           "Emacs: WARNING: TextInput mgr wants marked text to be permanent!\n");
5218 #endif
5219   firstTime = NO;
5220 #endif
5221   if (NS_KEYLOG && !processingCompose)
5222     fprintf (stderr, "keyDown: Begin compose sequence.\n");
5223
5224   processingCompose = YES;
5225   [nsEvArray addObject: theEvent];
5226   [self interpretKeyEvents: nsEvArray];
5227   [nsEvArray removeObject: theEvent];
5228 }
5229
5230
5231 #ifdef NS_IMPL_COCOA
5232 /* Needed to pick up Ctrl-tab and possibly other events that OS X has
5233    decided not to send key-down for.
5234    See http://osdir.com/ml/editors.vim.mac/2007-10/msg00141.html
5235    This only applies on Tiger and earlier.
5236    If it matches one of these, send it on to keyDown. */
5237 -(void)keyUp: (NSEvent *)theEvent
5238 {
5239   int flags = [theEvent modifierFlags];
5240   int code = [theEvent keyCode];
5241   if (floor (NSAppKitVersionNumber) <= 824 /*NSAppKitVersionNumber10_4*/ &&
5242       code == 0x30 && (flags & NSControlKeyMask) && !(flags & NSCommandKeyMask))
5243     {
5244       if (NS_KEYLOG)
5245         fprintf (stderr, "keyUp: passed test");
5246       ns_fake_keydown = YES;
5247       [self keyDown: theEvent];
5248     }
5249 }
5250 #endif
5251
5252
5253 /* <NSTextInput> implementation (called through super interpretKeyEvents:]). */
5254
5255
5256 /* <NSTextInput>: called when done composing;
5257    NOTE: also called when we delete over working text, followed immed.
5258          by doCommandBySelector: deleteBackward: */
5259 - (void)insertText: (id)aString
5260 {
5261   int code;
5262   int len = [(NSString *)aString length];
5263   int i;
5264
5265   if (NS_KEYLOG)
5266     NSLog (@"insertText '%@'\tlen = %d", aString, len);
5267   processingCompose = NO;
5268
5269   if (!emacs_event)
5270     return;
5271
5272   /* first, clear any working text */
5273   if (workingText != nil)
5274     [self deleteWorkingText];
5275
5276   /* now insert the string as keystrokes */
5277   for (i =0; i<len; i++)
5278     {
5279       code = [aString characterAtIndex: i];
5280       /* TODO: still need this? */
5281       if (code == 0x2DC)
5282         code = '~'; /* 0x7E */
5283       if (code != 32) /* Space */
5284         emacs_event->modifiers = 0;
5285       emacs_event->kind
5286         = code > 0xFF ? MULTIBYTE_CHAR_KEYSTROKE_EVENT : ASCII_KEYSTROKE_EVENT;
5287       emacs_event->code = code;
5288       EV_TRAILER ((id)nil);
5289     }
5290 }
5291
5292
5293 /* <NSTextInput>: inserts display of composing characters */
5294 - (void)setMarkedText: (id)aString selectedRange: (NSRange)selRange
5295 {
5296   NSString *str = [aString respondsToSelector: @selector (string)] ?
5297     [aString string] : aString;
5298   if (NS_KEYLOG)
5299     NSLog (@"setMarkedText '%@' len =%lu range %lu from %lu",
5300            str, (unsigned long)[str length],
5301            (unsigned long)selRange.length,
5302            (unsigned long)selRange.location);
5303
5304   if (workingText != nil)
5305     [self deleteWorkingText];
5306   if ([str length] == 0)
5307     return;
5308
5309   if (!emacs_event)
5310     return;
5311
5312   processingCompose = YES;
5313   workingText = [str copy];
5314   ns_working_text = build_string ([workingText UTF8String]);
5315
5316   emacs_event->kind = NS_TEXT_EVENT;
5317   emacs_event->code = KEY_NS_PUT_WORKING_TEXT;
5318   EV_TRAILER ((id)nil);
5319 }
5320
5321
5322 /* delete display of composing characters [not in <NSTextInput>] */
5323 - (void)deleteWorkingText
5324 {
5325   if (workingText == nil)
5326     return;
5327   if (NS_KEYLOG)
5328     NSLog(@"deleteWorkingText len =%lu\n", (unsigned long)[workingText length]);
5329   [workingText release];
5330   workingText = nil;
5331   processingCompose = NO;
5332
5333   if (!emacs_event)
5334     return;
5335
5336   emacs_event->kind = NS_TEXT_EVENT;
5337   emacs_event->code = KEY_NS_UNPUT_WORKING_TEXT;
5338   EV_TRAILER ((id)nil);
5339 }
5340
5341
5342 - (BOOL)hasMarkedText
5343 {
5344   return workingText != nil;
5345 }
5346
5347
5348 - (NSRange)markedRange
5349 {
5350   NSRange rng = workingText != nil
5351     ? NSMakeRange (0, [workingText length]) : NSMakeRange (NSNotFound, 0);
5352   if (NS_KEYLOG)
5353     NSLog (@"markedRange request");
5354   return rng;
5355 }
5356
5357
5358 - (void)unmarkText
5359 {
5360   if (NS_KEYLOG)
5361     NSLog (@"unmark (accept) text");
5362   [self deleteWorkingText];
5363   processingCompose = NO;
5364 }
5365
5366
5367 /* used to position char selection windows, etc. */
5368 - (NSRect)firstRectForCharacterRange: (NSRange)theRange
5369 {
5370   NSRect rect;
5371   NSPoint pt;
5372   struct window *win = XWINDOW (FRAME_SELECTED_WINDOW (emacsframe));
5373   if (NS_KEYLOG)
5374     NSLog (@"firstRectForCharRange request");
5375
5376   rect.size.width = theRange.length * FRAME_COLUMN_WIDTH (emacsframe);
5377   rect.size.height = FRAME_LINE_HEIGHT (emacsframe);
5378   pt.x = WINDOW_TEXT_TO_FRAME_PIXEL_X (win, win->phys_cursor.x);
5379   pt.y = WINDOW_TO_FRAME_PIXEL_Y (win, win->phys_cursor.y
5380                                        +FRAME_LINE_HEIGHT (emacsframe));
5381
5382   pt = [self convertPoint: pt toView: nil];
5383   pt = [[self window] convertBaseToScreen: pt];
5384   rect.origin = pt;
5385   return rect;
5386 }
5387
5388
5389 - (NSInteger)conversationIdentifier
5390 {
5391   return (NSInteger)self;
5392 }
5393
5394
5395 - (void)doCommandBySelector: (SEL)aSelector
5396 {
5397   if (NS_KEYLOG)
5398     NSLog (@"doCommandBySelector: %@", NSStringFromSelector (aSelector));
5399
5400   processingCompose = NO;
5401   if (aSelector == @selector (deleteBackward:))
5402     {
5403       /* happens when user backspaces over an ongoing composition:
5404          throw a 'delete' into the event queue */
5405       if (!emacs_event)
5406         return;
5407       emacs_event->kind = NON_ASCII_KEYSTROKE_EVENT;
5408       emacs_event->code = 0xFF08;
5409       EV_TRAILER ((id)nil);
5410     }
5411 }
5412
5413 - (NSArray *)validAttributesForMarkedText
5414 {
5415   static NSArray *arr = nil;
5416   if (arr == nil) arr = [NSArray new];
5417  /* [[NSArray arrayWithObject: NSUnderlineStyleAttributeName] retain]; */
5418   return arr;
5419 }
5420
5421 - (NSRange)selectedRange
5422 {
5423   if (NS_KEYLOG)
5424     NSLog (@"selectedRange request");
5425   return NSMakeRange (NSNotFound, 0);
5426 }
5427
5428 #if defined (NS_IMPL_COCOA) || GNUSTEP_GUI_MAJOR_VERSION > 0 || \
5429     GNUSTEP_GUI_MINOR_VERSION > 22
5430 - (NSUInteger)characterIndexForPoint: (NSPoint)thePoint
5431 #else
5432 - (unsigned int)characterIndexForPoint: (NSPoint)thePoint
5433 #endif
5434 {
5435   if (NS_KEYLOG)
5436     NSLog (@"characterIndexForPoint request");
5437   return 0;
5438 }
5439
5440 - (NSAttributedString *)attributedSubstringFromRange: (NSRange)theRange
5441 {
5442   static NSAttributedString *str = nil;
5443   if (str == nil) str = [NSAttributedString new];
5444   if (NS_KEYLOG)
5445     NSLog (@"attributedSubstringFromRange request");
5446   return str;
5447 }
5448
5449 /* End <NSTextInput> impl. */
5450 /*****************************************************************************/
5451
5452
5453 /* This is what happens when the user presses a mouse button.  */
5454 - (void)mouseDown: (NSEvent *)theEvent
5455 {
5456   struct ns_display_info *dpyinfo = FRAME_DISPLAY_INFO (emacsframe);
5457   NSPoint p = [self convertPoint: [theEvent locationInWindow] fromView: nil];
5458
5459   NSTRACE (mouseDown);
5460
5461   [self deleteWorkingText];
5462
5463   if (!emacs_event)
5464     return;
5465
5466   dpyinfo->last_mouse_frame = emacsframe;
5467   /* appears to be needed to prevent spurious movement events generated on
5468      button clicks */
5469   emacsframe->mouse_moved = 0;
5470
5471   if ([theEvent type] == NSScrollWheel)
5472     {
5473       CGFloat delta = [theEvent deltaY];
5474       /* Mac notebooks send wheel events w/delta =0 when trackpad scrolling */
5475       if (delta == 0)
5476         return;
5477       emacs_event->kind = WHEEL_EVENT;
5478       emacs_event->code = 0;
5479       emacs_event->modifiers = EV_MODIFIERS (theEvent) |
5480         ((delta > 0) ? up_modifier : down_modifier);
5481     }
5482   else
5483     {
5484       emacs_event->kind = MOUSE_CLICK_EVENT;
5485       emacs_event->code = EV_BUTTON (theEvent);
5486       emacs_event->modifiers = EV_MODIFIERS (theEvent)
5487                              | EV_UDMODIFIERS (theEvent);
5488     }
5489   XSETINT (emacs_event->x, lrint (p.x));
5490   XSETINT (emacs_event->y, lrint (p.y));
5491   EV_TRAILER (theEvent);
5492 }
5493
5494
5495 - (void)rightMouseDown: (NSEvent *)theEvent
5496 {
5497   NSTRACE (rightMouseDown);
5498   [self mouseDown: theEvent];
5499 }
5500
5501
5502 - (void)otherMouseDown: (NSEvent *)theEvent
5503 {
5504   NSTRACE (otherMouseDown);
5505   [self mouseDown: theEvent];
5506 }
5507
5508
5509 - (void)mouseUp: (NSEvent *)theEvent
5510 {
5511   NSTRACE (mouseUp);
5512   [self mouseDown: theEvent];
5513 }
5514
5515
5516 - (void)rightMouseUp: (NSEvent *)theEvent
5517 {
5518   NSTRACE (rightMouseUp);
5519   [self mouseDown: theEvent];
5520 }
5521
5522
5523 - (void)otherMouseUp: (NSEvent *)theEvent
5524 {
5525   NSTRACE (otherMouseUp);
5526   [self mouseDown: theEvent];
5527 }
5528
5529
5530 - (void) scrollWheel: (NSEvent *)theEvent
5531 {
5532   NSTRACE (scrollWheel);
5533   [self mouseDown: theEvent];
5534 }
5535
5536
5537 /* Tell emacs the mouse has moved. */
5538 - (void)mouseMoved: (NSEvent *)e
5539 {
5540   Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (emacsframe);
5541   struct ns_display_info *dpyinfo = FRAME_DISPLAY_INFO (emacsframe);
5542   Lisp_Object frame;
5543   NSPoint pt;
5544
5545 //  NSTRACE (mouseMoved);
5546
5547   dpyinfo->last_mouse_movement_time = EV_TIMESTAMP (e);
5548   pt = [self convertPoint: [e locationInWindow] fromView: nil];
5549   dpyinfo->last_mouse_motion_x = pt.x;
5550   dpyinfo->last_mouse_motion_y = pt.y;
5551
5552   /* update any mouse face */
5553   if (hlinfo->mouse_face_hidden)
5554     {
5555       hlinfo->mouse_face_hidden = 0;
5556       clear_mouse_face (hlinfo);
5557     }
5558
5559   /* tooltip handling */
5560   previous_help_echo_string = help_echo_string;
5561   help_echo_string = Qnil;
5562
5563   if (!NILP (Vmouse_autoselect_window))
5564     {
5565       NSTRACE (mouse_autoselect_window);
5566       static Lisp_Object last_mouse_window;
5567       Lisp_Object window
5568         = window_from_coordinates (emacsframe, pt.x, pt.y, 0, 0);
5569
5570       if (WINDOWP (window)
5571           && !EQ (window, last_mouse_window)
5572           && !EQ (window, selected_window)
5573           && (focus_follows_mouse
5574               || (EQ (XWINDOW (window)->frame,
5575                       XWINDOW (selected_window)->frame))))
5576         {
5577           NSTRACE (in_window);
5578           emacs_event->kind = SELECT_WINDOW_EVENT;
5579           emacs_event->frame_or_window = window;
5580           EV_TRAILER2 (e);
5581         }
5582       /* Remember the last window where we saw the mouse.  */
5583       last_mouse_window = window;
5584     }
5585
5586   if (!note_mouse_movement (emacsframe, pt.x, pt.y))
5587     help_echo_string = previous_help_echo_string;
5588
5589   XSETFRAME (frame, emacsframe);
5590   if (!NILP (help_echo_string) || !NILP (previous_help_echo_string))
5591     {
5592       /* NOTE: help_echo_{window,pos,object} are set in xdisp.c
5593          (note_mouse_highlight), which is called through the
5594          note_mouse_movement () call above */
5595       gen_help_event (help_echo_string, frame, help_echo_window,
5596                       help_echo_object, help_echo_pos);
5597     }
5598   else
5599     {
5600       help_echo_string = Qnil;
5601       gen_help_event (Qnil, frame, Qnil, Qnil, 0);
5602     }
5603
5604   if (emacsframe->mouse_moved && send_appdefined)
5605     ns_send_appdefined (-1);
5606 }
5607
5608
5609 - (void)mouseDragged: (NSEvent *)e
5610 {
5611   NSTRACE (mouseDragged);
5612   [self mouseMoved: e];
5613 }
5614
5615
5616 - (void)rightMouseDragged: (NSEvent *)e
5617 {
5618   NSTRACE (rightMouseDragged);
5619   [self mouseMoved: e];
5620 }
5621
5622
5623 - (void)otherMouseDragged: (NSEvent *)e
5624 {
5625   NSTRACE (otherMouseDragged);
5626   [self mouseMoved: e];
5627 }
5628
5629
5630 - (BOOL)windowShouldClose: (id)sender
5631 {
5632   NSEvent *e =[[self window] currentEvent];
5633
5634   NSTRACE (windowShouldClose);
5635   windowClosing = YES;
5636   if (!emacs_event)
5637     return NO;
5638   emacs_event->kind = DELETE_WINDOW_EVENT;
5639   emacs_event->modifiers = 0;
5640   emacs_event->code = 0;
5641   EV_TRAILER (e);
5642   /* Don't close this window, let this be done from lisp code.  */
5643   return NO;
5644 }
5645
5646 - (void) updateFrameSize: (BOOL) delay;
5647 {
5648   NSWindow *window = [self window];
5649   NSRect wr = [window frame];
5650   int extra = 0;
5651   int gsextra = 0;
5652 #ifdef NS_IMPL_GNUSTEP
5653   gsextra = 3;
5654 #endif
5655
5656   int oldc = cols, oldr = rows;
5657   int oldw = FRAME_PIXEL_WIDTH (emacsframe),
5658     oldh = FRAME_PIXEL_HEIGHT (emacsframe);
5659   int neww, newh;
5660
5661   cols = FRAME_PIXEL_WIDTH_TO_TEXT_COLS (emacsframe, wr.size.width + gsextra);
5662
5663   if (cols < MINWIDTH)
5664     cols = MINWIDTH;
5665
5666   if (! [self isFullscreen])
5667     {
5668       extra = FRAME_NS_TITLEBAR_HEIGHT (emacsframe)
5669         + FRAME_TOOLBAR_HEIGHT (emacsframe) - gsextra;
5670     }
5671
5672   rows = FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (emacsframe, wr.size.height - extra);
5673
5674   if (rows < MINHEIGHT)
5675     rows = MINHEIGHT;
5676
5677   neww = (int)wr.size.width - emacsframe->border_width;
5678   newh = (int)wr.size.height - extra;
5679
5680   if (oldr != rows || oldc != cols || neww != oldw || newh != oldh)
5681     {
5682       NSView *view = FRAME_NS_VIEW (emacsframe);
5683       NSWindow *win = [view window];
5684       NSSize sz = [win resizeIncrements];
5685
5686       FRAME_PIXEL_WIDTH (emacsframe) = neww;
5687       FRAME_PIXEL_HEIGHT (emacsframe) = newh;
5688       change_frame_size (emacsframe, cols, rows, 0, delay, 0, 0);
5689       SET_FRAME_GARBAGED (emacsframe);
5690       cancel_mouse_face (emacsframe);
5691
5692       // Did resize increments change because of a font change?
5693       if (sz.width != FRAME_COLUMN_WIDTH (emacsframe) ||
5694           sz.height != FRAME_LINE_HEIGHT (emacsframe))
5695         {
5696           sz.width = FRAME_COLUMN_WIDTH (emacsframe);
5697           sz.height = FRAME_LINE_HEIGHT (emacsframe);
5698           [win setResizeIncrements: sz];
5699         }
5700
5701       [view setFrame: NSMakeRect (0, 0, neww, newh)];
5702       [self windowDidMove:nil];   // Update top/left.
5703     }
5704 }
5705
5706 - (NSSize)windowWillResize: (NSWindow *)sender toSize: (NSSize)frameSize
5707 /* normalize frame to gridded text size */
5708 {
5709   int extra = 0;
5710   int gsextra = 0;
5711 #ifdef NS_IMPL_GNUSTEP
5712   gsextra = 3;
5713 #endif
5714
5715   NSTRACE (windowWillResize);
5716 /*fprintf (stderr,"Window will resize: %.0f x %.0f\n",frameSize.width,frameSize.height); */
5717
5718   if (fs_state == FULLSCREEN_MAXIMIZED
5719       && (maximized_width != (int)frameSize.width
5720           || maximized_height != (int)frameSize.height))
5721     [self setFSValue: FULLSCREEN_NONE];
5722   else if (fs_state == FULLSCREEN_WIDTH
5723            && maximized_width != (int)frameSize.width)
5724     [self setFSValue: FULLSCREEN_NONE];
5725   else if (fs_state == FULLSCREEN_HEIGHT
5726            && maximized_height != (int)frameSize.height)
5727     [self setFSValue: FULLSCREEN_NONE];
5728   if (fs_state == FULLSCREEN_NONE)
5729     maximized_width = maximized_height = -1;
5730
5731   cols = FRAME_PIXEL_WIDTH_TO_TEXT_COLS (emacsframe,
5732                                          frameSize.width + gsextra);
5733   if (cols < MINWIDTH)
5734     cols = MINWIDTH;
5735
5736   rows = FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (emacsframe,
5737                                            frameSize.height - extra);
5738   if (rows < MINHEIGHT)
5739     rows = MINHEIGHT;
5740 #ifdef NS_IMPL_COCOA
5741   {
5742     /* this sets window title to have size in it; the wm does this under GS */
5743     NSRect r = [[self window] frame];
5744     if (r.size.height == frameSize.height && r.size.width == frameSize.width)
5745       {
5746         if (old_title != 0)
5747           {
5748             xfree (old_title);
5749             old_title = 0;
5750           }
5751       }
5752     else if (fs_state == FULLSCREEN_NONE && ! maximizing_resize)
5753       {
5754         char *size_title;
5755         NSWindow *window = [self window];
5756         if (old_title == 0)
5757           {
5758             char *t = strdup ([[[self window] title] UTF8String]);
5759             char *pos = strstr (t, "  —  ");
5760             if (pos)
5761               *pos = '\0';
5762             old_title = t;
5763           }
5764         size_title = xmalloc (strlen (old_title) + 40);
5765         esprintf (size_title, "%s  —  (%d x %d)", old_title, cols, rows);
5766         [window setTitle: [NSString stringWithUTF8String: size_title]];
5767         [window display];
5768         xfree (size_title);
5769       }
5770   }
5771 #endif /* NS_IMPL_COCOA */
5772 /*fprintf (stderr,"    ...size became %.0f x %.0f  (%d x %d)\n",frameSize.width,frameSize.height,cols,rows); */
5773
5774   return frameSize;
5775 }
5776
5777
5778 - (void)windowDidResize: (NSNotification *)notification
5779 {
5780   if (! [self fsIsNative])
5781     {
5782       NSWindow *theWindow = [notification object];
5783       /* We can get notification on the non-FS window when in
5784          fullscreen mode.  */
5785       if ([self window] != theWindow) return;
5786     }
5787
5788 #ifdef NS_IMPL_GNUSTEP
5789   NSWindow *theWindow = [notification object];
5790
5791    /* In GNUstep, at least currently, it's possible to get a didResize
5792       without getting a willResize.. therefore we need to act as if we got
5793       the willResize now */
5794   NSSize sz = [theWindow frame].size;
5795   sz = [self windowWillResize: theWindow toSize: sz];
5796 #endif /* NS_IMPL_GNUSTEP */
5797
5798   NSTRACE (windowDidResize);
5799 /*fprintf (stderr,"windowDidResize: %.0f\n",[theWindow frame].size.height); */
5800
5801 if (cols > 0 && rows > 0)
5802     {
5803       [self updateFrameSize: YES];
5804     }
5805
5806   ns_send_appdefined (-1);
5807 }
5808
5809 #ifdef NS_IMPL_COCOA
5810 - (void)viewDidEndLiveResize
5811 {
5812   [super viewDidEndLiveResize];
5813   if (old_title != 0)
5814     {
5815       [[self window] setTitle: [NSString stringWithUTF8String: old_title]];
5816       xfree (old_title);
5817       old_title = 0;
5818     }
5819   maximizing_resize = NO;
5820 }
5821 #endif /* NS_IMPL_COCOA */
5822
5823
5824 - (void)windowDidBecomeKey: (NSNotification *)notification
5825 /* cf. x_detect_focus_change(), x_focus_changed(), x_new_focus_frame() */
5826 {
5827   struct ns_display_info *dpyinfo = FRAME_DISPLAY_INFO (emacsframe);
5828   struct frame *old_focus = dpyinfo->x_focus_frame;
5829
5830   NSTRACE (windowDidBecomeKey);
5831
5832   if (emacsframe != old_focus)
5833     dpyinfo->x_focus_frame = emacsframe;
5834
5835   ns_frame_rehighlight (emacsframe);
5836
5837   if (emacs_event)
5838     {
5839       emacs_event->kind = FOCUS_IN_EVENT;
5840       EV_TRAILER ((id)nil);
5841     }
5842 }
5843
5844
5845 - (void)windowDidResignKey: (NSNotification *)notification
5846 /* cf. x_detect_focus_change(), x_focus_changed(), x_new_focus_frame() */
5847 {
5848   struct ns_display_info *dpyinfo = FRAME_DISPLAY_INFO (emacsframe);
5849   BOOL is_focus_frame = dpyinfo->x_focus_frame == emacsframe;
5850   NSTRACE (windowDidResignKey);
5851
5852   if (is_focus_frame)
5853     dpyinfo->x_focus_frame = 0;
5854
5855   ns_frame_rehighlight (emacsframe);
5856
5857   /* FIXME: for some reason needed on second and subsequent clicks away
5858             from sole-frame Emacs to get hollow box to show */
5859   if (!windowClosing && [[self window] isVisible] == YES)
5860     {
5861       x_update_cursor (emacsframe, 1);
5862       x_set_frame_alpha (emacsframe);
5863     }
5864
5865   if (emacs_event && is_focus_frame)
5866     {
5867       [self deleteWorkingText];
5868       emacs_event->kind = FOCUS_OUT_EVENT;
5869       EV_TRAILER ((id)nil);
5870     }
5871 }
5872
5873
5874 - (void)windowWillMiniaturize: sender
5875 {
5876   NSTRACE (windowWillMiniaturize);
5877 }
5878
5879
5880 - (BOOL)isFlipped
5881 {
5882   return YES;
5883 }
5884
5885
5886 - (BOOL)isOpaque
5887 {
5888   return NO;
5889 }
5890
5891
5892 - initFrameFromEmacs: (struct frame *)f
5893 {
5894   NSRect r, wr;
5895   Lisp_Object tem;
5896   NSWindow *win;
5897   NSSize sz;
5898   NSColor *col;
5899   NSString *name;
5900
5901   NSTRACE (initFrameFromEmacs);
5902
5903   windowClosing = NO;
5904   processingCompose = NO;
5905   scrollbarsNeedingUpdate = 0;
5906   fs_state = FULLSCREEN_NONE;
5907   fs_before_fs = next_maximized = -1;
5908 #ifdef HAVE_NATIVE_FS
5909   fs_is_native = ns_use_native_fullscreen;
5910 #else
5911   fs_is_native = NO;
5912 #endif
5913   maximized_width = maximized_height = -1;
5914   nonfs_window = nil;
5915
5916 /*fprintf (stderr,"init with %d, %d\n",f->text_cols, f->text_lines); */
5917
5918   ns_userRect = NSMakeRect (0, 0, 0, 0);
5919   r = NSMakeRect (0, 0, FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f, f->text_cols),
5920                  FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f, f->text_lines));
5921   [self initWithFrame: r];
5922   [self setAutoresizingMask: NSViewWidthSizable | NSViewHeightSizable];
5923
5924   FRAME_NS_VIEW (f) = self;
5925   emacsframe = f;
5926 #ifdef NS_IMPL_COCOA
5927   old_title = 0;
5928   maximizing_resize = NO;
5929 #endif
5930
5931   win = [[EmacsWindow alloc]
5932             initWithContentRect: r
5933                       styleMask: (NSResizableWindowMask |
5934 #if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_7
5935                                   NSTitledWindowMask |
5936 #endif
5937                                   NSMiniaturizableWindowMask |
5938                                   NSClosableWindowMask)
5939                         backing: NSBackingStoreBuffered
5940                           defer: YES];
5941
5942 #ifdef HAVE_NATIVE_FS
5943     [win setCollectionBehavior:NSWindowCollectionBehaviorFullScreenPrimary];
5944 #endif
5945
5946   wr = [win frame];
5947   bwidth = f->border_width = wr.size.width - r.size.width;
5948   tibar_height = FRAME_NS_TITLEBAR_HEIGHT (f) = wr.size.height - r.size.height;
5949
5950   [win setAcceptsMouseMovedEvents: YES];
5951   [win setDelegate: self];
5952   [win useOptimizedDrawing: YES];
5953
5954   sz.width = FRAME_COLUMN_WIDTH (f);
5955   sz.height = FRAME_LINE_HEIGHT (f);
5956   [win setResizeIncrements: sz];
5957
5958   [[win contentView] addSubview: self];
5959
5960   if (ns_drag_types)
5961     [self registerForDraggedTypes: ns_drag_types];
5962
5963   tem = f->name;
5964   name = [NSString stringWithUTF8String:
5965                    NILP (tem) ? "Emacs" : SSDATA (tem)];
5966   [win setTitle: name];
5967
5968   /* toolbar support */
5969   toolbar = [[EmacsToolbar alloc] initForView: self withIdentifier:
5970                          [NSString stringWithFormat: @"Emacs Frame %d",
5971                                    ns_window_num]];
5972   [win setToolbar: toolbar];
5973   [toolbar setVisible: NO];
5974 #ifdef NS_IMPL_COCOA
5975   {
5976     NSButton *toggleButton;
5977   toggleButton = [win standardWindowButton: NSWindowToolbarButton];
5978   [toggleButton setTarget: self];
5979   [toggleButton setAction: @selector (toggleToolbar: )];
5980   }
5981 #endif
5982   FRAME_TOOLBAR_HEIGHT (f) = 0;
5983
5984   tem = f->icon_name;
5985   if (!NILP (tem))
5986     [win setMiniwindowTitle:
5987            [NSString stringWithUTF8String: SSDATA (tem)]];
5988
5989   {
5990     NSScreen *screen = [win screen];
5991
5992     if (screen != 0)
5993       [win setFrameTopLeftPoint: NSMakePoint
5994            (IN_BOUND (-SCREENMAX, f->left_pos, SCREENMAX),
5995             IN_BOUND (-SCREENMAX,
5996                      [screen frame].size.height - NS_TOP_POS (f), SCREENMAX))];
5997   }
5998
5999   [win makeFirstResponder: self];
6000
6001   col = ns_lookup_indexed_color (NS_FACE_BACKGROUND
6002                                   (FRAME_DEFAULT_FACE (emacsframe)), emacsframe);
6003   [win setBackgroundColor: col];
6004   if ([col alphaComponent] != (EmacsCGFloat) 1.0)
6005     [win setOpaque: NO];
6006
6007   [self allocateGState];
6008
6009   [NSApp registerServicesMenuSendTypes: ns_send_types
6010                            returnTypes: nil];
6011
6012   ns_window_num++;
6013   return self;
6014 }
6015
6016
6017 - (void)windowDidMove: sender
6018 {
6019   NSWindow *win = [self window];
6020   NSRect r = [win frame];
6021   NSArray *screens = [NSScreen screens];
6022   NSScreen *screen = [screens objectAtIndex: 0];
6023
6024   NSTRACE (windowDidMove);
6025
6026   if (!emacsframe->output_data.ns)
6027     return;
6028   if (screen != nil)
6029     {
6030       emacsframe->left_pos = r.origin.x;
6031       emacsframe->top_pos =
6032         [screen frame].size.height - (r.origin.y + r.size.height);
6033     }
6034 }
6035
6036
6037 /* Called AFTER method below, but before our windowWillResize call there leads
6038    to windowDidResize -> x_set_window_size.  Update emacs' notion of frame
6039    location so set_window_size moves the frame. */
6040 - (BOOL)windowShouldZoom: (NSWindow *)sender toFrame: (NSRect)newFrame
6041 {
6042   emacsframe->output_data.ns->zooming = 1;
6043   return YES;
6044 }
6045
6046
6047 /* Override to do something slightly nonstandard, but nice.  First click on
6048    zoom button will zoom vertically.  Second will zoom completely.  Third
6049    returns to original. */
6050 - (NSRect)windowWillUseStandardFrame:(NSWindow *)sender
6051                         defaultFrame:(NSRect)defaultFrame
6052 {
6053   NSRect result = [sender frame];
6054
6055   NSTRACE (windowWillUseStandardFrame);
6056
6057   if (fs_before_fs != -1) /* Entering fullscreen */
6058       {
6059         result = defaultFrame;
6060       }
6061   else if (next_maximized == FULLSCREEN_HEIGHT
6062       || (next_maximized == -1
6063           && abs (defaultFrame.size.height - result.size.height)
6064           > FRAME_LINE_HEIGHT (emacsframe)))
6065     {
6066       /* first click */
6067       ns_userRect = result;
6068       maximized_height = result.size.height = defaultFrame.size.height;
6069       maximized_width = -1;
6070       result.origin.y = defaultFrame.origin.y;
6071       [self setFSValue: FULLSCREEN_HEIGHT];
6072 #ifdef NS_IMPL_COCOA
6073       maximizing_resize = YES;
6074 #endif
6075     }
6076   else if (next_maximized == FULLSCREEN_WIDTH)
6077     {
6078       ns_userRect = result;
6079       maximized_width = result.size.width = defaultFrame.size.width;
6080       maximized_height = -1;
6081       result.origin.x = defaultFrame.origin.x;
6082       [self setFSValue: FULLSCREEN_WIDTH];
6083     }
6084   else if (next_maximized == FULLSCREEN_MAXIMIZED
6085            || (next_maximized == -1
6086                && abs (defaultFrame.size.width - result.size.width)
6087                > FRAME_COLUMN_WIDTH (emacsframe)))
6088     {
6089       result = defaultFrame;  /* second click */
6090       maximized_width = result.size.width;
6091       maximized_height = result.size.height;
6092       [self setFSValue: FULLSCREEN_MAXIMIZED];
6093 #ifdef NS_IMPL_COCOA
6094       maximizing_resize = YES;
6095 #endif
6096     }
6097   else
6098     {
6099       /* restore */
6100       result = ns_userRect.size.height ? ns_userRect : result;
6101       ns_userRect = NSMakeRect (0, 0, 0, 0);
6102 #ifdef NS_IMPL_COCOA
6103       maximizing_resize = fs_state != FULLSCREEN_NONE;
6104 #endif
6105       [self setFSValue: FULLSCREEN_NONE];
6106       maximized_width = maximized_height = -1;
6107     }
6108
6109   if (fs_before_fs == -1) next_maximized = -1;
6110   [self windowWillResize: sender toSize: result.size];
6111   return result;
6112 }
6113
6114
6115 - (void)windowDidDeminiaturize: sender
6116 {
6117   NSTRACE (windowDidDeminiaturize);
6118   if (!emacsframe->output_data.ns)
6119     return;
6120
6121   SET_FRAME_ICONIFIED (emacsframe, 0);
6122   SET_FRAME_VISIBLE (emacsframe, 1);
6123   windows_or_buffers_changed = 63;
6124
6125   if (emacs_event)
6126     {
6127       emacs_event->kind = DEICONIFY_EVENT;
6128       EV_TRAILER ((id)nil);
6129     }
6130 }
6131
6132
6133 - (void)windowDidExpose: sender
6134 {
6135   NSTRACE (windowDidExpose);
6136   if (!emacsframe->output_data.ns)
6137     return;
6138
6139   SET_FRAME_VISIBLE (emacsframe, 1);
6140   SET_FRAME_GARBAGED (emacsframe);
6141
6142   if (send_appdefined)
6143     ns_send_appdefined (-1);
6144 }
6145
6146
6147 - (void)windowDidMiniaturize: sender
6148 {
6149   NSTRACE (windowDidMiniaturize);
6150   if (!emacsframe->output_data.ns)
6151     return;
6152
6153   SET_FRAME_ICONIFIED (emacsframe, 1);
6154   SET_FRAME_VISIBLE (emacsframe, 0);
6155
6156   if (emacs_event)
6157     {
6158       emacs_event->kind = ICONIFY_EVENT;
6159       EV_TRAILER ((id)nil);
6160     }
6161 }
6162
6163 #ifdef HAVE_NATIVE_FS
6164 - (NSApplicationPresentationOptions)window:(NSWindow *)window
6165       willUseFullScreenPresentationOptions:
6166   (NSApplicationPresentationOptions)proposedOptions
6167 {
6168   return proposedOptions|NSApplicationPresentationAutoHideToolbar;
6169 }
6170 #endif
6171
6172 - (void)windowWillEnterFullScreen:(NSNotification *)notification
6173 {
6174   fs_before_fs = fs_state;
6175 }
6176
6177 - (void)windowDidEnterFullScreen:(NSNotification *)notification
6178 {
6179   [self setFSValue: FULLSCREEN_BOTH];
6180   if (! [self fsIsNative])
6181     {
6182       [self windowDidBecomeKey:notification];
6183       [nonfs_window orderOut:self];
6184     }
6185   else
6186     {
6187       BOOL tbar_visible = FRAME_EXTERNAL_TOOL_BAR (emacsframe) ? YES : NO;
6188 #ifdef NS_IMPL_COCOA
6189 #if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_7
6190       unsigned val = (unsigned)[NSApp presentationOptions];
6191
6192       // OSX 10.7 bug fix, the menu won't appear without this.
6193       // val is non-zero on other OSX versions.
6194       if (val == 0)
6195         {
6196           NSApplicationPresentationOptions options
6197             = NSApplicationPresentationAutoHideDock
6198             | NSApplicationPresentationAutoHideMenuBar
6199             | NSApplicationPresentationFullScreen
6200             | NSApplicationPresentationAutoHideToolbar;
6201
6202           [NSApp setPresentationOptions: options];
6203         }
6204 #endif
6205 #endif
6206       [toolbar setVisible:tbar_visible];
6207     }
6208 }
6209
6210 - (void)windowWillExitFullScreen:(NSNotification *)notification
6211 {
6212   if (next_maximized != -1)
6213     fs_before_fs = next_maximized;
6214 }
6215
6216 - (void)windowDidExitFullScreen:(NSNotification *)notification
6217 {
6218   [self setFSValue: fs_before_fs];
6219   fs_before_fs = -1;
6220 #ifdef HAVE_NATIVE_FS
6221   [self updateCollectionBehaviour];
6222 #endif
6223   if (FRAME_EXTERNAL_TOOL_BAR (emacsframe))
6224     {
6225       [toolbar setVisible:YES];
6226       update_frame_tool_bar (emacsframe);
6227       [self updateFrameSize:YES];
6228       [[self window] display];
6229     }
6230   else
6231     [toolbar setVisible:NO];
6232
6233   if (next_maximized != -1)
6234     [[self window] performZoom:self];
6235 }
6236
6237 - (BOOL)fsIsNative
6238 {
6239   return fs_is_native;
6240 }
6241
6242 - (BOOL)isFullscreen
6243 {
6244   if (! fs_is_native) return nonfs_window != nil;
6245 #ifdef HAVE_NATIVE_FS
6246   return ([[self window] styleMask] & NSFullScreenWindowMask) != 0;
6247 #else
6248   return NO;
6249 #endif
6250 }
6251
6252 #ifdef HAVE_NATIVE_FS
6253 - (void)updateCollectionBehaviour
6254 {
6255   if (! [self isFullscreen])
6256     {
6257       NSWindow *win = [self window];
6258       NSWindowCollectionBehavior b = [win collectionBehavior];
6259       if (ns_use_native_fullscreen)
6260         b |= NSWindowCollectionBehaviorFullScreenPrimary;
6261       else
6262         b &= ~NSWindowCollectionBehaviorFullScreenPrimary;
6263
6264       [win setCollectionBehavior: b];
6265       fs_is_native = ns_use_native_fullscreen;
6266     }
6267 }
6268 #endif
6269
6270 - (void)toggleFullScreen: (id)sender
6271 {
6272   NSWindow *w, *fw;
6273   BOOL onFirstScreen;
6274   struct frame *f;
6275   NSSize sz;
6276   NSRect r, wr;
6277   NSColor *col;
6278
6279   if (fs_is_native)
6280     {
6281 #ifdef HAVE_NATIVE_FS
6282       [[self window] toggleFullScreen:sender];
6283 #endif
6284       return;
6285     }
6286
6287   w = [self window];
6288   onFirstScreen = [[w screen] isEqual:[[NSScreen screens] objectAtIndex:0]];
6289   f = emacsframe;
6290   wr = [w frame];
6291   col = ns_lookup_indexed_color (NS_FACE_BACKGROUND
6292                                  (FRAME_DEFAULT_FACE (f)),
6293                                  f);
6294
6295   sz.width = FRAME_COLUMN_WIDTH (f);
6296   sz.height = FRAME_LINE_HEIGHT (f);
6297
6298   if (fs_state != FULLSCREEN_BOTH)
6299     {
6300       /* Hide dock and menubar if we are on the primary screen.  */
6301       if (onFirstScreen)
6302         {
6303 #if defined (NS_IMPL_COCOA) && \
6304   MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_6
6305           NSApplicationPresentationOptions options
6306             = NSApplicationPresentationAutoHideDock
6307             | NSApplicationPresentationAutoHideMenuBar;
6308
6309           [NSApp setPresentationOptions: options];
6310 #else
6311           [NSMenu setMenuBarVisible:NO];
6312 #endif
6313         }
6314
6315       fw = [[EmacsFSWindow alloc]
6316                        initWithContentRect:[w contentRectForFrameRect:wr]
6317                                  styleMask:NSBorderlessWindowMask
6318                                    backing:NSBackingStoreBuffered
6319                                      defer:YES
6320                                     screen:[w screen]];
6321
6322       [fw setContentView:[w contentView]];
6323       [fw setTitle:[w title]];
6324       [fw setDelegate:self];
6325       [fw setAcceptsMouseMovedEvents: YES];
6326       [fw useOptimizedDrawing: YES];
6327       [fw setResizeIncrements: sz];
6328       [fw setBackgroundColor: col];
6329       if ([col alphaComponent] != (EmacsCGFloat) 1.0)
6330         [fw setOpaque: NO];
6331
6332       f->border_width = 0;
6333       FRAME_NS_TITLEBAR_HEIGHT (f) = 0;
6334       tobar_height = FRAME_TOOLBAR_HEIGHT (f);
6335       FRAME_TOOLBAR_HEIGHT (f) = 0;
6336
6337       nonfs_window = w;
6338
6339       [self windowWillEnterFullScreen:nil];
6340       [fw makeKeyAndOrderFront:NSApp];
6341       [fw makeFirstResponder:self];
6342       [w orderOut:self];
6343       r = [fw frameRectForContentRect:[[fw screen] frame]];
6344       [fw setFrame: r display:YES animate:YES];
6345       [self windowDidEnterFullScreen:nil];
6346       [fw display];
6347     }
6348   else
6349     {
6350       fw = w;
6351       w = nonfs_window;
6352       nonfs_window = nil;
6353
6354       if (onFirstScreen)
6355         {
6356 #if defined (NS_IMPL_COCOA) && \
6357   MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_6
6358           [NSApp setPresentationOptions: NSApplicationPresentationDefault];
6359 #else
6360           [NSMenu setMenuBarVisible:YES];
6361 #endif
6362         }
6363
6364       [w setContentView:[fw contentView]];
6365       [w setResizeIncrements: sz];
6366       [w setBackgroundColor: col];
6367       if ([col alphaComponent] != (EmacsCGFloat) 1.0)
6368         [w setOpaque: NO];
6369
6370       f->border_width = bwidth;
6371       FRAME_NS_TITLEBAR_HEIGHT (f) = tibar_height;
6372       if (FRAME_EXTERNAL_TOOL_BAR (f))
6373         FRAME_TOOLBAR_HEIGHT (f) = tobar_height;
6374
6375       [self windowWillExitFullScreen:nil];
6376       [fw setFrame: [w frame] display:YES animate:YES];
6377       [fw close];
6378       [w makeKeyAndOrderFront:NSApp];
6379       [self windowDidExitFullScreen:nil];
6380       [self updateFrameSize:YES];
6381     }
6382 }
6383
6384 - (void)handleFS
6385 {
6386   if (fs_state != emacsframe->want_fullscreen)
6387     {
6388       if (fs_state == FULLSCREEN_BOTH)
6389         {
6390           [self toggleFullScreen:self];
6391         }
6392
6393       switch (emacsframe->want_fullscreen)
6394         {
6395         case FULLSCREEN_BOTH:
6396           [self toggleFullScreen:self];
6397           break;
6398         case FULLSCREEN_WIDTH:
6399           next_maximized = FULLSCREEN_WIDTH;
6400           if (fs_state != FULLSCREEN_BOTH)
6401             [[self window] performZoom:self];
6402           break;
6403         case FULLSCREEN_HEIGHT:
6404           next_maximized = FULLSCREEN_HEIGHT;
6405           if (fs_state != FULLSCREEN_BOTH)
6406             [[self window] performZoom:self];
6407           break;
6408         case FULLSCREEN_MAXIMIZED:
6409           next_maximized = FULLSCREEN_MAXIMIZED;
6410           if (fs_state != FULLSCREEN_BOTH)
6411             [[self window] performZoom:self];
6412           break;
6413         case FULLSCREEN_NONE:
6414           if (fs_state != FULLSCREEN_BOTH)
6415             {
6416               next_maximized = FULLSCREEN_NONE;
6417               [[self window] performZoom:self];
6418             }
6419           break;
6420         }
6421
6422       emacsframe->want_fullscreen = FULLSCREEN_NONE;
6423     }
6424
6425 }
6426
6427 - (void) setFSValue: (int)value
6428 {
6429   Lisp_Object lval = Qnil;
6430   switch (value)
6431     {
6432     case FULLSCREEN_BOTH:
6433       lval = Qfullboth;
6434       break;
6435     case FULLSCREEN_WIDTH:
6436       lval = Qfullwidth;
6437       break;
6438     case FULLSCREEN_HEIGHT:
6439       lval = Qfullheight;
6440       break;
6441     case FULLSCREEN_MAXIMIZED:
6442       lval = Qmaximized;
6443       break;
6444     }
6445   store_frame_param (emacsframe, Qfullscreen, lval);
6446   fs_state = value;
6447 }
6448
6449 - (void)mouseEntered: (NSEvent *)theEvent
6450 {
6451   NSTRACE (mouseEntered);
6452   if (emacsframe)
6453     FRAME_DISPLAY_INFO (emacsframe)->last_mouse_movement_time
6454       = EV_TIMESTAMP (theEvent);
6455 }
6456
6457
6458 - (void)mouseExited: (NSEvent *)theEvent
6459 {
6460   Mouse_HLInfo *hlinfo = emacsframe ? MOUSE_HL_INFO (emacsframe) : NULL;
6461
6462   NSTRACE (mouseExited);
6463
6464   if (!hlinfo)
6465     return;
6466
6467   FRAME_DISPLAY_INFO (emacsframe)->last_mouse_movement_time
6468     = EV_TIMESTAMP (theEvent);
6469
6470   if (emacsframe == hlinfo->mouse_face_mouse_frame)
6471     {
6472       clear_mouse_face (hlinfo);
6473       hlinfo->mouse_face_mouse_frame = 0;
6474     }
6475 }
6476
6477
6478 - menuDown: sender
6479 {
6480   NSTRACE (menuDown);
6481   if (context_menu_value == -1)
6482     context_menu_value = [sender tag];
6483   else
6484     {
6485       NSInteger tag = [sender tag];
6486       find_and_call_menu_selection (emacsframe, emacsframe->menu_bar_items_used,
6487                                     emacsframe->menu_bar_vector,
6488                                     (void *)tag);
6489     }
6490
6491   ns_send_appdefined (-1);
6492   return self;
6493 }
6494
6495
6496 - (EmacsToolbar *)toolbar
6497 {
6498   return toolbar;
6499 }
6500
6501
6502 /* this gets called on toolbar button click */
6503 - toolbarClicked: (id)item
6504 {
6505   NSEvent *theEvent;
6506   int idx = [item tag] * TOOL_BAR_ITEM_NSLOTS;
6507
6508   NSTRACE (toolbarClicked);
6509
6510   if (!emacs_event)
6511     return self;
6512
6513   /* send first event (for some reason two needed) */
6514   theEvent = [[self window] currentEvent];
6515   emacs_event->kind = TOOL_BAR_EVENT;
6516   XSETFRAME (emacs_event->arg, emacsframe);
6517   EV_TRAILER (theEvent);
6518
6519   emacs_event->kind = TOOL_BAR_EVENT;
6520 /*   XSETINT (emacs_event->code, 0); */
6521   emacs_event->arg = AREF (emacsframe->tool_bar_items,
6522                            idx + TOOL_BAR_ITEM_KEY);
6523   emacs_event->modifiers = EV_MODIFIERS (theEvent);
6524   EV_TRAILER (theEvent);
6525   return self;
6526 }
6527
6528
6529 - toggleToolbar: (id)sender
6530 {
6531   if (!emacs_event)
6532     return self;
6533
6534   emacs_event->kind = NS_NONKEY_EVENT;
6535   emacs_event->code = KEY_NS_TOGGLE_TOOLBAR;
6536   EV_TRAILER ((id)nil);
6537   return self;
6538 }
6539
6540
6541 - (void)drawRect: (NSRect)rect
6542 {
6543   int x = NSMinX (rect), y = NSMinY (rect);
6544   int width = NSWidth (rect), height = NSHeight (rect);
6545
6546   NSTRACE (drawRect);
6547
6548   if (!emacsframe || !emacsframe->output_data.ns)
6549     return;
6550
6551   ns_clear_frame_area (emacsframe, x, y, width, height);
6552   expose_frame (emacsframe, x, y, width, height);
6553
6554   /*
6555     drawRect: may be called (at least in OS X 10.5) for invisible
6556     views as well for some reason.  Thus, do not infer visibility
6557     here.
6558
6559     emacsframe->async_visible = 1;
6560     emacsframe->async_iconified = 0;
6561   */
6562 }
6563
6564
6565 /* NSDraggingDestination protocol methods.  Actually this is not really a
6566    protocol, but a category of Object.  O well...  */
6567
6568 -(NSUInteger) draggingEntered: (id <NSDraggingInfo>) sender
6569 {
6570   NSTRACE (draggingEntered);
6571   return NSDragOperationGeneric;
6572 }
6573
6574
6575 -(BOOL)prepareForDragOperation: (id <NSDraggingInfo>) sender
6576 {
6577   return YES;
6578 }
6579
6580
6581 -(BOOL)performDragOperation: (id <NSDraggingInfo>) sender
6582 {
6583   id pb;
6584   int x, y;
6585   NSString *type;
6586   NSEvent *theEvent = [[self window] currentEvent];
6587   NSPoint position;
6588
6589   NSTRACE (performDragOperation);
6590
6591   if (!emacs_event)
6592     return NO;
6593
6594   position = [self convertPoint: [sender draggingLocation] fromView: nil];
6595   x = lrint (position.x);  y = lrint (position.y);
6596
6597   pb = [sender draggingPasteboard];
6598   type = [pb availableTypeFromArray: ns_drag_types];
6599   if (type == 0)
6600     {
6601       return NO;
6602     }
6603   else if ([type isEqualToString: NSFilenamesPboardType])
6604     {
6605       NSArray *files;
6606       NSEnumerator *fenum;
6607       NSString *file;
6608
6609       if (!(files = [pb propertyListForType: type]))
6610         return NO;
6611
6612       fenum = [files objectEnumerator];
6613       while ( (file = [fenum nextObject]) )
6614         {
6615           emacs_event->kind = NS_NONKEY_EVENT;
6616           emacs_event->code = KEY_NS_DRAG_FILE;
6617           XSETINT (emacs_event->x, x);
6618           XSETINT (emacs_event->y, y);
6619           ns_input_file = append2 (ns_input_file,
6620                                    build_string ([file UTF8String]));
6621           emacs_event->modifiers = EV_MODIFIERS (theEvent);
6622           EV_TRAILER (theEvent);
6623         }
6624       return YES;
6625     }
6626   else if ([type isEqualToString: NSURLPboardType])
6627     {
6628       NSString *file;
6629       NSURL *fileURL;
6630
6631       if (!(fileURL = [NSURL URLFromPasteboard: pb]) ||
6632           [fileURL isFileURL] == NO)
6633         return NO;
6634
6635       file = [fileURL path];
6636       emacs_event->kind = NS_NONKEY_EVENT;
6637       emacs_event->code = KEY_NS_DRAG_FILE;
6638       XSETINT (emacs_event->x, x);
6639       XSETINT (emacs_event->y, y);
6640       ns_input_file = append2 (ns_input_file, build_string ([file UTF8String]));
6641       emacs_event->modifiers = EV_MODIFIERS (theEvent);
6642       EV_TRAILER (theEvent);
6643       return YES;
6644     }
6645   else if ([type isEqualToString: NSStringPboardType]
6646            || [type isEqualToString: NSTabularTextPboardType])
6647     {
6648       NSString *data;
6649
6650       if (! (data = [pb stringForType: type]))
6651         return NO;
6652
6653       emacs_event->kind = NS_NONKEY_EVENT;
6654       emacs_event->code = KEY_NS_DRAG_TEXT;
6655       XSETINT (emacs_event->x, x);
6656       XSETINT (emacs_event->y, y);
6657       ns_input_text = build_string ([data UTF8String]);
6658       emacs_event->modifiers = EV_MODIFIERS (theEvent);
6659       EV_TRAILER (theEvent);
6660       return YES;
6661     }
6662   else if ([type isEqualToString: NSColorPboardType])
6663     {
6664       NSColor *c = [NSColor colorFromPasteboard: pb];
6665       emacs_event->kind = NS_NONKEY_EVENT;
6666       emacs_event->code = KEY_NS_DRAG_COLOR;
6667       XSETINT (emacs_event->x, x);
6668       XSETINT (emacs_event->y, y);
6669       ns_input_color = ns_color_to_lisp (c);
6670       emacs_event->modifiers = EV_MODIFIERS (theEvent);
6671       EV_TRAILER (theEvent);
6672       return YES;
6673     }
6674   else if ([type isEqualToString: NSFontPboardType])
6675     {
6676       /* impl based on GNUstep NSTextView.m */
6677       NSData *data = [pb dataForType: NSFontPboardType];
6678       NSDictionary *dict = [NSUnarchiver unarchiveObjectWithData: data];
6679       NSFont *font = [dict objectForKey: NSFontAttributeName];
6680       char fontSize[10];
6681
6682       if (font == nil)
6683         return NO;
6684
6685       emacs_event->kind = NS_NONKEY_EVENT;
6686       emacs_event->code = KEY_NS_CHANGE_FONT;
6687       XSETINT (emacs_event->x, x);
6688       XSETINT (emacs_event->y, y);
6689       ns_input_font = build_string ([[font fontName] UTF8String]);
6690       snprintf (fontSize, 10, "%f", [font pointSize]);
6691       ns_input_fontsize = build_string (fontSize);
6692       emacs_event->modifiers = EV_MODIFIERS (theEvent);
6693       EV_TRAILER (theEvent);
6694       return YES;
6695     }
6696   else
6697     {
6698       error ("Invalid data type in dragging pasteboard.");
6699       return NO;
6700     }
6701 }
6702
6703
6704 - (id) validRequestorForSendType: (NSString *)typeSent
6705                       returnType: (NSString *)typeReturned
6706 {
6707   NSTRACE (validRequestorForSendType);
6708   if (typeSent != nil && [ns_send_types indexOfObject: typeSent] != NSNotFound
6709       && typeReturned == nil)
6710     {
6711       if (! NILP (ns_get_local_selection (QPRIMARY, QUTF8_STRING)))
6712         return self;
6713     }
6714
6715   return [super validRequestorForSendType: typeSent
6716                                returnType: typeReturned];
6717 }
6718
6719
6720 /* The next two methods are part of NSServicesRequests informal protocol,
6721    supposedly called when a services menu item is chosen from this app.
6722    But this should not happen because we override the services menu with our
6723    own entries which call ns-perform-service.
6724    Nonetheless, it appeared to happen (under strange circumstances): bug#1435.
6725    So let's at least stub them out until further investigation can be done. */
6726
6727 - (BOOL) readSelectionFromPasteboard: (NSPasteboard *)pb
6728 {
6729   /* we could call ns_string_from_pasteboard(pboard) here but then it should
6730      be written into the buffer in place of the existing selection..
6731      ordinary service calls go through functions defined in ns-win.el */
6732   return NO;
6733 }
6734
6735 - (BOOL) writeSelectionToPasteboard: (NSPasteboard *)pb types: (NSArray *)types
6736 {
6737   NSArray *typesDeclared;
6738   Lisp_Object val;
6739
6740   /* We only support NSStringPboardType */
6741   if ([types containsObject:NSStringPboardType] == NO) {
6742     return NO;
6743   }
6744
6745   val = ns_get_local_selection (QPRIMARY, QUTF8_STRING);
6746   if (CONSP (val) && SYMBOLP (XCAR (val)))
6747     {
6748       val = XCDR (val);
6749       if (CONSP (val) && NILP (XCDR (val)))
6750         val = XCAR (val);
6751     }
6752   if (! STRINGP (val))
6753     return NO;
6754
6755   typesDeclared = [NSArray arrayWithObject:NSStringPboardType];
6756   [pb declareTypes:typesDeclared owner:nil];
6757   ns_string_to_pasteboard (pb, val);
6758   return YES;
6759 }
6760
6761
6762 /* setMini =YES means set from internal (gives a finder icon), NO means set nil
6763    (gives a miniaturized version of the window); currently we use the latter for
6764    frames whose active buffer doesn't correspond to any file
6765    (e.g., '*scratch*') */
6766 - setMiniwindowImage: (BOOL) setMini
6767 {
6768   id image = [[self window] miniwindowImage];
6769   NSTRACE (setMiniwindowImage);
6770
6771   /* NOTE: under Cocoa miniwindowImage always returns nil, documentation
6772      about "AppleDockIconEnabled" notwithstanding, however the set message
6773      below has its effect nonetheless. */
6774   if (image != emacsframe->output_data.ns->miniimage)
6775     {
6776       if (image && [image isKindOfClass: [EmacsImage class]])
6777         [image release];
6778       [[self window] setMiniwindowImage:
6779                        setMini ? emacsframe->output_data.ns->miniimage : nil];
6780     }
6781
6782   return self;
6783 }
6784
6785
6786 - (void) setRows: (int) r andColumns: (int) c
6787 {
6788   rows = r;
6789   cols = c;
6790 }
6791
6792 @end  /* EmacsView */
6793
6794
6795
6796 /* ==========================================================================
6797
6798     EmacsWindow implementation
6799
6800    ========================================================================== */
6801
6802 @implementation EmacsWindow
6803
6804 #ifdef NS_IMPL_COCOA
6805 - (id)accessibilityAttributeValue:(NSString *)attribute
6806 {
6807   Lisp_Object str = Qnil;
6808   struct frame *f = SELECTED_FRAME ();
6809   struct buffer *curbuf = XBUFFER (XWINDOW (f->selected_window)->contents);
6810
6811   if ([attribute isEqualToString:NSAccessibilityRoleAttribute])
6812     return NSAccessibilityTextFieldRole;
6813
6814   if ([attribute isEqualToString:NSAccessibilitySelectedTextAttribute]
6815       && curbuf && ! NILP (BVAR (curbuf, mark_active)))
6816     {
6817       str = ns_get_local_selection (QPRIMARY, QUTF8_STRING);
6818     }
6819   else if (curbuf && [attribute isEqualToString:NSAccessibilityValueAttribute])
6820     {
6821       if (! NILP (BVAR (curbuf, mark_active)))
6822           str = ns_get_local_selection (QPRIMARY, QUTF8_STRING);
6823
6824       if (NILP (str))
6825         {
6826           ptrdiff_t start_byte = BUF_BEGV_BYTE (curbuf);
6827           ptrdiff_t byte_range = BUF_ZV_BYTE (curbuf) - start_byte;
6828           ptrdiff_t range = BUF_ZV (curbuf) - BUF_BEGV (curbuf);
6829
6830           if (! NILP (BVAR (curbuf, enable_multibyte_characters)))
6831             str = make_uninit_multibyte_string (range, byte_range);
6832           else
6833             str = make_uninit_string (range);
6834           /* To check: This returns emacs-utf-8, which is a superset of utf-8.
6835              Is this a problem?  */
6836           memcpy (SDATA (str), BYTE_POS_ADDR (start_byte), byte_range);
6837         }
6838     }
6839
6840
6841   if (! NILP (str))
6842     {
6843       if (CONSP (str) && SYMBOLP (XCAR (str)))
6844         {
6845           str = XCDR (str);
6846           if (CONSP (str) && NILP (XCDR (str)))
6847             str = XCAR (str);
6848         }
6849       if (STRINGP (str))
6850         {
6851           const char *utfStr = SSDATA (str);
6852           NSString *nsStr = [NSString stringWithUTF8String: utfStr];
6853           return nsStr;
6854         }
6855     }
6856
6857   return [super accessibilityAttributeValue:attribute];
6858 }
6859 #endif /* NS_IMPL_COCOA */
6860
6861 /* If we have multiple monitors, one above the other, we don't want to
6862    restrict the height to just one monitor.  So we override this.  */
6863 - (NSRect)constrainFrameRect:(NSRect)frameRect toScreen:(NSScreen *)screen
6864 {
6865   /* When making the frame visible for the first time or if there is just
6866      one screen, we want to constrain.  Other times not.  */
6867   NSUInteger nr_screens = [[NSScreen screens] count];
6868   struct frame *f = ((EmacsView *)[self delegate])->emacsframe;
6869   NSTRACE (constrainFrameRect);
6870
6871   if (nr_screens == 1)
6872     {
6873       NSRect r = [super constrainFrameRect:frameRect toScreen:screen];
6874       return r;
6875     }
6876
6877   if (f->output_data.ns->dont_constrain
6878       || ns_menu_bar_should_be_hidden ())
6879     return frameRect;
6880
6881   f->output_data.ns->dont_constrain = 1;
6882   return [super constrainFrameRect:frameRect toScreen:screen];
6883 }
6884
6885 @end /* EmacsWindow */
6886
6887
6888 @implementation EmacsFSWindow
6889
6890 - (BOOL)canBecomeKeyWindow
6891 {
6892   return YES;
6893 }
6894
6895 - (BOOL)canBecomeMainWindow
6896 {
6897   return YES;
6898 }
6899
6900 @end
6901
6902 /* ==========================================================================
6903
6904     EmacsScroller implementation
6905
6906    ========================================================================== */
6907
6908
6909 @implementation EmacsScroller
6910
6911 /* for repeat button push */
6912 #define SCROLL_BAR_FIRST_DELAY 0.5
6913 #define SCROLL_BAR_CONTINUOUS_DELAY (1.0 / 15)
6914
6915 + (CGFloat) scrollerWidth
6916 {
6917   /* TODO: if we want to allow variable widths, this is the place to do it,
6918            however neither GNUstep nor Cocoa support it very well */
6919   return [NSScroller scrollerWidth];
6920 }
6921
6922
6923 - initFrame: (NSRect )r window: (Lisp_Object)nwin
6924 {
6925   NSTRACE (EmacsScroller_initFrame);
6926
6927   r.size.width = [EmacsScroller scrollerWidth];
6928   [super initWithFrame: r/*NSMakeRect (0, 0, 0, 0)*/];
6929   [self setContinuous: YES];
6930   [self setEnabled: YES];
6931
6932   /* Ensure auto resizing of scrollbars occurs within the emacs frame's view
6933      locked against the top and bottom edges, and right edge on OS X, where
6934      scrollers are on right. */
6935 #ifdef NS_IMPL_GNUSTEP
6936   [self setAutoresizingMask: NSViewMaxXMargin | NSViewHeightSizable];
6937 #else
6938   [self setAutoresizingMask: NSViewMinXMargin | NSViewHeightSizable];
6939 #endif
6940
6941   win = nwin;
6942   condemned = NO;
6943   pixel_height = NSHeight (r);
6944   if (pixel_height == 0) pixel_height = 1;
6945   min_portion = 20 / pixel_height;
6946
6947   frame = XFRAME (XWINDOW (win)->frame);
6948   if (FRAME_LIVE_P (frame))
6949     {
6950       int i;
6951       EmacsView *view = FRAME_NS_VIEW (frame);
6952       NSView *sview = [[view window] contentView];
6953       NSArray *subs = [sview subviews];
6954
6955       /* disable optimization stopping redraw of other scrollbars */
6956       view->scrollbarsNeedingUpdate = 0;
6957       for (i =[subs count]-1; i >= 0; i--)
6958         if ([[subs objectAtIndex: i] isKindOfClass: [EmacsScroller class]])
6959           view->scrollbarsNeedingUpdate++;
6960       [sview addSubview: self];
6961     }
6962
6963 /*  [self setFrame: r]; */
6964
6965   return self;
6966 }
6967
6968
6969 - (void)setFrame: (NSRect)newRect
6970 {
6971   NSTRACE (EmacsScroller_setFrame);
6972 /*  block_input (); */
6973   pixel_height = NSHeight (newRect);
6974   if (pixel_height == 0) pixel_height = 1;
6975   min_portion = 20 / pixel_height;
6976   [super setFrame: newRect];
6977   [self display];
6978 /*  unblock_input (); */
6979 }
6980
6981
6982 - (void)dealloc
6983 {
6984   NSTRACE (EmacsScroller_dealloc);
6985   if (!NILP (win))
6986     wset_vertical_scroll_bar (XWINDOW (win), Qnil);
6987   [super dealloc];
6988 }
6989
6990
6991 - condemn
6992 {
6993   NSTRACE (condemn);
6994   condemned =YES;
6995   return self;
6996 }
6997
6998
6999 - reprieve
7000 {
7001   NSTRACE (reprieve);
7002   condemned =NO;
7003   return self;
7004 }
7005
7006
7007 - judge
7008 {
7009   NSTRACE (judge);
7010   if (condemned)
7011     {
7012       EmacsView *view;
7013       block_input ();
7014       /* ensure other scrollbar updates after deletion */
7015       view = (EmacsView *)FRAME_NS_VIEW (frame);
7016       if (view != nil)
7017         view->scrollbarsNeedingUpdate++;
7018       [self removeFromSuperview];
7019       [self release];
7020       unblock_input ();
7021     }
7022   return self;
7023 }
7024
7025
7026 - (void)resetCursorRects
7027 {
7028   NSRect visible = [self visibleRect];
7029   NSTRACE (resetCursorRects);
7030
7031   if (!NSIsEmptyRect (visible))
7032     [self addCursorRect: visible cursor: [NSCursor arrowCursor]];
7033   [[NSCursor arrowCursor] setOnMouseEntered: YES];
7034 }
7035
7036
7037 - (int) checkSamePosition: (int) position portion: (int) portion
7038                     whole: (int) whole
7039 {
7040   return em_position ==position && em_portion ==portion && em_whole ==whole
7041     && portion != whole; /* needed for resize empty buf */
7042 }
7043
7044
7045 - setPosition: (int)position portion: (int)portion whole: (int)whole
7046 {
7047   NSTRACE (setPosition);
7048
7049   em_position = position;
7050   em_portion = portion;
7051   em_whole = whole;
7052
7053   if (portion >= whole)
7054     {
7055 #if defined (NS_IMPL_COCOA) && MAC_OS_X_VERSION_MAX_ALLOWED > MAC_OS_X_VERSION_10_5
7056       [self setKnobProportion: 1.0];
7057       [self setDoubleValue: 1.0];
7058 #else
7059       [self setFloatValue: 0.0 knobProportion: 1.0];
7060 #endif
7061     }
7062   else
7063     {
7064       float pos;
7065       CGFloat por;
7066       portion = max ((float)whole*min_portion/pixel_height, portion);
7067       pos = (float)position / (whole - portion);
7068       por = (CGFloat)portion/whole;
7069 #if defined (NS_IMPL_COCOA) && MAC_OS_X_VERSION_MAX_ALLOWED > MAC_OS_X_VERSION_10_5
7070       [self setKnobProportion: por];
7071       [self setDoubleValue: pos];
7072 #else
7073       [self setFloatValue: pos knobProportion: por];
7074 #endif
7075     }
7076
7077   /* Events may come here even if the event loop is not running.
7078      If we don't enter the event loop, the scroll bar will not update.
7079      So send SIGIO to ourselves.  */
7080   if (apploopnr == 0) raise (SIGIO);
7081
7082   return self;
7083 }
7084
7085 /* FIXME: unused at moment (see ns_mouse_position) at the moment because
7086      drag events will go directly to the EmacsScroller.  Leaving in for now. */
7087 -(void)getMouseMotionPart: (int *)part window: (Lisp_Object *)window
7088                         x: (Lisp_Object *)x y: ( Lisp_Object *)y
7089 {
7090   *part = last_hit_part;
7091   *window = win;
7092   XSETINT (*y, pixel_height);
7093   if ([self floatValue] > 0.999F)
7094     XSETINT (*x, pixel_height);
7095   else
7096     XSETINT (*x, pixel_height * [self floatValue]);
7097 }
7098
7099
7100 /* set up emacs_event */
7101 - (void) sendScrollEventAtLoc: (float)loc fromEvent: (NSEvent *)e
7102 {
7103   if (!emacs_event)
7104     return;
7105
7106   emacs_event->part = last_hit_part;
7107   emacs_event->code = 0;
7108   emacs_event->modifiers = EV_MODIFIERS (e) | down_modifier;
7109   emacs_event->frame_or_window = win;
7110   emacs_event->timestamp = EV_TIMESTAMP (e);
7111   emacs_event->kind = SCROLL_BAR_CLICK_EVENT;
7112   emacs_event->arg = Qnil;
7113   XSETINT (emacs_event->x, loc * pixel_height);
7114   XSETINT (emacs_event->y, pixel_height-20);
7115
7116   if (q_event_ptr)
7117     {
7118       n_emacs_events_pending++;
7119       kbd_buffer_store_event_hold (emacs_event, q_event_ptr);
7120     }
7121   else
7122     hold_event (emacs_event);
7123   EVENT_INIT (*emacs_event);
7124   ns_send_appdefined (-1);
7125 }
7126
7127
7128 /* called manually thru timer to implement repeated button action w/hold-down */
7129 - repeatScroll: (NSTimer *)scrollEntry
7130 {
7131   NSEvent *e = [[self window] currentEvent];
7132   NSPoint p =  [[self window] mouseLocationOutsideOfEventStream];
7133   BOOL inKnob = [self testPart: p] == NSScrollerKnob;
7134
7135   /* clear timer if need be */
7136   if (inKnob || [scroll_repeat_entry timeInterval] == SCROLL_BAR_FIRST_DELAY)
7137     {
7138         [scroll_repeat_entry invalidate];
7139         [scroll_repeat_entry release];
7140         scroll_repeat_entry = nil;
7141
7142         if (inKnob)
7143           return self;
7144
7145         scroll_repeat_entry
7146           = [[NSTimer scheduledTimerWithTimeInterval:
7147                         SCROLL_BAR_CONTINUOUS_DELAY
7148                                             target: self
7149                                           selector: @selector (repeatScroll:)
7150                                           userInfo: 0
7151                                            repeats: YES]
7152               retain];
7153     }
7154
7155   [self sendScrollEventAtLoc: 0 fromEvent: e];
7156   return self;
7157 }
7158
7159
7160 /* Asynchronous mouse tracking for scroller.  This allows us to dispatch
7161    mouseDragged events without going into a modal loop. */
7162 - (void)mouseDown: (NSEvent *)e
7163 {
7164   NSRect sr, kr;
7165   /* hitPart is only updated AFTER event is passed on */
7166   NSScrollerPart part = [self testPart: [e locationInWindow]];
7167   CGFloat inc = 0.0, loc, kloc, pos;
7168   int edge = 0;
7169
7170   NSTRACE (EmacsScroller_mouseDown);
7171
7172   switch (part)
7173     {
7174     case NSScrollerDecrementPage:
7175         last_hit_part = scroll_bar_above_handle; inc = -1.0; break;
7176     case NSScrollerIncrementPage:
7177         last_hit_part = scroll_bar_below_handle; inc = 1.0; break;
7178     case NSScrollerDecrementLine:
7179       last_hit_part = scroll_bar_up_arrow; inc = -0.1; break;
7180     case NSScrollerIncrementLine:
7181       last_hit_part = scroll_bar_down_arrow; inc = 0.1; break;
7182     case NSScrollerKnob:
7183       last_hit_part = scroll_bar_handle; break;
7184     case NSScrollerKnobSlot:  /* GNUstep-only */
7185       last_hit_part = scroll_bar_move_ratio; break;
7186     default:  /* NSScrollerNoPart? */
7187       fprintf (stderr, "EmacsScoller-mouseDown: unexpected part %ld\n",
7188                (long) part);
7189       return;
7190     }
7191
7192   if (inc != 0.0)
7193     {
7194       pos = 0;      /* ignored */
7195
7196       /* set a timer to repeat, as we can't let superclass do this modally */
7197       scroll_repeat_entry
7198         = [[NSTimer scheduledTimerWithTimeInterval: SCROLL_BAR_FIRST_DELAY
7199                                             target: self
7200                                           selector: @selector (repeatScroll:)
7201                                           userInfo: 0
7202                                            repeats: YES]
7203             retain];
7204     }
7205   else
7206     {
7207       /* handle, or on GNUstep possibly slot */
7208       NSEvent *fake_event;
7209
7210       /* compute float loc in slot and mouse offset on knob */
7211       sr = [self convertRect: [self rectForPart: NSScrollerKnobSlot]
7212                       toView: nil];
7213       loc = NSHeight (sr) - ([e locationInWindow].y - NSMinY (sr));
7214       if (loc <= 0.0)
7215         {
7216           loc = 0.0;
7217           edge = -1;
7218         }
7219       else if (loc >= NSHeight (sr))
7220         {
7221           loc = NSHeight (sr);
7222           edge = 1;
7223         }
7224
7225       if (edge)
7226         kloc = 0.5 * edge;
7227       else
7228         {
7229           kr = [self convertRect: [self rectForPart: NSScrollerKnob]
7230                           toView: nil];
7231           kloc = NSHeight (kr) - ([e locationInWindow].y - NSMinY (kr));
7232         }
7233       last_mouse_offset = kloc;
7234
7235       /* if knob, tell emacs a location offset by knob pos
7236          (to indicate top of handle) */
7237       if (part == NSScrollerKnob)
7238           pos = (loc - last_mouse_offset) / NSHeight (sr);
7239       else
7240         /* else this is a slot click on GNUstep: go straight there */
7241         pos = loc / NSHeight (sr);
7242
7243       /* send a fake mouse-up to super to preempt modal -trackKnob: mode */
7244       fake_event = [NSEvent mouseEventWithType: NSLeftMouseUp
7245                                       location: [e locationInWindow]
7246                                  modifierFlags: [e modifierFlags]
7247                                      timestamp: [e timestamp]
7248                                   windowNumber: [e windowNumber]
7249                                        context: [e context]
7250                                    eventNumber: [e eventNumber]
7251                                     clickCount: [e clickCount]
7252                                       pressure: [e pressure]];
7253       [super mouseUp: fake_event];
7254     }
7255
7256   if (part != NSScrollerKnob)
7257     [self sendScrollEventAtLoc: pos fromEvent: e];
7258 }
7259
7260
7261 /* Called as we manually track scroller drags, rather than superclass. */
7262 - (void)mouseDragged: (NSEvent *)e
7263 {
7264     NSRect sr;
7265     double loc, pos;
7266
7267     NSTRACE (EmacsScroller_mouseDragged);
7268
7269       sr = [self convertRect: [self rectForPart: NSScrollerKnobSlot]
7270                       toView: nil];
7271       loc = NSHeight (sr) - ([e locationInWindow].y - NSMinY (sr));
7272
7273       if (loc <= 0.0)
7274         {
7275           loc = 0.0;
7276         }
7277       else if (loc >= NSHeight (sr) + last_mouse_offset)
7278         {
7279           loc = NSHeight (sr) + last_mouse_offset;
7280         }
7281
7282       pos = (loc - last_mouse_offset) / NSHeight (sr);
7283       [self sendScrollEventAtLoc: pos fromEvent: e];
7284 }
7285
7286
7287 - (void)mouseUp: (NSEvent *)e
7288 {
7289   if (scroll_repeat_entry)
7290     {
7291       [scroll_repeat_entry invalidate];
7292       [scroll_repeat_entry release];
7293       scroll_repeat_entry = nil;
7294     }
7295   last_hit_part = 0;
7296 }
7297
7298
7299 /* treat scrollwheel events in the bar as though they were in the main window */
7300 - (void) scrollWheel: (NSEvent *)theEvent
7301 {
7302   EmacsView *view = (EmacsView *)FRAME_NS_VIEW (frame);
7303   [view mouseDown: theEvent];
7304 }
7305
7306 @end  /* EmacsScroller */
7307
7308
7309 #ifdef NS_IMPL_GNUSTEP
7310 /* Dummy class to get rid of startup warnings.  */
7311 @implementation EmacsDocument
7312
7313 @end
7314 #endif
7315
7316
7317 /* ==========================================================================
7318
7319    Font-related functions; these used to be in nsfaces.m
7320
7321    ========================================================================== */
7322
7323
7324 Lisp_Object
7325 x_new_font (struct frame *f, Lisp_Object font_object, int fontset)
7326 {
7327   struct font *font = XFONT_OBJECT (font_object);
7328
7329   if (fontset < 0)
7330     fontset = fontset_from_font (font_object);
7331   FRAME_FONTSET (f) = fontset;
7332
7333   if (FRAME_FONT (f) == font)
7334     /* This font is already set in frame F.  There's nothing more to
7335        do.  */
7336     return font_object;
7337
7338   FRAME_FONT (f) = font;
7339
7340   FRAME_BASELINE_OFFSET (f) = font->baseline_offset;
7341   FRAME_COLUMN_WIDTH (f) = font->average_width;
7342   FRAME_LINE_HEIGHT (f) = font->height;
7343
7344   compute_fringe_widths (f, 1);
7345
7346   /* Compute the scroll bar width in character columns.  */
7347   if (FRAME_CONFIG_SCROLL_BAR_WIDTH (f) > 0)
7348     {
7349       int wid = FRAME_COLUMN_WIDTH (f);
7350       FRAME_CONFIG_SCROLL_BAR_COLS (f)
7351         = (FRAME_CONFIG_SCROLL_BAR_WIDTH (f) + wid - 1) / wid;
7352     }
7353   else
7354     {
7355       int wid = FRAME_COLUMN_WIDTH (f);
7356       FRAME_CONFIG_SCROLL_BAR_COLS (f) = (14 + wid - 1) / wid;
7357     }
7358
7359   /* Now make the frame display the given font.  */
7360   if (FRAME_NS_WINDOW (f) != 0)
7361     x_set_window_size (f, 0, FRAME_COLS (f), FRAME_LINES (f), 0);
7362
7363   return font_object;
7364 }
7365
7366
7367 /* XLFD: -foundry-family-weight-slant-swidth-adstyle-pxlsz-ptSz-resx-resy-spc-avgWidth-rgstry-encoding */
7368 /* Note: ns_font_to_xlfd and ns_fontname_to_xlfd no longer needed, removed
7369          in 1.43. */
7370
7371 const char *
7372 ns_xlfd_to_fontname (const char *xlfd)
7373 /* --------------------------------------------------------------------------
7374     Convert an X font name (XLFD) to an NS font name.
7375     Only family is used.
7376     The string returned is temporarily allocated.
7377    -------------------------------------------------------------------------- */
7378 {
7379   char *name = xmalloc (180);
7380   int i, len;
7381   const char *ret;
7382
7383   if (!strncmp (xlfd, "--", 2))
7384     sscanf (xlfd, "--%*[^-]-%[^-]179-", name);
7385   else
7386     sscanf (xlfd, "-%*[^-]-%[^-]179-", name);
7387
7388   /* stopgap for malformed XLFD input */
7389   if (strlen (name) == 0)
7390     strcpy (name, "Monaco");
7391
7392   /* undo hack in ns_fontname_to_xlfd, converting '$' to '-', '_' to ' '
7393      also uppercase after '-' or ' ' */
7394   name[0] = c_toupper (name[0]);
7395   for (len =strlen (name), i =0; i<len; i++)
7396     {
7397       if (name[i] == '$')
7398         {
7399           name[i] = '-';
7400           if (i+1<len)
7401             name[i+1] = c_toupper (name[i+1]);
7402         }
7403       else if (name[i] == '_')
7404         {
7405           name[i] = ' ';
7406           if (i+1<len)
7407             name[i+1] = c_toupper (name[i+1]);
7408         }
7409     }
7410 /*fprintf (stderr, "converted '%s' to '%s'\n",xlfd,name);  */
7411   ret = [[NSString stringWithUTF8String: name] UTF8String];
7412   xfree (name);
7413   return ret;
7414 }
7415
7416
7417 void
7418 syms_of_nsterm (void)
7419 {
7420   NSTRACE (syms_of_nsterm);
7421
7422   ns_antialias_threshold = 10.0;
7423
7424   /* from 23+ we need to tell emacs what modifiers there are.. */
7425   DEFSYM (Qmodifier_value, "modifier-value");
7426   DEFSYM (Qalt, "alt");
7427   DEFSYM (Qhyper, "hyper");
7428   DEFSYM (Qmeta, "meta");
7429   DEFSYM (Qsuper, "super");
7430   DEFSYM (Qcontrol, "control");
7431   DEFSYM (QUTF8_STRING, "UTF8_STRING");
7432
7433   Fput (Qalt, Qmodifier_value, make_number (alt_modifier));
7434   Fput (Qhyper, Qmodifier_value, make_number (hyper_modifier));
7435   Fput (Qmeta, Qmodifier_value, make_number (meta_modifier));
7436   Fput (Qsuper, Qmodifier_value, make_number (super_modifier));
7437   Fput (Qcontrol, Qmodifier_value, make_number (ctrl_modifier));
7438
7439   DEFVAR_LISP ("ns-input-file", ns_input_file,
7440               "The file specified in the last NS event.");
7441   ns_input_file =Qnil;
7442
7443   DEFVAR_LISP ("ns-input-text", ns_input_text,
7444               "The data received in the last NS text drag event.");
7445   ns_input_text =Qnil;
7446
7447   DEFVAR_LISP ("ns-working-text", ns_working_text,
7448               "String for visualizing working composition sequence.");
7449   ns_working_text =Qnil;
7450
7451   DEFVAR_LISP ("ns-input-font", ns_input_font,
7452               "The font specified in the last NS event.");
7453   ns_input_font =Qnil;
7454
7455   DEFVAR_LISP ("ns-input-fontsize", ns_input_fontsize,
7456               "The fontsize specified in the last NS event.");
7457   ns_input_fontsize =Qnil;
7458
7459   DEFVAR_LISP ("ns-input-line", ns_input_line,
7460                "The line specified in the last NS event.");
7461   ns_input_line =Qnil;
7462
7463   DEFVAR_LISP ("ns-input-color", ns_input_color,
7464                "The color specified in the last NS event.");
7465   ns_input_color =Qnil;
7466
7467   DEFVAR_LISP ("ns-input-spi-name", ns_input_spi_name,
7468                "The service name specified in the last NS event.");
7469   ns_input_spi_name =Qnil;
7470
7471   DEFVAR_LISP ("ns-input-spi-arg", ns_input_spi_arg,
7472                "The service argument specified in the last NS event.");
7473   ns_input_spi_arg =Qnil;
7474
7475   DEFVAR_LISP ("ns-alternate-modifier", ns_alternate_modifier,
7476                "This variable describes the behavior of the alternate or option key.\n\
7477 Set to control, meta, alt, super, or hyper means it is taken to be that key.\n\
7478 Set to none means that the alternate / option key is not interpreted by Emacs\n\
7479 at all, allowing it to be used at a lower level for accented character entry.");
7480   ns_alternate_modifier = Qmeta;
7481
7482   DEFVAR_LISP ("ns-right-alternate-modifier", ns_right_alternate_modifier,
7483                "This variable describes the behavior of the right alternate or option key.\n\
7484 Set to control, meta, alt, super, or hyper means it is taken to be that key.\n\
7485 Set to left means be the same key as `ns-alternate-modifier'.\n\
7486 Set to none means that the alternate / option key is not interpreted by Emacs\n\
7487 at all, allowing it to be used at a lower level for accented character entry.");
7488   ns_right_alternate_modifier = Qleft;
7489
7490   DEFVAR_LISP ("ns-command-modifier", ns_command_modifier,
7491                "This variable describes the behavior of the command key.\n\
7492 Set to control, meta, alt, super, or hyper means it is taken to be that key.");
7493   ns_command_modifier = Qsuper;
7494
7495   DEFVAR_LISP ("ns-right-command-modifier", ns_right_command_modifier,
7496                "This variable describes the behavior of the right command key.\n\
7497 Set to control, meta, alt, super, or hyper means it is taken to be that key.\n\
7498 Set to left means be the same key as `ns-command-modifier'.\n\
7499 Set to none means that the command / option key is not interpreted by Emacs\n\
7500 at all, allowing it to be used at a lower level for accented character entry.");
7501   ns_right_command_modifier = Qleft;
7502
7503   DEFVAR_LISP ("ns-control-modifier", ns_control_modifier,
7504                "This variable describes the behavior of the control key.\n\
7505 Set to control, meta, alt, super, or hyper means it is taken to be that key.");
7506   ns_control_modifier = Qcontrol;
7507
7508   DEFVAR_LISP ("ns-right-control-modifier", ns_right_control_modifier,
7509                "This variable describes the behavior of the right control key.\n\
7510 Set to control, meta, alt, super, or hyper means it is taken to be that key.\n\
7511 Set to left means be the same key as `ns-control-modifier'.\n\
7512 Set to none means that the control / option key is not interpreted by Emacs\n\
7513 at all, allowing it to be used at a lower level for accented character entry.");
7514   ns_right_control_modifier = Qleft;
7515
7516   DEFVAR_LISP ("ns-function-modifier", ns_function_modifier,
7517                "This variable describes the behavior of the function key (on laptops).\n\
7518 Set to control, meta, alt, super, or hyper means it is taken to be that key.\n\
7519 Set to none means that the function key is not interpreted by Emacs at all,\n\
7520 allowing it to be used at a lower level for accented character entry.");
7521   ns_function_modifier = Qnone;
7522
7523   DEFVAR_LISP ("ns-antialias-text", ns_antialias_text,
7524                "Non-nil (the default) means to render text antialiased.");
7525   ns_antialias_text = Qt;
7526
7527   DEFVAR_LISP ("ns-confirm-quit", ns_confirm_quit,
7528                "Whether to confirm application quit using dialog.");
7529   ns_confirm_quit = Qnil;
7530
7531   DEFVAR_LISP ("ns-auto-hide-menu-bar", ns_auto_hide_menu_bar,
7532                doc: /* Non-nil means that the menu bar is hidden, but appears when the mouse is near.
7533 Only works on OSX 10.6 or later.  */);
7534   ns_auto_hide_menu_bar = Qnil;
7535
7536   DEFVAR_BOOL ("ns-use-native-fullscreen", ns_use_native_fullscreen,
7537      doc: /*Non-nil means to use native fullscreen on OSX >= 10.7.
7538 Nil means use fullscreen the old (< 10.7) way.  The old way works better with
7539 multiple monitors, but lacks tool bar.  This variable is ignored on OSX < 10.7.
7540 Default is t for OSX >= 10.7, nil otherwise. */);
7541 #ifdef HAVE_NATIVE_FS
7542   ns_use_native_fullscreen = YES;
7543 #else
7544   ns_use_native_fullscreen = NO;
7545 #endif
7546   ns_last_use_native_fullscreen = ns_use_native_fullscreen;
7547
7548   /* TODO: move to common code */
7549   DEFVAR_LISP ("x-toolkit-scroll-bars", Vx_toolkit_scroll_bars,
7550                doc: /* Which toolkit scroll bars Emacs uses, if any.
7551 A value of nil means Emacs doesn't use toolkit scroll bars.
7552 With the X Window system, the value is a symbol describing the
7553 X toolkit.  Possible values are: gtk, motif, xaw, or xaw3d.
7554 With MS Windows or Nextstep, the value is t.  */);
7555   Vx_toolkit_scroll_bars = Qt;
7556
7557   DEFVAR_BOOL ("x-use-underline-position-properties",
7558                x_use_underline_position_properties,
7559      doc: /*Non-nil means make use of UNDERLINE_POSITION font properties.
7560 A value of nil means ignore them.  If you encounter fonts with bogus
7561 UNDERLINE_POSITION font properties, for example 7x13 on XFree prior
7562 to 4.1, set this to nil. */);
7563   x_use_underline_position_properties = 0;
7564
7565   DEFVAR_BOOL ("x-underline-at-descent-line",
7566                x_underline_at_descent_line,
7567      doc: /* Non-nil means to draw the underline at the same place as the descent line.
7568 A value of nil means to draw the underline according to the value of the
7569 variable `x-use-underline-position-properties', which is usually at the
7570 baseline level.  The default value is nil.  */);
7571   x_underline_at_descent_line = 0;
7572
7573   /* Tell Emacs about this window system.  */
7574   Fprovide (Qns, Qnil);
7575
7576   DEFSYM (Qcocoa, "cocoa");
7577   DEFSYM (Qgnustep, "gnustep");
7578
7579   syms_of_nsfont ();
7580 #ifdef NS_IMPL_COCOA
7581   Fprovide (Qcocoa, Qnil);
7582 #if MAC_OS_X_VERSION_MAX_ALLOWED >= 1050
7583   syms_of_macfont ();
7584 #endif
7585 #else
7586   Fprovide (Qgnustep, Qnil);
7587 #endif
7588
7589 }