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