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