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