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