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