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