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