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