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