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