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