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