blob: 573dc7a116cd4abd1598734cd7d48e956559c72b [file] [log] [blame]
Bram Moolenaar071d4272004-06-13 20:20:40 +00001/* vi:set ts=8 sts=4 sw=4:
2 *
3 * VIM - Vi IMproved by Bram Moolenaar
4 * GUI/Motif support by Robert Webb
5 * Macintosh port by Dany St-Amant
6 * and Axel Kielhorn
Bram Moolenaar79ee3152007-04-26 16:20:50 +00007 * Port to MPW by Bernhard Pruemmer
Bram Moolenaar071d4272004-06-13 20:20:40 +00008 * Initial Carbon port by Ammon Skidmore
9 *
10 * Do ":help uganda" in Vim to read copying and usage conditions.
11 * Do ":help credits" in Vim to see a list of people who contributed.
12 * See README.txt for an overview of the Vim source code.
13 */
14
15/*
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +000016 * NOTES: - Vim 7+ does not support classic MacOS. Please use Vim 6.x
Bram Moolenaarc9b4b052006-04-30 18:54:39 +000017 * - Comments mentioning FAQ refer to the book:
18 * "Macworld Mac Programming FAQs" from "IDG Books"
Bram Moolenaar071d4272004-06-13 20:20:40 +000019 */
20
21/*
22 * TODO: Change still to merge from the macvim's iDisk
23 *
24 * error_ga, mch_errmsg, Navigation's changes in gui_mch_browse
25 * uses of MenuItemIndex, changes in gui_mch_set_shellsize,
26 * ScrapManager error handling.
27 * Comments about function remaining to Carbonize.
28 *
29 */
30
Bram Moolenaarbbe8c3f2007-04-26 16:40:56 +000031/* TODO (Jussi)
32 * * Clipboard does not work (at least some cases)
33 * * ATSU font rendering has some problems
34 * * Investigate and remove dead code (there is still lots of that)
35 */
Bram Moolenaar071d4272004-06-13 20:20:40 +000036
37#include <Devices.h> /* included first to avoid CR problems */
38#include "vim.h"
39
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +000040#define USE_CARBONIZED
41#define USE_AEVENT /* Enable AEVENT */
42#undef USE_OFFSETED_WINDOW /* Debugging feature: start Vim window OFFSETed */
Bram Moolenaar071d4272004-06-13 20:20:40 +000043
Bram Moolenaar84a05ac2013-05-06 04:24:17 +020044/* Compile as CodeWarrior External Editor */
Bram Moolenaar071d4272004-06-13 20:20:40 +000045#if defined(FEAT_CW_EDITOR) && !defined(USE_AEVENT)
46# define USE_AEVENT /* Need Apple Event Support */
47#endif
48
Bram Moolenaar69a7cb42004-06-20 12:51:53 +000049/* Vim's Scrap flavor. */
50#define VIMSCRAPFLAVOR 'VIM!'
Bram Moolenaarfc1421e2006-04-20 22:17:20 +000051#ifdef FEAT_MBYTE
52# define SCRAPTEXTFLAVOR kScrapFlavorTypeUnicode
53#else
54# define SCRAPTEXTFLAVOR kScrapFlavorTypeText
55#endif
Bram Moolenaar69a7cb42004-06-20 12:51:53 +000056
Bram Moolenaar071d4272004-06-13 20:20:40 +000057static EventHandlerUPP mouseWheelHandlerUPP = NULL;
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +000058SInt32 gMacSystemVersion;
Bram Moolenaar071d4272004-06-13 20:20:40 +000059
Bram Moolenaar7d47b6e2006-03-15 22:59:18 +000060#ifdef MACOS_CONVERT
61# define USE_CARBONKEYHANDLER
Bram Moolenaar1b60e502008-03-12 13:40:54 +000062
63static int im_is_active = FALSE;
64#if 0
Bram Moolenaared39e1d2008-08-09 17:55:22 +000065 /* TODO: Implement me! */
Bram Moolenaar1b60e502008-03-12 13:40:54 +000066static int im_start_row = 0;
67static int im_start_col = 0;
68#endif
69
70#define NR_ELEMS(x) (sizeof(x) / sizeof(x[0]))
71
72static TSMDocumentID gTSMDocument;
73
74static void im_on_window_switch(int active);
Bram Moolenaar26a60b42005-02-22 08:49:11 +000075static EventHandlerUPP keyEventHandlerUPP = NULL;
Bram Moolenaar1b60e502008-03-12 13:40:54 +000076static EventHandlerUPP winEventHandlerUPP = NULL;
77
78static pascal OSStatus gui_mac_handle_window_activate(
79 EventHandlerCallRef nextHandler, EventRef theEvent, void *data);
80
81static pascal OSStatus gui_mac_handle_text_input(
82 EventHandlerCallRef nextHandler, EventRef theEvent, void *data);
83
84static pascal OSStatus gui_mac_update_input_area(
85 EventHandlerCallRef nextHandler, EventRef theEvent);
86
87static pascal OSStatus gui_mac_unicode_key_event(
88 EventHandlerCallRef nextHandler, EventRef theEvent);
89
Bram Moolenaar26a60b42005-02-22 08:49:11 +000090#endif
91
Bram Moolenaar071d4272004-06-13 20:20:40 +000092
93/* Include some file. TODO: move into os_mac.h */
94#include <Menus.h>
95#include <Resources.h>
Bram Moolenaar071d4272004-06-13 20:20:40 +000096#include <Processes.h>
97#ifdef USE_AEVENT
98# include <AppleEvents.h>
99# include <AERegistry.h>
100#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +0000101# include <Gestalt.h>
Bram Moolenaar071d4272004-06-13 20:20:40 +0000102#if UNIVERSAL_INTERFACES_VERSION >= 0x0330
103# include <ControlDefinitions.h>
104# include <Navigation.h> /* Navigation only part of ?? */
105#endif
106
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +0000107/* Help Manager (balloon.h, HM prefixed functions) are not supported
108 * under Carbon (Jussi) */
109# if 0
Bram Moolenaar071d4272004-06-13 20:20:40 +0000110/* New Help Interface for Mac, not implemented yet.*/
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +0000111# include <MacHelp.h>
112# endif
Bram Moolenaar071d4272004-06-13 20:20:40 +0000113
114/*
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +0000115 * These seem to be rectangle options. Why are they not found in
116 * headers? (Jussi)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000117 */
Bram Moolenaar071d4272004-06-13 20:20:40 +0000118#define kNothing 0
119#define kCreateEmpty 2 /*1*/
120#define kCreateRect 2
121#define kDestroy 3
122
123/*
124 * Dany: Don't like those...
125 */
Bram Moolenaar071d4272004-06-13 20:20:40 +0000126#define topLeft(r) (((Point*)&(r))[0])
127#define botRight(r) (((Point*)&(r))[1])
128
129
130/* Time of last mouse click, to detect double-click */
131static long lastMouseTick = 0;
132
133/* ??? */
134static RgnHandle cursorRgn;
135static RgnHandle dragRgn;
136static Rect dragRect;
137static short dragRectEnbl;
138static short dragRectControl;
139
140/* This variable is set when waiting for an event, which is the only moment
141 * scrollbar dragging can be done directly. It's not allowed while commands
142 * are executed, because it may move the cursor and that may cause unexpected
143 * problems (e.g., while ":s" is working).
144 */
145static int allow_scrollbar = FALSE;
146
147/* Last mouse click caused contextual menu, (to provide proper release) */
Bram Moolenaar071d4272004-06-13 20:20:40 +0000148static short clickIsPopup;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000149
150/* Feedback Action for Scrollbar */
151ControlActionUPP gScrollAction;
152ControlActionUPP gScrollDrag;
153
154/* Keeping track of which scrollbar is being dragged */
155static ControlHandle dragged_sb = NULL;
156
Bram Moolenaarc52da9d2008-03-20 13:39:37 +0000157/* Vector of char_u --> control index for hotkeys in dialogs */
158static short *gDialogHotKeys;
159
Bram Moolenaar592e0a22004-07-03 16:05:59 +0000160static struct
161{
162 FMFontFamily family;
163 FMFontSize size;
164 FMFontStyle style;
165 Boolean isPanelVisible;
166} gFontPanelInfo = { 0, 0, 0, false };
Bram Moolenaar592e0a22004-07-03 16:05:59 +0000167
Bram Moolenaar7d47b6e2006-03-15 22:59:18 +0000168#ifdef MACOS_CONVERT
Bram Moolenaar26a60b42005-02-22 08:49:11 +0000169# define USE_ATSUI_DRAWING
Bram Moolenaar1b60e502008-03-12 13:40:54 +0000170int p_macatsui_last;
Bram Moolenaar26a60b42005-02-22 08:49:11 +0000171ATSUStyle gFontStyle;
Bram Moolenaar1b60e502008-03-12 13:40:54 +0000172# ifdef FEAT_MBYTE
173ATSUStyle gWideFontStyle;
174# endif
Bram Moolenaar26a60b42005-02-22 08:49:11 +0000175Boolean gIsFontFallbackSet;
Bram Moolenaar76b96fc2010-07-17 16:44:59 +0200176UInt32 useAntialias_cached = 0x0;
Bram Moolenaar26a60b42005-02-22 08:49:11 +0000177#endif
178
Bram Moolenaar071d4272004-06-13 20:20:40 +0000179/* Colors Macros */
180#define RGB(r,g,b) ((r) << 16) + ((g) << 8) + (b)
181#define Red(c) ((c & 0x00FF0000) >> 16)
182#define Green(c) ((c & 0x0000FF00) >> 8)
183#define Blue(c) ((c & 0x000000FF) >> 0)
184
185/* Key mapping */
186
187#define vk_Esc 0x35 /* -> 1B */
188
189#define vk_F1 0x7A /* -> 10 */
190#define vk_F2 0x78 /*0x63*/
191#define vk_F3 0x63 /*0x76*/
192#define vk_F4 0x76 /*0x60*/
193#define vk_F5 0x60 /*0x61*/
194#define vk_F6 0x61 /*0x62*/
195#define vk_F7 0x62 /*0x63*/ /*?*/
196#define vk_F8 0x64
197#define vk_F9 0x65
198#define vk_F10 0x6D
199#define vk_F11 0x67
200#define vk_F12 0x6F
201#define vk_F13 0x69
202#define vk_F14 0x6B
203#define vk_F15 0x71
204
205#define vk_Clr 0x47 /* -> 1B (ESC) */
206#define vk_Enter 0x4C /* -> 03 */
207
208#define vk_Space 0x31 /* -> 20 */
209#define vk_Tab 0x30 /* -> 09 */
210#define vk_Return 0x24 /* -> 0D */
211/* This is wrong for OSX, what is it for? */
212#define vk_Delete 0X08 /* -> 08 BackSpace */
213
214#define vk_Help 0x72 /* -> 05 */
215#define vk_Home 0x73 /* -> 01 */
216#define vk_PageUp 0x74 /* -> 0D */
217#define vk_FwdDelete 0x75 /* -> 7F */
218#define vk_End 0x77 /* -> 04 */
219#define vk_PageDown 0x79 /* -> 0C */
220
221#define vk_Up 0x7E /* -> 1E */
222#define vk_Down 0x7D /* -> 1F */
223#define vk_Left 0x7B /* -> 1C */
224#define vk_Right 0x7C /* -> 1D */
225
226#define vk_Undo vk_F1
227#define vk_Cut vk_F2
228#define vk_Copy vk_F3
229#define vk_Paste vk_F4
230#define vk_PrintScreen vk_F13
231#define vk_SCrollLock vk_F14
232#define vk_Pause vk_F15
233#define vk_NumLock vk_Clr
234#define vk_Insert vk_Help
235
236#define KeySym char
237
238static struct
239{
240 KeySym key_sym;
241 char_u vim_code0;
242 char_u vim_code1;
243} special_keys[] =
244{
245 {vk_Up, 'k', 'u'},
246 {vk_Down, 'k', 'd'},
247 {vk_Left, 'k', 'l'},
248 {vk_Right, 'k', 'r'},
249
250 {vk_F1, 'k', '1'},
251 {vk_F2, 'k', '2'},
252 {vk_F3, 'k', '3'},
253 {vk_F4, 'k', '4'},
254 {vk_F5, 'k', '5'},
255 {vk_F6, 'k', '6'},
256 {vk_F7, 'k', '7'},
257 {vk_F8, 'k', '8'},
258 {vk_F9, 'k', '9'},
259 {vk_F10, 'k', ';'},
260
261 {vk_F11, 'F', '1'},
262 {vk_F12, 'F', '2'},
263 {vk_F13, 'F', '3'},
264 {vk_F14, 'F', '4'},
265 {vk_F15, 'F', '5'},
266
267/* {XK_Help, '%', '1'}, */
268/* {XK_Undo, '&', '8'}, */
269/* {XK_BackSpace, 'k', 'b'}, */
270#ifndef MACOS_X
271 {vk_Delete, 'k', 'b'},
272#endif
273 {vk_Insert, 'k', 'I'},
274 {vk_FwdDelete, 'k', 'D'},
275 {vk_Home, 'k', 'h'},
276 {vk_End, '@', '7'},
277/* {XK_Prior, 'k', 'P'}, */
278/* {XK_Next, 'k', 'N'}, */
279/* {XK_Print, '%', '9'}, */
280
281 {vk_PageUp, 'k', 'P'},
282 {vk_PageDown, 'k', 'N'},
283
284 /* End of list marker: */
285 {(KeySym)0, 0, 0}
286};
287
288/*
289 * ------------------------------------------------------------
290 * Forward declaration (for those needed)
291 * ------------------------------------------------------------
292 */
293
294#ifdef USE_AEVENT
Bram Moolenaar69a7cb42004-06-20 12:51:53 +0000295OSErr HandleUnusedParms(const AppleEvent *theAEvent);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000296#endif
297
Bram Moolenaar79ee3152007-04-26 16:20:50 +0000298#ifdef FEAT_GUI_TABLINE
299static void initialise_tabline(void);
300static WindowRef drawer = NULL; // TODO: put into gui.h
301#endif
302
Bram Moolenaar1b60e502008-03-12 13:40:54 +0000303#ifdef USE_ATSUI_DRAWING
304static void gui_mac_set_font_attributes(GuiFont font);
305static void gui_mac_dispose_atsui_style(void);
306#endif
307
Bram Moolenaar071d4272004-06-13 20:20:40 +0000308/*
309 * ------------------------------------------------------------
310 * Conversion Utility
311 * ------------------------------------------------------------
312 */
313
314/*
315 * C2Pascal_save
316 *
317 * Allocate memory and convert the C-String passed in
318 * into a pascal string
319 *
320 */
321
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +0000322 char_u *
323C2Pascal_save(char_u *Cstring)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000324{
325 char_u *PascalString;
326 int len;
327
328 if (Cstring == NULL)
329 return NULL;
330
331 len = STRLEN(Cstring);
332
333 if (len > 255) /* Truncate if necessary */
334 len = 255;
335
336 PascalString = alloc(len + 1);
337 if (PascalString != NULL)
338 {
339 mch_memmove(PascalString + 1, Cstring, len);
340 PascalString[0] = len;
341 }
342
343 return PascalString;
344}
345
346/*
347 * C2Pascal_save_and_remove_backslash
348 *
349 * Allocate memory and convert the C-String passed in
350 * into a pascal string. Also remove the backslash at the same time
351 *
352 */
353
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +0000354 char_u *
355C2Pascal_save_and_remove_backslash(char_u *Cstring)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000356{
357 char_u *PascalString;
358 int len;
359 char_u *p, *c;
360
361 len = STRLEN(Cstring);
362
363 if (len > 255) /* Truncate if necessary */
364 len = 255;
365
366 PascalString = alloc(len + 1);
367 if (PascalString != NULL)
368 {
369 for (c = Cstring, p = PascalString+1, len = 0; (*c != 0) && (len < 255); c++)
370 {
371 if ((*c == '\\') && (c[1] != 0))
372 {
373 c++;
374 }
375 *p = *c;
376 p++;
377 len++;
378 }
379 PascalString[0] = len;
380 }
381
382 return PascalString;
383}
384
385/*
386 * Convert the modifiers of an Event into vim's modifiers (mouse)
387 */
388
389 int_u
390EventModifiers2VimMouseModifiers(EventModifiers macModifiers)
391{
392 int_u vimModifiers = 0x00;
393
394 if (macModifiers & (shiftKey | rightShiftKey))
395 vimModifiers |= MOUSE_SHIFT;
396 if (macModifiers & (controlKey | rightControlKey))
397 vimModifiers |= MOUSE_CTRL;
398 if (macModifiers & (optionKey | rightOptionKey))
399 vimModifiers |= MOUSE_ALT;
400#if 0
401 /* Not yet supported */
402 if (macModifiers & (cmdKey)) /* There's no rightCmdKey */
403 vimModifiers |= MOUSE_CMD;
404#endif
405 return (vimModifiers);
406}
407
408/*
409 * Convert the modifiers of an Event into vim's modifiers (keys)
410 */
411
412 static int_u
413EventModifiers2VimModifiers(EventModifiers macModifiers)
414{
415 int_u vimModifiers = 0x00;
416
417 if (macModifiers & (shiftKey | rightShiftKey))
418 vimModifiers |= MOD_MASK_SHIFT;
419 if (macModifiers & (controlKey | rightControlKey))
420 vimModifiers |= MOD_MASK_CTRL;
421 if (macModifiers & (optionKey | rightOptionKey))
422 vimModifiers |= MOD_MASK_ALT;
423#ifdef USE_CMD_KEY
424 if (macModifiers & (cmdKey)) /* There's no rightCmdKey */
425 vimModifiers |= MOD_MASK_CMD;
426#endif
427 return (vimModifiers);
428}
429
430/* Convert a string representing a point size into pixels. The string should
431 * be a positive decimal number, with an optional decimal point (eg, "12", or
432 * "10.5"). The pixel value is returned, and a pointer to the next unconverted
433 * character is stored in *end. The flag "vertical" says whether this
434 * calculation is for a vertical (height) size or a horizontal (width) one.
435 *
436 * From gui_w48.c
437 */
438 static int
439points_to_pixels(char_u *str, char_u **end, int vertical)
440{
441 int pixels;
442 int points = 0;
443 int divisor = 0;
444
445 while (*str)
446 {
447 if (*str == '.' && divisor == 0)
448 {
449 /* Start keeping a divisor, for later */
450 divisor = 1;
451 continue;
452 }
453
454 if (!isdigit(*str))
455 break;
456
457 points *= 10;
458 points += *str - '0';
459 divisor *= 10;
460
461 ++str;
462 }
463
464 if (divisor == 0)
465 divisor = 1;
466
467 pixels = points/divisor;
468 *end = str;
469 return pixels;
470}
471
Bram Moolenaar7d47b6e2006-03-15 22:59:18 +0000472#ifdef MACOS_CONVERT
Bram Moolenaar26a60b42005-02-22 08:49:11 +0000473/*
474 * Deletes all traces of any Windows-style mnemonic text (including any
475 * parentheses) from a menu item and returns the cleaned menu item title.
476 * The caller is responsible for releasing the returned string.
477 */
478 static CFStringRef
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +0000479menu_title_removing_mnemonic(vimmenu_T *menu)
Bram Moolenaar26a60b42005-02-22 08:49:11 +0000480{
481 CFStringRef name;
482 size_t menuTitleLen;
483 CFIndex displayLen;
484 CFRange mnemonicStart;
485 CFRange mnemonicEnd;
486 CFMutableStringRef cleanedName;
487
488 menuTitleLen = STRLEN(menu->dname);
Bram Moolenaar446cb832008-06-24 21:56:24 +0000489 name = (CFStringRef) mac_enc_to_cfstring(menu->dname, menuTitleLen);
Bram Moolenaar26a60b42005-02-22 08:49:11 +0000490
491 if (name)
492 {
493 /* Simple mnemonic-removal algorithm, assumes single parenthesized
494 * mnemonic character towards the end of the menu text */
495 mnemonicStart = CFStringFind(name, CFSTR("("), kCFCompareBackwards);
496 displayLen = CFStringGetLength(name);
497
498 if (mnemonicStart.location != kCFNotFound
499 && (mnemonicStart.location + 2) < displayLen
500 && CFStringGetCharacterAtIndex(name,
501 mnemonicStart.location + 1) == (UniChar)menu->mnemonic)
502 {
503 if (CFStringFindWithOptions(name, CFSTR(")"),
504 CFRangeMake(mnemonicStart.location + 1,
505 displayLen - mnemonicStart.location - 1),
506 kCFCompareBackwards, &mnemonicEnd) &&
507 (mnemonicStart.location + 2) == mnemonicEnd.location)
508 {
509 cleanedName = CFStringCreateMutableCopy(NULL, 0, name);
510 if (cleanedName)
511 {
512 CFStringDelete(cleanedName,
513 CFRangeMake(mnemonicStart.location,
514 mnemonicEnd.location + 1 -
515 mnemonicStart.location));
516
517 CFRelease(name);
518 name = cleanedName;
519 }
520 }
521 }
522 }
523
524 return name;
525}
526#endif
527
Bram Moolenaar071d4272004-06-13 20:20:40 +0000528/*
529 * Convert a list of FSSpec aliases into a list of fullpathname
530 * character strings.
531 */
532
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +0000533 char_u **
534new_fnames_from_AEDesc(AEDesc *theList, long *numFiles, OSErr *error)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000535{
536 char_u **fnames = NULL;
537 OSErr newError;
538 long fileCount;
539 FSSpec fileToOpen;
540 long actualSize;
541 AEKeyword dummyKeyword;
542 DescType dummyType;
543
544 /* Get number of files in list */
545 *error = AECountItems(theList, numFiles);
546 if (*error)
Bram Moolenaarbbe8c3f2007-04-26 16:40:56 +0000547 return fnames;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000548
549 /* Allocate the pointer list */
550 fnames = (char_u **) alloc(*numFiles * sizeof(char_u *));
551
552 /* Empty out the list */
553 for (fileCount = 0; fileCount < *numFiles; fileCount++)
554 fnames[fileCount] = NULL;
555
556 /* Scan the list of FSSpec */
557 for (fileCount = 1; fileCount <= *numFiles; fileCount++)
558 {
559 /* Get the alias for the nth file, convert to an FSSpec */
560 newError = AEGetNthPtr(theList, fileCount, typeFSS,
561 &dummyKeyword, &dummyType,
562 (Ptr) &fileToOpen, sizeof(FSSpec), &actualSize);
563 if (newError)
564 {
565 /* Caller is able to clean up */
566 /* TODO: Should be clean up or not? For safety. */
Bram Moolenaarbbe8c3f2007-04-26 16:40:56 +0000567 return fnames;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000568 }
569
570 /* Convert the FSSpec to a pathname */
Bram Moolenaar69a7cb42004-06-20 12:51:53 +0000571 fnames[fileCount - 1] = FullPathFromFSSpec_save(fileToOpen);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000572 }
573
574 return (fnames);
575}
576
577/*
578 * ------------------------------------------------------------
579 * CodeWarrior External Editor Support
580 * ------------------------------------------------------------
581 */
582#ifdef FEAT_CW_EDITOR
583
584/*
585 * Handle the Window Search event from CodeWarrior
586 *
587 * Description
588 * -----------
589 *
590 * The IDE sends the Window Search AppleEvent to the editor when it
591 * needs to know whether a particular file is open in the editor.
592 *
593 * Event Reply
594 * -----------
595 *
596 * None. Put data in the location specified in the structure received.
597 *
598 * Remarks
599 * -------
600 *
601 * When the editor receives this event, determine whether the specified
602 * file is open. If it is, return the modification date/time for that file
603 * in the appropriate location specified in the structure. If the file is
Bram Moolenaar69a7cb42004-06-20 12:51:53 +0000604 * not opened, put the value fnfErr(file not found) in that location.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000605 *
606 */
607
Bram Moolenaar071d4272004-06-13 20:20:40 +0000608typedef struct WindowSearch WindowSearch;
609struct WindowSearch /* for handling class 'KAHL', event 'SRCH', keyDirectObject typeChar*/
610{
611 FSSpec theFile; // identifies the file
612 long *theDate; // where to put the modification date/time
613};
Bram Moolenaar071d4272004-06-13 20:20:40 +0000614
Bram Moolenaar69a7cb42004-06-20 12:51:53 +0000615 pascal OSErr
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +0000616Handle_KAHL_SRCH_AE(
617 const AppleEvent *theAEvent,
618 AppleEvent *theReply,
619 long refCon)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000620{
621 OSErr error = noErr;
622 buf_T *buf;
623 int foundFile = false;
624 DescType typeCode;
625 WindowSearch SearchData;
626 Size actualSize;
627
628 error = AEGetParamPtr(theAEvent, keyDirectObject, typeChar, &typeCode, (Ptr) &SearchData, sizeof(WindowSearch), &actualSize);
629 if (error)
Bram Moolenaarbbe8c3f2007-04-26 16:40:56 +0000630 return error;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000631
Bram Moolenaar69a7cb42004-06-20 12:51:53 +0000632 error = HandleUnusedParms(theAEvent);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000633 if (error)
Bram Moolenaarbbe8c3f2007-04-26 16:40:56 +0000634 return error;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000635
636 for (buf = firstbuf; buf != NULL; buf = buf->b_next)
637 if (buf->b_ml.ml_mfp != NULL
638 && SearchData.theFile.parID == buf->b_FSSpec.parID
639 && SearchData.theFile.name[0] == buf->b_FSSpec.name[0]
640 && STRNCMP(SearchData.theFile.name, buf->b_FSSpec.name, buf->b_FSSpec.name[0] + 1) == 0)
641 {
642 foundFile = true;
643 break;
644 }
645
646 if (foundFile == false)
647 *SearchData.theDate = fnfErr;
648 else
649 *SearchData.theDate = buf->b_mtime;
650
Bram Moolenaar071d4272004-06-13 20:20:40 +0000651 return error;
652};
653
654/*
655 * Handle the Modified (from IDE to Editor) event from CodeWarrior
656 *
657 * Description
658 * -----------
659 *
660 * The IDE sends this event to the external editor when it wants to
661 * know which files that are open in the editor have been modified.
662 *
663 * Parameters None.
664 * ----------
665 *
666 * Event Reply
667 * -----------
668 * The reply for this event is:
669 *
670 * keyDirectObject typeAEList required
671 * each element in the list is a structure of typeChar
672 *
673 * Remarks
674 * -------
675 *
676 * When building the reply event, include one element in the list for
677 * each open file that has been modified.
678 *
679 */
680
Bram Moolenaar071d4272004-06-13 20:20:40 +0000681typedef struct ModificationInfo ModificationInfo;
682struct ModificationInfo /* for replying to class 'KAHL', event 'MOD ', keyDirectObject typeAEList*/
683{
684 FSSpec theFile; // identifies the file
685 long theDate; // the date/time the file was last modified
686 short saved; // set this to zero when replying, unused
687};
Bram Moolenaar071d4272004-06-13 20:20:40 +0000688
Bram Moolenaar69a7cb42004-06-20 12:51:53 +0000689 pascal OSErr
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +0000690Handle_KAHL_MOD_AE(
691 const AppleEvent *theAEvent,
692 AppleEvent *theReply,
693 long refCon)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000694{
695 OSErr error = noErr;
696 AEDescList replyList;
697 long numFiles;
698 ModificationInfo theFile;
699 buf_T *buf;
700
701 theFile.saved = 0;
702
Bram Moolenaar69a7cb42004-06-20 12:51:53 +0000703 error = HandleUnusedParms(theAEvent);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000704 if (error)
Bram Moolenaarbbe8c3f2007-04-26 16:40:56 +0000705 return error;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000706
707 /* Send the reply */
708/* replyObject.descriptorType = typeNull;
709 replyObject.dataHandle = nil;*/
710
711/* AECreateDesc(typeChar, (Ptr)&title[1], title[0], &data) */
712 error = AECreateList(nil, 0, false, &replyList);
713 if (error)
Bram Moolenaarbbe8c3f2007-04-26 16:40:56 +0000714 return error;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000715
716#if 0
717 error = AECountItems(&replyList, &numFiles);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000718
Bram Moolenaar69a7cb42004-06-20 12:51:53 +0000719 /* AEPutKeyDesc(&replyList, keyAEPnject, &aDesc)
720 * AEPutKeyPtr(&replyList, keyAEPosition, typeChar, (Ptr)&theType,
Bram Moolenaar071d4272004-06-13 20:20:40 +0000721 * sizeof(DescType))
722 */
723
724 /* AEPutDesc */
725#endif
726
727 numFiles = 0;
728 for (buf = firstbuf; buf != NULL; buf = buf->b_next)
729 if (buf->b_ml.ml_mfp != NULL)
730 {
731 /* Add this file to the list */
732 theFile.theFile = buf->b_FSSpec;
733 theFile.theDate = buf->b_mtime;
Bram Moolenaar69a7cb42004-06-20 12:51:53 +0000734/* theFile.theDate = time(NULL) & (time_t) 0xFFFFFFF0; */
735 error = AEPutPtr(&replyList, numFiles, typeChar, (Ptr) &theFile, sizeof(theFile));
Bram Moolenaar071d4272004-06-13 20:20:40 +0000736 };
737
Bram Moolenaar071d4272004-06-13 20:20:40 +0000738#if 0
739 error = AECountItems(&replyList, &numFiles);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000740#endif
741
742 /* We can add data only if something to reply */
Bram Moolenaar69a7cb42004-06-20 12:51:53 +0000743 error = AEPutParamDesc(theReply, keyDirectObject, &replyList);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000744
Bram Moolenaar071d4272004-06-13 20:20:40 +0000745 if (replyList.dataHandle)
746 AEDisposeDesc(&replyList);
747
748 return error;
749};
750
751/*
752 * Handle the Get Text event from CodeWarrior
753 *
754 * Description
755 * -----------
756 *
757 * The IDE sends the Get Text AppleEvent to the editor when it needs
758 * the source code from a file. For example, when the user issues a
759 * Check Syntax or Compile command, the compiler needs access to
760 * the source code contained in the file.
761 *
762 * Event Reply
763 * -----------
764 *
765 * None. Put data in locations specified in the structure received.
766 *
767 * Remarks
768 * -------
769 *
770 * When the editor receives this event, it must set the size of the handle
771 * in theText to fit the data in the file. It must then copy the entire
772 * contents of the specified file into the memory location specified in
773 * theText.
774 *
775 */
776
Bram Moolenaar071d4272004-06-13 20:20:40 +0000777typedef struct CW_GetText CW_GetText;
778struct CW_GetText /* for handling class 'KAHL', event 'GTTX', keyDirectObject typeChar*/
779{
780 FSSpec theFile; /* identifies the file */
781 Handle theText; /* the location where you return the text (must be resized properly) */
782 long *unused; /* 0 (not used) */
783 long *theDate; /* where to put the modification date/time */
784};
Bram Moolenaar071d4272004-06-13 20:20:40 +0000785
Bram Moolenaar69a7cb42004-06-20 12:51:53 +0000786 pascal OSErr
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +0000787Handle_KAHL_GTTX_AE(
788 const AppleEvent *theAEvent,
789 AppleEvent *theReply,
790 long refCon)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000791{
792 OSErr error = noErr;
793 buf_T *buf;
794 int foundFile = false;
795 DescType typeCode;
796 CW_GetText GetTextData;
797 Size actualSize;
798 char_u *line;
799 char_u *fullbuffer = NULL;
800 long linesize;
801 long lineStart;
802 long BufferSize;
803 long lineno;
804
805 error = AEGetParamPtr(theAEvent, keyDirectObject, typeChar, &typeCode, (Ptr) &GetTextData, sizeof(GetTextData), &actualSize);
806
807 if (error)
Bram Moolenaarbbe8c3f2007-04-26 16:40:56 +0000808 return error;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000809
810 for (buf = firstbuf; buf != NULL; buf = buf->b_next)
811 if (buf->b_ml.ml_mfp != NULL)
812 if (GetTextData.theFile.parID == buf->b_FSSpec.parID)
813 {
814 foundFile = true;
815 break;
816 }
817
818 if (foundFile)
819 {
Bram Moolenaar69a7cb42004-06-20 12:51:53 +0000820 BufferSize = 0; /* GetHandleSize(GetTextData.theText); */
Bram Moolenaar071d4272004-06-13 20:20:40 +0000821 for (lineno = 0; lineno <= buf->b_ml.ml_line_count; lineno++)
822 {
823 /* Must use the right buffer */
824 line = ml_get_buf(buf, (linenr_T) lineno, FALSE);
825 linesize = STRLEN(line) + 1;
826 lineStart = BufferSize;
827 BufferSize += linesize;
828 /* Resize handle to linesize+1 to include the linefeed */
Bram Moolenaar69a7cb42004-06-20 12:51:53 +0000829 SetHandleSize(GetTextData.theText, BufferSize);
830 if (GetHandleSize(GetTextData.theText) != BufferSize)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000831 {
Bram Moolenaar071d4272004-06-13 20:20:40 +0000832 break; /* Simple handling for now */
833 }
834 else
835 {
Bram Moolenaar69a7cb42004-06-20 12:51:53 +0000836 HLock(GetTextData.theText);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000837 fullbuffer = (char_u *) *GetTextData.theText;
Bram Moolenaar69a7cb42004-06-20 12:51:53 +0000838 STRCPY((char_u *)(fullbuffer + lineStart), line);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000839 fullbuffer[BufferSize-1] = '\r';
Bram Moolenaar69a7cb42004-06-20 12:51:53 +0000840 HUnlock(GetTextData.theText);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000841 }
842 }
843 if (fullbuffer != NULL)
844 {
Bram Moolenaar69a7cb42004-06-20 12:51:53 +0000845 HLock(GetTextData.theText);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000846 fullbuffer[BufferSize-1] = 0;
Bram Moolenaar69a7cb42004-06-20 12:51:53 +0000847 HUnlock(GetTextData.theText);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000848 }
849 if (foundFile == false)
850 *GetTextData.theDate = fnfErr;
851 else
Bram Moolenaar69a7cb42004-06-20 12:51:53 +0000852/* *GetTextData.theDate = time(NULL) & (time_t) 0xFFFFFFF0;*/
Bram Moolenaar071d4272004-06-13 20:20:40 +0000853 *GetTextData.theDate = buf->b_mtime;
854 }
Bram Moolenaar071d4272004-06-13 20:20:40 +0000855
Bram Moolenaar69a7cb42004-06-20 12:51:53 +0000856 error = HandleUnusedParms(theAEvent);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000857
Bram Moolenaarbbe8c3f2007-04-26 16:40:56 +0000858 return error;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000859}
860
861/*
862 *
863 */
864
865/* Taken from MoreAppleEvents:ProcessHelpers*/
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +0000866 pascal OSErr
867FindProcessBySignature(
868 const OSType targetType,
869 const OSType targetCreator,
870 ProcessSerialNumberPtr psnPtr)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000871{
872 OSErr anErr = noErr;
873 Boolean lookingForProcess = true;
874
875 ProcessInfoRec infoRec;
876
Bram Moolenaar69a7cb42004-06-20 12:51:53 +0000877 infoRec.processInfoLength = sizeof(ProcessInfoRec);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000878 infoRec.processName = nil;
879 infoRec.processAppSpec = nil;
880
881 psnPtr->lowLongOfPSN = kNoProcess;
882 psnPtr->highLongOfPSN = kNoProcess;
883
Bram Moolenaar69a7cb42004-06-20 12:51:53 +0000884 while (lookingForProcess)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000885 {
Bram Moolenaar69a7cb42004-06-20 12:51:53 +0000886 anErr = GetNextProcess(psnPtr);
887 if (anErr != noErr)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000888 lookingForProcess = false;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000889 else
890 {
Bram Moolenaar69a7cb42004-06-20 12:51:53 +0000891 anErr = GetProcessInformation(psnPtr, &infoRec);
892 if ((anErr == noErr)
893 && (infoRec.processType == targetType)
894 && (infoRec.processSignature == targetCreator))
Bram Moolenaar071d4272004-06-13 20:20:40 +0000895 lookingForProcess = false;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000896 }
897 }
898
899 return anErr;
900}//end FindProcessBySignature
901
Bram Moolenaar69a7cb42004-06-20 12:51:53 +0000902 void
903Send_KAHL_MOD_AE(buf_T *buf)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000904{
Bram Moolenaar69a7cb42004-06-20 12:51:53 +0000905 OSErr anErr = noErr;
906 AEDesc targetAppDesc = { typeNull, nil };
Bram Moolenaar071d4272004-06-13 20:20:40 +0000907 ProcessSerialNumber psn = { kNoProcess, kNoProcess };
908 AppleEvent theReply = { typeNull, nil };
909 AESendMode sendMode;
910 AppleEvent theEvent = {typeNull, nil };
911 AEIdleUPP idleProcUPP = nil;
912 ModificationInfo ModData;
913
914
Bram Moolenaar69a7cb42004-06-20 12:51:53 +0000915 anErr = FindProcessBySignature('APPL', 'CWIE', &psn);
Bram Moolenaar69a7cb42004-06-20 12:51:53 +0000916 if (anErr == noErr)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000917 {
Bram Moolenaar69a7cb42004-06-20 12:51:53 +0000918 anErr = AECreateDesc(typeProcessSerialNumber, &psn,
919 sizeof(ProcessSerialNumber), &targetAppDesc);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000920
Bram Moolenaar69a7cb42004-06-20 12:51:53 +0000921 if (anErr == noErr)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000922 {
923 anErr = AECreateAppleEvent( 'KAHL', 'MOD ', &targetAppDesc,
924 kAutoGenerateReturnID, kAnyTransactionID, &theEvent);
925 }
926
Bram Moolenaar69a7cb42004-06-20 12:51:53 +0000927 AEDisposeDesc(&targetAppDesc);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000928
929 /* Add the parms */
930 ModData.theFile = buf->b_FSSpec;
931 ModData.theDate = buf->b_mtime;
932
933 if (anErr == noErr)
Bram Moolenaar69a7cb42004-06-20 12:51:53 +0000934 anErr = AEPutParamPtr(&theEvent, keyDirectObject, typeChar, &ModData, sizeof(ModData));
Bram Moolenaar071d4272004-06-13 20:20:40 +0000935
Bram Moolenaar69a7cb42004-06-20 12:51:53 +0000936 if (idleProcUPP == nil)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000937 sendMode = kAENoReply;
938 else
939 sendMode = kAEWaitReply;
940
Bram Moolenaar69a7cb42004-06-20 12:51:53 +0000941 if (anErr == noErr)
942 anErr = AESend(&theEvent, &theReply, sendMode, kAENormalPriority, kNoTimeOut, idleProcUPP, nil);
943 if (anErr == noErr && sendMode == kAEWaitReply)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000944 {
Bram Moolenaar69a7cb42004-06-20 12:51:53 +0000945/* anErr = AEHGetHandlerError(&theReply);*/
Bram Moolenaar071d4272004-06-13 20:20:40 +0000946 }
Bram Moolenaar69a7cb42004-06-20 12:51:53 +0000947 (void) AEDisposeDesc(&theReply);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000948 }
949}
950#endif /* FEAT_CW_EDITOR */
951
952/*
953 * ------------------------------------------------------------
954 * Apple Event Handling procedure
955 * ------------------------------------------------------------
956 */
957#ifdef USE_AEVENT
958
959/*
960 * Handle the Unused parms of an AppleEvent
961 */
962
Bram Moolenaar69a7cb42004-06-20 12:51:53 +0000963 OSErr
964HandleUnusedParms(const AppleEvent *theAEvent)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000965{
966 OSErr error;
967 long actualSize;
968 DescType dummyType;
969 AEKeyword missedKeyword;
970
971 /* Get the "missed keyword" attribute from the AppleEvent. */
972 error = AEGetAttributePtr(theAEvent, keyMissedKeywordAttr,
973 typeKeyword, &dummyType,
974 (Ptr)&missedKeyword, sizeof(missedKeyword),
975 &actualSize);
976
977 /* If the descriptor isn't found, then we got the required parameters. */
978 if (error == errAEDescNotFound)
979 {
980 error = noErr;
981 }
982 else
983 {
984#if 0
985 /* Why is this removed? */
986 error = errAEEventNotHandled;
987#endif
988 }
989
990 return error;
991}
992
993
994/*
995 * Handle the ODoc AppleEvent
996 *
997 * Deals with all files dragged to the application icon.
998 *
999 */
1000
Bram Moolenaar071d4272004-06-13 20:20:40 +00001001typedef struct SelectionRange SelectionRange;
1002struct SelectionRange /* for handling kCoreClassEvent:kOpenDocuments:keyAEPosition typeChar */
1003{
1004 short unused1; // 0 (not used)
1005 short lineNum; // line to select (<0 to specify range)
1006 long startRange; // start of selection range (if line < 0)
1007 long endRange; // end of selection range (if line < 0)
1008 long unused2; // 0 (not used)
1009 long theDate; // modification date/time
1010};
Bram Moolenaar071d4272004-06-13 20:20:40 +00001011
1012/* The IDE uses the optional keyAEPosition parameter to tell the ed-
1013 itor the selection range. If lineNum is zero or greater, scroll the text
1014 to the specified line. If lineNum is less than zero, use the values in
1015 startRange and endRange to select the specified characters. Scroll
1016 the text to display the selection. If lineNum, startRange, and
1017 endRange are all negative, there is no selection range specified.
1018 */
1019
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00001020 pascal OSErr
1021HandleODocAE(const AppleEvent *theAEvent, AppleEvent *theReply, long refCon)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001022{
1023 /*
1024 * TODO: Clean up the code with convert the AppleEvent into
1025 * a ":args"
1026 */
1027 OSErr error = noErr;
1028// OSErr firstError = noErr;
1029// short numErrors = 0;
1030 AEDesc theList;
1031 DescType typeCode;
1032 long numFiles;
1033 // long fileCount;
1034 char_u **fnames;
1035// char_u fname[256];
1036 Size actualSize;
1037 SelectionRange thePosition;
1038 short gotPosition = false;
1039 long lnum;
1040
Bram Moolenaar071d4272004-06-13 20:20:40 +00001041 /* the direct object parameter is the list of aliases to files (one or more) */
1042 error = AEGetParamDesc(theAEvent, keyDirectObject, typeAEList, &theList);
1043 if (error)
Bram Moolenaarbbe8c3f2007-04-26 16:40:56 +00001044 return error;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001045
1046
1047 error = AEGetParamPtr(theAEvent, keyAEPosition, typeChar, &typeCode, (Ptr) &thePosition, sizeof(SelectionRange), &actualSize);
1048 if (error == noErr)
1049 gotPosition = true;
1050 if (error == errAEDescNotFound)
1051 error = noErr;
1052 if (error)
Bram Moolenaarbbe8c3f2007-04-26 16:40:56 +00001053 return error;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001054
Bram Moolenaar071d4272004-06-13 20:20:40 +00001055/*
1056 error = AEGetParamDesc(theAEvent, keyAEPosition, typeChar, &thePosition);
1057
1058 if (^error) then
1059 {
1060 if (thePosition.lineNum >= 0)
1061 {
1062 // Goto this line
1063 }
1064 else
1065 {
1066 // Set the range char wise
1067 }
1068 }
1069 */
1070
1071
1072#ifdef FEAT_VISUAL
1073 reset_VIsual();
1074#endif
1075
1076 fnames = new_fnames_from_AEDesc(&theList, &numFiles, &error);
1077
1078 if (error)
1079 {
1080 /* TODO: empty fnames[] first */
1081 vim_free(fnames);
1082 return (error);
1083 }
1084
1085 if (starting > 0)
1086 {
1087 int i;
1088 char_u *p;
Bram Moolenaar51b84362007-09-29 11:16:17 +00001089 int fnum = -1;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001090
1091 /* these are the initial files dropped on the Vim icon */
1092 for (i = 0 ; i < numFiles; i++)
1093 {
1094 if (ga_grow(&global_alist.al_ga, 1) == FAIL
1095 || (p = vim_strsave(fnames[i])) == NULL)
1096 mch_exit(2);
1097 else
1098 alist_add(&global_alist, p, 2);
Bram Moolenaar51b84362007-09-29 11:16:17 +00001099 if (fnum == -1)
1100 fnum = GARGLIST[GARGCOUNT - 1].ae_fnum;
1101 }
1102
1103 /* If the file name was already in the buffer list we need to switch
1104 * to it. */
1105 if (curbuf->b_fnum != fnum)
1106 {
1107 char_u cmd[30];
1108
1109 vim_snprintf((char *)cmd, 30, "silent %dbuffer", fnum);
1110 do_cmdline_cmd(cmd);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001111 }
Bram Moolenaard2cec5b2006-03-28 21:08:56 +00001112
1113 /* Change directory to the location of the first file. */
1114 if (GARGCOUNT > 0 && vim_chdirfile(alist_name(&GARGLIST[0])) == OK)
1115 shorten_fnames(TRUE);
1116
Bram Moolenaar071d4272004-06-13 20:20:40 +00001117 goto finished;
1118 }
1119
1120 /* Handle the drop, :edit to get to the file */
1121 handle_drop(numFiles, fnames, FALSE);
1122
1123 /* TODO: Handle the goto/select line more cleanly */
1124 if ((numFiles == 1) & (gotPosition))
1125 {
1126 if (thePosition.lineNum >= 0)
1127 {
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00001128 lnum = thePosition.lineNum + 1;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001129 /* oap->motion_type = MLINE;
1130 setpcmark();*/
1131 if (lnum < 1L)
1132 lnum = 1L;
1133 else if (lnum > curbuf->b_ml.ml_line_count)
1134 lnum = curbuf->b_ml.ml_line_count;
1135 curwin->w_cursor.lnum = lnum;
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00001136 curwin->w_cursor.col = 0;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001137 /* beginline(BL_SOL | BL_FIX);*/
1138 }
1139 else
1140 goto_byte(thePosition.startRange + 1);
1141 }
1142
1143 /* Update the screen display */
1144 update_screen(NOT_VALID);
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00001145#ifdef FEAT_VISUAL
1146 /* Select the text if possible */
1147 if (gotPosition)
1148 {
Bram Moolenaar26a60b42005-02-22 08:49:11 +00001149 VIsual_active = TRUE;
1150 VIsual_select = FALSE;
1151 VIsual = curwin->w_cursor;
1152 if (thePosition.lineNum < 0)
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00001153 {
Bram Moolenaar26a60b42005-02-22 08:49:11 +00001154 VIsual_mode = 'v';
1155 goto_byte(thePosition.endRange);
1156 }
1157 else
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00001158 {
Bram Moolenaar26a60b42005-02-22 08:49:11 +00001159 VIsual_mode = 'V';
1160 VIsual.col = 0;
1161 }
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00001162 }
1163#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00001164 setcursor();
1165 out_flush();
1166
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00001167 /* Fake mouse event to wake from stall */
1168 PostEvent(mouseUp, 0);
1169
Bram Moolenaarbbe8c3f2007-04-26 16:40:56 +00001170finished:
Bram Moolenaar071d4272004-06-13 20:20:40 +00001171 AEDisposeDesc(&theList); /* dispose what we allocated */
1172
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00001173 error = HandleUnusedParms(theAEvent);
Bram Moolenaarbbe8c3f2007-04-26 16:40:56 +00001174 return error;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001175}
1176
1177/*
1178 *
1179 */
1180
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00001181 pascal OSErr
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00001182Handle_aevt_oapp_AE(
1183 const AppleEvent *theAEvent,
1184 AppleEvent *theReply,
1185 long refCon)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001186{
1187 OSErr error = noErr;
1188
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00001189 error = HandleUnusedParms(theAEvent);
Bram Moolenaarbbe8c3f2007-04-26 16:40:56 +00001190 return error;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001191}
1192
1193/*
1194 *
1195 */
1196
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00001197 pascal OSErr
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00001198Handle_aevt_quit_AE(
1199 const AppleEvent *theAEvent,
1200 AppleEvent *theReply,
1201 long refCon)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001202{
1203 OSErr error = noErr;
1204
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00001205 error = HandleUnusedParms(theAEvent);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001206 if (error)
Bram Moolenaarbbe8c3f2007-04-26 16:40:56 +00001207 return error;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001208
1209 /* Need to fake a :confirm qa */
1210 do_cmdline_cmd((char_u *)"confirm qa");
1211
Bram Moolenaarbbe8c3f2007-04-26 16:40:56 +00001212 return error;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001213}
1214
1215/*
1216 *
1217 */
1218
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00001219 pascal OSErr
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00001220Handle_aevt_pdoc_AE(
1221 const AppleEvent *theAEvent,
1222 AppleEvent *theReply,
1223 long refCon)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001224{
1225 OSErr error = noErr;
1226
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00001227 error = HandleUnusedParms(theAEvent);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001228
Bram Moolenaarbbe8c3f2007-04-26 16:40:56 +00001229 return error;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001230}
1231
1232/*
1233 * Handling of unknown AppleEvent
1234 *
1235 * (Just get rid of all the parms)
1236 */
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00001237 pascal OSErr
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00001238Handle_unknown_AE(
1239 const AppleEvent *theAEvent,
1240 AppleEvent *theReply,
1241 long refCon)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001242{
1243 OSErr error = noErr;
1244
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00001245 error = HandleUnusedParms(theAEvent);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001246
Bram Moolenaarbbe8c3f2007-04-26 16:40:56 +00001247 return error;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001248}
1249
1250
Bram Moolenaar071d4272004-06-13 20:20:40 +00001251/*
1252 * Install the various AppleEvent Handlers
1253 */
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00001254 OSErr
1255InstallAEHandlers(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001256{
1257 OSErr error;
1258
1259 /* install open application handler */
1260 error = AEInstallEventHandler(kCoreEventClass, kAEOpenApplication,
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00001261 NewAEEventHandlerUPP(Handle_aevt_oapp_AE), 0, false);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001262 if (error)
1263 {
1264 return error;
1265 }
1266
1267 /* install quit application handler */
1268 error = AEInstallEventHandler(kCoreEventClass, kAEQuitApplication,
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00001269 NewAEEventHandlerUPP(Handle_aevt_quit_AE), 0, false);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001270 if (error)
1271 {
1272 return error;
1273 }
1274
1275 /* install open document handler */
1276 error = AEInstallEventHandler(kCoreEventClass, kAEOpenDocuments,
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00001277 NewAEEventHandlerUPP(HandleODocAE), 0, false);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001278 if (error)
1279 {
1280 return error;
1281 }
1282
1283 /* install print document handler */
1284 error = AEInstallEventHandler(kCoreEventClass, kAEPrintDocuments,
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00001285 NewAEEventHandlerUPP(Handle_aevt_pdoc_AE), 0, false);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001286
1287/* Install Core Suite */
1288/* error = AEInstallEventHandler(kAECoreSuite, kAEClone,
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00001289 NewAEEventHandlerUPP(Handle_unknown_AE), nil, false);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001290
1291 error = AEInstallEventHandler(kAECoreSuite, kAEClose,
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00001292 NewAEEventHandlerUPP(Handle_unknown_AE), nil, false);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001293
1294 error = AEInstallEventHandler(kAECoreSuite, kAECountElements,
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00001295 NewAEEventHandlerUPP(Handle_unknown_AE), nil, false);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001296
1297 error = AEInstallEventHandler(kAECoreSuite, kAECreateElement,
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00001298 NewAEEventHandlerUPP(Handle_unknown_AE), nil, false);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001299
1300 error = AEInstallEventHandler(kAECoreSuite, kAEDelete,
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00001301 NewAEEventHandlerUPP(Handle_unknown_AE), nil, false);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001302
1303 error = AEInstallEventHandler(kAECoreSuite, kAEDoObjectsExist,
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00001304 NewAEEventHandlerUPP(Handle_unknown_AE), nil, false);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001305
1306 error = AEInstallEventHandler(kAECoreSuite, kAEGetData,
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00001307 NewAEEventHandlerUPP(Handle_unknown_AE), kAEGetData, false);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001308
1309 error = AEInstallEventHandler(kAECoreSuite, kAEGetDataSize,
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00001310 NewAEEventHandlerUPP(Handle_unknown_AE), kAEGetDataSize, false);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001311
1312 error = AEInstallEventHandler(kAECoreSuite, kAEGetClassInfo,
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00001313 NewAEEventHandlerUPP(Handle_unknown_AE), nil, false);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001314
1315 error = AEInstallEventHandler(kAECoreSuite, kAEGetEventInfo,
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00001316 NewAEEventHandlerUPP(Handle_unknown_AE), nil, false);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001317
1318 error = AEInstallEventHandler(kAECoreSuite, kAEMove,
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00001319 NewAEEventHandlerUPP(Handle_unknown_AE), nil, false);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001320
1321 error = AEInstallEventHandler(kAECoreSuite, kAESave,
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00001322 NewAEEventHandlerUPP(Handle_unknown_AE), nil, false);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001323
1324 error = AEInstallEventHandler(kAECoreSuite, kAESetData,
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00001325 NewAEEventHandlerUPP(Handle_unknown_AE), nil, false);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001326*/
1327
1328#ifdef FEAT_CW_EDITOR
1329 /*
1330 * Bind codewarrior support handlers
1331 */
1332 error = AEInstallEventHandler('KAHL', 'GTTX',
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00001333 NewAEEventHandlerUPP(Handle_KAHL_GTTX_AE), 0, false);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001334 if (error)
1335 {
1336 return error;
1337 }
1338 error = AEInstallEventHandler('KAHL', 'SRCH',
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00001339 NewAEEventHandlerUPP(Handle_KAHL_SRCH_AE), 0, false);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001340 if (error)
1341 {
1342 return error;
1343 }
1344 error = AEInstallEventHandler('KAHL', 'MOD ',
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00001345 NewAEEventHandlerUPP(Handle_KAHL_MOD_AE), 0, false);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001346 if (error)
1347 {
1348 return error;
1349 }
1350#endif
1351
1352 return error;
1353
1354}
1355#endif /* USE_AEVENT */
1356
Bram Moolenaar592e0a22004-07-03 16:05:59 +00001357
Bram Moolenaar592e0a22004-07-03 16:05:59 +00001358/*
1359 * Callback function, installed by InstallFontPanelHandler(), below,
1360 * to handle Font Panel events.
1361 */
1362 static OSStatus
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00001363FontPanelHandler(
1364 EventHandlerCallRef inHandlerCallRef,
1365 EventRef inEvent,
1366 void *inUserData)
Bram Moolenaar592e0a22004-07-03 16:05:59 +00001367{
1368 if (GetEventKind(inEvent) == kEventFontPanelClosed)
1369 {
1370 gFontPanelInfo.isPanelVisible = false;
1371 return noErr;
1372 }
1373
1374 if (GetEventKind(inEvent) == kEventFontSelection)
1375 {
1376 OSStatus status;
1377 FMFontFamily newFamily;
1378 FMFontSize newSize;
1379 FMFontStyle newStyle;
1380
1381 /* Retrieve the font family ID number. */
1382 status = GetEventParameter(inEvent, kEventParamFMFontFamily,
1383 /*inDesiredType=*/typeFMFontFamily, /*outActualType=*/NULL,
1384 /*inBufferSize=*/sizeof(FMFontFamily), /*outActualSize=*/NULL,
1385 &newFamily);
1386 if (status == noErr)
1387 gFontPanelInfo.family = newFamily;
1388
1389 /* Retrieve the font size. */
1390 status = GetEventParameter(inEvent, kEventParamFMFontSize,
1391 typeFMFontSize, NULL, sizeof(FMFontSize), NULL, &newSize);
1392 if (status == noErr)
1393 gFontPanelInfo.size = newSize;
1394
1395 /* Retrieve the font style (bold, etc.). Currently unused. */
1396 status = GetEventParameter(inEvent, kEventParamFMFontStyle,
1397 typeFMFontStyle, NULL, sizeof(FMFontStyle), NULL, &newStyle);
1398 if (status == noErr)
1399 gFontPanelInfo.style = newStyle;
1400 }
1401 return noErr;
1402}
1403
1404
1405 static void
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00001406InstallFontPanelHandler(void)
Bram Moolenaar592e0a22004-07-03 16:05:59 +00001407{
1408 EventTypeSpec eventTypes[2];
1409 EventHandlerUPP handlerUPP;
1410 /* EventHandlerRef handlerRef; */
1411
1412 eventTypes[0].eventClass = kEventClassFont;
1413 eventTypes[0].eventKind = kEventFontSelection;
1414 eventTypes[1].eventClass = kEventClassFont;
1415 eventTypes[1].eventKind = kEventFontPanelClosed;
1416
1417 handlerUPP = NewEventHandlerUPP(FontPanelHandler);
1418
1419 InstallApplicationEventHandler(handlerUPP, /*numTypes=*/2, eventTypes,
1420 /*userData=*/NULL, /*handlerRef=*/NULL);
1421}
1422
1423
1424/*
1425 * Fill the buffer pointed to by outName with the name and size
1426 * of the font currently selected in the Font Panel.
1427 */
Bram Moolenaar26a60b42005-02-22 08:49:11 +00001428#define FONT_STYLE_BUFFER_SIZE 32
Bram Moolenaar592e0a22004-07-03 16:05:59 +00001429 static void
Bram Moolenaarda2303d2005-08-30 21:55:26 +00001430GetFontPanelSelection(char_u *outName)
Bram Moolenaar592e0a22004-07-03 16:05:59 +00001431{
Bram Moolenaar26a60b42005-02-22 08:49:11 +00001432 Str255 buf;
1433 ByteCount fontNameLen = 0;
1434 ATSUFontID fid;
1435 char_u styleString[FONT_STYLE_BUFFER_SIZE];
Bram Moolenaar592e0a22004-07-03 16:05:59 +00001436
1437 if (!outName)
1438 return;
1439
Bram Moolenaar26a60b42005-02-22 08:49:11 +00001440 if (FMGetFontFamilyName(gFontPanelInfo.family, buf) == noErr)
1441 {
1442 /* Canonicalize localized font names */
1443 if (FMGetFontFromFontFamilyInstance(gFontPanelInfo.family,
1444 gFontPanelInfo.style, &fid, NULL) != noErr)
1445 return;
Bram Moolenaar592e0a22004-07-03 16:05:59 +00001446
Bram Moolenaar26a60b42005-02-22 08:49:11 +00001447 /* Request font name with Mac encoding (otherwise we could
1448 * get an unwanted utf-16 name) */
1449 if (ATSUFindFontName(fid, kFontFullName, kFontMacintoshPlatform,
1450 kFontNoScriptCode, kFontNoLanguageCode,
Bram Moolenaarda2303d2005-08-30 21:55:26 +00001451 255, (char *)outName, &fontNameLen, NULL) != noErr)
Bram Moolenaar26a60b42005-02-22 08:49:11 +00001452 return;
Bram Moolenaar592e0a22004-07-03 16:05:59 +00001453
Bram Moolenaar26a60b42005-02-22 08:49:11 +00001454 /* Only encode font size, because style (bold, italic, etc) is
1455 * already part of the font full name */
Bram Moolenaarda2303d2005-08-30 21:55:26 +00001456 vim_snprintf((char *)styleString, FONT_STYLE_BUFFER_SIZE, ":h%d",
Bram Moolenaar26a60b42005-02-22 08:49:11 +00001457 gFontPanelInfo.size/*,
1458 ((gFontPanelInfo.style & bold)!=0 ? ":b" : ""),
1459 ((gFontPanelInfo.style & italic)!=0 ? ":i" : ""),
1460 ((gFontPanelInfo.style & underline)!=0 ? ":u" : "")*/);
1461
1462 if ((fontNameLen + STRLEN(styleString)) < 255)
1463 STRCPY(outName + fontNameLen, styleString);
1464 }
1465 else
1466 {
Bram Moolenaarda2303d2005-08-30 21:55:26 +00001467 *outName = NUL;
Bram Moolenaar26a60b42005-02-22 08:49:11 +00001468 }
Bram Moolenaar592e0a22004-07-03 16:05:59 +00001469}
Bram Moolenaar592e0a22004-07-03 16:05:59 +00001470
1471
Bram Moolenaar071d4272004-06-13 20:20:40 +00001472/*
1473 * ------------------------------------------------------------
1474 * Unfiled yet
1475 * ------------------------------------------------------------
1476 */
1477
1478/*
1479 * gui_mac_get_menu_item_index
1480 *
Bram Moolenaar84a05ac2013-05-06 04:24:17 +02001481 * Returns the index inside the menu where
Bram Moolenaar071d4272004-06-13 20:20:40 +00001482 */
Bram Moolenaarb05034a2010-09-21 17:34:31 +02001483 short /* Should we return MenuItemIndex? */
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00001484gui_mac_get_menu_item_index(vimmenu_T *pMenu)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001485{
1486 short index;
1487 short itemIndex = -1;
1488 vimmenu_T *pBrother;
1489
1490 /* Only menu without parent are the:
1491 * -menu in the menubar
1492 * -popup menu
1493 * -toolbar (guess)
1494 *
1495 * Which are not items anyway.
1496 */
1497 if (pMenu->parent)
1498 {
1499 /* Start from the Oldest Brother */
1500 pBrother = pMenu->parent->children;
1501 index = 1;
1502 while ((pBrother) && (itemIndex == -1))
1503 {
1504 if (pBrother == pMenu)
1505 itemIndex = index;
1506 index++;
1507 pBrother = pBrother->next;
1508 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00001509 }
1510 return itemIndex;
1511}
1512
1513 static vimmenu_T *
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00001514gui_mac_get_vim_menu(short menuID, short itemIndex, vimmenu_T *pMenu)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001515{
1516 short index;
1517 vimmenu_T *pChildMenu;
1518 vimmenu_T *pElder = pMenu->parent;
1519
1520
1521 /* Only menu without parent are the:
1522 * -menu in the menubar
1523 * -popup menu
1524 * -toolbar (guess)
1525 *
1526 * Which are not items anyway.
1527 */
1528
1529 if ((pElder) && (pElder->submenu_id == menuID))
1530 {
Bram Moolenaar071d4272004-06-13 20:20:40 +00001531 for (index = 1; (index != itemIndex) && (pMenu != NULL); index++)
1532 pMenu = pMenu->next;
1533 }
1534 else
1535 {
1536 for (; pMenu != NULL; pMenu = pMenu->next)
1537 {
1538 if (pMenu->children != NULL)
1539 {
1540 pChildMenu = gui_mac_get_vim_menu
1541 (menuID, itemIndex, pMenu->children);
1542 if (pChildMenu)
1543 {
1544 pMenu = pChildMenu;
1545 break;
1546 }
1547 }
1548 }
1549 }
1550 return pMenu;
1551}
1552
1553/*
1554 * ------------------------------------------------------------
1555 * MacOS Feedback procedures
1556 * ------------------------------------------------------------
1557 */
1558 pascal
1559 void
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00001560gui_mac_drag_thumb(ControlHandle theControl, short partCode)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001561{
1562 scrollbar_T *sb;
1563 int value, dragging;
1564 ControlHandle theControlToUse;
1565 int dont_scroll_save = dont_scroll;
1566
1567 theControlToUse = dragged_sb;
1568
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00001569 sb = gui_find_scrollbar((long) GetControlReference(theControlToUse));
Bram Moolenaar071d4272004-06-13 20:20:40 +00001570
1571 if (sb == NULL)
1572 return;
1573
1574 /* Need to find value by diff between Old Poss New Pos */
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00001575 value = GetControl32BitValue(theControlToUse);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001576 dragging = (partCode != 0);
1577
1578 /* When "allow_scrollbar" is FALSE still need to remember the new
1579 * position, but don't actually scroll by setting "dont_scroll". */
1580 dont_scroll = !allow_scrollbar;
1581 gui_drag_scrollbar(sb, value, dragging);
1582 dont_scroll = dont_scroll_save;
1583}
1584
1585 pascal
1586 void
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00001587gui_mac_scroll_action(ControlHandle theControl, short partCode)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001588{
1589 /* TODO: have live support */
1590 scrollbar_T *sb, *sb_info;
1591 long data;
1592 long value;
1593 int page;
1594 int dragging = FALSE;
1595 int dont_scroll_save = dont_scroll;
1596
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00001597 sb = gui_find_scrollbar((long)GetControlReference(theControl));
Bram Moolenaar071d4272004-06-13 20:20:40 +00001598
1599 if (sb == NULL)
1600 return;
1601
1602 if (sb->wp != NULL) /* Left or right scrollbar */
1603 {
1604 /*
1605 * Careful: need to get scrollbar info out of first (left) scrollbar
1606 * for window, but keep real scrollbar too because we must pass it to
1607 * gui_drag_scrollbar().
1608 */
1609 sb_info = &sb->wp->w_scrollbars[0];
1610
1611 if (sb_info->size > 5)
1612 page = sb_info->size - 2; /* use two lines of context */
1613 else
1614 page = sb_info->size;
1615 }
1616 else /* Bottom scrollbar */
1617 {
1618 sb_info = sb;
1619 page = W_WIDTH(curwin) - 5;
1620 }
1621
1622 switch (partCode)
1623 {
1624 case kControlUpButtonPart: data = -1; break;
1625 case kControlDownButtonPart: data = 1; break;
1626 case kControlPageDownPart: data = page; break;
1627 case kControlPageUpPart: data = -page; break;
1628 default: data = 0; break;
1629 }
1630
1631 value = sb_info->value + data;
1632/* if (value > sb_info->max)
1633 value = sb_info->max;
1634 else if (value < 0)
1635 value = 0;*/
1636
1637 /* When "allow_scrollbar" is FALSE still need to remember the new
1638 * position, but don't actually scroll by setting "dont_scroll". */
1639 dont_scroll = !allow_scrollbar;
1640 gui_drag_scrollbar(sb, value, dragging);
1641 dont_scroll = dont_scroll_save;
1642
1643 out_flush();
1644 gui_mch_set_scrollbar_thumb(sb, value, sb_info->size, sb_info->max);
1645
1646/* if (sb_info->wp != NULL)
1647 {
1648 win_T *wp;
1649 int sb_num;
1650
1651 sb_num = 0;
1652 for (wp = firstwin; wp != sb->wp && wp != NULL; wp = W_NEXT(wp))
1653 sb_num++;
1654
1655 if (wp != NULL)
1656 {
1657 current_scrollbar = sb_num;
1658 scrollbar_value = value;
1659 gui_do_scroll();
1660 gui_mch_set_scrollbar_thumb(sb, value, sb_info->size, sb_info->max);
1661 }
1662 }*/
1663}
1664
1665/*
1666 * ------------------------------------------------------------
1667 * MacOS Click Handling procedures
1668 * ------------------------------------------------------------
1669 */
1670
1671
1672/*
1673 * Handle a click inside the window, it may happens in the
1674 * scrollbar or the contents.
1675 *
1676 * TODO: Add support for potential TOOLBAR
1677 */
1678 void
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00001679gui_mac_doInContentClick(EventRecord *theEvent, WindowPtr whichWindow)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001680{
1681 Point thePoint;
1682 int_u vimModifiers;
1683 short thePortion;
1684 ControlHandle theControl;
1685 int vimMouseButton;
1686 short dblClick;
1687
1688 thePoint = theEvent->where;
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00001689 GlobalToLocal(&thePoint);
1690 SelectWindow(whichWindow);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001691
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00001692 thePortion = FindControl(thePoint, whichWindow, &theControl);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001693
1694 if (theControl != NUL)
1695 {
Bram Moolenaar84a05ac2013-05-06 04:24:17 +02001696 /* We hit a scrollbar */
Bram Moolenaar071d4272004-06-13 20:20:40 +00001697
1698 if (thePortion != kControlIndicatorPart)
1699 {
1700 dragged_sb = theControl;
1701 TrackControl(theControl, thePoint, gScrollAction);
1702 dragged_sb = NULL;
1703 }
1704 else
1705 {
1706 dragged_sb = theControl;
1707#if 1
1708 TrackControl(theControl, thePoint, gScrollDrag);
1709#else
1710 TrackControl(theControl, thePoint, NULL);
1711#endif
1712 /* pass 0 as the part to tell gui_mac_drag_thumb, that the mouse
1713 * button has been released */
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00001714 gui_mac_drag_thumb(theControl, 0); /* Should it be thePortion ? (Dany) */
Bram Moolenaar071d4272004-06-13 20:20:40 +00001715 dragged_sb = NULL;
1716 }
1717 }
1718 else
1719 {
1720 /* We are inside the contents */
1721
1722 /* Convert the CTRL, OPTION, SHIFT and CMD key */
1723 vimModifiers = EventModifiers2VimMouseModifiers(theEvent->modifiers);
1724
1725 /* Defaults to MOUSE_LEFT as there's only one mouse button */
1726 vimMouseButton = MOUSE_LEFT;
1727
Bram Moolenaar071d4272004-06-13 20:20:40 +00001728 /* Convert the CTRL_MOUSE_LEFT to MOUSE_RIGHT */
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00001729 /* TODO: NEEDED? */
Bram Moolenaar071d4272004-06-13 20:20:40 +00001730 clickIsPopup = FALSE;
1731
Bram Moolenaare02d7b22007-06-19 14:29:43 +00001732 if (mouse_model_popup() && IsShowContextualMenuClick(theEvent))
1733 {
1734 vimMouseButton = MOUSE_RIGHT;
1735 vimModifiers &= ~MOUSE_CTRL;
1736 clickIsPopup = TRUE;
1737 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00001738
1739 /* Is it a double click ? */
1740 dblClick = ((theEvent->when - lastMouseTick) < GetDblTime());
1741
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00001742 /* Send the mouse click to Vim */
Bram Moolenaar071d4272004-06-13 20:20:40 +00001743 gui_send_mouse_event(vimMouseButton, thePoint.h,
1744 thePoint.v, dblClick, vimModifiers);
1745
1746 /* Create the rectangle around the cursor to detect
1747 * the mouse dragging
1748 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00001749#if 0
1750 /* TODO: Do we need to this even for the contextual menu?
1751 * It may be require for popup_setpos, but for popup?
1752 */
1753 if (vimMouseButton == MOUSE_LEFT)
1754#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00001755 {
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00001756 SetRect(&dragRect, FILL_X(X_2_COL(thePoint.h)),
Bram Moolenaar071d4272004-06-13 20:20:40 +00001757 FILL_Y(Y_2_ROW(thePoint.v)),
1758 FILL_X(X_2_COL(thePoint.h)+1),
1759 FILL_Y(Y_2_ROW(thePoint.v)+1));
1760
1761 dragRectEnbl = TRUE;
1762 dragRectControl = kCreateRect;
1763 }
1764 }
1765}
1766
1767/*
1768 * Handle the click in the titlebar (to move the window)
1769 */
1770 void
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00001771gui_mac_doInDragClick(Point where, WindowPtr whichWindow)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001772{
1773 Rect movingLimits;
1774 Rect *movingLimitsPtr = &movingLimits;
1775
1776 /* TODO: may try to prevent move outside screen? */
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00001777 movingLimitsPtr = GetRegionBounds(GetGrayRgn(), &movingLimits);
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00001778 DragWindow(whichWindow, where, movingLimitsPtr);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001779}
1780
1781/*
1782 * Handle the click in the grow box
1783 */
1784 void
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00001785gui_mac_doInGrowClick(Point where, WindowPtr whichWindow)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001786{
1787
1788 long newSize;
1789 unsigned short newWidth;
1790 unsigned short newHeight;
1791 Rect resizeLimits;
1792 Rect *resizeLimitsPtr = &resizeLimits;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001793 Rect NewContentRect;
1794
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00001795 resizeLimitsPtr = GetRegionBounds(GetGrayRgn(), &resizeLimits);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001796
Bram Moolenaar720c7102007-05-10 18:07:50 +00001797 /* Set the minimum size */
Bram Moolenaar071d4272004-06-13 20:20:40 +00001798 /* TODO: Should this come from Vim? */
1799 resizeLimits.top = 100;
1800 resizeLimits.left = 100;
1801
Bram Moolenaar071d4272004-06-13 20:20:40 +00001802 newSize = ResizeWindow(whichWindow, where, &resizeLimits, &NewContentRect);
1803 newWidth = NewContentRect.right - NewContentRect.left;
1804 newHeight = NewContentRect.bottom - NewContentRect.top;
1805 gui_resize_shell(newWidth, newHeight);
1806 gui_mch_set_bg_color(gui.back_pixel);
Bram Moolenaarafa24992006-03-27 20:58:26 +00001807 gui_set_shellsize(TRUE, FALSE, RESIZE_BOTH);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001808}
1809
1810/*
1811 * Handle the click in the zoom box
1812 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00001813 static void
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00001814gui_mac_doInZoomClick(EventRecord *theEvent, WindowPtr whichWindow)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001815{
1816 Rect r;
1817 Point p;
1818 short thePart;
1819
1820 /* ideal width is current */
1821 p.h = Columns * gui.char_width + 2 * gui.border_offset;
1822 if (gui.which_scrollbars[SBAR_LEFT])
1823 p.h += gui.scrollbar_width;
1824 if (gui.which_scrollbars[SBAR_RIGHT])
1825 p.h += gui.scrollbar_width;
Bram Moolenaarb05034a2010-09-21 17:34:31 +02001826 /* ideal height is as high as we can get */
Bram Moolenaar071d4272004-06-13 20:20:40 +00001827 p.v = 15 * 1024;
1828
1829 thePart = IsWindowInStandardState(whichWindow, &p, &r)
1830 ? inZoomIn : inZoomOut;
1831
1832 if (!TrackBox(whichWindow, theEvent->where, thePart))
1833 return;
1834
1835 /* use returned width */
1836 p.h = r.right - r.left;
1837 /* adjust returned height */
1838 p.v = r.bottom - r.top - 2 * gui.border_offset;
1839 if (gui.which_scrollbars[SBAR_BOTTOM])
1840 p.v -= gui.scrollbar_height;
1841 p.v -= p.v % gui.char_height;
1842 p.v += 2 * gui.border_width;
Bram Moolenaard8644bd2011-06-12 20:33:38 +02001843 if (gui.which_scrollbars[SBAR_BOTTOM])
Bram Moolenaar071d4272004-06-13 20:20:40 +00001844 p.v += gui.scrollbar_height;
1845
1846 ZoomWindowIdeal(whichWindow, thePart, &p);
1847
1848 GetWindowBounds(whichWindow, kWindowContentRgn, &r);
1849 gui_resize_shell(r.right - r.left, r.bottom - r.top);
1850 gui_mch_set_bg_color(gui.back_pixel);
Bram Moolenaarafa24992006-03-27 20:58:26 +00001851 gui_set_shellsize(TRUE, FALSE, RESIZE_BOTH);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001852}
Bram Moolenaar071d4272004-06-13 20:20:40 +00001853
1854/*
1855 * ------------------------------------------------------------
1856 * MacOS Event Handling procedure
1857 * ------------------------------------------------------------
1858 */
1859
1860/*
1861 * Handle the Update Event
1862 */
1863
1864 void
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00001865gui_mac_doUpdateEvent(EventRecord *event)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001866{
1867 WindowPtr whichWindow;
1868 GrafPtr savePort;
1869 RgnHandle updateRgn;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001870 Rect updateRect;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001871 Rect *updateRectPtr;
1872 Rect rc;
1873 Rect growRect;
1874 RgnHandle saveRgn;
1875
1876
Bram Moolenaar071d4272004-06-13 20:20:40 +00001877 updateRgn = NewRgn();
1878 if (updateRgn == NULL)
1879 return;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001880
1881 /* This could be done by the caller as we
1882 * don't require anything else out of the event
1883 */
1884 whichWindow = (WindowPtr) event->message;
1885
1886 /* Save Current Port */
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00001887 GetPort(&savePort);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001888
1889 /* Select the Window's Port */
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00001890 SetPortWindowPort(whichWindow);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001891
1892 /* Let's update the window */
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00001893 BeginUpdate(whichWindow);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001894 /* Redraw the biggest rectangle covering the area
1895 * to be updated.
1896 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00001897 GetPortVisibleRegion(GetWindowPort(whichWindow), updateRgn);
1898# if 0
Bram Moolenaar720c7102007-05-10 18:07:50 +00001899 /* Would be more appropriate to use the following but doesn't
Bram Moolenaar071d4272004-06-13 20:20:40 +00001900 * seem to work under MacOS X (Dany)
1901 */
1902 GetWindowRegion(whichWindow, kWindowUpdateRgn, updateRgn);
1903# endif
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00001904
Bram Moolenaar071d4272004-06-13 20:20:40 +00001905 /* Use the HLock useless in Carbon? Is it harmful?*/
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00001906 HLock((Handle) updateRgn);
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00001907
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00001908 updateRectPtr = GetRegionBounds(updateRgn, &updateRect);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001909# if 0
1910 /* Code from original Carbon Port (using GetWindowRegion.
1911 * I believe the UpdateRgn is already in local (Dany)
1912 */
1913 GlobalToLocal(&topLeft(updateRect)); /* preCarbon? */
1914 GlobalToLocal(&botRight(updateRect));
1915# endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00001916 /* Update the content (i.e. the text) */
1917 gui_redraw(updateRectPtr->left, updateRectPtr->top,
1918 updateRectPtr->right - updateRectPtr->left,
1919 updateRectPtr->bottom - updateRectPtr->top);
1920 /* Clear the border areas if needed */
1921 gui_mch_set_bg_color(gui.back_pixel);
1922 if (updateRectPtr->left < FILL_X(0))
1923 {
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00001924 SetRect(&rc, 0, 0, FILL_X(0), FILL_Y(Rows));
1925 EraseRect(&rc);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001926 }
1927 if (updateRectPtr->top < FILL_Y(0))
1928 {
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00001929 SetRect(&rc, 0, 0, FILL_X(Columns), FILL_Y(0));
1930 EraseRect(&rc);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001931 }
1932 if (updateRectPtr->right > FILL_X(Columns))
1933 {
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00001934 SetRect(&rc, FILL_X(Columns), 0,
Bram Moolenaar071d4272004-06-13 20:20:40 +00001935 FILL_X(Columns) + gui.border_offset, FILL_Y(Rows));
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00001936 EraseRect(&rc);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001937 }
1938 if (updateRectPtr->bottom > FILL_Y(Rows))
1939 {
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00001940 SetRect(&rc, 0, FILL_Y(Rows), FILL_X(Columns) + gui.border_offset,
Bram Moolenaar071d4272004-06-13 20:20:40 +00001941 FILL_Y(Rows) + gui.border_offset);
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00001942 EraseRect(&rc);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001943 }
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00001944 HUnlock((Handle) updateRgn);
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00001945 DisposeRgn(updateRgn);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001946
1947 /* Update scrollbars */
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00001948 DrawControls(whichWindow);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001949
1950 /* Update the GrowBox */
1951 /* Taken from FAQ 33-27 */
1952 saveRgn = NewRgn();
Bram Moolenaar071d4272004-06-13 20:20:40 +00001953 GetWindowBounds(whichWindow, kWindowGrowRgn, &growRect);
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00001954 GetClip(saveRgn);
1955 ClipRect(&growRect);
1956 DrawGrowIcon(whichWindow);
1957 SetClip(saveRgn);
1958 DisposeRgn(saveRgn);
1959 EndUpdate(whichWindow);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001960
1961 /* Restore original Port */
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00001962 SetPort(savePort);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001963}
1964
1965/*
1966 * Handle the activate/deactivate event
1967 * (apply to a window)
1968 */
1969 void
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00001970gui_mac_doActivateEvent(EventRecord *event)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001971{
1972 WindowPtr whichWindow;
1973
1974 whichWindow = (WindowPtr) event->message;
Bram Moolenaare02d7b22007-06-19 14:29:43 +00001975 /* Dim scrollbars */
1976 if (whichWindow == gui.VimWindow)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001977 {
Bram Moolenaar1b60e502008-03-12 13:40:54 +00001978 ControlRef rootControl;
1979 GetRootControl(gui.VimWindow, &rootControl);
1980 if ((event->modifiers) & activeFlag)
1981 ActivateControl(rootControl);
1982 else
1983 DeactivateControl(rootControl);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001984 }
Bram Moolenaare02d7b22007-06-19 14:29:43 +00001985
1986 /* Activate */
1987 gui_focus_change((event->modifiers) & activeFlag);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001988}
1989
1990
1991/*
1992 * Handle the suspend/resume event
1993 * (apply to the application)
1994 */
1995 void
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00001996gui_mac_doSuspendEvent(EventRecord *event)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001997{
1998 /* The frontmost application just changed */
1999
2000 /* NOTE: the suspend may happen before the deactivate
2001 * seen on MacOS X
2002 */
2003
2004 /* May not need to change focus as the window will
Bram Moolenaar720c7102007-05-10 18:07:50 +00002005 * get an activate/deactivate event
Bram Moolenaar071d4272004-06-13 20:20:40 +00002006 */
2007 if (event->message & 1)
2008 /* Resume */
2009 gui_focus_change(TRUE);
2010 else
2011 /* Suspend */
2012 gui_focus_change(FALSE);
2013}
2014
2015/*
2016 * Handle the key
2017 */
Bram Moolenaar26a60b42005-02-22 08:49:11 +00002018#ifdef USE_CARBONKEYHANDLER
Bram Moolenaar1b60e502008-03-12 13:40:54 +00002019 static pascal OSStatus
2020gui_mac_handle_window_activate(
2021 EventHandlerCallRef nextHandler,
2022 EventRef theEvent,
2023 void *data)
2024{
2025 UInt32 eventClass = GetEventClass(theEvent);
2026 UInt32 eventKind = GetEventKind(theEvent);
Bram Moolenaard68071d2006-05-02 22:08:30 +00002027
Bram Moolenaar1b60e502008-03-12 13:40:54 +00002028 if (eventClass == kEventClassWindow)
2029 {
2030 switch (eventKind)
2031 {
2032 case kEventWindowActivated:
2033#if defined(USE_IM_CONTROL)
2034 im_on_window_switch(TRUE);
2035#endif
2036 return noErr;
2037
2038 case kEventWindowDeactivated:
2039#if defined(USE_IM_CONTROL)
2040 im_on_window_switch(FALSE);
2041#endif
2042 return noErr;
2043 }
2044 }
2045
2046 return eventNotHandledErr;
2047}
2048
2049 static pascal OSStatus
2050gui_mac_handle_text_input(
2051 EventHandlerCallRef nextHandler,
2052 EventRef theEvent,
2053 void *data)
2054{
2055 UInt32 eventClass = GetEventClass(theEvent);
2056 UInt32 eventKind = GetEventKind(theEvent);
2057
2058 if (eventClass != kEventClassTextInput)
2059 return eventNotHandledErr;
2060
2061 if ((kEventTextInputUpdateActiveInputArea != eventKind) &&
2062 (kEventTextInputUnicodeForKeyEvent != eventKind) &&
2063 (kEventTextInputOffsetToPos != eventKind) &&
2064 (kEventTextInputPosToOffset != eventKind) &&
2065 (kEventTextInputGetSelectedText != eventKind))
2066 return eventNotHandledErr;
2067
2068 switch (eventKind)
2069 {
2070 case kEventTextInputUpdateActiveInputArea:
2071 return gui_mac_update_input_area(nextHandler, theEvent);
2072 case kEventTextInputUnicodeForKeyEvent:
2073 return gui_mac_unicode_key_event(nextHandler, theEvent);
2074
2075 case kEventTextInputOffsetToPos:
2076 case kEventTextInputPosToOffset:
2077 case kEventTextInputGetSelectedText:
2078 break;
2079 }
2080
2081 return eventNotHandledErr;
2082}
2083
2084 static pascal
2085OSStatus gui_mac_update_input_area(
2086 EventHandlerCallRef nextHandler,
2087 EventRef theEvent)
2088{
2089 return eventNotHandledErr;
2090}
2091
2092static int dialog_busy = FALSE; /* TRUE when gui_mch_dialog() wants the
2093 keys */
Bram Moolenaard68071d2006-05-02 22:08:30 +00002094
Bram Moolenaar26a60b42005-02-22 08:49:11 +00002095# define INLINE_KEY_BUFFER_SIZE 80
2096 static pascal OSStatus
Bram Moolenaar1b60e502008-03-12 13:40:54 +00002097gui_mac_unicode_key_event(
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00002098 EventHandlerCallRef nextHandler,
Bram Moolenaar1b60e502008-03-12 13:40:54 +00002099 EventRef theEvent)
Bram Moolenaar26a60b42005-02-22 08:49:11 +00002100{
2101 /* Multibyte-friendly key event handler */
Bram Moolenaaradcb9492006-10-17 10:51:57 +00002102 OSStatus err = -1;
Bram Moolenaar26a60b42005-02-22 08:49:11 +00002103 UInt32 actualSize;
2104 UniChar *text;
2105 char_u result[INLINE_KEY_BUFFER_SIZE];
2106 short len = 0;
2107 UInt32 key_sym;
2108 char charcode;
2109 int key_char;
Bram Moolenaaradcb9492006-10-17 10:51:57 +00002110 UInt32 modifiers, vimModifiers;
Bram Moolenaar26a60b42005-02-22 08:49:11 +00002111 size_t encLen;
2112 char_u *to = NULL;
2113 Boolean isSpecial = FALSE;
2114 int i;
Bram Moolenaar1b60e502008-03-12 13:40:54 +00002115 EventRef keyEvent;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002116
Bram Moolenaar26a60b42005-02-22 08:49:11 +00002117 /* Mask the mouse (as per user setting) */
2118 if (p_mh)
2119 ObscureCursor();
2120
Bram Moolenaaradcb9492006-10-17 10:51:57 +00002121 /* Don't use the keys when the dialog wants them. */
2122 if (dialog_busy)
Bram Moolenaar1b60e502008-03-12 13:40:54 +00002123 return eventNotHandledErr;
Bram Moolenaard68071d2006-05-02 22:08:30 +00002124
Bram Moolenaaradcb9492006-10-17 10:51:57 +00002125 if (noErr != GetEventParameter(theEvent, kEventParamTextInputSendText,
Bram Moolenaar1b60e502008-03-12 13:40:54 +00002126 typeUnicodeText, NULL, 0, &actualSize, NULL))
2127 return eventNotHandledErr;
Bram Moolenaar26a60b42005-02-22 08:49:11 +00002128
Bram Moolenaaradcb9492006-10-17 10:51:57 +00002129 text = (UniChar *)alloc(actualSize);
2130 if (!text)
Bram Moolenaar1b60e502008-03-12 13:40:54 +00002131 return eventNotHandledErr;
Bram Moolenaar26a60b42005-02-22 08:49:11 +00002132
Bram Moolenaaradcb9492006-10-17 10:51:57 +00002133 err = GetEventParameter(theEvent, kEventParamTextInputSendText,
Bram Moolenaar1b60e502008-03-12 13:40:54 +00002134 typeUnicodeText, NULL, actualSize, NULL, text);
Bram Moolenaaradcb9492006-10-17 10:51:57 +00002135 require_noerr(err, done);
Bram Moolenaar26a60b42005-02-22 08:49:11 +00002136
Bram Moolenaaradcb9492006-10-17 10:51:57 +00002137 err = GetEventParameter(theEvent, kEventParamTextInputSendKeyboardEvent,
Bram Moolenaar1b60e502008-03-12 13:40:54 +00002138 typeEventRef, NULL, sizeof(EventRef), NULL, &keyEvent);
Bram Moolenaaradcb9492006-10-17 10:51:57 +00002139 require_noerr(err, done);
Bram Moolenaar26a60b42005-02-22 08:49:11 +00002140
Bram Moolenaaradcb9492006-10-17 10:51:57 +00002141 err = GetEventParameter(keyEvent, kEventParamKeyModifiers,
Bram Moolenaar1b60e502008-03-12 13:40:54 +00002142 typeUInt32, NULL, sizeof(UInt32), NULL, &modifiers);
Bram Moolenaaradcb9492006-10-17 10:51:57 +00002143 require_noerr(err, done);
Bram Moolenaar26a60b42005-02-22 08:49:11 +00002144
Bram Moolenaaradcb9492006-10-17 10:51:57 +00002145 err = GetEventParameter(keyEvent, kEventParamKeyCode,
Bram Moolenaar1b60e502008-03-12 13:40:54 +00002146 typeUInt32, NULL, sizeof(UInt32), NULL, &key_sym);
Bram Moolenaaradcb9492006-10-17 10:51:57 +00002147 require_noerr(err, done);
Bram Moolenaar26a60b42005-02-22 08:49:11 +00002148
Bram Moolenaaradcb9492006-10-17 10:51:57 +00002149 err = GetEventParameter(keyEvent, kEventParamKeyMacCharCodes,
Bram Moolenaar1b60e502008-03-12 13:40:54 +00002150 typeChar, NULL, sizeof(char), NULL, &charcode);
Bram Moolenaaradcb9492006-10-17 10:51:57 +00002151 require_noerr(err, done);
2152
Bram Moolenaar26a60b42005-02-22 08:49:11 +00002153#ifndef USE_CMD_KEY
Bram Moolenaaradcb9492006-10-17 10:51:57 +00002154 if (modifiers & cmdKey)
Bram Moolenaar1b60e502008-03-12 13:40:54 +00002155 goto done; /* Let system handle Cmd+... */
Bram Moolenaar26a60b42005-02-22 08:49:11 +00002156#endif
Bram Moolenaar26a60b42005-02-22 08:49:11 +00002157
Bram Moolenaaradcb9492006-10-17 10:51:57 +00002158 key_char = charcode;
2159 vimModifiers = EventModifiers2VimModifiers(modifiers);
Bram Moolenaar26a60b42005-02-22 08:49:11 +00002160
Bram Moolenaaradcb9492006-10-17 10:51:57 +00002161 /* Find the special key (eg., for cursor keys) */
2162 if (actualSize <= sizeof(UniChar) &&
Bram Moolenaar1b60e502008-03-12 13:40:54 +00002163 ((text[0] < 0x20) || (text[0] == 0x7f)))
Bram Moolenaaradcb9492006-10-17 10:51:57 +00002164 {
Bram Moolenaar1b60e502008-03-12 13:40:54 +00002165 for (i = 0; special_keys[i].key_sym != (KeySym)0; ++i)
2166 if (special_keys[i].key_sym == key_sym)
2167 {
2168 key_char = TO_SPECIAL(special_keys[i].vim_code0,
2169 special_keys[i].vim_code1);
2170 key_char = simplify_key(key_char,
2171 (int *)&vimModifiers);
2172 isSpecial = TRUE;
2173 break;
2174 }
Bram Moolenaar26a60b42005-02-22 08:49:11 +00002175 }
Bram Moolenaar26a60b42005-02-22 08:49:11 +00002176
Bram Moolenaaradcb9492006-10-17 10:51:57 +00002177 /* Intercept CMD-. and CTRL-c */
2178 if (((modifiers & controlKey) && key_char == 'c') ||
Bram Moolenaar1b60e502008-03-12 13:40:54 +00002179 ((modifiers & cmdKey) && key_char == '.'))
2180 got_int = TRUE;
Bram Moolenaaradcb9492006-10-17 10:51:57 +00002181
2182 if (!isSpecial)
2183 {
Bram Moolenaar1b60e502008-03-12 13:40:54 +00002184 /* remove SHIFT for keys that are already shifted, e.g.,
2185 * '(' and '*' */
2186 if (key_char < 0x100 && !isalpha(key_char) && isprint(key_char))
2187 vimModifiers &= ~MOD_MASK_SHIFT;
Bram Moolenaaradcb9492006-10-17 10:51:57 +00002188
Bram Moolenaar1b60e502008-03-12 13:40:54 +00002189 /* remove CTRL from keys that already have it */
2190 if (key_char < 0x20)
2191 vimModifiers &= ~MOD_MASK_CTRL;
Bram Moolenaaradcb9492006-10-17 10:51:57 +00002192
Bram Moolenaar1b60e502008-03-12 13:40:54 +00002193 /* don't process unicode characters here */
2194 if (!IS_SPECIAL(key_char))
2195 {
2196 /* Following code to simplify and consolidate vimModifiers
2197 * taken liberally from gui_w48.c */
2198 key_char = simplify_key(key_char, (int *)&vimModifiers);
Bram Moolenaaradcb9492006-10-17 10:51:57 +00002199
Bram Moolenaar1b60e502008-03-12 13:40:54 +00002200 /* Interpret META, include SHIFT, etc. */
2201 key_char = extract_modifiers(key_char, (int *)&vimModifiers);
2202 if (key_char == CSI)
2203 key_char = K_CSI;
Bram Moolenaaradcb9492006-10-17 10:51:57 +00002204
Bram Moolenaar1b60e502008-03-12 13:40:54 +00002205 if (IS_SPECIAL(key_char))
2206 isSpecial = TRUE;
2207 }
Bram Moolenaaradcb9492006-10-17 10:51:57 +00002208 }
2209
2210 if (vimModifiers)
2211 {
Bram Moolenaar1b60e502008-03-12 13:40:54 +00002212 result[len++] = CSI;
2213 result[len++] = KS_MODIFIER;
2214 result[len++] = vimModifiers;
Bram Moolenaaradcb9492006-10-17 10:51:57 +00002215 }
2216
2217 if (isSpecial && IS_SPECIAL(key_char))
2218 {
Bram Moolenaar1b60e502008-03-12 13:40:54 +00002219 result[len++] = CSI;
2220 result[len++] = K_SECOND(key_char);
2221 result[len++] = K_THIRD(key_char);
Bram Moolenaaradcb9492006-10-17 10:51:57 +00002222 }
2223 else
2224 {
Bram Moolenaar1b60e502008-03-12 13:40:54 +00002225 encLen = actualSize;
2226 to = mac_utf16_to_enc(text, actualSize, &encLen);
2227 if (to)
2228 {
2229 /* This is basically add_to_input_buf_csi() */
2230 for (i = 0; i < encLen && len < (INLINE_KEY_BUFFER_SIZE-1); ++i)
2231 {
2232 result[len++] = to[i];
2233 if (to[i] == CSI)
2234 {
2235 result[len++] = KS_EXTRA;
2236 result[len++] = (int)KE_CSI;
2237 }
2238 }
2239 vim_free(to);
2240 }
Bram Moolenaaradcb9492006-10-17 10:51:57 +00002241 }
2242
2243 add_to_input_buf(result, len);
2244 err = noErr;
2245
2246done:
2247 vim_free(text);
2248 if (err == noErr)
2249 {
Bram Moolenaar1b60e502008-03-12 13:40:54 +00002250 /* Fake event to wake up WNE (required to get
2251 * key repeat working */
2252 PostEvent(keyUp, 0);
2253 return noErr;
Bram Moolenaaradcb9492006-10-17 10:51:57 +00002254 }
2255
2256 return eventNotHandledErr;
Bram Moolenaar26a60b42005-02-22 08:49:11 +00002257}
2258#else
Bram Moolenaar071d4272004-06-13 20:20:40 +00002259 void
2260gui_mac_doKeyEvent(EventRecord *theEvent)
2261{
2262 /* TODO: add support for COMMAND KEY */
2263 long menu;
2264 unsigned char string[20];
2265 short num, i;
2266 short len = 0;
2267 KeySym key_sym;
2268 int key_char;
2269 int modifiers;
Bram Moolenaar3fdfa4a2004-10-07 21:02:47 +00002270 int simplify = FALSE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002271
2272 /* Mask the mouse (as per user setting) */
2273 if (p_mh)
2274 ObscureCursor();
2275
2276 /* Get the key code and it's ASCII representation */
2277 key_sym = ((theEvent->message & keyCodeMask) >> 8);
2278 key_char = theEvent->message & charCodeMask;
2279 num = 1;
2280
2281 /* Intercept CTRL-C */
2282 if (theEvent->modifiers & controlKey)
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00002283 {
Bram Moolenaar071d4272004-06-13 20:20:40 +00002284 if (key_char == Ctrl_C && ctrl_c_interrupts)
2285 got_int = TRUE;
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00002286 else if ((theEvent->modifiers & ~(controlKey|shiftKey)) == 0
2287 && (key_char == '2' || key_char == '6'))
2288 {
2289 /* CTRL-^ and CTRL-@ don't work in the normal way. */
2290 if (key_char == '2')
2291 key_char = Ctrl_AT;
2292 else
2293 key_char = Ctrl_HAT;
2294 theEvent->modifiers = 0;
2295 }
2296 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00002297
2298 /* Intercept CMD-. */
2299 if (theEvent->modifiers & cmdKey)
2300 if (key_char == '.')
2301 got_int = TRUE;
2302
2303 /* Handle command key as per menu */
2304 /* TODO: should override be allowed? Require YAO or could use 'winaltkey' */
2305 if (theEvent->modifiers & cmdKey)
2306 /* Only accept CMD alone or with CAPLOCKS and the mouse button.
2307 * Why the mouse button? */
2308 if ((theEvent->modifiers & (~(cmdKey | btnState | alphaLock))) == 0)
2309 {
2310 menu = MenuKey(key_char);
2311 if (HiWord(menu))
2312 {
2313 gui_mac_handle_menu(menu);
2314 return;
2315 }
2316 }
2317
2318 /* Convert the modifiers */
2319 modifiers = EventModifiers2VimModifiers(theEvent->modifiers);
2320
2321
2322 /* Handle special keys. */
2323#if 0
Bram Moolenaar3fdfa4a2004-10-07 21:02:47 +00002324 /* Why has this been removed? */
Bram Moolenaar071d4272004-06-13 20:20:40 +00002325 if (!(theEvent->modifiers & (cmdKey | controlKey | rightControlKey)))
2326#endif
2327 {
2328 /* Find the special key (for non-printable keyt_char) */
2329 if ((key_char < 0x20) || (key_char == 0x7f))
2330 for (i = 0; special_keys[i].key_sym != (KeySym)0; i++)
2331 if (special_keys[i].key_sym == key_sym)
2332 {
2333# if 0
2334 /* We currently don't have not so special key */
2335 if (special_keys[i].vim_code1 == NUL)
2336 key_char = special_keys[i].vim_code0;
2337 else
2338# endif
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00002339 key_char = TO_SPECIAL(special_keys[i].vim_code0,
2340 special_keys[i].vim_code1);
Bram Moolenaar3fdfa4a2004-10-07 21:02:47 +00002341 simplify = TRUE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002342 break;
2343 }
2344 }
2345
Bram Moolenaar3fdfa4a2004-10-07 21:02:47 +00002346 /* For some keys the modifier is included in the char itself. */
2347 if (simplify || key_char == TAB || key_char == ' ')
2348 key_char = simplify_key(key_char, &modifiers);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002349
2350 /* Add the modifier to the input bu if needed */
2351 /* Do not want SHIFT-A or CTRL-A with modifier */
2352 if (!IS_SPECIAL(key_char)
2353 && key_sym != vk_Space
2354 && key_sym != vk_Tab
2355 && key_sym != vk_Return
2356 && key_sym != vk_Enter
2357 && key_sym != vk_Esc)
2358 {
2359#if 1
2360 /* Clear modifiers when only one modifier is set */
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00002361 if ((modifiers == MOD_MASK_SHIFT)
2362 || (modifiers == MOD_MASK_CTRL)
2363 || (modifiers == MOD_MASK_ALT))
Bram Moolenaar071d4272004-06-13 20:20:40 +00002364 modifiers = 0;
2365#else
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00002366 if (modifiers & MOD_MASK_CTRL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002367 modifiers = modifiers & ~MOD_MASK_CTRL;
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00002368 if (modifiers & MOD_MASK_ALT)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002369 modifiers = modifiers & ~MOD_MASK_ALT;
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00002370 if (modifiers & MOD_MASK_SHIFT)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002371 modifiers = modifiers & ~MOD_MASK_SHIFT;
2372#endif
2373 }
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00002374 if (modifiers)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002375 {
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00002376 string[len++] = CSI;
2377 string[len++] = KS_MODIFIER;
2378 string[len++] = modifiers;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002379 }
2380
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00002381 if (IS_SPECIAL(key_char))
Bram Moolenaar071d4272004-06-13 20:20:40 +00002382 {
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00002383 string[len++] = CSI;
2384 string[len++] = K_SECOND(key_char);
2385 string[len++] = K_THIRD(key_char);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002386 }
2387 else
2388 {
2389#ifdef FEAT_MBYTE
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00002390 /* Convert characters when needed (e.g., from MacRoman to latin1).
2391 * This doesn't work for the NUL byte. */
2392 if (input_conv.vc_type != CONV_NONE && key_char > 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002393 {
2394 char_u from[2], *to;
2395 int l;
2396
2397 from[0] = key_char;
2398 from[1] = NUL;
2399 l = 1;
2400 to = string_convert(&input_conv, from, &l);
2401 if (to != NULL)
2402 {
2403 for (i = 0; i < l && len < 19; i++)
2404 {
2405 if (to[i] == CSI)
2406 {
2407 string[len++] = KS_EXTRA;
2408 string[len++] = KE_CSI;
2409 }
2410 else
2411 string[len++] = to[i];
2412 }
2413 vim_free(to);
2414 }
2415 else
2416 string[len++] = key_char;
2417 }
2418 else
2419#endif
2420 string[len++] = key_char;
2421 }
2422
2423 if (len == 1 && string[0] == CSI)
2424 {
2425 /* Turn CSI into K_CSI. */
2426 string[ len++ ] = KS_EXTRA;
2427 string[ len++ ] = KE_CSI;
2428 }
2429
2430 add_to_input_buf(string, len);
2431}
Bram Moolenaar26a60b42005-02-22 08:49:11 +00002432#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00002433
2434/*
2435 * Handle MouseClick
2436 */
2437 void
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00002438gui_mac_doMouseDownEvent(EventRecord *theEvent)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002439{
2440 short thePart;
2441 WindowPtr whichWindow;
2442
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00002443 thePart = FindWindow(theEvent->where, &whichWindow);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002444
Bram Moolenaar79ee3152007-04-26 16:20:50 +00002445#ifdef FEAT_GUI_TABLINE
2446 /* prevent that the vim window size changes if it's activated by a
2447 click into the tab pane */
2448 if (whichWindow == drawer)
Bram Moolenaar1b60e502008-03-12 13:40:54 +00002449 return;
Bram Moolenaar79ee3152007-04-26 16:20:50 +00002450#endif
2451
Bram Moolenaar071d4272004-06-13 20:20:40 +00002452 switch (thePart)
2453 {
2454 case (inDesk):
2455 /* TODO: what to do? */
2456 break;
2457
2458 case (inMenuBar):
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00002459 gui_mac_handle_menu(MenuSelect(theEvent->where));
Bram Moolenaar071d4272004-06-13 20:20:40 +00002460 break;
2461
2462 case (inContent):
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00002463 gui_mac_doInContentClick(theEvent, whichWindow);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002464 break;
2465
2466 case (inDrag):
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00002467 gui_mac_doInDragClick(theEvent->where, whichWindow);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002468 break;
2469
2470 case (inGrow):
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00002471 gui_mac_doInGrowClick(theEvent->where, whichWindow);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002472 break;
2473
2474 case (inGoAway):
2475 if (TrackGoAway(whichWindow, theEvent->where))
2476 gui_shell_closed();
2477 break;
2478
2479 case (inZoomIn):
2480 case (inZoomOut):
Bram Moolenaar071d4272004-06-13 20:20:40 +00002481 gui_mac_doInZoomClick(theEvent, whichWindow);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002482 break;
2483 }
2484}
2485
2486/*
2487 * Handle MouseMoved
2488 * [this event is a moving in and out of a region]
2489 */
2490 void
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00002491gui_mac_doMouseMovedEvent(EventRecord *event)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002492{
2493 Point thePoint;
2494 int_u vimModifiers;
2495
2496 thePoint = event->where;
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00002497 GlobalToLocal(&thePoint);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002498 vimModifiers = EventModifiers2VimMouseModifiers(event->modifiers);
2499
2500 if (!Button())
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00002501 gui_mouse_moved(thePoint.h, thePoint.v);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002502 else
Bram Moolenaar071d4272004-06-13 20:20:40 +00002503 if (!clickIsPopup)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002504 gui_send_mouse_event(MOUSE_DRAG, thePoint.h,
2505 thePoint.v, FALSE, vimModifiers);
2506
2507 /* Reset the region from which we move in and out */
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00002508 SetRect(&dragRect, FILL_X(X_2_COL(thePoint.h)),
Bram Moolenaar071d4272004-06-13 20:20:40 +00002509 FILL_Y(Y_2_ROW(thePoint.v)),
2510 FILL_X(X_2_COL(thePoint.h)+1),
2511 FILL_Y(Y_2_ROW(thePoint.v)+1));
2512
2513 if (dragRectEnbl)
2514 dragRectControl = kCreateRect;
2515
2516}
2517
2518/*
2519 * Handle the mouse release
2520 */
2521 void
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00002522gui_mac_doMouseUpEvent(EventRecord *theEvent)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002523{
2524 Point thePoint;
2525 int_u vimModifiers;
2526
2527 /* TODO: Properly convert the Contextual menu mouse-up */
2528 /* Potential source of the double menu */
2529 lastMouseTick = theEvent->when;
2530 dragRectEnbl = FALSE;
2531 dragRectControl = kCreateEmpty;
2532 thePoint = theEvent->where;
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00002533 GlobalToLocal(&thePoint);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002534
2535 vimModifiers = EventModifiers2VimMouseModifiers(theEvent->modifiers);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002536 if (clickIsPopup)
2537 {
2538 vimModifiers &= ~MOUSE_CTRL;
2539 clickIsPopup = FALSE;
2540 }
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00002541 gui_send_mouse_event(MOUSE_RELEASE, thePoint.h, thePoint.v, FALSE, vimModifiers);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002542}
2543
Bram Moolenaar071d4272004-06-13 20:20:40 +00002544 static pascal OSStatus
2545gui_mac_mouse_wheel(EventHandlerCallRef nextHandler, EventRef theEvent,
2546 void *data)
2547{
Bram Moolenaar071d4272004-06-13 20:20:40 +00002548 Point point;
2549 Rect bounds;
2550 UInt32 mod;
2551 SInt32 delta;
2552 int_u vim_mod;
Bram Moolenaar621e2fd2006-08-22 19:36:17 +00002553 EventMouseWheelAxis axis;
2554
2555 if (noErr == GetEventParameter(theEvent, kEventParamMouseWheelAxis,
2556 typeMouseWheelAxis, NULL, sizeof(axis), NULL, &axis)
2557 && axis != kEventMouseWheelAxisY)
2558 goto bail; /* Vim only does up-down scrolling */
Bram Moolenaar071d4272004-06-13 20:20:40 +00002559
2560 if (noErr != GetEventParameter(theEvent, kEventParamMouseWheelDelta,
2561 typeSInt32, NULL, sizeof(SInt32), NULL, &delta))
2562 goto bail;
2563 if (noErr != GetEventParameter(theEvent, kEventParamMouseLocation,
2564 typeQDPoint, NULL, sizeof(Point), NULL, &point))
2565 goto bail;
2566 if (noErr != GetEventParameter(theEvent, kEventParamKeyModifiers,
2567 typeUInt32, NULL, sizeof(UInt32), NULL, &mod))
2568 goto bail;
2569
2570 vim_mod = 0;
2571 if (mod & shiftKey)
2572 vim_mod |= MOUSE_SHIFT;
2573 if (mod & controlKey)
2574 vim_mod |= MOUSE_CTRL;
2575 if (mod & optionKey)
2576 vim_mod |= MOUSE_ALT;
2577
Bram Moolenaar071d4272004-06-13 20:20:40 +00002578 if (noErr == GetWindowBounds(gui.VimWindow, kWindowContentRgn, &bounds))
2579 {
2580 point.h -= bounds.left;
2581 point.v -= bounds.top;
2582 }
2583
2584 gui_send_mouse_event((delta > 0) ? MOUSE_4 : MOUSE_5,
2585 point.h, point.v, FALSE, vim_mod);
2586
Bram Moolenaarc236c162008-07-13 17:41:49 +00002587 /* post a bogus event to wake up WaitNextEvent */
2588 PostEvent(keyUp, 0);
2589
Bram Moolenaar071d4272004-06-13 20:20:40 +00002590 return noErr;
2591
Bram Moolenaarbbe8c3f2007-04-26 16:40:56 +00002592bail:
Bram Moolenaar071d4272004-06-13 20:20:40 +00002593 /*
2594 * when we fail give any additional callback handler a chance to perform
2595 * it's actions
2596 */
2597 return CallNextEventHandler(nextHandler, theEvent);
2598}
Bram Moolenaar071d4272004-06-13 20:20:40 +00002599
Bram Moolenaare00289d2010-08-14 21:56:42 +02002600 void
2601gui_mch_mousehide(int hide)
2602{
2603 /* TODO */
2604}
2605
Bram Moolenaar071d4272004-06-13 20:20:40 +00002606#if 0
2607
2608/*
2609 * This would be the normal way of invoking the contextual menu
2610 * but the Vim API doesn't seem to a support a request to get
2611 * the menu that we should display
2612 */
2613 void
2614gui_mac_handle_contextual_menu(event)
2615 EventRecord *event;
2616{
2617/*
2618 * Clone PopUp to use menu
2619 * Create a object descriptor for the current selection
2620 * Call the procedure
2621 */
2622
2623// Call to Handle Popup
2624 OSStatus status = ContextualMenuSelect(CntxMenu, event->where, false, kCMHelpItemNoHelp, "", NULL, &CntxType, &CntxMenuID, &CntxMenuItem);
2625
2626 if (status != noErr)
2627 return;
2628
2629 if (CntxType == kCMMenuItemSelected)
2630 {
2631 /* Handle the menu CntxMenuID, CntxMenuItem */
2632 /* The submenu can be handle directly by gui_mac_handle_menu */
Bram Moolenaar84a05ac2013-05-06 04:24:17 +02002633 /* But what about the current menu, is the many changed by ContextualMenuSelect */
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00002634 gui_mac_handle_menu((CntxMenuID << 16) + CntxMenuItem);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002635 }
2636 else if (CntxMenuID == kCMShowHelpSelected)
2637 {
2638 /* Should come up with the help */
2639 }
2640
2641}
2642#endif
2643
2644/*
2645 * Handle menubar selection
2646 */
2647 void
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00002648gui_mac_handle_menu(long menuChoice)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002649{
2650 short menu = HiWord(menuChoice);
2651 short item = LoWord(menuChoice);
2652 vimmenu_T *theVimMenu = root_menu;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002653
2654 if (menu == 256) /* TODO: use constant or gui.xyz */
2655 {
2656 if (item == 1)
2657 gui_mch_beep(); /* TODO: Popup dialog or do :intro */
Bram Moolenaar071d4272004-06-13 20:20:40 +00002658 }
2659 else if (item != 0)
2660 {
2661 theVimMenu = gui_mac_get_vim_menu(menu, item, root_menu);
2662
2663 if (theVimMenu)
2664 gui_menu_cb(theVimMenu);
2665 }
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00002666 HiliteMenu(0);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002667}
2668
2669/*
2670 * Dispatch the event to proper handler
2671 */
2672
2673 void
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00002674gui_mac_handle_event(EventRecord *event)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002675{
2676 OSErr error;
2677
2678 /* Handle contextual menu right now (if needed) */
Bram Moolenaare02d7b22007-06-19 14:29:43 +00002679 if (IsShowContextualMenuClick(event))
2680 {
Bram Moolenaar071d4272004-06-13 20:20:40 +00002681# if 0
Bram Moolenaar1b60e502008-03-12 13:40:54 +00002682 gui_mac_handle_contextual_menu(event);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002683# else
Bram Moolenaar1b60e502008-03-12 13:40:54 +00002684 gui_mac_doMouseDownEvent(event);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002685# endif
Bram Moolenaar1b60e502008-03-12 13:40:54 +00002686 return;
Bram Moolenaare02d7b22007-06-19 14:29:43 +00002687 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00002688
2689 /* Handle normal event */
2690 switch (event->what)
2691 {
Bram Moolenaar26a60b42005-02-22 08:49:11 +00002692#ifndef USE_CARBONKEYHANDLER
Bram Moolenaar071d4272004-06-13 20:20:40 +00002693 case (keyDown):
2694 case (autoKey):
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00002695 gui_mac_doKeyEvent(event);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002696 break;
Bram Moolenaar26a60b42005-02-22 08:49:11 +00002697#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00002698 case (keyUp):
Bram Moolenaard68071d2006-05-02 22:08:30 +00002699 /* We don't care about when the key is released */
Bram Moolenaar071d4272004-06-13 20:20:40 +00002700 break;
2701
2702 case (mouseDown):
2703 gui_mac_doMouseDownEvent(event);
2704 break;
2705
2706 case (mouseUp):
2707 gui_mac_doMouseUpEvent(event);
2708 break;
2709
2710 case (updateEvt):
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00002711 gui_mac_doUpdateEvent(event);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002712 break;
2713
2714 case (diskEvt):
2715 /* We don't need special handling for disk insertion */
2716 break;
2717
2718 case (activateEvt):
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00002719 gui_mac_doActivateEvent(event);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002720 break;
2721
2722 case (osEvt):
2723 switch ((event->message >> 24) & 0xFF)
2724 {
2725 case (0xFA): /* mouseMovedMessage */
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00002726 gui_mac_doMouseMovedEvent(event);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002727 break;
2728 case (0x01): /* suspendResumeMessage */
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00002729 gui_mac_doSuspendEvent(event);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002730 break;
2731 }
2732 break;
2733
2734#ifdef USE_AEVENT
2735 case (kHighLevelEvent):
2736 /* Someone's talking to us, through AppleEvents */
2737 error = AEProcessAppleEvent(event); /* TODO: Error Handling */
2738 break;
2739#endif
2740 }
2741}
2742
2743/*
2744 * ------------------------------------------------------------
2745 * Unknown Stuff
2746 * ------------------------------------------------------------
2747 */
2748
2749
2750 GuiFont
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00002751gui_mac_find_font(char_u *font_name)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002752{
2753 char_u c;
2754 char_u *p;
2755 char_u pFontName[256];
2756 Str255 systemFontname;
2757 short font_id;
2758 short size=9;
2759 GuiFont font;
2760#if 0
2761 char_u *fontNamePtr;
2762#endif
2763
2764 for (p = font_name; ((*p != 0) && (*p != ':')); p++)
2765 ;
2766
2767 c = *p;
2768 *p = 0;
2769
2770#if 1
2771 STRCPY(&pFontName[1], font_name);
2772 pFontName[0] = STRLEN(font_name);
2773 *p = c;
2774
Bram Moolenaar26a60b42005-02-22 08:49:11 +00002775 /* Get the font name, minus the style suffix (:h, etc) */
Bram Moolenaar26a60b42005-02-22 08:49:11 +00002776 char_u fontName[256];
2777 char_u *styleStart = vim_strchr(font_name, ':');
2778 size_t fontNameLen = styleStart ? styleStart - font_name : STRLEN(fontName);
2779 vim_strncpy(fontName, font_name, fontNameLen);
2780
2781 ATSUFontID fontRef;
2782 FMFontStyle fontStyle;
2783 font_id = 0;
2784
2785 if (ATSUFindFontFromName(&pFontName[1], pFontName[0], kFontFullName,
2786 kFontMacintoshPlatform, kFontNoScriptCode, kFontNoLanguageCode,
2787 &fontRef) == noErr)
2788 {
2789 if (FMGetFontFamilyInstanceFromFont(fontRef, &font_id, &fontStyle) != noErr)
2790 font_id = 0;
2791 }
Bram Moolenaar592e0a22004-07-03 16:05:59 +00002792
2793 if (font_id == 0)
2794 {
2795 /*
2796 * Try again, this time replacing underscores in the font name
2797 * with spaces (:set guifont allows the two to be used
2798 * interchangeably; the Font Manager doesn't).
2799 */
2800 int i, changed = FALSE;
2801
2802 for (i = pFontName[0]; i > 0; --i)
2803 {
2804 if (pFontName[i] == '_')
2805 {
2806 pFontName[i] = ' ';
2807 changed = TRUE;
2808 }
2809 }
2810 if (changed)
Bram Moolenaar26a60b42005-02-22 08:49:11 +00002811 if (ATSUFindFontFromName(&pFontName[1], pFontName[0],
2812 kFontFullName, kFontNoPlatformCode, kFontNoScriptCode,
2813 kFontNoLanguageCode, &fontRef) == noErr)
2814 {
2815 if (FMGetFontFamilyInstanceFromFont(fontRef, &font_id, &fontStyle) != noErr)
2816 font_id = 0;
2817 }
Bram Moolenaar592e0a22004-07-03 16:05:59 +00002818 }
2819
Bram Moolenaar071d4272004-06-13 20:20:40 +00002820#else
2821 /* name = C2Pascal_save(menu->dname); */
2822 fontNamePtr = C2Pascal_save_and_remove_backslash(font_name);
2823
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00002824 GetFNum(fontNamePtr, &font_id);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002825#endif
2826
2827
2828 if (font_id == 0)
2829 {
2830 /* Oups, the system font was it the one the user want */
2831
Bram Moolenaar26a60b42005-02-22 08:49:11 +00002832 if (FMGetFontFamilyName(systemFont, systemFontname) != noErr)
2833 return NOFONT;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002834 if (!EqualString(pFontName, systemFontname, false, false))
2835 return NOFONT;
2836 }
2837 if (*p == ':')
2838 {
2839 p++;
2840 /* Set the values found after ':' */
2841 while (*p)
2842 {
2843 switch (*p++)
2844 {
2845 case 'h':
2846 size = points_to_pixels(p, &p, TRUE);
2847 break;
2848 /*
2849 * TODO: Maybe accept width and styles
2850 */
2851 }
2852 while (*p == ':')
2853 p++;
2854 }
2855 }
2856
2857 if (size < 1)
2858 size = 1; /* Avoid having a size of 0 with system font */
2859
2860 font = (size << 16) + ((long) font_id & 0xFFFF);
2861
2862 return font;
2863}
2864
2865/*
2866 * ------------------------------------------------------------
Bram Moolenaar720c7102007-05-10 18:07:50 +00002867 * GUI_MCH functionality
Bram Moolenaar071d4272004-06-13 20:20:40 +00002868 * ------------------------------------------------------------
2869 */
2870
2871/*
2872 * Parse the GUI related command-line arguments. Any arguments used are
2873 * deleted from argv, and *argc is decremented accordingly. This is called
2874 * when vim is started, whether or not the GUI has been started.
2875 */
2876 void
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00002877gui_mch_prepare(int *argc, char **argv)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002878{
2879 /* TODO: Move most of this stuff toward gui_mch_init */
2880#ifdef USE_EXE_NAME
2881 FSSpec applDir;
2882# ifndef USE_FIND_BUNDLE_PATH
2883 short applVRefNum;
2884 long applDirID;
2885 Str255 volName;
2886# else
2887 ProcessSerialNumber psn;
2888 FSRef applFSRef;
2889# endif
2890#endif
2891
Bram Moolenaar071d4272004-06-13 20:20:40 +00002892#if 0
2893 InitCursor();
2894
Bram Moolenaar071d4272004-06-13 20:20:40 +00002895 RegisterAppearanceClient();
Bram Moolenaar071d4272004-06-13 20:20:40 +00002896
2897#ifdef USE_AEVENT
2898 (void) InstallAEHandlers();
2899#endif
2900
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00002901 pomme = NewMenu(256, "\p\024"); /* 0x14= = Apple Menu */
Bram Moolenaar071d4272004-06-13 20:20:40 +00002902
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00002903 AppendMenu(pomme, "\pAbout VIM");
Bram Moolenaar071d4272004-06-13 20:20:40 +00002904
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00002905 InsertMenu(pomme, 0);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002906
2907 DrawMenuBar();
2908
2909
2910#ifndef USE_OFFSETED_WINDOW
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00002911 SetRect(&windRect, 10, 48, 10+80*7 + 16, 48+24*11);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002912#else
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00002913 SetRect(&windRect, 300, 40, 300+80*7 + 16, 40+24*11);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002914#endif
2915
2916
Bram Moolenaar071d4272004-06-13 20:20:40 +00002917 CreateNewWindow(kDocumentWindowClass,
2918 kWindowResizableAttribute | kWindowCollapseBoxAttribute,
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00002919 &windRect, &gui.VimWindow);
2920 SetPortWindowPort(gui.VimWindow);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002921
2922 gui.char_width = 7;
2923 gui.char_height = 11;
2924 gui.char_ascent = 6;
2925 gui.num_rows = 24;
2926 gui.num_cols = 80;
2927 gui.in_focus = TRUE; /* For the moment -> syn. of front application */
2928
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00002929 gScrollAction = NewControlActionUPP(gui_mac_scroll_action);
2930 gScrollDrag = NewControlActionUPP(gui_mac_drag_thumb);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002931
2932 dragRectEnbl = FALSE;
2933 dragRgn = NULL;
2934 dragRectControl = kCreateEmpty;
2935 cursorRgn = NewRgn();
2936#endif
2937#ifdef USE_EXE_NAME
2938# ifndef USE_FIND_BUNDLE_PATH
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00002939 HGetVol(volName, &applVRefNum, &applDirID);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002940 /* TN2015: mention a possible bad VRefNum */
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00002941 FSMakeFSSpec(applVRefNum, applDirID, "\p", &applDir);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002942# else
2943 /* OSErr GetApplicationBundleFSSpec(FSSpecPtr theFSSpecPtr)
2944 * of TN2015
Bram Moolenaar071d4272004-06-13 20:20:40 +00002945 */
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00002946 (void)GetCurrentProcess(&psn);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002947 /* if (err != noErr) return err; */
2948
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00002949 (void)GetProcessBundleLocation(&psn, &applFSRef);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002950 /* if (err != noErr) return err; */
2951
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00002952 (void)FSGetCatalogInfo(&applFSRef, kFSCatInfoNone, NULL, NULL, &applDir, NULL);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002953
2954 /* This technic return NIL when we disallow_gui */
2955# endif
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00002956 exe_name = FullPathFromFSSpec_save(applDir);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002957#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00002958}
2959
2960#ifndef ALWAYS_USE_GUI
2961/*
2962 * Check if the GUI can be started. Called before gvimrc is sourced.
2963 * Return OK or FAIL.
2964 */
2965 int
2966gui_mch_init_check(void)
2967{
2968 /* TODO: For MacOS X find a way to return FAIL, if the user logged in
2969 * using the >console
2970 */
2971 if (disallow_gui) /* see main.c for reason to disallow */
2972 return FAIL;
2973 return OK;
2974}
2975#endif
2976
2977 static OSErr
Bram Moolenaarbbe8c3f2007-04-26 16:40:56 +00002978receiveHandler(WindowRef theWindow, void *handlerRefCon, DragRef theDrag)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002979{
2980 int x, y;
2981 int_u modifiers;
2982 char_u **fnames = NULL;
2983 int count;
2984 int i, j;
2985
2986 /* Get drop position, modifiers and count of items */
2987 {
2988 Point point;
2989 SInt16 mouseUpModifiers;
2990 UInt16 countItem;
2991
2992 GetDragMouse(theDrag, &point, NULL);
2993 GlobalToLocal(&point);
2994 x = point.h;
2995 y = point.v;
2996 GetDragModifiers(theDrag, NULL, NULL, &mouseUpModifiers);
2997 modifiers = EventModifiers2VimMouseModifiers(mouseUpModifiers);
2998 CountDragItems(theDrag, &countItem);
2999 count = countItem;
3000 }
3001
3002 fnames = (char_u **)alloc(count * sizeof(char_u *));
3003 if (fnames == NULL)
3004 return dragNotAcceptedErr;
3005
3006 /* Get file names dropped */
3007 for (i = j = 0; i < count; ++i)
3008 {
3009 DragItemRef item;
3010 OSErr err;
3011 Size size;
3012 FlavorType type = flavorTypeHFS;
3013 HFSFlavor hfsFlavor;
3014
3015 fnames[i] = NULL;
3016 GetDragItemReferenceNumber(theDrag, i + 1, &item);
3017 err = GetFlavorDataSize(theDrag, item, type, &size);
3018 if (err != noErr || size > sizeof(hfsFlavor))
3019 continue;
3020 err = GetFlavorData(theDrag, item, type, &hfsFlavor, &size, 0);
3021 if (err != noErr)
3022 continue;
3023 fnames[j++] = FullPathFromFSSpec_save(hfsFlavor.fileSpec);
3024 }
3025 count = j;
3026
3027 gui_handle_drop(x, y, modifiers, fnames, count);
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00003028
3029 /* Fake mouse event to wake from stall */
3030 PostEvent(mouseUp, 0);
3031
Bram Moolenaar071d4272004-06-13 20:20:40 +00003032 return noErr;
3033}
3034
3035/*
3036 * Initialise the GUI. Create all the windows, set up all the call-backs
3037 * etc.
3038 */
3039 int
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00003040gui_mch_init(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003041{
3042 /* TODO: Move most of this stuff toward gui_mch_init */
Bram Moolenaar39858af2008-03-12 20:48:13 +00003043 Rect windRect;
3044 MenuHandle pomme;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003045 EventHandlerRef mouseWheelHandlerRef;
Bram Moolenaar1b60e502008-03-12 13:40:54 +00003046 EventTypeSpec eventTypeSpec;
Bram Moolenaar39858af2008-03-12 20:48:13 +00003047 ControlRef rootControl;
Bram Moolenaar26a60b42005-02-22 08:49:11 +00003048
Bram Moolenaar26a60b42005-02-22 08:49:11 +00003049 if (Gestalt(gestaltSystemVersion, &gMacSystemVersion) != noErr)
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00003050 gMacSystemVersion = 0x1000; /* TODO: Default to minimum sensible value */
Bram Moolenaar26a60b42005-02-22 08:49:11 +00003051
Bram Moolenaar071d4272004-06-13 20:20:40 +00003052#if 1
3053 InitCursor();
3054
Bram Moolenaar071d4272004-06-13 20:20:40 +00003055 RegisterAppearanceClient();
Bram Moolenaar071d4272004-06-13 20:20:40 +00003056
3057#ifdef USE_AEVENT
3058 (void) InstallAEHandlers();
3059#endif
3060
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00003061 pomme = NewMenu(256, "\p\024"); /* 0x14= = Apple Menu */
Bram Moolenaar071d4272004-06-13 20:20:40 +00003062
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00003063 AppendMenu(pomme, "\pAbout VIM");
Bram Moolenaar071d4272004-06-13 20:20:40 +00003064
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00003065 InsertMenu(pomme, 0);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003066
3067 DrawMenuBar();
3068
3069
3070#ifndef USE_OFFSETED_WINDOW
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00003071 SetRect(&windRect, 10, 48, 10+80*7 + 16, 48+24*11);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003072#else
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00003073 SetRect(&windRect, 300, 40, 300+80*7 + 16, 40+24*11);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003074#endif
3075
3076 gui.VimWindow = NewCWindow(nil, &windRect, "\pgVim on Macintosh", true,
Bram Moolenaar071d4272004-06-13 20:20:40 +00003077 zoomDocProc,
Bram Moolenaar071d4272004-06-13 20:20:40 +00003078 (WindowPtr)-1L, true, 0);
Bram Moolenaare02d7b22007-06-19 14:29:43 +00003079 CreateRootControl(gui.VimWindow, &rootControl);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003080 InstallReceiveHandler((DragReceiveHandlerUPP)receiveHandler,
3081 gui.VimWindow, NULL);
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00003082 SetPortWindowPort(gui.VimWindow);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003083
3084 gui.char_width = 7;
3085 gui.char_height = 11;
3086 gui.char_ascent = 6;
3087 gui.num_rows = 24;
3088 gui.num_cols = 80;
3089 gui.in_focus = TRUE; /* For the moment -> syn. of front application */
3090
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00003091 gScrollAction = NewControlActionUPP(gui_mac_scroll_action);
3092 gScrollDrag = NewControlActionUPP(gui_mac_drag_thumb);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003093
Bram Moolenaar592e0a22004-07-03 16:05:59 +00003094 /* Install Carbon event callbacks. */
3095 (void)InstallFontPanelHandler();
Bram Moolenaar071d4272004-06-13 20:20:40 +00003096
3097 dragRectEnbl = FALSE;
3098 dragRgn = NULL;
3099 dragRectControl = kCreateEmpty;
3100 cursorRgn = NewRgn();
3101#endif
3102 /* Display any pending error messages */
3103 display_errors();
3104
3105 /* Get background/foreground colors from system */
Bram Moolenaar720c7102007-05-10 18:07:50 +00003106 /* TODO: do the appropriate call to get real defaults */
Bram Moolenaar071d4272004-06-13 20:20:40 +00003107 gui.norm_pixel = 0x00000000;
3108 gui.back_pixel = 0x00FFFFFF;
3109
3110 /* Get the colors from the "Normal" group (set in syntax.c or in a vimrc
3111 * file). */
3112 set_normal_colors();
3113
3114 /*
3115 * Check that none of the colors are the same as the background color.
3116 * Then store the current values as the defaults.
3117 */
3118 gui_check_colors();
3119 gui.def_norm_pixel = gui.norm_pixel;
3120 gui.def_back_pixel = gui.back_pixel;
3121
3122 /* Get the colors for the highlight groups (gui_check_colors() might have
3123 * changed them) */
3124 highlight_gui_started();
3125
3126 /*
3127 * Setting the gui constants
3128 */
3129#ifdef FEAT_MENU
3130 gui.menu_height = 0;
3131#endif
3132 gui.scrollbar_height = gui.scrollbar_width = 15; /* cheat 1 overlap */
3133 gui.border_offset = gui.border_width = 2;
3134
Bram Moolenaar720c7102007-05-10 18:07:50 +00003135 /* If Quartz-style text anti aliasing is available (see
Bram Moolenaar071d4272004-06-13 20:20:40 +00003136 gui_mch_draw_string() below), enable it for all font sizes. */
3137 vim_setenv((char_u *)"QDTEXT_MINSIZE", (char_u *)"1");
Bram Moolenaar071d4272004-06-13 20:20:40 +00003138
Bram Moolenaar071d4272004-06-13 20:20:40 +00003139 eventTypeSpec.eventClass = kEventClassMouse;
3140 eventTypeSpec.eventKind = kEventMouseWheelMoved;
3141 mouseWheelHandlerUPP = NewEventHandlerUPP(gui_mac_mouse_wheel);
3142 if (noErr != InstallApplicationEventHandler(mouseWheelHandlerUPP, 1,
3143 &eventTypeSpec, NULL, &mouseWheelHandlerRef))
3144 {
3145 mouseWheelHandlerRef = NULL;
3146 DisposeEventHandlerUPP(mouseWheelHandlerUPP);
3147 mouseWheelHandlerUPP = NULL;
3148 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00003149
Bram Moolenaar26a60b42005-02-22 08:49:11 +00003150#ifdef USE_CARBONKEYHANDLER
Bram Moolenaar1b60e502008-03-12 13:40:54 +00003151 InterfaceTypeList supportedServices = { kUnicodeDocument };
3152 NewTSMDocument(1, supportedServices, &gTSMDocument, 0);
3153
3154 /* We don't support inline input yet, use input window by default */
3155 UseInputWindow(gTSMDocument, TRUE);
3156
3157 /* Should we activate the document by default? */
3158 // ActivateTSMDocument(gTSMDocument);
3159
3160 EventTypeSpec textEventTypes[] = {
3161 { kEventClassTextInput, kEventTextInputUpdateActiveInputArea },
3162 { kEventClassTextInput, kEventTextInputUnicodeForKeyEvent },
3163 { kEventClassTextInput, kEventTextInputPosToOffset },
3164 { kEventClassTextInput, kEventTextInputOffsetToPos },
3165 };
3166
3167 keyEventHandlerUPP = NewEventHandlerUPP(gui_mac_handle_text_input);
3168 if (noErr != InstallApplicationEventHandler(keyEventHandlerUPP,
3169 NR_ELEMS(textEventTypes),
3170 textEventTypes, NULL, NULL))
Bram Moolenaar26a60b42005-02-22 08:49:11 +00003171 {
Bram Moolenaar26a60b42005-02-22 08:49:11 +00003172 DisposeEventHandlerUPP(keyEventHandlerUPP);
3173 keyEventHandlerUPP = NULL;
3174 }
Bram Moolenaar1b60e502008-03-12 13:40:54 +00003175
3176 EventTypeSpec windowEventTypes[] = {
3177 { kEventClassWindow, kEventWindowActivated },
3178 { kEventClassWindow, kEventWindowDeactivated },
3179 };
3180
3181 /* Install window event handler to support TSMDocument activate and
3182 * deactivate */
3183 winEventHandlerUPP = NewEventHandlerUPP(gui_mac_handle_window_activate);
3184 if (noErr != InstallWindowEventHandler(gui.VimWindow,
3185 winEventHandlerUPP,
3186 NR_ELEMS(windowEventTypes),
3187 windowEventTypes, NULL, NULL))
3188 {
3189 DisposeEventHandlerUPP(winEventHandlerUPP);
3190 winEventHandlerUPP = NULL;
3191 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00003192#endif
3193
Bram Moolenaar26a60b42005-02-22 08:49:11 +00003194/*
3195#ifdef FEAT_MBYTE
3196 set_option_value((char_u *)"encoding", 0L, (char_u *)"utf-8", 0);
3197#endif
3198*/
3199
Bram Moolenaar79ee3152007-04-26 16:20:50 +00003200#ifdef FEAT_GUI_TABLINE
3201 /*
3202 * Create the tabline
3203 */
3204 initialise_tabline();
3205#endif
3206
Bram Moolenaar071d4272004-06-13 20:20:40 +00003207 /* TODO: Load bitmap if using TOOLBAR */
3208 return OK;
3209}
3210
3211/*
3212 * Called when the foreground or background color has been changed.
3213 */
3214 void
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00003215gui_mch_new_colors(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003216{
3217 /* TODO:
3218 * This proc is called when Normal is set to a value
Bram Moolenaar68dfcdf2011-12-14 15:07:29 +01003219 * so what must be done? I don't know
Bram Moolenaar071d4272004-06-13 20:20:40 +00003220 */
3221}
3222
3223/*
3224 * Open the GUI window which was created by a call to gui_mch_init().
3225 */
3226 int
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00003227gui_mch_open(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003228{
3229 ShowWindow(gui.VimWindow);
3230
3231 if (gui_win_x != -1 && gui_win_y != -1)
3232 gui_mch_set_winpos(gui_win_x, gui_win_y);
3233
Bram Moolenaar071d4272004-06-13 20:20:40 +00003234 /*
3235 * Make the GUI the foreground process (in case it was launched
3236 * from the Terminal or via :gui).
3237 */
3238 {
3239 ProcessSerialNumber psn;
3240 if (GetCurrentProcess(&psn) == noErr)
3241 SetFrontProcess(&psn);
3242 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00003243
3244 return OK;
3245}
3246
Bram Moolenaar1b60e502008-03-12 13:40:54 +00003247#ifdef USE_ATSUI_DRAWING
3248 static void
3249gui_mac_dispose_atsui_style(void)
3250{
3251 if (p_macatsui && gFontStyle)
3252 ATSUDisposeStyle(gFontStyle);
3253#ifdef FEAT_MBYTE
3254 if (p_macatsui && gWideFontStyle)
3255 ATSUDisposeStyle(gWideFontStyle);
3256#endif
3257}
3258#endif
3259
Bram Moolenaar071d4272004-06-13 20:20:40 +00003260 void
3261gui_mch_exit(int rc)
3262{
3263 /* TODO: find out all what is missing here? */
3264 DisposeRgn(cursorRgn);
3265
Bram Moolenaar26a60b42005-02-22 08:49:11 +00003266#ifdef USE_CARBONKEYHANDLER
3267 if (keyEventHandlerUPP)
3268 DisposeEventHandlerUPP(keyEventHandlerUPP);
3269#endif
3270
Bram Moolenaar071d4272004-06-13 20:20:40 +00003271 if (mouseWheelHandlerUPP != NULL)
3272 DisposeEventHandlerUPP(mouseWheelHandlerUPP);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003273
Bram Moolenaar26a60b42005-02-22 08:49:11 +00003274#ifdef USE_ATSUI_DRAWING
Bram Moolenaar1b60e502008-03-12 13:40:54 +00003275 gui_mac_dispose_atsui_style();
3276#endif
3277
3278#ifdef USE_CARBONKEYHANDLER
3279 FixTSMDocument(gTSMDocument);
3280 DeactivateTSMDocument(gTSMDocument);
3281 DeleteTSMDocument(gTSMDocument);
Bram Moolenaar26a60b42005-02-22 08:49:11 +00003282#endif
3283
Bram Moolenaar071d4272004-06-13 20:20:40 +00003284 /* Exit to shell? */
3285 exit(rc);
3286}
3287
3288/*
3289 * Get the position of the top left corner of the window.
3290 */
3291 int
3292gui_mch_get_winpos(int *x, int *y)
3293{
3294 /* TODO */
Bram Moolenaar071d4272004-06-13 20:20:40 +00003295 Rect bounds;
3296 OSStatus status;
3297
3298 /* Carbon >= 1.0.2, MacOS >= 8.5 */
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00003299 status = GetWindowBounds(gui.VimWindow, kWindowStructureRgn, &bounds);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003300
3301 if (status != noErr)
3302 return FAIL;
3303 *x = bounds.left;
3304 *y = bounds.top;
3305 return OK;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003306}
3307
3308/*
3309 * Set the position of the top left corner of the window to the given
3310 * coordinates.
3311 */
3312 void
3313gui_mch_set_winpos(int x, int y)
3314{
3315 /* TODO: Should make sure the window is move within range
3316 * e.g.: y > ~16 [Menu bar], x > 0, x < screen width
3317 */
Bram Moolenaarec831732007-08-30 10:51:14 +00003318 MoveWindowStructure(gui.VimWindow, x, y);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003319}
3320
3321 void
3322gui_mch_set_shellsize(
3323 int width,
3324 int height,
3325 int min_width,
3326 int min_height,
3327 int base_width,
Bram Moolenaarafa24992006-03-27 20:58:26 +00003328 int base_height,
3329 int direction)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003330{
Bram Moolenaar071d4272004-06-13 20:20:40 +00003331 CGrafPtr VimPort;
3332 Rect VimBound;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003333
3334 if (gui.which_scrollbars[SBAR_LEFT])
3335 {
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00003336 VimPort = GetWindowPort(gui.VimWindow);
3337 GetPortBounds(VimPort, &VimBound);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003338 VimBound.left = -gui.scrollbar_width; /* + 1;*/
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00003339 SetPortBounds(VimPort, &VimBound);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003340 /* GetWindowBounds(gui.VimWindow, kWindowGlobalPortRgn, &winPortRect); ??*/
Bram Moolenaar071d4272004-06-13 20:20:40 +00003341 }
3342 else
3343 {
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00003344 VimPort = GetWindowPort(gui.VimWindow);
3345 GetPortBounds(VimPort, &VimBound);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003346 VimBound.left = 0;
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00003347 SetPortBounds(VimPort, &VimBound);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003348 }
3349
3350 SizeWindow(gui.VimWindow, width, height, TRUE);
3351
3352 gui_resize_shell(width, height);
3353}
3354
3355/*
3356 * Get the screen dimensions.
3357 * Allow 10 pixels for horizontal borders, 40 for vertical borders.
3358 * Is there no way to find out how wide the borders really are?
Bram Moolenaar720c7102007-05-10 18:07:50 +00003359 * TODO: Add live update of those value on suspend/resume.
Bram Moolenaar071d4272004-06-13 20:20:40 +00003360 */
3361 void
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00003362gui_mch_get_screen_dimensions(int *screen_w, int *screen_h)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003363{
3364 GDHandle dominantDevice = GetMainDevice();
3365 Rect screenRect = (**dominantDevice).gdRect;
3366
3367 *screen_w = screenRect.right - 10;
3368 *screen_h = screenRect.bottom - 40;
3369}
3370
3371
Bram Moolenaar592e0a22004-07-03 16:05:59 +00003372/*
3373 * Open the Font Panel and wait for the user to select a font and
3374 * close the panel. Then fill the buffer pointed to by font_name with
3375 * the name and size of the selected font and return the font's handle,
3376 * or NOFONT in case of an error.
3377 */
3378 static GuiFont
3379gui_mac_select_font(char_u *font_name)
3380{
3381 GuiFont selected_font = NOFONT;
3382 OSStatus status;
3383 FontSelectionQDStyle curr_font;
3384
3385 /* Initialize the Font Panel with the current font. */
3386 curr_font.instance.fontFamily = gui.norm_font & 0xFFFF;
3387 curr_font.size = (gui.norm_font >> 16);
3388 /* TODO: set fontStyle once styles are supported in gui_mac_find_font() */
3389 curr_font.instance.fontStyle = 0;
3390 curr_font.hasColor = false;
3391 curr_font.version = 0; /* version number of the style structure */
3392 status = SetFontInfoForSelection(kFontSelectionQDType,
3393 /*numStyles=*/1, &curr_font, /*eventTarget=*/NULL);
3394
3395 gFontPanelInfo.family = curr_font.instance.fontFamily;
3396 gFontPanelInfo.style = curr_font.instance.fontStyle;
3397 gFontPanelInfo.size = curr_font.size;
3398
3399 /* Pop up the Font Panel. */
3400 status = FPShowHideFontPanel();
3401 if (status == noErr)
3402 {
3403 /*
3404 * The Font Panel is modeless. We really need it to be modal,
3405 * so we spin in an event loop until the panel is closed.
3406 */
3407 gFontPanelInfo.isPanelVisible = true;
3408 while (gFontPanelInfo.isPanelVisible)
3409 {
3410 EventRecord e;
3411 WaitNextEvent(everyEvent, &e, /*sleep=*/20, /*mouseRgn=*/NULL);
3412 }
3413
3414 GetFontPanelSelection(font_name);
3415 selected_font = gui_mac_find_font(font_name);
3416 }
3417 return selected_font;
3418}
Bram Moolenaar592e0a22004-07-03 16:05:59 +00003419
Bram Moolenaar1b60e502008-03-12 13:40:54 +00003420#ifdef USE_ATSUI_DRAWING
3421 static void
3422gui_mac_create_atsui_style(void)
3423{
3424 if (p_macatsui && gFontStyle == NULL)
3425 {
3426 if (ATSUCreateStyle(&gFontStyle) != noErr)
3427 gFontStyle = NULL;
3428 }
3429#ifdef FEAT_MBYTE
3430 if (p_macatsui && gWideFontStyle == NULL)
3431 {
3432 if (ATSUCreateStyle(&gWideFontStyle) != noErr)
3433 gWideFontStyle = NULL;
3434 }
3435#endif
3436
3437 p_macatsui_last = p_macatsui;
3438}
3439#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00003440
3441/*
3442 * Initialise vim to use the font with the given name. Return FAIL if the font
3443 * could not be loaded, OK otherwise.
3444 */
3445 int
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00003446gui_mch_init_font(char_u *font_name, int fontset)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003447{
3448 /* TODO: Add support for bold italic underline proportional etc... */
3449 Str255 suggestedFont = "\pMonaco";
Bram Moolenaar05159a02005-02-26 23:04:13 +00003450 int suggestedSize = 10;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003451 FontInfo font_info;
3452 short font_id;
3453 GuiFont font;
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00003454 char_u used_font_name[512];
Bram Moolenaar071d4272004-06-13 20:20:40 +00003455
Bram Moolenaar26a60b42005-02-22 08:49:11 +00003456#ifdef USE_ATSUI_DRAWING
Bram Moolenaar1b60e502008-03-12 13:40:54 +00003457 gui_mac_create_atsui_style();
Bram Moolenaar26a60b42005-02-22 08:49:11 +00003458#endif
3459
Bram Moolenaar071d4272004-06-13 20:20:40 +00003460 if (font_name == NULL)
3461 {
3462 /* First try to get the suggested font */
3463 GetFNum(suggestedFont, &font_id);
3464
3465 if (font_id == 0)
3466 {
3467 /* Then pickup the standard application font */
3468 font_id = GetAppFont();
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00003469 STRCPY(used_font_name, "default");
Bram Moolenaar071d4272004-06-13 20:20:40 +00003470 }
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00003471 else
3472 STRCPY(used_font_name, "Monaco");
Bram Moolenaar071d4272004-06-13 20:20:40 +00003473 font = (suggestedSize << 16) + ((long) font_id & 0xFFFF);
3474 }
Bram Moolenaar592e0a22004-07-03 16:05:59 +00003475 else if (STRCMP(font_name, "*") == 0)
3476 {
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00003477 char_u *new_p_guifont;
Bram Moolenaar592e0a22004-07-03 16:05:59 +00003478
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00003479 font = gui_mac_select_font(used_font_name);
Bram Moolenaar592e0a22004-07-03 16:05:59 +00003480 if (font == NOFONT)
3481 return FAIL;
3482
3483 /* Set guifont to the name of the selected font. */
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00003484 new_p_guifont = alloc(STRLEN(used_font_name) + 1);
Bram Moolenaar592e0a22004-07-03 16:05:59 +00003485 if (new_p_guifont != NULL)
3486 {
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00003487 STRCPY(new_p_guifont, used_font_name);
Bram Moolenaar592e0a22004-07-03 16:05:59 +00003488 vim_free(p_guifont);
3489 p_guifont = new_p_guifont;
3490 /* Replace spaces in the font name with underscores. */
3491 for ( ; *new_p_guifont; ++new_p_guifont)
3492 {
3493 if (*new_p_guifont == ' ')
3494 *new_p_guifont = '_';
3495 }
3496 }
3497 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00003498 else
3499 {
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00003500 font = gui_mac_find_font(font_name);
Bram Moolenaarbbebc852005-07-18 21:47:53 +00003501 vim_strncpy(used_font_name, font_name, sizeof(used_font_name) - 1);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003502
3503 if (font == NOFONT)
3504 return FAIL;
3505 }
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00003506
Bram Moolenaar071d4272004-06-13 20:20:40 +00003507 gui.norm_font = font;
3508
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00003509 hl_set_font_name(used_font_name);
3510
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00003511 TextSize(font >> 16);
3512 TextFont(font & 0xFFFF);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003513
Bram Moolenaare4efc3b2005-03-07 23:16:51 +00003514 GetFontInfo(&font_info);
3515
3516 gui.char_ascent = font_info.ascent;
3517 gui.char_width = CharWidth('_');
3518 gui.char_height = font_info.ascent + font_info.descent + p_linespace;
3519
Bram Moolenaar26a60b42005-02-22 08:49:11 +00003520#ifdef USE_ATSUI_DRAWING
Bram Moolenaarf9393ef2006-04-24 19:47:27 +00003521 if (p_macatsui && gFontStyle)
Bram Moolenaar1b60e502008-03-12 13:40:54 +00003522 gui_mac_set_font_attributes(font);
Bram Moolenaar26a60b42005-02-22 08:49:11 +00003523#endif
3524
Bram Moolenaar071d4272004-06-13 20:20:40 +00003525 return OK;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003526}
3527
Bram Moolenaar02743632005-07-25 20:42:36 +00003528/*
3529 * Adjust gui.char_height (after 'linespace' was changed).
3530 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00003531 int
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00003532gui_mch_adjust_charheight(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003533{
3534 FontInfo font_info;
3535
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00003536 GetFontInfo(&font_info);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003537 gui.char_height = font_info.ascent + font_info.descent + p_linespace;
3538 gui.char_ascent = font_info.ascent + p_linespace / 2;
3539 return OK;
3540}
3541
3542/*
3543 * Get a font structure for highlighting.
3544 */
3545 GuiFont
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00003546gui_mch_get_font(char_u *name, int giveErrorIfMissing)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003547{
3548 GuiFont font;
3549
3550 font = gui_mac_find_font(name);
3551
3552 if (font == NOFONT)
3553 {
3554 if (giveErrorIfMissing)
3555 EMSG2(_(e_font), name);
3556 return NOFONT;
3557 }
3558 /*
3559 * TODO : Accept only monospace
3560 */
3561
3562 return font;
3563}
3564
Bram Moolenaardfccaf02004-12-31 20:56:11 +00003565#if defined(FEAT_EVAL) || defined(PROTO)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003566/*
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00003567 * Return the name of font "font" in allocated memory.
3568 * Don't know how to get the actual name, thus use the provided name.
3569 */
3570 char_u *
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00003571gui_mch_get_fontname(GuiFont font, char_u *name)
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00003572{
3573 if (name == NULL)
3574 return NULL;
3575 return vim_strsave(name);
3576}
Bram Moolenaardfccaf02004-12-31 20:56:11 +00003577#endif
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00003578
Bram Moolenaar1b60e502008-03-12 13:40:54 +00003579#ifdef USE_ATSUI_DRAWING
3580 static void
3581gui_mac_set_font_attributes(GuiFont font)
3582{
3583 ATSUFontID fontID;
3584 Fixed fontSize;
3585 Fixed fontWidth;
3586
3587 fontID = font & 0xFFFF;
3588 fontSize = Long2Fix(font >> 16);
3589 fontWidth = Long2Fix(gui.char_width);
3590
3591 ATSUAttributeTag attribTags[] =
3592 {
3593 kATSUFontTag, kATSUSizeTag, kATSUImposeWidthTag,
3594 kATSUMaxATSUITagValue + 1
3595 };
3596
3597 ByteCount attribSizes[] =
3598 {
3599 sizeof(ATSUFontID), sizeof(Fixed), sizeof(fontWidth),
3600 sizeof(font)
3601 };
3602
3603 ATSUAttributeValuePtr attribValues[] =
3604 {
3605 &fontID, &fontSize, &fontWidth, &font
3606 };
3607
3608 if (FMGetFontFromFontFamilyInstance(fontID, 0, &fontID, NULL) == noErr)
3609 {
3610 if (ATSUSetAttributes(gFontStyle,
3611 (sizeof attribTags) / sizeof(ATSUAttributeTag),
3612 attribTags, attribSizes, attribValues) != noErr)
3613 {
3614# ifndef NDEBUG
3615 fprintf(stderr, "couldn't set font style\n");
3616# endif
3617 ATSUDisposeStyle(gFontStyle);
3618 gFontStyle = NULL;
3619 }
3620
3621#ifdef FEAT_MBYTE
3622 if (has_mbyte)
3623 {
3624 /* FIXME: we should use a more mbyte sensitive way to support
3625 * wide font drawing */
3626 fontWidth = Long2Fix(gui.char_width * 2);
3627
3628 if (ATSUSetAttributes(gWideFontStyle,
3629 (sizeof attribTags) / sizeof(ATSUAttributeTag),
3630 attribTags, attribSizes, attribValues) != noErr)
3631 {
3632 ATSUDisposeStyle(gWideFontStyle);
3633 gWideFontStyle = NULL;
3634 }
3635 }
3636#endif
3637 }
3638}
3639#endif
3640
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00003641/*
Bram Moolenaar071d4272004-06-13 20:20:40 +00003642 * Set the current text font.
3643 */
3644 void
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00003645gui_mch_set_font(GuiFont font)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003646{
Bram Moolenaar26a60b42005-02-22 08:49:11 +00003647#ifdef USE_ATSUI_DRAWING
3648 GuiFont currFont;
3649 ByteCount actualFontByteCount;
Bram Moolenaar26a60b42005-02-22 08:49:11 +00003650
Bram Moolenaarf9393ef2006-04-24 19:47:27 +00003651 if (p_macatsui && gFontStyle)
Bram Moolenaar26a60b42005-02-22 08:49:11 +00003652 {
3653 /* Avoid setting same font again */
Bram Moolenaar1b60e502008-03-12 13:40:54 +00003654 if (ATSUGetAttribute(gFontStyle, kATSUMaxATSUITagValue + 1,
3655 sizeof(font), &currFont, &actualFontByteCount) == noErr
3656 && actualFontByteCount == (sizeof font))
Bram Moolenaar26a60b42005-02-22 08:49:11 +00003657 {
3658 if (currFont == font)
3659 return;
3660 }
3661
Bram Moolenaar1b60e502008-03-12 13:40:54 +00003662 gui_mac_set_font_attributes(font);
Bram Moolenaar26a60b42005-02-22 08:49:11 +00003663 }
3664
Bram Moolenaarf9393ef2006-04-24 19:47:27 +00003665 if (p_macatsui && !gIsFontFallbackSet)
Bram Moolenaar26a60b42005-02-22 08:49:11 +00003666 {
3667 /* Setup automatic font substitution. The user's guifontwide
3668 * is tried first, then the system tries other fonts. */
3669/*
3670 ATSUAttributeTag fallbackTags[] = { kATSULineFontFallbacksTag };
3671 ByteCount fallbackSizes[] = { sizeof(ATSUFontFallbacks) };
3672 ATSUCreateFontFallbacks(&gFontFallbacks);
3673 ATSUSetObjFontFallbacks(gFontFallbacks, );
3674*/
3675 if (gui.wide_font)
3676 {
3677 ATSUFontID fallbackFonts;
3678 gIsFontFallbackSet = TRUE;
3679
3680 if (FMGetFontFromFontFamilyInstance(
3681 (gui.wide_font & 0xFFFF),
3682 0,
3683 &fallbackFonts,
3684 NULL) == noErr)
3685 {
Bram Moolenaar1b60e502008-03-12 13:40:54 +00003686 ATSUSetFontFallbacks((sizeof fallbackFonts)/sizeof(ATSUFontID),
3687 &fallbackFonts,
3688 kATSUSequentialFallbacksPreferred);
Bram Moolenaar26a60b42005-02-22 08:49:11 +00003689 }
3690/*
3691 ATSUAttributeValuePtr fallbackValues[] = { };
3692*/
3693 }
3694 }
3695#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00003696 TextSize(font >> 16);
3697 TextFont(font & 0xFFFF);
3698}
3699
Bram Moolenaar071d4272004-06-13 20:20:40 +00003700/*
3701 * If a font is not going to be used, free its structure.
3702 */
3703 void
3704gui_mch_free_font(font)
3705 GuiFont font;
3706{
3707 /*
3708 * Free font when "font" is not 0.
3709 * Nothing to do in the current implementation, since
3710 * nothing is allocated for each font used.
3711 */
3712}
3713
3714 static int
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00003715hex_digit(int c)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003716{
3717 if (isdigit(c))
3718 return c - '0';
3719 c = TOLOWER_ASC(c);
3720 if (c >= 'a' && c <= 'f')
3721 return c - 'a' + 10;
3722 return -1000;
3723}
3724
3725/*
3726 * Return the Pixel value (color) for the given color name. This routine was
3727 * pretty much taken from example code in the Silicon Graphics OSF/Motif
3728 * Programmer's Guide.
3729 * Return INVALCOLOR when failed.
3730 */
3731 guicolor_T
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00003732gui_mch_get_color(char_u *name)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003733{
3734 /* TODO: Add support for the new named color of MacOS 8
3735 */
3736 RGBColor MacColor;
3737// guicolor_T color = 0;
3738
3739 typedef struct guicolor_tTable
3740 {
3741 char *name;
3742 guicolor_T color;
3743 } guicolor_tTable;
3744
3745 /*
3746 * The comment at the end of each line is the source
3747 * (Mac, Window, Unix) and the number is the unix rgb.txt value
3748 */
3749 static guicolor_tTable table[] =
3750 {
3751 {"Black", RGB(0x00, 0x00, 0x00)},
3752 {"darkgray", RGB(0x80, 0x80, 0x80)}, /*W*/
3753 {"darkgrey", RGB(0x80, 0x80, 0x80)}, /*W*/
3754 {"Gray", RGB(0xC0, 0xC0, 0xC0)}, /*W*/
3755 {"Grey", RGB(0xC0, 0xC0, 0xC0)}, /*W*/
3756 {"lightgray", RGB(0xE0, 0xE0, 0xE0)}, /*W*/
3757 {"lightgrey", RGB(0xE0, 0xE0, 0xE0)}, /*W*/
Bram Moolenaarb21e5842006-04-16 18:30:08 +00003758 {"gray10", RGB(0x1A, 0x1A, 0x1A)}, /*W*/
3759 {"grey10", RGB(0x1A, 0x1A, 0x1A)}, /*W*/
3760 {"gray20", RGB(0x33, 0x33, 0x33)}, /*W*/
3761 {"grey20", RGB(0x33, 0x33, 0x33)}, /*W*/
3762 {"gray30", RGB(0x4D, 0x4D, 0x4D)}, /*W*/
3763 {"grey30", RGB(0x4D, 0x4D, 0x4D)}, /*W*/
3764 {"gray40", RGB(0x66, 0x66, 0x66)}, /*W*/
3765 {"grey40", RGB(0x66, 0x66, 0x66)}, /*W*/
3766 {"gray50", RGB(0x7F, 0x7F, 0x7F)}, /*W*/
3767 {"grey50", RGB(0x7F, 0x7F, 0x7F)}, /*W*/
3768 {"gray60", RGB(0x99, 0x99, 0x99)}, /*W*/
3769 {"grey60", RGB(0x99, 0x99, 0x99)}, /*W*/
3770 {"gray70", RGB(0xB3, 0xB3, 0xB3)}, /*W*/
3771 {"grey70", RGB(0xB3, 0xB3, 0xB3)}, /*W*/
3772 {"gray80", RGB(0xCC, 0xCC, 0xCC)}, /*W*/
3773 {"grey80", RGB(0xCC, 0xCC, 0xCC)}, /*W*/
Bram Moolenaare2f98b92006-03-29 21:18:24 +00003774 {"gray90", RGB(0xE5, 0xE5, 0xE5)}, /*W*/
3775 {"grey90", RGB(0xE5, 0xE5, 0xE5)}, /*W*/
Bram Moolenaar071d4272004-06-13 20:20:40 +00003776 {"white", RGB(0xFF, 0xFF, 0xFF)},
3777 {"darkred", RGB(0x80, 0x00, 0x00)}, /*W*/
3778 {"red", RGB(0xDD, 0x08, 0x06)}, /*M*/
3779 {"lightred", RGB(0xFF, 0xA0, 0xA0)}, /*W*/
3780 {"DarkBlue", RGB(0x00, 0x00, 0x80)}, /*W*/
3781 {"Blue", RGB(0x00, 0x00, 0xD4)}, /*M*/
3782 {"lightblue", RGB(0xA0, 0xA0, 0xFF)}, /*W*/
3783 {"DarkGreen", RGB(0x00, 0x80, 0x00)}, /*W*/
3784 {"Green", RGB(0x00, 0x64, 0x11)}, /*M*/
3785 {"lightgreen", RGB(0xA0, 0xFF, 0xA0)}, /*W*/
3786 {"DarkCyan", RGB(0x00, 0x80, 0x80)}, /*W ?0x307D7E */
3787 {"cyan", RGB(0x02, 0xAB, 0xEA)}, /*M*/
3788 {"lightcyan", RGB(0xA0, 0xFF, 0xFF)}, /*W*/
3789 {"darkmagenta", RGB(0x80, 0x00, 0x80)}, /*W*/
3790 {"magenta", RGB(0xF2, 0x08, 0x84)}, /*M*/
3791 {"lightmagenta",RGB(0xF0, 0xA0, 0xF0)}, /*W*/
3792 {"brown", RGB(0x80, 0x40, 0x40)}, /*W*/
3793 {"yellow", RGB(0xFC, 0xF3, 0x05)}, /*M*/
3794 {"lightyellow", RGB(0xFF, 0xFF, 0xA0)}, /*M*/
Bram Moolenaar45eeb132005-06-06 21:59:07 +00003795 {"darkyellow", RGB(0xBB, 0xBB, 0x00)}, /*U*/
Bram Moolenaar071d4272004-06-13 20:20:40 +00003796 {"SeaGreen", RGB(0x2E, 0x8B, 0x57)}, /*W 0x4E8975 */
3797 {"orange", RGB(0xFC, 0x80, 0x00)}, /*W 0xF87A17 */
3798 {"Purple", RGB(0xA0, 0x20, 0xF0)}, /*W 0x8e35e5 */
3799 {"SlateBlue", RGB(0x6A, 0x5A, 0xCD)}, /*W 0x737CA1 */
3800 {"Violet", RGB(0x8D, 0x38, 0xC9)}, /*U*/
3801 };
3802
3803 int r, g, b;
3804 int i;
3805
3806 if (name[0] == '#' && strlen((char *) name) == 7)
3807 {
3808 /* Name is in "#rrggbb" format */
3809 r = hex_digit(name[1]) * 16 + hex_digit(name[2]);
3810 g = hex_digit(name[3]) * 16 + hex_digit(name[4]);
3811 b = hex_digit(name[5]) * 16 + hex_digit(name[6]);
3812 if (r < 0 || g < 0 || b < 0)
3813 return INVALCOLOR;
3814 return RGB(r, g, b);
3815 }
3816 else
3817 {
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00003818 if (STRICMP(name, "hilite") == 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003819 {
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00003820 LMGetHiliteRGB(&MacColor);
3821 return (RGB(MacColor.red >> 8, MacColor.green >> 8, MacColor.blue >> 8));
Bram Moolenaar071d4272004-06-13 20:20:40 +00003822 }
3823 /* Check if the name is one of the colors we know */
3824 for (i = 0; i < sizeof(table) / sizeof(table[0]); i++)
3825 if (STRICMP(name, table[i].name) == 0)
3826 return table[i].color;
3827 }
3828
Bram Moolenaar071d4272004-06-13 20:20:40 +00003829 /*
3830 * Last attempt. Look in the file "$VIM/rgb.txt".
3831 */
3832 {
3833#define LINE_LEN 100
3834 FILE *fd;
3835 char line[LINE_LEN];
3836 char_u *fname;
3837
Bram Moolenaar071d4272004-06-13 20:20:40 +00003838 fname = expand_env_save((char_u *)"$VIMRUNTIME/rgb.txt");
Bram Moolenaar071d4272004-06-13 20:20:40 +00003839 if (fname == NULL)
3840 return INVALCOLOR;
3841
3842 fd = fopen((char *)fname, "rt");
3843 vim_free(fname);
3844 if (fd == NULL)
3845 return INVALCOLOR;
3846
3847 while (!feof(fd))
3848 {
3849 int len;
3850 int pos;
3851 char *color;
3852
3853 fgets(line, LINE_LEN, fd);
3854 len = strlen(line);
3855
3856 if (len <= 1 || line[len-1] != '\n')
3857 continue;
3858
3859 line[len-1] = '\0';
3860
3861 i = sscanf(line, "%d %d %d %n", &r, &g, &b, &pos);
3862 if (i != 3)
3863 continue;
3864
3865 color = line + pos;
3866
3867 if (STRICMP(color, name) == 0)
3868 {
3869 fclose(fd);
3870 return (guicolor_T) RGB(r, g, b);
3871 }
3872 }
3873 fclose(fd);
3874 }
3875
3876 return INVALCOLOR;
3877}
3878
3879/*
3880 * Set the current text foreground color.
3881 */
3882 void
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00003883gui_mch_set_fg_color(guicolor_T color)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003884{
3885 RGBColor TheColor;
3886
3887 TheColor.red = Red(color) * 0x0101;
3888 TheColor.green = Green(color) * 0x0101;
3889 TheColor.blue = Blue(color) * 0x0101;
3890
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00003891 RGBForeColor(&TheColor);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003892}
3893
3894/*
3895 * Set the current text background color.
3896 */
3897 void
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00003898gui_mch_set_bg_color(guicolor_T color)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003899{
3900 RGBColor TheColor;
3901
3902 TheColor.red = Red(color) * 0x0101;
3903 TheColor.green = Green(color) * 0x0101;
3904 TheColor.blue = Blue(color) * 0x0101;
3905
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00003906 RGBBackColor(&TheColor);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003907}
3908
Bram Moolenaar5fe38612005-11-26 23:45:02 +00003909RGBColor specialColor;
3910
Bram Moolenaar916b7af2005-03-16 09:52:38 +00003911/*
Bram Moolenaar5fe38612005-11-26 23:45:02 +00003912 * Set the current text special color.
Bram Moolenaar916b7af2005-03-16 09:52:38 +00003913 */
3914 void
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00003915gui_mch_set_sp_color(guicolor_T color)
Bram Moolenaar916b7af2005-03-16 09:52:38 +00003916{
Bram Moolenaar5fe38612005-11-26 23:45:02 +00003917 specialColor.red = Red(color) * 0x0101;
3918 specialColor.green = Green(color) * 0x0101;
3919 specialColor.blue = Blue(color) * 0x0101;
3920}
3921
3922/*
3923 * Draw undercurl at the bottom of the character cell.
3924 */
3925 static void
3926draw_undercurl(int flags, int row, int col, int cells)
3927{
Bram Moolenaarc9b4b052006-04-30 18:54:39 +00003928 int x;
3929 int offset;
3930 const static int val[8] = {1, 0, 0, 0, 1, 2, 2, 2 };
3931 int y = FILL_Y(row + 1) - 1;
Bram Moolenaar5fe38612005-11-26 23:45:02 +00003932
3933 RGBForeColor(&specialColor);
3934
3935 offset = val[FILL_X(col) % 8];
3936 MoveTo(FILL_X(col), y - offset);
3937
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00003938 for (x = FILL_X(col); x < FILL_X(col + cells); ++x)
Bram Moolenaar5fe38612005-11-26 23:45:02 +00003939 {
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00003940 offset = val[x % 8];
3941 LineTo(x, y - offset);
Bram Moolenaar5fe38612005-11-26 23:45:02 +00003942 }
Bram Moolenaar916b7af2005-03-16 09:52:38 +00003943}
3944
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00003945
3946 static void
3947draw_string_QD(int row, int col, char_u *s, int len, int flags)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003948{
Bram Moolenaar071d4272004-06-13 20:20:40 +00003949#ifdef FEAT_MBYTE
3950 char_u *tofree = NULL;
3951
3952 if (output_conv.vc_type != CONV_NONE)
3953 {
3954 tofree = string_convert(&output_conv, s, &len);
3955 if (tofree != NULL)
3956 s = tofree;
3957 }
3958#endif
3959
Bram Moolenaar071d4272004-06-13 20:20:40 +00003960 /*
3961 * On OS X, try using Quartz-style text antialiasing.
3962 */
Bram Moolenaare4efc3b2005-03-07 23:16:51 +00003963 if (gMacSystemVersion >= 0x1020)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003964 {
3965 /* Quartz antialiasing is available only in OS 10.2 and later. */
3966 UInt32 qd_flags = (p_antialias ?
3967 kQDUseCGTextRendering | kQDUseCGTextMetrics : 0);
Bram Moolenaar26a60b42005-02-22 08:49:11 +00003968 QDSwapTextFlags(qd_flags);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003969 }
3970
Bram Moolenaar293ee4d2004-12-09 21:34:53 +00003971 /*
3972 * When antialiasing we're using srcOr mode, we have to clear the block
3973 * before drawing the text.
3974 * Also needed when 'linespace' is non-zero to remove the cursor and
3975 * underlining.
3976 * But not when drawing transparently.
3977 * The following is like calling gui_mch_clear_block(row, col, row, col +
3978 * len - 1), but without setting the bg color to gui.back_pixel.
3979 */
Bram Moolenaare4efc3b2005-03-07 23:16:51 +00003980 if (((gMacSystemVersion >= 0x1020 && p_antialias) || p_linespace != 0)
Bram Moolenaar293ee4d2004-12-09 21:34:53 +00003981 && !(flags & DRAW_TRANSP))
3982 {
3983 Rect rc;
3984
3985 rc.left = FILL_X(col);
3986 rc.top = FILL_Y(row);
Bram Moolenaar26a60b42005-02-22 08:49:11 +00003987#ifdef FEAT_MBYTE
3988 /* Multibyte computation taken from gui_w32.c */
3989 if (has_mbyte)
3990 {
Bram Moolenaar26a60b42005-02-22 08:49:11 +00003991 /* Compute the length in display cells. */
Bram Moolenaar72597a52010-07-18 15:31:08 +02003992 rc.right = FILL_X(col + mb_string2cells(s, len));
Bram Moolenaar26a60b42005-02-22 08:49:11 +00003993 }
3994 else
3995#endif
Bram Moolenaar293ee4d2004-12-09 21:34:53 +00003996 rc.right = FILL_X(col + len) + (col + len == Columns);
3997 rc.bottom = FILL_Y(row + 1);
3998 EraseRect(&rc);
3999 }
4000
Bram Moolenaare4efc3b2005-03-07 23:16:51 +00004001 if (gMacSystemVersion >= 0x1020 && p_antialias)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004002 {
4003 StyleParameter face;
4004
4005 face = normal;
4006 if (flags & DRAW_BOLD)
4007 face |= bold;
4008 if (flags & DRAW_UNDERL)
4009 face |= underline;
4010 TextFace(face);
4011
4012 /* Quartz antialiasing works only in srcOr transfer mode. */
4013 TextMode(srcOr);
4014
Bram Moolenaar071d4272004-06-13 20:20:40 +00004015 MoveTo(TEXT_X(col), TEXT_Y(row));
4016 DrawText((char*)s, 0, len);
4017 }
4018 else
Bram Moolenaar071d4272004-06-13 20:20:40 +00004019 {
4020 /* Use old-style, non-antialiased QuickDraw text rendering. */
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00004021 TextMode(srcCopy);
4022 TextFace(normal);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004023
4024 /* SelectFont(hdc, gui.currFont); */
4025
4026 if (flags & DRAW_TRANSP)
4027 {
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00004028 TextMode(srcOr);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004029 }
4030
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00004031 MoveTo(TEXT_X(col), TEXT_Y(row));
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00004032 DrawText((char *)s, 0, len);
4033
4034 if (flags & DRAW_BOLD)
4035 {
4036 TextMode(srcOr);
4037 MoveTo(TEXT_X(col) + 1, TEXT_Y(row));
4038 DrawText((char *)s, 0, len);
4039 }
4040
4041 if (flags & DRAW_UNDERL)
4042 {
4043 MoveTo(FILL_X(col), FILL_Y(row + 1) - 1);
4044 LineTo(FILL_X(col + len) - 1, FILL_Y(row + 1) - 1);
4045 }
4046 }
4047
4048 if (flags & DRAW_UNDERC)
4049 draw_undercurl(flags, row, col, len);
4050
4051#ifdef FEAT_MBYTE
4052 vim_free(tofree);
4053#endif
4054}
4055
Bram Moolenaarf9393ef2006-04-24 19:47:27 +00004056#ifdef USE_ATSUI_DRAWING
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00004057
4058 static void
4059draw_string_ATSUI(int row, int col, char_u *s, int len, int flags)
4060{
4061 /* ATSUI requires utf-16 strings */
4062 UniCharCount utf16_len;
4063 UniChar *tofree = mac_enc_to_utf16(s, len, (size_t *)&utf16_len);
4064 utf16_len /= sizeof(UniChar);
4065
4066 /* - ATSUI automatically antialiases text (Someone)
4067 * - for some reason it does not work... (Jussi) */
Bram Moolenaar1b60e502008-03-12 13:40:54 +00004068#ifdef MAC_ATSUI_DEBUG
4069 fprintf(stderr, "row = %d, col = %d, len = %d: '%c'\n",
4070 row, col, len, len == 1 ? s[0] : ' ');
4071#endif
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00004072 /*
4073 * When antialiasing we're using srcOr mode, we have to clear the block
4074 * before drawing the text.
4075 * Also needed when 'linespace' is non-zero to remove the cursor and
4076 * underlining.
4077 * But not when drawing transparently.
4078 * The following is like calling gui_mch_clear_block(row, col, row, col +
4079 * len - 1), but without setting the bg color to gui.back_pixel.
4080 */
4081 if ((flags & DRAW_TRANSP) == 0)
4082 {
4083 Rect rc;
4084
4085 rc.left = FILL_X(col);
4086 rc.top = FILL_Y(row);
4087 /* Multibyte computation taken from gui_w32.c */
4088 if (has_mbyte)
4089 {
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00004090 /* Compute the length in display cells. */
Bram Moolenaar72597a52010-07-18 15:31:08 +02004091 rc.right = FILL_X(col + mb_string2cells(s, len));
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00004092 }
4093 else
4094 rc.right = FILL_X(col + len) + (col + len == Columns);
4095
4096 rc.bottom = FILL_Y(row + 1);
4097 EraseRect(&rc);
4098 }
4099
4100 {
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00004101 TextMode(srcCopy);
4102 TextFace(normal);
4103
Bram Moolenaar1b60e502008-03-12 13:40:54 +00004104 /* SelectFont(hdc, gui.currFont); */
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00004105 if (flags & DRAW_TRANSP)
4106 {
4107 TextMode(srcOr);
4108 }
4109
4110 MoveTo(TEXT_X(col), TEXT_Y(row));
Bram Moolenaar26a60b42005-02-22 08:49:11 +00004111
Bram Moolenaar1b60e502008-03-12 13:40:54 +00004112 if (gFontStyle && flags & DRAW_BOLD)
Bram Moolenaar26a60b42005-02-22 08:49:11 +00004113 {
Bram Moolenaar1b60e502008-03-12 13:40:54 +00004114 Boolean attValue = true;
4115 ATSUAttributeTag attribTags[] = { kATSUQDBoldfaceTag };
4116 ByteCount attribSizes[] = { sizeof(Boolean) };
4117 ATSUAttributeValuePtr attribValues[] = { &attValue };
4118
4119 ATSUSetAttributes(gFontStyle, 1, attribTags, attribSizes, attribValues);
4120 }
4121
Bram Moolenaar76b96fc2010-07-17 16:44:59 +02004122 UInt32 useAntialias = p_antialias ? kATSStyleApplyAntiAliasing
4123 : kATSStyleNoAntiAliasing;
4124 if (useAntialias != useAntialias_cached)
4125 {
4126 ATSUAttributeTag attribTags[] = { kATSUStyleRenderingOptionsTag };
4127 ByteCount attribSizes[] = { sizeof(UInt32) };
4128 ATSUAttributeValuePtr attribValues[] = { &useAntialias };
4129
4130 if (gFontStyle)
4131 ATSUSetAttributes(gFontStyle, 1, attribTags,
4132 attribSizes, attribValues);
4133 if (gWideFontStyle)
4134 ATSUSetAttributes(gWideFontStyle, 1, attribTags,
4135 attribSizes, attribValues);
4136
4137 useAntialias_cached = useAntialias;
4138 }
4139
Bram Moolenaar1b60e502008-03-12 13:40:54 +00004140#ifdef FEAT_MBYTE
4141 if (has_mbyte)
4142 {
4143 int n, width_in_cell, last_width_in_cell;
4144 UniCharArrayOffset offset = 0;
4145 UniCharCount yet_to_draw = 0;
4146 ATSUTextLayout textLayout;
4147 ATSUStyle textStyle;
4148
4149 last_width_in_cell = 1;
4150 ATSUCreateTextLayout(&textLayout);
4151 ATSUSetTextPointerLocation(textLayout, tofree,
4152 kATSUFromTextBeginning,
4153 kATSUToTextEnd, utf16_len);
4154 /*
4155 ATSUSetRunStyle(textLayout, gFontStyle,
4156 kATSUFromTextBeginning, kATSUToTextEnd); */
4157
4158 /* Compute the length in display cells. */
4159 for (n = 0; n < len; n += MB_BYTE2LEN(s[n]))
4160 {
4161 width_in_cell = (*mb_ptr2cells)(s + n);
4162
4163 /* probably we are switching from single byte character
4164 * to multibyte characters (which requires more than one
4165 * cell to draw) */
4166 if (width_in_cell != last_width_in_cell)
4167 {
4168#ifdef MAC_ATSUI_DEBUG
4169 fprintf(stderr, "\tn = %2d, (%d-%d), offset = %d, yet_to_draw = %d\n",
4170 n, last_width_in_cell, width_in_cell, offset, yet_to_draw);
4171#endif
4172 textStyle = last_width_in_cell > 1 ? gWideFontStyle
4173 : gFontStyle;
4174
4175 ATSUSetRunStyle(textLayout, textStyle, offset, yet_to_draw);
4176 offset += yet_to_draw;
4177 yet_to_draw = 0;
4178 last_width_in_cell = width_in_cell;
4179 }
4180
4181 yet_to_draw++;
4182 }
4183
4184 if (yet_to_draw)
4185 {
4186#ifdef MAC_ATSUI_DEBUG
4187 fprintf(stderr, "\tn = %2d, (%d-%d), offset = %d, yet_to_draw = %d\n",
4188 n, last_width_in_cell, width_in_cell, offset, yet_to_draw);
4189#endif
4190 /* finish the rest style */
4191 textStyle = width_in_cell > 1 ? gWideFontStyle : gFontStyle;
4192 ATSUSetRunStyle(textLayout, textStyle, offset, kATSUToTextEnd);
4193 }
4194
Bram Moolenaar26a60b42005-02-22 08:49:11 +00004195 ATSUSetTransientFontMatching(textLayout, TRUE);
Bram Moolenaar26a60b42005-02-22 08:49:11 +00004196 ATSUDrawText(textLayout,
Bram Moolenaar1b60e502008-03-12 13:40:54 +00004197 kATSUFromTextBeginning, kATSUToTextEnd,
4198 kATSUUseGrafPortPenLoc, kATSUUseGrafPortPenLoc);
Bram Moolenaar26a60b42005-02-22 08:49:11 +00004199 ATSUDisposeTextLayout(textLayout);
4200 }
Bram Moolenaar1b60e502008-03-12 13:40:54 +00004201 else
4202#endif
4203 {
4204 ATSUTextLayout textLayout;
4205
4206 if (ATSUCreateTextLayoutWithTextPtr(tofree,
4207 kATSUFromTextBeginning, kATSUToTextEnd,
4208 utf16_len,
4209 (gFontStyle ? 1 : 0), &utf16_len,
4210 (gFontStyle ? &gFontStyle : NULL),
4211 &textLayout) == noErr)
4212 {
4213 ATSUSetTransientFontMatching(textLayout, TRUE);
4214
4215 ATSUDrawText(textLayout,
4216 kATSUFromTextBeginning, kATSUToTextEnd,
4217 kATSUUseGrafPortPenLoc, kATSUUseGrafPortPenLoc);
4218
4219 ATSUDisposeTextLayout(textLayout);
4220 }
4221 }
4222
4223 /* drawing is done, now reset bold to normal */
4224 if (gFontStyle && flags & DRAW_BOLD)
4225 {
4226 Boolean attValue = false;
4227
4228 ATSUAttributeTag attribTags[] = { kATSUQDBoldfaceTag };
4229 ByteCount attribSizes[] = { sizeof(Boolean) };
4230 ATSUAttributeValuePtr attribValues[] = { &attValue };
4231
4232 ATSUSetAttributes(gFontStyle, 1, attribTags, attribSizes,
4233 attribValues);
4234 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00004235 }
4236
Bram Moolenaar5fe38612005-11-26 23:45:02 +00004237 if (flags & DRAW_UNDERC)
4238 draw_undercurl(flags, row, col, len);
4239
Bram Moolenaar071d4272004-06-13 20:20:40 +00004240 vim_free(tofree);
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00004241}
4242#endif
4243
4244 void
4245gui_mch_draw_string(int row, int col, char_u *s, int len, int flags)
4246{
4247#if defined(USE_ATSUI_DRAWING)
Bram Moolenaar1b60e502008-03-12 13:40:54 +00004248 if (p_macatsui == 0 && p_macatsui_last != 0)
4249 /* switch from macatsui to nomacatsui */
4250 gui_mac_dispose_atsui_style();
4251 else if (p_macatsui != 0 && p_macatsui_last == 0)
4252 /* switch from nomacatsui to macatsui */
4253 gui_mac_create_atsui_style();
4254
Bram Moolenaarf9393ef2006-04-24 19:47:27 +00004255 if (p_macatsui)
4256 draw_string_ATSUI(row, col, s, len, flags);
4257 else
Bram Moolenaar071d4272004-06-13 20:20:40 +00004258#endif
Bram Moolenaarf9393ef2006-04-24 19:47:27 +00004259 draw_string_QD(row, col, s, len, flags);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004260}
4261
4262/*
4263 * Return OK if the key with the termcap name "name" is supported.
4264 */
4265 int
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00004266gui_mch_haskey(char_u *name)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004267{
4268 int i;
4269
4270 for (i = 0; special_keys[i].key_sym != (KeySym)0; i++)
4271 if (name[0] == special_keys[i].vim_code0 &&
4272 name[1] == special_keys[i].vim_code1)
4273 return OK;
4274 return FAIL;
4275}
4276
4277 void
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00004278gui_mch_beep(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004279{
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00004280 SysBeep(1); /* Should this be 0? (????) */
Bram Moolenaar071d4272004-06-13 20:20:40 +00004281}
4282
4283 void
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00004284gui_mch_flash(int msec)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004285{
4286 /* Do a visual beep by reversing the foreground and background colors */
4287 Rect rc;
4288
4289 /*
4290 * Note: InvertRect() excludes right and bottom of rectangle.
4291 */
4292 rc.left = 0;
4293 rc.top = 0;
4294 rc.right = gui.num_cols * gui.char_width;
4295 rc.bottom = gui.num_rows * gui.char_height;
4296 InvertRect(&rc);
4297
4298 ui_delay((long)msec, TRUE); /* wait for some msec */
4299
4300 InvertRect(&rc);
4301}
4302
4303/*
4304 * Invert a rectangle from row r, column c, for nr rows and nc columns.
4305 */
4306 void
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00004307gui_mch_invert_rectangle(int r, int c, int nr, int nc)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004308{
4309 Rect rc;
4310
4311 /*
4312 * Note: InvertRect() excludes right and bottom of rectangle.
4313 */
4314 rc.left = FILL_X(c);
4315 rc.top = FILL_Y(r);
4316 rc.right = rc.left + nc * gui.char_width;
4317 rc.bottom = rc.top + nr * gui.char_height;
4318 InvertRect(&rc);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004319}
4320
4321/*
4322 * Iconify the GUI window.
4323 */
4324 void
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00004325gui_mch_iconify(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004326{
4327 /* TODO: find out what could replace iconify
4328 * -window shade?
4329 * -hide application?
4330 */
4331}
4332
4333#if defined(FEAT_EVAL) || defined(PROTO)
4334/*
4335 * Bring the Vim window to the foreground.
4336 */
4337 void
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00004338gui_mch_set_foreground(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004339{
4340 /* TODO */
4341}
4342#endif
4343
4344/*
4345 * Draw a cursor without focus.
4346 */
4347 void
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00004348gui_mch_draw_hollow_cursor(guicolor_T color)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004349{
4350 Rect rc;
4351
Bram Moolenaar071d4272004-06-13 20:20:40 +00004352 /*
4353 * Note: FrameRect() excludes right and bottom of rectangle.
4354 */
4355 rc.left = FILL_X(gui.col);
4356 rc.top = FILL_Y(gui.row);
4357 rc.right = rc.left + gui.char_width;
Bram Moolenaar26a60b42005-02-22 08:49:11 +00004358#ifdef FEAT_MBYTE
4359 if (mb_lefthalve(gui.row, gui.col))
4360 rc.right += gui.char_width;
4361#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00004362 rc.bottom = rc.top + gui.char_height;
4363
4364 gui_mch_set_fg_color(color);
4365
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00004366 FrameRect(&rc);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004367}
4368
4369/*
4370 * Draw part of a cursor, only w pixels wide, and h pixels high.
4371 */
4372 void
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00004373gui_mch_draw_part_cursor(int w, int h, guicolor_T color)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004374{
4375 Rect rc;
4376
4377#ifdef FEAT_RIGHTLEFT
4378 /* vertical line should be on the right of current point */
4379 if (CURSOR_BAR_RIGHT)
4380 rc.left = FILL_X(gui.col + 1) - w;
4381 else
4382#endif
4383 rc.left = FILL_X(gui.col);
4384 rc.top = FILL_Y(gui.row) + gui.char_height - h;
4385 rc.right = rc.left + w;
4386 rc.bottom = rc.top + h;
4387
4388 gui_mch_set_fg_color(color);
4389
Bram Moolenaar26a60b42005-02-22 08:49:11 +00004390 FrameRect(&rc);
4391// PaintRect(&rc);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004392}
4393
4394
4395
4396/*
4397 * Catch up with any queued X events. This may put keyboard input into the
4398 * input buffer, call resize call-backs, trigger timers etc. If there is
4399 * nothing in the X event queue (& no timers pending), then we return
4400 * immediately.
4401 */
4402 void
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00004403gui_mch_update(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004404{
4405 /* TODO: find what to do
4406 * maybe call gui_mch_wait_for_chars (0)
4407 * more like look at EventQueue then
4408 * call heart of gui_mch_wait_for_chars;
4409 *
4410 * if (eventther)
4411 * gui_mac_handle_event(&event);
4412 */
4413 EventRecord theEvent;
4414
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00004415 if (EventAvail(everyEvent, &theEvent))
Bram Moolenaar071d4272004-06-13 20:20:40 +00004416 if (theEvent.what != nullEvent)
4417 gui_mch_wait_for_chars(0);
4418}
4419
4420/*
4421 * Simple wrapper to neglect more easily the time
4422 * spent inside WaitNextEvent while profiling.
4423 */
4424
Bram Moolenaar071d4272004-06-13 20:20:40 +00004425 pascal
4426 Boolean
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00004427WaitNextEventWrp(EventMask eventMask, EventRecord *theEvent, UInt32 sleep, RgnHandle mouseRgn)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004428{
4429 if (((long) sleep) < -1)
4430 sleep = 32767;
4431 return WaitNextEvent(eventMask, theEvent, sleep, mouseRgn);
4432}
4433
4434/*
4435 * GUI input routine called by gui_wait_for_chars(). Waits for a character
4436 * from the keyboard.
4437 * wtime == -1 Wait forever.
4438 * wtime == 0 This should never happen.
4439 * wtime > 0 Wait wtime milliseconds for a character.
4440 * Returns OK if a character was found to be available within the given time,
4441 * or FAIL otherwise.
4442 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00004443 int
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00004444gui_mch_wait_for_chars(int wtime)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004445{
4446 EventMask mask = (everyEvent);
4447 EventRecord event;
4448 long entryTick;
4449 long currentTick;
4450 long sleeppyTick;
4451
4452 /* If we are providing life feedback with the scrollbar,
4453 * we don't want to try to wait for an event, or else
4454 * there won't be any life feedback.
4455 */
4456 if (dragged_sb != NULL)
4457 return FAIL;
4458 /* TODO: Check if FAIL is the proper return code */
4459
4460 entryTick = TickCount();
4461
4462 allow_scrollbar = TRUE;
4463
4464 do
4465 {
4466/* if (dragRectControl == kCreateEmpty)
4467 {
4468 dragRgn = NULL;
4469 dragRectControl = kNothing;
4470 }
4471 else*/ if (dragRectControl == kCreateRect)
4472 {
4473 dragRgn = cursorRgn;
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00004474 RectRgn(dragRgn, &dragRect);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004475 dragRectControl = kNothing;
4476 }
4477 /*
4478 * Don't use gui_mch_update() because then we will spin-lock until a
4479 * char arrives, instead we use WaitNextEventWrp() to hang until an
4480 * event arrives. No need to check for input_buf_full because we are
4481 * returning as soon as it contains a single char.
4482 */
Bram Moolenaarb05034a2010-09-21 17:34:31 +02004483 /* TODO: reduce wtime accordingly??? */
Bram Moolenaar071d4272004-06-13 20:20:40 +00004484 if (wtime > -1)
Bram Moolenaar1b60e502008-03-12 13:40:54 +00004485 sleeppyTick = 60 * wtime / 1000;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004486 else
4487 sleeppyTick = 32767;
Bram Moolenaar1b60e502008-03-12 13:40:54 +00004488
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00004489 if (WaitNextEventWrp(mask, &event, sleeppyTick, dragRgn))
Bram Moolenaar071d4272004-06-13 20:20:40 +00004490 {
Bram Moolenaar1b60e502008-03-12 13:40:54 +00004491 gui_mac_handle_event(&event);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004492 if (input_available())
4493 {
4494 allow_scrollbar = FALSE;
4495 return OK;
4496 }
4497 }
4498 currentTick = TickCount();
4499 }
4500 while ((wtime == -1) || ((currentTick - entryTick) < 60*wtime/1000));
4501
4502 allow_scrollbar = FALSE;
4503 return FAIL;
4504}
4505
Bram Moolenaar071d4272004-06-13 20:20:40 +00004506/*
4507 * Output routines.
4508 */
4509
4510/* Flush any output to the screen */
4511 void
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00004512gui_mch_flush(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004513{
4514 /* TODO: Is anything needed here? */
4515}
4516
4517/*
4518 * Clear a rectangular region of the screen from text pos (row1, col1) to
4519 * (row2, col2) inclusive.
4520 */
4521 void
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00004522gui_mch_clear_block(int row1, int col1, int row2, int col2)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004523{
4524 Rect rc;
4525
4526 /*
4527 * Clear one extra pixel at the far right, for when bold characters have
4528 * spilled over to the next column.
4529 */
4530 rc.left = FILL_X(col1);
4531 rc.top = FILL_Y(row1);
4532 rc.right = FILL_X(col2 + 1) + (col2 == Columns - 1);
4533 rc.bottom = FILL_Y(row2 + 1);
4534
4535 gui_mch_set_bg_color(gui.back_pixel);
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00004536 EraseRect(&rc);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004537}
4538
4539/*
4540 * Clear the whole text window.
4541 */
4542 void
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00004543gui_mch_clear_all(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004544{
4545 Rect rc;
4546
4547 rc.left = 0;
4548 rc.top = 0;
4549 rc.right = Columns * gui.char_width + 2 * gui.border_width;
4550 rc.bottom = Rows * gui.char_height + 2 * gui.border_width;
4551
4552 gui_mch_set_bg_color(gui.back_pixel);
4553 EraseRect(&rc);
4554/* gui_mch_set_fg_color(gui.norm_pixel);
4555 FrameRect(&rc);
4556*/
4557}
4558
4559/*
4560 * Delete the given number of lines from the given row, scrolling up any
4561 * text further down within the scroll region.
4562 */
4563 void
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00004564gui_mch_delete_lines(int row, int num_lines)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004565{
4566 Rect rc;
4567
4568 /* changed without checking! */
4569 rc.left = FILL_X(gui.scroll_region_left);
4570 rc.right = FILL_X(gui.scroll_region_right + 1);
4571 rc.top = FILL_Y(row);
4572 rc.bottom = FILL_Y(gui.scroll_region_bot + 1);
4573
4574 gui_mch_set_bg_color(gui.back_pixel);
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00004575 ScrollRect(&rc, 0, -num_lines * gui.char_height, (RgnHandle) nil);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004576
4577 gui_clear_block(gui.scroll_region_bot - num_lines + 1,
4578 gui.scroll_region_left,
4579 gui.scroll_region_bot, gui.scroll_region_right);
4580}
4581
4582/*
4583 * Insert the given number of lines before the given row, scrolling down any
4584 * following text within the scroll region.
4585 */
4586 void
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00004587gui_mch_insert_lines(int row, int num_lines)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004588{
4589 Rect rc;
4590
4591 rc.left = FILL_X(gui.scroll_region_left);
4592 rc.right = FILL_X(gui.scroll_region_right + 1);
4593 rc.top = FILL_Y(row);
4594 rc.bottom = FILL_Y(gui.scroll_region_bot + 1);
4595
4596 gui_mch_set_bg_color(gui.back_pixel);
4597
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00004598 ScrollRect(&rc, 0, gui.char_height * num_lines, (RgnHandle) nil);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004599
4600 /* Update gui.cursor_row if the cursor scrolled or copied over */
4601 if (gui.cursor_row >= gui.row
4602 && gui.cursor_col >= gui.scroll_region_left
4603 && gui.cursor_col <= gui.scroll_region_right)
4604 {
4605 if (gui.cursor_row <= gui.scroll_region_bot - num_lines)
4606 gui.cursor_row += num_lines;
4607 else if (gui.cursor_row <= gui.scroll_region_bot)
4608 gui.cursor_is_valid = FALSE;
4609 }
4610
4611 gui_clear_block(row, gui.scroll_region_left,
4612 row + num_lines - 1, gui.scroll_region_right);
4613}
4614
4615 /*
4616 * TODO: add a vim format to the clipboard which remember
4617 * LINEWISE, CHARWISE, BLOCKWISE
4618 */
4619
4620 void
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00004621clip_mch_request_selection(VimClipboard *cbd)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004622{
4623
4624 Handle textOfClip;
Bram Moolenaar89cb5e02004-07-19 20:55:54 +00004625 int flavor = 0;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004626 Size scrapSize;
4627 ScrapFlavorFlags scrapFlags;
4628 ScrapRef scrap = nil;
4629 OSStatus error;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004630 int type;
4631 char *searchCR;
4632 char_u *tempclip;
4633
4634
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00004635 error = GetCurrentScrap(&scrap);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004636 if (error != noErr)
4637 return;
4638
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00004639 error = GetScrapFlavorFlags(scrap, VIMSCRAPFLAVOR, &scrapFlags);
4640 if (error == noErr)
4641 {
4642 error = GetScrapFlavorSize(scrap, VIMSCRAPFLAVOR, &scrapSize);
4643 if (error == noErr && scrapSize > 1)
4644 flavor = 1;
4645 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00004646
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00004647 if (flavor == 0)
4648 {
Bram Moolenaarfc1421e2006-04-20 22:17:20 +00004649 error = GetScrapFlavorFlags(scrap, SCRAPTEXTFLAVOR, &scrapFlags);
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00004650 if (error != noErr)
4651 return;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004652
Bram Moolenaarfc1421e2006-04-20 22:17:20 +00004653 error = GetScrapFlavorSize(scrap, SCRAPTEXTFLAVOR, &scrapSize);
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00004654 if (error != noErr)
4655 return;
4656 }
4657
4658 ReserveMem(scrapSize);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004659
Bram Moolenaarfc1421e2006-04-20 22:17:20 +00004660 /* In CARBON we don't need a Handle, a pointer is good */
4661 textOfClip = NewHandle(scrapSize);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004662
Bram Moolenaarfc1421e2006-04-20 22:17:20 +00004663 /* tempclip = lalloc(scrapSize+1, TRUE); */
4664 HLock(textOfClip);
4665 error = GetScrapFlavorData(scrap,
4666 flavor ? VIMSCRAPFLAVOR : SCRAPTEXTFLAVOR,
4667 &scrapSize, *textOfClip);
4668 scrapSize -= flavor;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004669
Bram Moolenaarfc1421e2006-04-20 22:17:20 +00004670 if (flavor)
4671 type = **textOfClip;
4672 else
Bram Moolenaard44347f2011-06-19 01:14:29 +02004673 type = MAUTO;
Bram Moolenaarfc1421e2006-04-20 22:17:20 +00004674
4675 tempclip = lalloc(scrapSize + 1, TRUE);
4676 mch_memmove(tempclip, *textOfClip + flavor, scrapSize);
4677 tempclip[scrapSize] = 0;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004678
Bram Moolenaar7d47b6e2006-03-15 22:59:18 +00004679#ifdef MACOS_CONVERT
Bram Moolenaarfc1421e2006-04-20 22:17:20 +00004680 {
Bram Moolenaar26a60b42005-02-22 08:49:11 +00004681 /* Convert from utf-16 (clipboard) */
4682 size_t encLen = 0;
4683 char_u *to = mac_utf16_to_enc((UniChar *)tempclip, scrapSize, &encLen);
Bram Moolenaarfc1421e2006-04-20 22:17:20 +00004684
4685 if (to != NULL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004686 {
Bram Moolenaar26a60b42005-02-22 08:49:11 +00004687 scrapSize = encLen;
4688 vim_free(tempclip);
4689 tempclip = to;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004690 }
Bram Moolenaarfc1421e2006-04-20 22:17:20 +00004691 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00004692#endif
Bram Moolenaare344bea2005-09-01 20:46:49 +00004693
Bram Moolenaarfc1421e2006-04-20 22:17:20 +00004694 searchCR = (char *)tempclip;
4695 while (searchCR != NULL)
4696 {
4697 searchCR = strchr(searchCR, '\r');
4698 if (searchCR != NULL)
4699 *searchCR = '\n';
Bram Moolenaar071d4272004-06-13 20:20:40 +00004700 }
Bram Moolenaarfc1421e2006-04-20 22:17:20 +00004701
4702 clip_yank_selection(type, tempclip, scrapSize, cbd);
4703
4704 vim_free(tempclip);
4705 HUnlock(textOfClip);
4706
4707 DisposeHandle(textOfClip);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004708}
4709
4710 void
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00004711clip_mch_lose_selection(VimClipboard *cbd)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004712{
4713 /*
4714 * TODO: Really nothing to do?
4715 */
4716}
4717
4718 int
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00004719clip_mch_own_selection(VimClipboard *cbd)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004720{
4721 return OK;
4722}
4723
4724/*
4725 * Send the current selection to the clipboard.
4726 */
4727 void
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00004728clip_mch_set_selection(VimClipboard *cbd)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004729{
4730 Handle textOfClip;
4731 long scrapSize;
4732 int type;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004733 ScrapRef scrap;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004734
4735 char_u *str = NULL;
4736
4737 if (!cbd->owned)
4738 return;
4739
4740 clip_get_selection(cbd);
4741
4742 /*
4743 * Once we set the clipboard, lose ownership. If another application sets
4744 * the clipboard, we don't want to think that we still own it.
Bram Moolenaar071d4272004-06-13 20:20:40 +00004745 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00004746 cbd->owned = FALSE;
4747
Bram Moolenaarfc1421e2006-04-20 22:17:20 +00004748 type = clip_convert_selection(&str, (long_u *)&scrapSize, cbd);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004749
Bram Moolenaar7d47b6e2006-03-15 22:59:18 +00004750#ifdef MACOS_CONVERT
Bram Moolenaar26a60b42005-02-22 08:49:11 +00004751 size_t utf16_len = 0;
4752 UniChar *to = mac_enc_to_utf16(str, scrapSize, &utf16_len);
4753 if (to)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004754 {
Bram Moolenaar26a60b42005-02-22 08:49:11 +00004755 scrapSize = utf16_len;
4756 vim_free(str);
4757 str = (char_u *)to;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004758 }
4759#endif
4760
4761 if (type >= 0)
4762 {
Bram Moolenaar071d4272004-06-13 20:20:40 +00004763 ClearCurrentScrap();
Bram Moolenaar071d4272004-06-13 20:20:40 +00004764
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00004765 textOfClip = NewHandle(scrapSize + 1);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004766 HLock(textOfClip);
4767
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00004768 **textOfClip = type;
Bram Moolenaar26a60b42005-02-22 08:49:11 +00004769 mch_memmove(*textOfClip + 1, str, scrapSize);
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00004770 GetCurrentScrap(&scrap);
Bram Moolenaarfc1421e2006-04-20 22:17:20 +00004771 PutScrapFlavor(scrap, SCRAPTEXTFLAVOR, kScrapFlavorMaskNone,
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00004772 scrapSize, *textOfClip + 1);
4773 PutScrapFlavor(scrap, VIMSCRAPFLAVOR, kScrapFlavorMaskNone,
4774 scrapSize + 1, *textOfClip);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004775 HUnlock(textOfClip);
4776 DisposeHandle(textOfClip);
4777 }
4778
4779 vim_free(str);
4780}
4781
4782 void
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00004783gui_mch_set_text_area_pos(int x, int y, int w, int h)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004784{
4785 Rect VimBound;
4786
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00004787/* HideWindow(gui.VimWindow); */
Bram Moolenaar071d4272004-06-13 20:20:40 +00004788 GetWindowBounds(gui.VimWindow, kWindowGlobalPortRgn, &VimBound);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004789
4790 if (gui.which_scrollbars[SBAR_LEFT])
4791 {
4792 VimBound.left = -gui.scrollbar_width + 1;
4793 }
4794 else
4795 {
4796 VimBound.left = 0;
4797 }
4798
Bram Moolenaar071d4272004-06-13 20:20:40 +00004799 SetWindowBounds(gui.VimWindow, kWindowGlobalPortRgn, &VimBound);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004800
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00004801 ShowWindow(gui.VimWindow);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004802}
4803
4804/*
4805 * Menu stuff.
4806 */
4807
4808 void
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00004809gui_mch_enable_menu(int flag)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004810{
4811 /*
Bram Moolenaar02743632005-07-25 20:42:36 +00004812 * Menu is always active.
Bram Moolenaar071d4272004-06-13 20:20:40 +00004813 */
4814}
4815
4816 void
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00004817gui_mch_set_menu_pos(int x, int y, int w, int h)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004818{
4819 /*
Bram Moolenaar02743632005-07-25 20:42:36 +00004820 * The menu is always at the top of the screen.
Bram Moolenaar071d4272004-06-13 20:20:40 +00004821 */
4822}
4823
4824/*
4825 * Add a sub menu to the menu bar.
4826 */
4827 void
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00004828gui_mch_add_menu(vimmenu_T *menu, int idx)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004829{
4830 /*
4831 * TODO: Try to use only menu_id instead of both menu_id and menu_handle.
4832 * TODO: use menu->mnemonic and menu->actext
4833 * TODO: Try to reuse menu id
4834 * Carbon Help suggest to use only id between 1 and 235
4835 */
4836 static long next_avail_id = 128;
4837 long menu_after_me = 0; /* Default to the end */
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00004838#if defined(FEAT_MBYTE)
Bram Moolenaar26a60b42005-02-22 08:49:11 +00004839 CFStringRef name;
4840#else
Bram Moolenaar071d4272004-06-13 20:20:40 +00004841 char_u *name;
Bram Moolenaar26a60b42005-02-22 08:49:11 +00004842#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00004843 short index;
4844 vimmenu_T *parent = menu->parent;
4845 vimmenu_T *brother = menu->next;
4846
4847 /* Cannot add a menu if ... */
4848 if ((parent != NULL && parent->submenu_id == 0))
4849 return;
4850
4851 /* menu ID greater than 1024 are reserved for ??? */
4852 if (next_avail_id == 1024)
4853 return;
4854
4855 /* My brother could be the PopUp, find my real brother */
4856 while ((brother != NULL) && (!menu_is_menubar(brother->name)))
4857 brother = brother->next;
4858
4859 /* Find where to insert the menu (for MenuBar) */
4860 if ((parent == NULL) && (brother != NULL))
4861 menu_after_me = brother->submenu_id;
4862
4863 /* If the menu is not part of the menubar (and its submenus), add it 'nowhere' */
4864 if (!menu_is_menubar(menu->name))
4865 menu_after_me = hierMenu;
4866
4867 /* Convert the name */
Bram Moolenaar7d47b6e2006-03-15 22:59:18 +00004868#ifdef MACOS_CONVERT
Bram Moolenaar26a60b42005-02-22 08:49:11 +00004869 name = menu_title_removing_mnemonic(menu);
4870#else
Bram Moolenaar071d4272004-06-13 20:20:40 +00004871 name = C2Pascal_save(menu->dname);
Bram Moolenaar26a60b42005-02-22 08:49:11 +00004872#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00004873 if (name == NULL)
4874 return;
4875
4876 /* Create the menu unless it's the help menu */
Bram Moolenaar071d4272004-06-13 20:20:40 +00004877 {
4878 /* Carbon suggest use of
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00004879 * OSStatus CreateNewMenu(MenuID, MenuAttributes, MenuRef *);
4880 * OSStatus SetMenuTitle(MenuRef, ConstStr255Param title);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004881 */
4882 menu->submenu_id = next_avail_id;
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00004883#if defined(FEAT_MBYTE)
Bram Moolenaar26a60b42005-02-22 08:49:11 +00004884 if (CreateNewMenu(menu->submenu_id, 0, (MenuRef *)&menu->submenu_handle) == noErr)
4885 SetMenuTitleWithCFString((MenuRef)menu->submenu_handle, name);
4886#else
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00004887 menu->submenu_handle = NewMenu(menu->submenu_id, name);
Bram Moolenaar26a60b42005-02-22 08:49:11 +00004888#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00004889 next_avail_id++;
4890 }
4891
4892 if (parent == NULL)
4893 {
4894 /* Adding a menu to the menubar, or in the no mans land (for PopUp) */
4895
4896 /* TODO: Verify if we could only Insert Menu if really part of the
4897 * menubar The Inserted menu are scanned or the Command-key combos
4898 */
4899
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00004900 /* Insert the menu */
4901 InsertMenu(menu->submenu_handle, menu_after_me); /* insert before */
Bram Moolenaar071d4272004-06-13 20:20:40 +00004902#if 1
4903 /* Vim should normally update it. TODO: verify */
4904 DrawMenuBar();
4905#endif
4906 }
4907 else
4908 {
4909 /* Adding as a submenu */
4910
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00004911 index = gui_mac_get_menu_item_index(menu);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004912
4913 /* Call InsertMenuItem followed by SetMenuItemText
4914 * to avoid special character recognition by InsertMenuItem
4915 */
4916 InsertMenuItem(parent->submenu_handle, "\p ", idx); /* afterItem */
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00004917#if defined(FEAT_MBYTE)
Bram Moolenaar26a60b42005-02-22 08:49:11 +00004918 SetMenuItemTextWithCFString(parent->submenu_handle, idx+1, name);
4919#else
Bram Moolenaar071d4272004-06-13 20:20:40 +00004920 SetMenuItemText(parent->submenu_handle, idx+1, name);
Bram Moolenaar26a60b42005-02-22 08:49:11 +00004921#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00004922 SetItemCmd(parent->submenu_handle, idx+1, 0x1B);
4923 SetItemMark(parent->submenu_handle, idx+1, menu->submenu_id);
4924 InsertMenu(menu->submenu_handle, hierMenu);
4925 }
4926
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00004927#if defined(FEAT_MBYTE)
Bram Moolenaar26a60b42005-02-22 08:49:11 +00004928 CFRelease(name);
4929#else
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00004930 vim_free(name);
Bram Moolenaar26a60b42005-02-22 08:49:11 +00004931#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00004932
4933#if 0
4934 /* Done by Vim later on */
4935 DrawMenuBar();
4936#endif
4937}
4938
4939/*
4940 * Add a menu item to a menu
4941 */
4942 void
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00004943gui_mch_add_menu_item(vimmenu_T *menu, int idx)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004944{
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00004945#if defined(FEAT_MBYTE)
Bram Moolenaar26a60b42005-02-22 08:49:11 +00004946 CFStringRef name;
4947#else
Bram Moolenaar071d4272004-06-13 20:20:40 +00004948 char_u *name;
Bram Moolenaar26a60b42005-02-22 08:49:11 +00004949#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00004950 vimmenu_T *parent = menu->parent;
4951 int menu_inserted;
4952
4953 /* Cannot add item, if the menu have not been created */
4954 if (parent->submenu_id == 0)
4955 return;
4956
4957 /* Could call SetMenuRefCon [CARBON] to associate with the Menu,
4958 for older OS call GetMenuItemData (menu, item, isCommandID?, data) */
4959
4960 /* Convert the name */
Bram Moolenaar7d47b6e2006-03-15 22:59:18 +00004961#ifdef MACOS_CONVERT
Bram Moolenaar26a60b42005-02-22 08:49:11 +00004962 name = menu_title_removing_mnemonic(menu);
4963#else
Bram Moolenaar071d4272004-06-13 20:20:40 +00004964 name = C2Pascal_save(menu->dname);
Bram Moolenaar26a60b42005-02-22 08:49:11 +00004965#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00004966
4967 /* Where are just a menu item, so no handle, no id */
4968 menu->submenu_id = 0;
4969 menu->submenu_handle = NULL;
4970
Bram Moolenaar071d4272004-06-13 20:20:40 +00004971 menu_inserted = 0;
4972 if (menu->actext)
4973 {
4974 /* If the accelerator text for the menu item looks like it describes
4975 * a command key (e.g., "<D-S-t>" or "<C-7>"), display it as the
4976 * item's command equivalent.
4977 */
4978 int key = 0;
4979 int modifiers = 0;
4980 char_u *p_actext;
4981
4982 p_actext = menu->actext;
Bram Moolenaardc5e2182008-12-24 12:06:26 +00004983 key = find_special_key(&p_actext, &modifiers, FALSE, FALSE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004984 if (*p_actext != 0)
4985 key = 0; /* error: trailing text */
4986 /* find_special_key() returns a keycode with as many of the
4987 * specified modifiers as appropriate already applied (e.g., for
4988 * "<D-C-x>" it returns Ctrl-X as the keycode and MOD_MASK_CMD
4989 * as the only modifier). Since we want to display all of the
4990 * modifiers, we need to convert the keycode back to a printable
4991 * character plus modifiers.
4992 * TODO: Write an alternative find_special_key() that doesn't
4993 * apply modifiers.
4994 */
4995 if (key > 0 && key < 32)
4996 {
4997 /* Convert a control key to an uppercase letter. Note that
4998 * by this point it is no longer possible to distinguish
4999 * between, e.g., Ctrl-S and Ctrl-Shift-S.
5000 */
5001 modifiers |= MOD_MASK_CTRL;
5002 key += '@';
5003 }
5004 /* If the keycode is an uppercase letter, set the Shift modifier.
5005 * If it is a lowercase letter, don't set the modifier, but convert
5006 * the letter to uppercase for display in the menu.
5007 */
5008 else if (key >= 'A' && key <= 'Z')
5009 modifiers |= MOD_MASK_SHIFT;
5010 else if (key >= 'a' && key <= 'z')
5011 key += 'A' - 'a';
5012 /* Note: keycodes below 0x22 are reserved by Apple. */
5013 if (key >= 0x22 && vim_isprintc_strict(key))
5014 {
5015 int valid = 1;
5016 char_u mac_mods = kMenuNoModifiers;
5017 /* Convert Vim modifier codes to Menu Manager equivalents. */
5018 if (modifiers & MOD_MASK_SHIFT)
5019 mac_mods |= kMenuShiftModifier;
5020 if (modifiers & MOD_MASK_CTRL)
5021 mac_mods |= kMenuControlModifier;
5022 if (!(modifiers & MOD_MASK_CMD))
5023 mac_mods |= kMenuNoCommandModifier;
5024 if (modifiers & MOD_MASK_ALT || modifiers & MOD_MASK_MULTI_CLICK)
5025 valid = 0; /* TODO: will Alt someday map to Option? */
5026 if (valid)
5027 {
5028 char_u item_txt[10];
5029 /* Insert the menu item after idx, with its command key. */
5030 item_txt[0] = 3; item_txt[1] = ' '; item_txt[2] = '/';
5031 item_txt[3] = key;
5032 InsertMenuItem(parent->submenu_handle, item_txt, idx);
5033 /* Set the modifier keys. */
5034 SetMenuItemModifiers(parent->submenu_handle, idx+1, mac_mods);
5035 menu_inserted = 1;
5036 }
5037 }
5038 }
5039 /* Call InsertMenuItem followed by SetMenuItemText
5040 * to avoid special character recognition by InsertMenuItem
5041 */
5042 if (!menu_inserted)
5043 InsertMenuItem(parent->submenu_handle, "\p ", idx); /* afterItem */
5044 /* Set the menu item name. */
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00005045#if defined(FEAT_MBYTE)
Bram Moolenaar26a60b42005-02-22 08:49:11 +00005046 SetMenuItemTextWithCFString(parent->submenu_handle, idx+1, name);
5047#else
Bram Moolenaar071d4272004-06-13 20:20:40 +00005048 SetMenuItemText(parent->submenu_handle, idx+1, name);
Bram Moolenaar26a60b42005-02-22 08:49:11 +00005049#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00005050
5051#if 0
5052 /* Called by Vim */
5053 DrawMenuBar();
5054#endif
5055
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00005056#if defined(FEAT_MBYTE)
Bram Moolenaar26a60b42005-02-22 08:49:11 +00005057 CFRelease(name);
5058#else
Bram Moolenaar071d4272004-06-13 20:20:40 +00005059 /* TODO: Can name be freed? */
5060 vim_free(name);
Bram Moolenaar26a60b42005-02-22 08:49:11 +00005061#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00005062}
5063
5064 void
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00005065gui_mch_toggle_tearoffs(int enable)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005066{
5067 /* no tearoff menus */
5068}
5069
5070/*
5071 * Destroy the machine specific menu widget.
5072 */
5073 void
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00005074gui_mch_destroy_menu(vimmenu_T *menu)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005075{
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00005076 short index = gui_mac_get_menu_item_index(menu);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005077
5078 if (index > 0)
5079 {
5080 if (menu->parent)
5081 {
Bram Moolenaar071d4272004-06-13 20:20:40 +00005082 {
5083 /* For now just don't delete help menu items. (Huh? Dany) */
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00005084 DeleteMenuItem(menu->parent->submenu_handle, index);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005085
5086 /* Delete the Menu if it was a hierarchical Menu */
5087 if (menu->submenu_id != 0)
5088 {
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00005089 DeleteMenu(menu->submenu_id);
5090 DisposeMenu(menu->submenu_handle);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005091 }
5092 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00005093 }
5094#ifdef DEBUG_MAC_MENU
5095 else
5096 {
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00005097 printf("gmdm 2\n");
Bram Moolenaar071d4272004-06-13 20:20:40 +00005098 }
5099#endif
5100 }
5101 else
5102 {
Bram Moolenaar071d4272004-06-13 20:20:40 +00005103 {
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00005104 DeleteMenu(menu->submenu_id);
5105 DisposeMenu(menu->submenu_handle);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005106 }
5107 }
5108 /* Shouldn't this be already done by Vim. TODO: Check */
5109 DrawMenuBar();
5110}
5111
5112/*
5113 * Make a menu either grey or not grey.
5114 */
5115 void
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00005116gui_mch_menu_grey(vimmenu_T *menu, int grey)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005117{
5118 /* TODO: Check if menu really exists */
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00005119 short index = gui_mac_get_menu_item_index(menu);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005120/*
5121 index = menu->index;
5122*/
5123 if (grey)
5124 {
5125 if (menu->children)
5126 DisableMenuItem(menu->submenu_handle, index);
5127 if (menu->parent)
5128 if (menu->parent->submenu_handle)
5129 DisableMenuItem(menu->parent->submenu_handle, index);
5130 }
5131 else
5132 {
5133 if (menu->children)
5134 EnableMenuItem(menu->submenu_handle, index);
5135 if (menu->parent)
5136 if (menu->parent->submenu_handle)
5137 EnableMenuItem(menu->parent->submenu_handle, index);
5138 }
5139}
5140
5141/*
5142 * Make menu item hidden or not hidden
5143 */
5144 void
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00005145gui_mch_menu_hidden(vimmenu_T *menu, int hidden)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005146{
5147 /* There's no hidden mode on MacOS */
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00005148 gui_mch_menu_grey(menu, hidden);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005149}
5150
5151
5152/*
5153 * This is called after setting all the menus to grey/hidden or not.
5154 */
5155 void
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00005156gui_mch_draw_menubar(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005157{
5158 DrawMenuBar();
5159}
5160
5161
5162/*
5163 * Scrollbar stuff.
5164 */
5165
5166 void
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00005167gui_mch_enable_scrollbar(
5168 scrollbar_T *sb,
5169 int flag)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005170{
5171 if (flag)
5172 ShowControl(sb->id);
5173 else
5174 HideControl(sb->id);
5175
5176#ifdef DEBUG_MAC_SB
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00005177 printf("enb_sb (%x) %x\n",sb->id, flag);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005178#endif
5179}
5180
5181 void
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00005182gui_mch_set_scrollbar_thumb(
5183 scrollbar_T *sb,
5184 long val,
5185 long size,
5186 long max)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005187{
5188 SetControl32BitMaximum (sb->id, max);
5189 SetControl32BitMinimum (sb->id, 0);
5190 SetControl32BitValue (sb->id, val);
Bram Moolenaarbbe8c3f2007-04-26 16:40:56 +00005191 SetControlViewSize (sb->id, size);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005192#ifdef DEBUG_MAC_SB
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00005193 printf("thumb_sb (%x) %x, %x,%x\n",sb->id, val, size, max);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005194#endif
5195}
5196
5197 void
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00005198gui_mch_set_scrollbar_pos(
5199 scrollbar_T *sb,
5200 int x,
5201 int y,
5202 int w,
5203 int h)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005204{
5205 gui_mch_set_bg_color(gui.back_pixel);
5206/* if (gui.which_scrollbars[SBAR_LEFT])
5207 {
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00005208 MoveControl(sb->id, x-16, y);
5209 SizeControl(sb->id, w + 1, h);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005210 }
5211 else
5212 {
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00005213 MoveControl(sb->id, x, y);
5214 SizeControl(sb->id, w + 1, h);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005215 }*/
5216 if (sb == &gui.bottom_sbar)
5217 h += 1;
5218 else
5219 w += 1;
5220
5221 if (gui.which_scrollbars[SBAR_LEFT])
5222 x -= 15;
5223
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00005224 MoveControl(sb->id, x, y);
5225 SizeControl(sb->id, w, h);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005226#ifdef DEBUG_MAC_SB
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00005227 printf("size_sb (%x) %x, %x, %x, %x\n",sb->id, x, y, w, h);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005228#endif
5229}
5230
5231 void
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00005232gui_mch_create_scrollbar(
5233 scrollbar_T *sb,
5234 int orient) /* SBAR_VERT or SBAR_HORIZ */
Bram Moolenaar071d4272004-06-13 20:20:40 +00005235{
5236 Rect bounds;
5237
5238 bounds.top = -16;
5239 bounds.bottom = -10;
5240 bounds.right = -10;
5241 bounds.left = -16;
5242
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00005243 sb->id = NewControl(gui.VimWindow,
Bram Moolenaar071d4272004-06-13 20:20:40 +00005244 &bounds,
5245 "\pScrollBar",
5246 TRUE,
5247 0, /* current*/
5248 0, /* top */
5249 0, /* bottom */
Bram Moolenaar071d4272004-06-13 20:20:40 +00005250 kControlScrollBarLiveProc,
Bram Moolenaar071d4272004-06-13 20:20:40 +00005251 (long) sb->ident);
5252#ifdef DEBUG_MAC_SB
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00005253 printf("create_sb (%x) %x\n",sb->id, orient);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005254#endif
5255}
5256
5257 void
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00005258gui_mch_destroy_scrollbar(scrollbar_T *sb)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005259{
5260 gui_mch_set_bg_color(gui.back_pixel);
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00005261 DisposeControl(sb->id);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005262#ifdef DEBUG_MAC_SB
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00005263 printf("dest_sb (%x) \n",sb->id);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005264#endif
5265}
5266
5267
5268/*
5269 * Cursor blink functions.
5270 *
5271 * This is a simple state machine:
5272 * BLINK_NONE not blinking at all
5273 * BLINK_OFF blinking, cursor is not shown
5274 * BLINK_ON blinking, cursor is shown
5275 */
5276 void
5277gui_mch_set_blinking(long wait, long on, long off)
5278{
5279 /* TODO: TODO: TODO: TODO: */
5280/* blink_waittime = wait;
5281 blink_ontime = on;
5282 blink_offtime = off;*/
5283}
5284
5285/*
5286 * Stop the cursor blinking. Show the cursor if it wasn't shown.
5287 */
5288 void
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00005289gui_mch_stop_blink(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005290{
5291 gui_update_cursor(TRUE, FALSE);
5292 /* TODO: TODO: TODO: TODO: */
5293/* gui_w32_rm_blink_timer();
5294 if (blink_state == BLINK_OFF)
5295 gui_update_cursor(TRUE, FALSE);
5296 blink_state = BLINK_NONE;*/
5297}
5298
5299/*
5300 * Start the cursor blinking. If it was already blinking, this restarts the
5301 * waiting time and shows the cursor.
5302 */
5303 void
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00005304gui_mch_start_blink(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005305{
5306 gui_update_cursor(TRUE, FALSE);
5307 /* TODO: TODO: TODO: TODO: */
5308/* gui_w32_rm_blink_timer(); */
5309
5310 /* Only switch blinking on if none of the times is zero */
5311/* if (blink_waittime && blink_ontime && blink_offtime)
5312 {
5313 blink_timer = SetTimer(NULL, 0, (UINT)blink_waittime,
5314 (TIMERPROC)_OnBlinkTimer);
5315 blink_state = BLINK_ON;
5316 gui_update_cursor(TRUE, FALSE);
5317 }*/
5318}
5319
5320/*
5321 * Return the RGB value of a pixel as long.
5322 */
5323 long_u
5324gui_mch_get_rgb(guicolor_T pixel)
5325{
5326 return (Red(pixel) << 16) + (Green(pixel) << 8) + Blue(pixel);
5327}
5328
5329
5330
5331#ifdef FEAT_BROWSE
5332/*
5333 * Pop open a file browser and return the file selected, in allocated memory,
5334 * or NULL if Cancel is hit.
5335 * saving - TRUE if the file will be saved to, FALSE if it will be opened.
5336 * title - Title message for the file browser dialog.
5337 * dflt - Default name of file.
5338 * ext - Default extension to be added to files without extensions.
5339 * initdir - directory in which to open the browser (NULL = current dir)
5340 * filter - Filter for matched files to choose from.
5341 * Has a format like this:
5342 * "C Files (*.c)\0*.c\0"
5343 * "All Files\0*.*\0\0"
5344 * If these two strings were concatenated, then a choice of two file
5345 * filters will be selectable to the user. Then only matching files will
5346 * be shown in the browser. If NULL, the default allows all files.
5347 *
5348 * *NOTE* - the filter string must be terminated with TWO nulls.
5349 */
5350 char_u *
5351gui_mch_browse(
5352 int saving,
5353 char_u *title,
5354 char_u *dflt,
5355 char_u *ext,
5356 char_u *initdir,
5357 char_u *filter)
5358{
Bram Moolenaar84a05ac2013-05-06 04:24:17 +02005359 /* TODO: Add Ammon's safety check (Dany) */
Bram Moolenaar071d4272004-06-13 20:20:40 +00005360 NavReplyRecord reply;
5361 char_u *fname = NULL;
5362 char_u **fnames = NULL;
5363 long numFiles;
5364 NavDialogOptions navOptions;
5365 OSErr error;
5366
5367 /* Get Navigation Service Defaults value */
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00005368 NavGetDefaultDialogOptions(&navOptions);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005369
5370
5371 /* TODO: If we get a :browse args, set the Multiple bit. */
5372 navOptions.dialogOptionFlags = kNavAllowInvisibleFiles
5373 | kNavDontAutoTranslate
5374 | kNavDontAddTranslateItems
5375 /* | kNavAllowMultipleFiles */
5376 | kNavAllowStationery;
5377
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00005378 (void) C2PascalString(title, &navOptions.message);
5379 (void) C2PascalString(dflt, &navOptions.savedFileName);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005380 /* Could set clientName?
5381 * windowTitle? (there's no title bar?)
5382 */
5383
5384 if (saving)
5385 {
5386 /* Change first parm AEDesc (typeFSS) *defaultLocation to match dflt */
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00005387 NavPutFile(NULL, &reply, &navOptions, NULL, 'TEXT', 'VIM!', NULL);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005388 if (!reply.validRecord)
5389 return NULL;
5390 }
5391 else
5392 {
5393 /* Change first parm AEDesc (typeFSS) *defaultLocation to match dflt */
5394 NavGetFile(NULL, &reply, &navOptions, NULL, NULL, NULL, NULL, NULL);
5395 if (!reply.validRecord)
5396 return NULL;
5397 }
5398
5399 fnames = new_fnames_from_AEDesc(&reply.selection, &numFiles, &error);
5400
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00005401 NavDisposeReply(&reply);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005402
5403 if (fnames)
5404 {
5405 fname = fnames[0];
5406 vim_free(fnames);
5407 }
5408
5409 /* TODO: Shorten the file name if possible */
5410 return fname;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005411}
5412#endif /* FEAT_BROWSE */
5413
5414#ifdef FEAT_GUI_DIALOG
5415/*
5416 * Stuff for dialogues
5417 */
5418
5419/*
5420 * Create a dialogue dynamically from the parameter strings.
5421 * type = type of dialogue (question, alert, etc.)
5422 * title = dialogue title. may be NULL for default title.
5423 * message = text to display. Dialogue sizes to accommodate it.
5424 * buttons = '\n' separated list of button captions, default first.
5425 * dfltbutton = number of default button.
5426 *
5427 * This routine returns 1 if the first button is pressed,
5428 * 2 for the second, etc.
5429 *
5430 * 0 indicates Esc was pressed.
5431 * -1 for unexpected error
5432 *
5433 * If stubbing out this fn, return 1.
5434 */
5435
5436typedef struct
5437{
5438 short idx;
5439 short width; /* Size of the text in pixel */
5440 Rect box;
5441} vgmDlgItm; /* Vim Gui_Mac.c Dialog Item */
5442
5443#define MoveRectTo(r,x,y) OffsetRect(r,x-r->left,y-r->top)
5444
5445 static void
5446macMoveDialogItem(
5447 DialogRef theDialog,
5448 short itemNumber,
5449 short X,
5450 short Y,
5451 Rect *inBox)
5452{
5453#if 0 /* USE_CARBONIZED */
5454 /* Untested */
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00005455 MoveDialogItem(theDialog, itemNumber, X, Y);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005456 if (inBox != nil)
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00005457 GetDialogItem(theDialog, itemNumber, &itemType, &itemHandle, inBox);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005458#else
5459 short itemType;
5460 Handle itemHandle;
5461 Rect localBox;
5462 Rect *itemBox = &localBox;
5463
5464 if (inBox != nil)
5465 itemBox = inBox;
5466
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00005467 GetDialogItem(theDialog, itemNumber, &itemType, &itemHandle, itemBox);
5468 OffsetRect(itemBox, -itemBox->left, -itemBox->top);
5469 OffsetRect(itemBox, X, Y);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005470 /* To move a control (like a button) we need to call both
5471 * MoveControl and SetDialogItem. FAQ 6-18 */
5472 if (1) /*(itemType & kControlDialogItem) */
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00005473 MoveControl((ControlRef) itemHandle, X, Y);
5474 SetDialogItem(theDialog, itemNumber, itemType, itemHandle, itemBox);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005475#endif
5476}
5477
5478 static void
5479macSizeDialogItem(
5480 DialogRef theDialog,
5481 short itemNumber,
5482 short width,
5483 short height)
5484{
5485 short itemType;
5486 Handle itemHandle;
5487 Rect itemBox;
5488
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00005489 GetDialogItem(theDialog, itemNumber, &itemType, &itemHandle, &itemBox);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005490
5491 /* When width or height is zero do not change it */
5492 if (width == 0)
5493 width = itemBox.right - itemBox.left;
5494 if (height == 0)
5495 height = itemBox.bottom - itemBox.top;
5496
5497#if 0 /* USE_CARBONIZED */
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00005498 SizeDialogItem(theDialog, itemNumber, width, height); /* Untested */
Bram Moolenaar071d4272004-06-13 20:20:40 +00005499#else
5500 /* Resize the bounding box */
5501 itemBox.right = itemBox.left + width;
5502 itemBox.bottom = itemBox.top + height;
5503
5504 /* To resize a control (like a button) we need to call both
5505 * SizeControl and SetDialogItem. (deducted from FAQ 6-18) */
5506 if (itemType & kControlDialogItem)
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00005507 SizeControl((ControlRef) itemHandle, width, height);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005508
5509 /* Configure back the item */
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00005510 SetDialogItem(theDialog, itemNumber, itemType, itemHandle, &itemBox);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005511#endif
5512}
5513
5514 static void
5515macSetDialogItemText(
5516 DialogRef theDialog,
5517 short itemNumber,
5518 Str255 itemName)
5519{
5520 short itemType;
5521 Handle itemHandle;
5522 Rect itemBox;
5523
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00005524 GetDialogItem(theDialog, itemNumber, &itemType, &itemHandle, &itemBox);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005525
5526 if (itemType & kControlDialogItem)
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00005527 SetControlTitle((ControlRef) itemHandle, itemName);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005528 else
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00005529 SetDialogItemText(itemHandle, itemName);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005530}
5531
Bram Moolenaarc52da9d2008-03-20 13:39:37 +00005532
5533/* ModalDialog() handler for message dialogs that have hotkey accelerators.
5534 * Expects a mapping of hotkey char to control index in gDialogHotKeys;
5535 * setting gDialogHotKeys to NULL disables any hotkey handling.
5536 */
5537 static pascal Boolean
5538DialogHotkeyFilterProc (
5539 DialogRef theDialog,
5540 EventRecord *event,
5541 DialogItemIndex *itemHit)
5542{
5543 char_u keyHit;
5544
5545 if (event->what == keyDown || event->what == autoKey)
5546 {
5547 keyHit = (event->message & charCodeMask);
5548
5549 if (gDialogHotKeys && gDialogHotKeys[keyHit])
5550 {
5551#ifdef DEBUG_MAC_DIALOG_HOTKEYS
5552 printf("user pressed hotkey '%c' --> item %d\n", keyHit, gDialogHotKeys[keyHit]);
5553#endif
5554 *itemHit = gDialogHotKeys[keyHit];
5555
5556 /* When handing off to StdFilterProc, pretend that the user
5557 * clicked the control manually. Note that this is also supposed
5558 * to cause the button to hilite briefly (to give some user
5559 * feedback), but this seems not to actually work (or it's too
5560 * fast to be seen).
5561 */
5562 event->what = kEventControlSimulateHit;
5563
5564 return true; /* we took care of it */
5565 }
5566
5567 /* Defer to the OS's standard behavior for this event.
5568 * This ensures that Enter will still activate the default button. */
5569 return StdFilterProc(theDialog, event, itemHit);
5570 }
5571 return false; /* Let ModalDialog deal with it */
5572}
5573
5574
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00005575/* TODO: There have been some crashes with dialogs, check your inbox
5576 * (Jussi)
5577 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00005578 int
5579gui_mch_dialog(
5580 int type,
5581 char_u *title,
5582 char_u *message,
5583 char_u *buttons,
5584 int dfltbutton,
Bram Moolenaard2c340a2011-01-17 20:08:11 +01005585 char_u *textfield,
5586 int ex_cmd)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005587{
5588 Handle buttonDITL;
5589 Handle iconDITL;
5590 Handle inputDITL;
5591 Handle messageDITL;
5592 Handle itemHandle;
5593 Handle iconHandle;
5594 DialogPtr theDialog;
5595 char_u len;
5596 char_u PascalTitle[256]; /* place holder for the title */
5597 char_u name[256];
5598 GrafPtr oldPort;
5599 short itemHit;
5600 char_u *buttonChar;
Bram Moolenaarc52da9d2008-03-20 13:39:37 +00005601 short hotKeys[256]; /* map of hotkey -> control ID */
5602 char_u aHotKey;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005603 Rect box;
5604 short button;
5605 short lastButton;
5606 short itemType;
5607 short useIcon;
5608 short width;
Bram Moolenaarec831732007-08-30 10:51:14 +00005609 short totalButtonWidth = 0; /* the width of all buttons together
Bram Moolenaar720c7102007-05-10 18:07:50 +00005610 including spacing */
Bram Moolenaar071d4272004-06-13 20:20:40 +00005611 short widestButton = 0;
5612 short dfltButtonEdge = 20; /* gut feeling */
5613 short dfltElementSpacing = 13; /* from IM:V.2-29 */
5614 short dfltIconSideSpace = 23; /* from IM:V.2-29 */
5615 short maximumWidth = 400; /* gut feeling */
5616 short maxButtonWidth = 175; /* gut feeling */
5617
5618 short vertical;
5619 short dialogHeight;
5620 short messageLines = 3;
5621 FontInfo textFontInfo;
5622
5623 vgmDlgItm iconItm;
5624 vgmDlgItm messageItm;
5625 vgmDlgItm inputItm;
5626 vgmDlgItm buttonItm;
5627
5628 WindowRef theWindow;
5629
Bram Moolenaarc52da9d2008-03-20 13:39:37 +00005630 ModalFilterUPP dialogUPP;
5631
Bram Moolenaar071d4272004-06-13 20:20:40 +00005632 /* Check 'v' flag in 'guioptions': vertical button placement. */
5633 vertical = (vim_strchr(p_go, GO_VERTICAL) != NULL);
5634
5635 /* Create a new Dialog Box from template. */
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00005636 theDialog = GetNewDialog(129, nil, (WindowRef) -1);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005637
5638 /* Get the WindowRef */
5639 theWindow = GetDialogWindow(theDialog);
5640
5641 /* Hide the window.
5642 * 1. to avoid seeing slow drawing
5643 * 2. to prevent a problem seen while moving dialog item
5644 * within a visible window. (non-Carbon MacOS 9)
5645 * Could be avoided by changing the resource.
5646 */
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00005647 HideWindow(theWindow);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005648
5649 /* Change the graphical port to the dialog,
5650 * so we can measure the text with the proper font */
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00005651 GetPort(&oldPort);
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00005652 SetPortDialogPort(theDialog);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005653
5654 /* Get the info about the default text,
5655 * used to calculate the height of the message
5656 * and of the text field */
5657 GetFontInfo(&textFontInfo);
5658
5659 /* Set the dialog title */
5660 if (title != NULL)
5661 {
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00005662 (void) C2PascalString(title, &PascalTitle);
5663 SetWTitle(theWindow, PascalTitle);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005664 }
5665
5666 /* Creates the buttons and add them to the Dialog Box. */
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00005667 buttonDITL = GetResource('DITL', 130);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005668 buttonChar = buttons;
5669 button = 0;
5670
Bram Moolenaarc52da9d2008-03-20 13:39:37 +00005671 /* initialize the hotkey mapping */
Bram Moolenaar7db5fc82010-05-24 11:59:29 +02005672 vim_memset(hotKeys, 0, sizeof(hotKeys));
Bram Moolenaarc52da9d2008-03-20 13:39:37 +00005673
Bram Moolenaar071d4272004-06-13 20:20:40 +00005674 for (;*buttonChar != 0;)
5675 {
5676 /* Get the name of the button */
5677 button++;
5678 len = 0;
5679 for (;((*buttonChar != DLG_BUTTON_SEP) && (*buttonChar != 0) && (len < 255)); buttonChar++)
5680 {
5681 if (*buttonChar != DLG_HOTKEY_CHAR)
5682 name[++len] = *buttonChar;
Bram Moolenaarc52da9d2008-03-20 13:39:37 +00005683 else
5684 {
5685 aHotKey = (char_u)*(buttonChar+1);
5686 if (aHotKey >= 'A' && aHotKey <= 'Z')
5687 aHotKey = (char_u)((int)aHotKey + (int)'a' - (int)'A');
5688 hotKeys[aHotKey] = button;
5689#ifdef DEBUG_MAC_DIALOG_HOTKEYS
5690 printf("### hotKey for button %d is '%c'\n", button, aHotKey);
5691#endif
5692 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00005693 }
Bram Moolenaarc52da9d2008-03-20 13:39:37 +00005694
Bram Moolenaar071d4272004-06-13 20:20:40 +00005695 if (*buttonChar != 0)
5696 buttonChar++;
5697 name[0] = len;
5698
5699 /* Add the button */
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00005700 AppendDITL(theDialog, buttonDITL, overlayDITL); /* appendDITLRight); */
Bram Moolenaar071d4272004-06-13 20:20:40 +00005701
5702 /* Change the button's name */
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00005703 macSetDialogItemText(theDialog, button, name);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005704
5705 /* Resize the button to fit its name */
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00005706 width = StringWidth(name) + 2 * dfltButtonEdge;
Bram Moolenaar84a05ac2013-05-06 04:24:17 +02005707 /* Limit the size of any button to an acceptable value. */
Bram Moolenaar071d4272004-06-13 20:20:40 +00005708 /* TODO: Should be based on the message width */
5709 if (width > maxButtonWidth)
5710 width = maxButtonWidth;
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00005711 macSizeDialogItem(theDialog, button, width, 0);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005712
5713 totalButtonWidth += width;
5714
5715 if (width > widestButton)
5716 widestButton = width;
5717 }
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00005718 ReleaseResource(buttonDITL);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005719 lastButton = button;
5720
5721 /* Add the icon to the Dialog Box. */
5722 iconItm.idx = lastButton + 1;
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00005723 iconDITL = GetResource('DITL', 131);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005724 switch (type)
5725 {
Bram Moolenaarb05034a2010-09-21 17:34:31 +02005726 case VIM_GENERIC:
5727 case VIM_INFO:
5728 case VIM_QUESTION: useIcon = kNoteIcon; break;
5729 case VIM_WARNING: useIcon = kCautionIcon; break;
5730 case VIM_ERROR: useIcon = kStopIcon; break;
Bram Moolenaar8d4eecc2012-11-20 17:19:01 +01005731 default: useIcon = kStopIcon;
Bram Moolenaarb05034a2010-09-21 17:34:31 +02005732 }
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00005733 AppendDITL(theDialog, iconDITL, overlayDITL);
5734 ReleaseResource(iconDITL);
5735 GetDialogItem(theDialog, iconItm.idx, &itemType, &itemHandle, &box);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005736 /* TODO: Should the item be freed? */
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00005737 iconHandle = GetIcon(useIcon);
5738 SetDialogItem(theDialog, iconItm.idx, itemType, iconHandle, &box);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005739
5740 /* Add the message to the Dialog box. */
5741 messageItm.idx = lastButton + 2;
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00005742 messageDITL = GetResource('DITL', 132);
5743 AppendDITL(theDialog, messageDITL, overlayDITL);
5744 ReleaseResource(messageDITL);
5745 GetDialogItem(theDialog, messageItm.idx, &itemType, &itemHandle, &box);
5746 (void) C2PascalString(message, &name);
5747 SetDialogItemText(itemHandle, name);
5748 messageItm.width = StringWidth(name);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005749
5750 /* Add the input box if needed */
5751 if (textfield != NULL)
5752 {
Bram Moolenaard68071d2006-05-02 22:08:30 +00005753 /* Cheat for now reuse the message and convert to text edit */
Bram Moolenaar071d4272004-06-13 20:20:40 +00005754 inputItm.idx = lastButton + 3;
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00005755 inputDITL = GetResource('DITL', 132);
5756 AppendDITL(theDialog, inputDITL, overlayDITL);
5757 ReleaseResource(inputDITL);
5758 GetDialogItem(theDialog, inputItm.idx, &itemType, &itemHandle, &box);
5759/* SetDialogItem(theDialog, inputItm.idx, kEditTextDialogItem, itemHandle, &box);*/
5760 (void) C2PascalString(textfield, &name);
5761 SetDialogItemText(itemHandle, name);
5762 inputItm.width = StringWidth(name);
Bram Moolenaarc52da9d2008-03-20 13:39:37 +00005763
5764 /* Hotkeys don't make sense if there's a text field */
5765 gDialogHotKeys = NULL;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005766 }
Bram Moolenaarc52da9d2008-03-20 13:39:37 +00005767 else
5768 /* Install hotkey table */
5769 gDialogHotKeys = (short *)&hotKeys;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005770
5771 /* Set the <ENTER> and <ESC> button. */
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00005772 SetDialogDefaultItem(theDialog, dfltbutton);
5773 SetDialogCancelItem(theDialog, 0);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005774
5775 /* Reposition element */
5776
5777 /* Check if we need to force vertical */
5778 if (totalButtonWidth > maximumWidth)
5779 vertical = TRUE;
5780
5781 /* Place icon */
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00005782 macMoveDialogItem(theDialog, iconItm.idx, dfltIconSideSpace, dfltElementSpacing, &box);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005783 iconItm.box.right = box.right;
5784 iconItm.box.bottom = box.bottom;
5785
5786 /* Place Message */
5787 messageItm.box.left = iconItm.box.right + dfltIconSideSpace;
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00005788 macSizeDialogItem(theDialog, messageItm.idx, 0, messageLines * (textFontInfo.ascent + textFontInfo.descent));
5789 macMoveDialogItem(theDialog, messageItm.idx, messageItm.box.left, dfltElementSpacing, &messageItm.box);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005790
5791 /* Place Input */
5792 if (textfield != NULL)
5793 {
5794 inputItm.box.left = messageItm.box.left;
5795 inputItm.box.top = messageItm.box.bottom + dfltElementSpacing;
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00005796 macSizeDialogItem(theDialog, inputItm.idx, 0, textFontInfo.ascent + textFontInfo.descent);
5797 macMoveDialogItem(theDialog, inputItm.idx, inputItm.box.left, inputItm.box.top, &inputItm.box);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005798 /* Convert the static text into a text edit.
5799 * For some reason this change need to be done last (Dany) */
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00005800 GetDialogItem(theDialog, inputItm.idx, &itemType, &itemHandle, &inputItm.box);
5801 SetDialogItem(theDialog, inputItm.idx, kEditTextDialogItem, itemHandle, &inputItm.box);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005802 SelectDialogItemText(theDialog, inputItm.idx, 0, 32767);
5803 }
5804
5805 /* Place Button */
5806 if (textfield != NULL)
5807 {
5808 buttonItm.box.left = inputItm.box.left;
5809 buttonItm.box.top = inputItm.box.bottom + dfltElementSpacing;
5810 }
5811 else
5812 {
5813 buttonItm.box.left = messageItm.box.left;
5814 buttonItm.box.top = messageItm.box.bottom + dfltElementSpacing;
5815 }
5816
5817 for (button=1; button <= lastButton; button++)
5818 {
5819
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00005820 macMoveDialogItem(theDialog, button, buttonItm.box.left, buttonItm.box.top, &box);
Bram Moolenaarec831732007-08-30 10:51:14 +00005821 /* With vertical, it's better to have all buttons the same length */
Bram Moolenaar071d4272004-06-13 20:20:40 +00005822 if (vertical)
5823 {
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00005824 macSizeDialogItem(theDialog, button, widestButton, 0);
5825 GetDialogItem(theDialog, button, &itemType, &itemHandle, &box);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005826 }
5827 /* Calculate position of next button */
5828 if (vertical)
5829 buttonItm.box.top = box.bottom + dfltElementSpacing;
5830 else
5831 buttonItm.box.left = box.right + dfltElementSpacing;
5832 }
5833
5834 /* Resize the dialog box */
5835 dialogHeight = box.bottom + dfltElementSpacing;
5836 SizeWindow(theWindow, maximumWidth, dialogHeight, TRUE);
5837
Bram Moolenaar071d4272004-06-13 20:20:40 +00005838 /* Magic resize */
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00005839 AutoSizeDialog(theDialog);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005840 /* Need a horizontal resize anyway so not that useful */
Bram Moolenaar071d4272004-06-13 20:20:40 +00005841
5842 /* Display it */
5843 ShowWindow(theWindow);
5844/* BringToFront(theWindow); */
5845 SelectWindow(theWindow);
5846
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00005847/* DrawDialog(theDialog); */
Bram Moolenaar071d4272004-06-13 20:20:40 +00005848#if 0
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00005849 GetPort(&oldPort);
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00005850 SetPortDialogPort(theDialog);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005851#endif
5852
Bram Moolenaard68071d2006-05-02 22:08:30 +00005853#ifdef USE_CARBONKEYHANDLER
5854 /* Avoid that we use key events for the main window. */
5855 dialog_busy = TRUE;
5856#endif
5857
Bram Moolenaarc52da9d2008-03-20 13:39:37 +00005858 /* Prepare the shortcut-handling filterProc for handing to the dialog */
5859 dialogUPP = NewModalFilterUPP(DialogHotkeyFilterProc);
5860
Bram Moolenaar071d4272004-06-13 20:20:40 +00005861 /* Hang until one of the button is hit */
5862 do
5863 {
Bram Moolenaarc52da9d2008-03-20 13:39:37 +00005864 ModalDialog(dialogUPP, &itemHit);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005865 } while ((itemHit < 1) || (itemHit > lastButton));
5866
Bram Moolenaard68071d2006-05-02 22:08:30 +00005867#ifdef USE_CARBONKEYHANDLER
5868 dialog_busy = FALSE;
5869#endif
5870
Bram Moolenaar071d4272004-06-13 20:20:40 +00005871 /* Copy back the text entered by the user into the param */
5872 if (textfield != NULL)
5873 {
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00005874 GetDialogItem(theDialog, inputItm.idx, &itemType, &itemHandle, &box);
5875 GetDialogItemText(itemHandle, (char_u *) &name);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005876#if IOSIZE < 256
5877 /* Truncate the name to IOSIZE if needed */
5878 if (name[0] > IOSIZE)
5879 name[0] = IOSIZE - 1;
5880#endif
Bram Moolenaarbbebc852005-07-18 21:47:53 +00005881 vim_strncpy(textfield, &name[1], name[0]);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005882 }
5883
5884 /* Restore the original graphical port */
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00005885 SetPort(oldPort);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005886
Bram Moolenaarc52da9d2008-03-20 13:39:37 +00005887 /* Free the modal filterProc */
5888 DisposeRoutineDescriptor(dialogUPP);
5889
Bram Moolenaar84a05ac2013-05-06 04:24:17 +02005890 /* Get ride of the dialog (free memory) */
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00005891 DisposeDialog(theDialog);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005892
5893 return itemHit;
5894/*
Bram Moolenaarb05034a2010-09-21 17:34:31 +02005895 * Useful thing which could be used
Bram Moolenaar071d4272004-06-13 20:20:40 +00005896 * SetDialogTimeout(): Auto click a button after timeout
5897 * SetDialogTracksCursor() : Get the I-beam cursor over input box
5898 * MoveDialogItem(): Probably better than SetDialogItem
5899 * SizeDialogItem(): (but is it Carbon Only?)
Bram Moolenaar14d0e792007-08-30 08:35:35 +00005900 * AutoSizeDialog(): Magic resize of dialog based on text length
Bram Moolenaar071d4272004-06-13 20:20:40 +00005901 */
5902}
5903#endif /* FEAT_DIALOG_GUI */
5904
5905/*
5906 * Display the saved error message(s).
5907 */
5908#ifdef USE_MCH_ERRMSG
5909 void
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00005910display_errors(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005911{
5912 char *p;
5913 char_u pError[256];
5914
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00005915 if (error_ga.ga_data == NULL)
5916 return;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005917
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00005918 /* avoid putting up a message box with blanks only */
5919 for (p = (char *)error_ga.ga_data; *p; ++p)
5920 if (!isspace(*p))
5921 {
5922 if (STRLEN(p) > 255)
5923 pError[0] = 255;
5924 else
5925 pError[0] = STRLEN(p);
5926
5927 STRNCPY(&pError[1], p, pError[0]);
5928 ParamText(pError, nil, nil, nil);
5929 Alert(128, nil);
5930 break;
5931 /* TODO: handled message longer than 256 chars
5932 * use auto-sizeable alert
5933 * or dialog with scrollbars (TextEdit zone)
5934 */
5935 }
5936 ga_clear(&error_ga);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005937}
5938#endif
5939
5940/*
Bram Moolenaar9588a0f2005-01-08 21:45:39 +00005941 * Get current mouse coordinates in text window.
Bram Moolenaar071d4272004-06-13 20:20:40 +00005942 */
Bram Moolenaar5f2bb9f2005-01-11 21:29:04 +00005943 void
5944gui_mch_getmouse(int *x, int *y)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005945{
5946 Point where;
5947
5948 GetMouse(&where);
5949
Bram Moolenaar9588a0f2005-01-08 21:45:39 +00005950 *x = where.h;
5951 *y = where.v;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005952}
5953
5954 void
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00005955gui_mch_setmouse(int x, int y)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005956{
5957 /* TODO */
5958#if 0
5959 /* From FAQ 3-11 */
5960
5961 CursorDevicePtr myMouse;
5962 Point where;
5963
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00005964 if ( NGetTrapAddress(_CursorDeviceDispatch, ToolTrap)
5965 != NGetTrapAddress(_Unimplemented, ToolTrap))
Bram Moolenaar071d4272004-06-13 20:20:40 +00005966 {
5967 /* New way */
5968
5969 /*
Bram Moolenaar84a05ac2013-05-06 04:24:17 +02005970 * Get first device with one button.
5971 * This will probably be the standard mouse
5972 * start at head of cursor dev list
Bram Moolenaar071d4272004-06-13 20:20:40 +00005973 *
5974 */
5975
5976 myMouse = nil;
5977
5978 do
5979 {
5980 /* Get the next cursor device */
5981 CursorDeviceNextDevice(&myMouse);
5982 }
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00005983 while ((myMouse != nil) && (myMouse->cntButtons != 1));
Bram Moolenaar071d4272004-06-13 20:20:40 +00005984
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00005985 CursorDeviceMoveTo(myMouse, x, y);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005986 }
5987 else
5988 {
5989 /* Old way */
5990 where.h = x;
5991 where.v = y;
5992
5993 *(Point *)RawMouse = where;
5994 *(Point *)MTemp = where;
5995 *(Ptr) CrsrNew = 0xFFFF;
5996 }
5997#endif
5998}
5999
6000 void
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00006001gui_mch_show_popupmenu(vimmenu_T *menu)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006002{
Bram Moolenaar071d4272004-06-13 20:20:40 +00006003/*
6004 * Clone PopUp to use menu
6005 * Create a object descriptor for the current selection
6006 * Call the procedure
6007 */
6008
6009 MenuHandle CntxMenu;
6010 Point where;
6011 OSStatus status;
6012 UInt32 CntxType;
6013 SInt16 CntxMenuID;
6014 UInt16 CntxMenuItem;
6015 Str255 HelpName = "";
6016 GrafPtr savePort;
6017
6018 /* Save Current Port: On MacOS X we seem to lose the port */
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00006019 GetPort(&savePort); /*OSX*/
Bram Moolenaar071d4272004-06-13 20:20:40 +00006020
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00006021 GetMouse(&where);
6022 LocalToGlobal(&where); /*OSX*/
Bram Moolenaar071d4272004-06-13 20:20:40 +00006023 CntxMenu = menu->submenu_handle;
6024
6025 /* TODO: Get the text selection from Vim */
6026
6027 /* Call to Handle Popup */
Bram Moolenaar48c2c9a2007-03-08 19:34:12 +00006028 status = ContextualMenuSelect(CntxMenu, where, false, kCMHelpItemRemoveHelp,
Bram Moolenaaradcb9492006-10-17 10:51:57 +00006029 HelpName, NULL, &CntxType, &CntxMenuID, &CntxMenuItem);
Bram Moolenaar071d4272004-06-13 20:20:40 +00006030
6031 if (status == noErr)
6032 {
6033 if (CntxType == kCMMenuItemSelected)
6034 {
6035 /* Handle the menu CntxMenuID, CntxMenuItem */
6036 /* The submenu can be handle directly by gui_mac_handle_menu */
Bram Moolenaaradcb9492006-10-17 10:51:57 +00006037 /* But what about the current menu, is the menu changed by
6038 * ContextualMenuSelect */
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00006039 gui_mac_handle_menu((CntxMenuID << 16) + CntxMenuItem);
Bram Moolenaar071d4272004-06-13 20:20:40 +00006040 }
6041 else if (CntxMenuID == kCMShowHelpSelected)
6042 {
6043 /* Should come up with the help */
6044 }
6045 }
6046
6047 /* Restore original Port */
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00006048 SetPort(savePort); /*OSX*/
Bram Moolenaar071d4272004-06-13 20:20:40 +00006049}
6050
6051#if defined(FEAT_CW_EDITOR) || defined(PROTO)
6052/* TODO: Is it need for MACOS_X? (Dany) */
6053 void
6054mch_post_buffer_write(buf_T *buf)
6055{
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00006056 GetFSSpecFromPath(buf->b_ffname, &buf->b_FSSpec);
6057 Send_KAHL_MOD_AE(buf);
Bram Moolenaar071d4272004-06-13 20:20:40 +00006058}
6059#endif
6060
6061#ifdef FEAT_TITLE
6062/*
6063 * Set the window title and icon.
6064 * (The icon is not taken care of).
6065 */
6066 void
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00006067gui_mch_settitle(char_u *title, char_u *icon)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006068{
6069 /* TODO: Get vim to make sure maxlen (from p_titlelen) is smaller
6070 * that 256. Even better get it to fit nicely in the titlebar.
6071 */
Bram Moolenaar7d47b6e2006-03-15 22:59:18 +00006072#ifdef MACOS_CONVERT
Bram Moolenaar26a60b42005-02-22 08:49:11 +00006073 CFStringRef windowTitle;
6074 size_t windowTitleLen;
6075#else
Bram Moolenaar071d4272004-06-13 20:20:40 +00006076 char_u *pascalTitle;
Bram Moolenaar26a60b42005-02-22 08:49:11 +00006077#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00006078
6079 if (title == NULL) /* nothing to do */
6080 return;
6081
Bram Moolenaar7d47b6e2006-03-15 22:59:18 +00006082#ifdef MACOS_CONVERT
Bram Moolenaar26a60b42005-02-22 08:49:11 +00006083 windowTitleLen = STRLEN(title);
Bram Moolenaar446cb832008-06-24 21:56:24 +00006084 windowTitle = (CFStringRef)mac_enc_to_cfstring(title, windowTitleLen);
Bram Moolenaar26a60b42005-02-22 08:49:11 +00006085
6086 if (windowTitle)
6087 {
6088 SetWindowTitleWithCFString(gui.VimWindow, windowTitle);
6089 CFRelease(windowTitle);
6090 }
6091#else
Bram Moolenaar071d4272004-06-13 20:20:40 +00006092 pascalTitle = C2Pascal_save(title);
6093 if (pascalTitle != NULL)
6094 {
6095 SetWTitle(gui.VimWindow, pascalTitle);
6096 vim_free(pascalTitle);
6097 }
Bram Moolenaar26a60b42005-02-22 08:49:11 +00006098#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00006099}
6100#endif
6101
6102/*
Bram Moolenaarb05034a2010-09-21 17:34:31 +02006103 * Transferred from os_mac.c for MacOS X using os_unix.c prep work
Bram Moolenaar071d4272004-06-13 20:20:40 +00006104 */
6105
6106 int
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00006107C2PascalString(char_u *CString, Str255 *PascalString)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006108{
6109 char_u *PascalPtr = (char_u *) PascalString;
6110 int len;
6111 int i;
6112
6113 PascalPtr[0] = 0;
6114 if (CString == NULL)
6115 return 0;
6116
6117 len = STRLEN(CString);
6118 if (len > 255)
6119 len = 255;
6120
6121 for (i = 0; i < len; i++)
6122 PascalPtr[i+1] = CString[i];
6123
6124 PascalPtr[0] = len;
6125
6126 return 0;
6127}
6128
6129 int
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00006130GetFSSpecFromPath(char_u *file, FSSpec *fileFSSpec)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006131{
6132 /* From FAQ 8-12 */
6133 Str255 filePascal;
6134 CInfoPBRec myCPB;
6135 OSErr err;
6136
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00006137 (void) C2PascalString(file, &filePascal);
Bram Moolenaar071d4272004-06-13 20:20:40 +00006138
6139 myCPB.dirInfo.ioNamePtr = filePascal;
6140 myCPB.dirInfo.ioVRefNum = 0;
6141 myCPB.dirInfo.ioFDirIndex = 0;
6142 myCPB.dirInfo.ioDrDirID = 0;
6143
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00006144 err= PBGetCatInfo(&myCPB, false);
Bram Moolenaar071d4272004-06-13 20:20:40 +00006145
6146 /* vRefNum, dirID, name */
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00006147 FSMakeFSSpec(0, 0, filePascal, fileFSSpec);
Bram Moolenaar071d4272004-06-13 20:20:40 +00006148
6149 /* TODO: Use an error code mechanism */
6150 return 0;
6151}
6152
6153/*
Bram Moolenaar84a05ac2013-05-06 04:24:17 +02006154 * Convert a FSSpec to a full path
Bram Moolenaar071d4272004-06-13 20:20:40 +00006155 */
6156
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00006157char_u *FullPathFromFSSpec_save(FSSpec file)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006158{
6159 /*
6160 * TODO: Add protection for 256 char max.
6161 */
6162
6163 CInfoPBRec theCPB;
6164 char_u fname[256];
6165 char_u *filenamePtr = fname;
6166 OSErr error;
6167 int folder = 1;
6168#ifdef USE_UNIXFILENAME
6169 SInt16 dfltVol_vRefNum;
6170 SInt32 dfltVol_dirID;
6171 FSRef refFile;
6172 OSStatus status;
6173 UInt32 pathSize = 256;
6174 char_u pathname[256];
6175 char_u *path = pathname;
6176#else
6177 Str255 directoryName;
6178 char_u temporary[255];
6179 char_u *temporaryPtr = temporary;
6180#endif
6181
6182#ifdef USE_UNIXFILENAME
6183 /* Get the default volume */
6184 /* TODO: Remove as this only work if Vim is on the Boot Volume*/
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00006185 error=HGetVol(NULL, &dfltVol_vRefNum, &dfltVol_dirID);
Bram Moolenaar071d4272004-06-13 20:20:40 +00006186
6187 if (error)
6188 return NULL;
6189#endif
6190
6191 /* Start filling fname with file.name */
Bram Moolenaarbbebc852005-07-18 21:47:53 +00006192 vim_strncpy(filenamePtr, &file.name[1], file.name[0]);
Bram Moolenaar071d4272004-06-13 20:20:40 +00006193
6194 /* Get the info about the file specified in FSSpec */
6195 theCPB.dirInfo.ioFDirIndex = 0;
6196 theCPB.dirInfo.ioNamePtr = file.name;
6197 theCPB.dirInfo.ioVRefNum = file.vRefNum;
Bram Moolenaar79ee3152007-04-26 16:20:50 +00006198 /*theCPB.hFileInfo.ioDirID = 0;*/
Bram Moolenaar071d4272004-06-13 20:20:40 +00006199 theCPB.dirInfo.ioDrDirID = file.parID;
6200
6201 /* As ioFDirIndex = 0, get the info of ioNamePtr,
6202 which is relative to ioVrefNum, ioDirID */
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00006203 error = PBGetCatInfo(&theCPB, false);
Bram Moolenaar071d4272004-06-13 20:20:40 +00006204
6205 /* If we are called for a new file we expect fnfErr */
6206 if ((error) && (error != fnfErr))
6207 return NULL;
6208
6209 /* Check if it's a file or folder */
6210 /* default to file if file don't exist */
6211 if (((theCPB.hFileInfo.ioFlAttrib & ioDirMask) == 0) || (error))
6212 folder = 0; /* It's not a folder */
6213 else
6214 folder = 1;
6215
6216#ifdef USE_UNIXFILENAME
6217 /*
Bram Moolenaar84a05ac2013-05-06 04:24:17 +02006218 * The functions used here are available in Carbon, but do nothing on
6219 * MacOS 8 and 9.
Bram Moolenaar071d4272004-06-13 20:20:40 +00006220 */
6221 if (error == fnfErr)
6222 {
6223 /* If the file to be saved does not already exist, it isn't possible
6224 to convert its FSSpec into an FSRef. But we can construct an
6225 FSSpec for the file's parent folder (since we have its volume and
6226 directory IDs), and since that folder does exist, we can convert
6227 that FSSpec into an FSRef, convert the FSRef in turn into a path,
6228 and, finally, append the filename. */
6229 FSSpec dirSpec;
6230 FSRef dirRef;
6231 Str255 emptyFilename = "\p";
6232 error = FSMakeFSSpec(theCPB.dirInfo.ioVRefNum,
6233 theCPB.dirInfo.ioDrDirID, emptyFilename, &dirSpec);
6234 if (error)
6235 return NULL;
6236
6237 error = FSpMakeFSRef(&dirSpec, &dirRef);
6238 if (error)
6239 return NULL;
6240
6241 status = FSRefMakePath(&dirRef, (UInt8*)path, pathSize);
6242 if (status)
6243 return NULL;
6244
6245 STRCAT(path, "/");
6246 STRCAT(path, filenamePtr);
6247 }
6248 else
6249 {
6250 /* If the file to be saved already exists, we can get its full path
6251 by converting its FSSpec into an FSRef. */
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00006252 error=FSpMakeFSRef(&file, &refFile);
Bram Moolenaar071d4272004-06-13 20:20:40 +00006253 if (error)
6254 return NULL;
6255
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00006256 status=FSRefMakePath(&refFile, (UInt8 *) path, pathSize);
Bram Moolenaar071d4272004-06-13 20:20:40 +00006257 if (status)
6258 return NULL;
6259 }
6260
6261 /* Add a slash at the end if needed */
6262 if (folder)
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00006263 STRCAT(path, "/");
Bram Moolenaar071d4272004-06-13 20:20:40 +00006264
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00006265 return (vim_strsave(path));
Bram Moolenaar071d4272004-06-13 20:20:40 +00006266#else
6267 /* TODO: Get rid of all USE_UNIXFILENAME below */
6268 /* Set ioNamePtr, it's the same area which is always reused. */
6269 theCPB.dirInfo.ioNamePtr = directoryName;
6270
6271 /* Trick for first entry, set ioDrParID to the first value
6272 * we want for ioDrDirID*/
6273 theCPB.dirInfo.ioDrParID = file.parID;
6274 theCPB.dirInfo.ioDrDirID = file.parID;
6275
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00006276 if ((TRUE) && (file.parID != fsRtDirID /*fsRtParID*/))
Bram Moolenaar071d4272004-06-13 20:20:40 +00006277 do
6278 {
6279 theCPB.dirInfo.ioFDirIndex = -1;
6280 /* theCPB.dirInfo.ioNamePtr = directoryName; Already done above. */
6281 theCPB.dirInfo.ioVRefNum = file.vRefNum;
Bram Moolenaar720c7102007-05-10 18:07:50 +00006282 /* theCPB.dirInfo.ioDirID = irrelevant when ioFDirIndex = -1 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00006283 theCPB.dirInfo.ioDrDirID = theCPB.dirInfo.ioDrParID;
6284
6285 /* As ioFDirIndex = -1, get the info of ioDrDirID, */
6286 /* *ioNamePtr[0 TO 31] will be updated */
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00006287 error = PBGetCatInfo(&theCPB,false);
Bram Moolenaar071d4272004-06-13 20:20:40 +00006288
6289 if (error)
6290 return NULL;
6291
6292 /* Put the new directoryName in front of the current fname */
6293 STRCPY(temporaryPtr, filenamePtr);
Bram Moolenaarbbebc852005-07-18 21:47:53 +00006294 vim_strncpy(filenamePtr, &directoryName[1], directoryName[0]);
Bram Moolenaar071d4272004-06-13 20:20:40 +00006295 STRCAT(filenamePtr, ":");
6296 STRCAT(filenamePtr, temporaryPtr);
6297 }
6298#if 1 /* def USE_UNIXFILENAME */
6299 while ((theCPB.dirInfo.ioDrParID != fsRtDirID) /* && */
6300 /* (theCPB.dirInfo.ioDrDirID != fsRtDirID)*/);
6301#else
6302 while (theCPB.dirInfo.ioDrDirID != fsRtDirID);
6303#endif
6304
6305 /* Get the information about the volume on which the file reside */
6306 theCPB.dirInfo.ioFDirIndex = -1;
6307 /* theCPB.dirInfo.ioNamePtr = directoryName; Already done above. */
6308 theCPB.dirInfo.ioVRefNum = file.vRefNum;
Bram Moolenaar720c7102007-05-10 18:07:50 +00006309 /* theCPB.dirInfo.ioDirID = irrelevant when ioFDirIndex = -1 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00006310 theCPB.dirInfo.ioDrDirID = theCPB.dirInfo.ioDrParID;
6311
6312 /* As ioFDirIndex = -1, get the info of ioDrDirID, */
6313 /* *ioNamePtr[0 TO 31] will be updated */
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00006314 error = PBGetCatInfo(&theCPB,false);
Bram Moolenaar071d4272004-06-13 20:20:40 +00006315
6316 if (error)
6317 return NULL;
6318
6319 /* For MacOS Classic always add the volume name */
6320 /* For MacOS X add the volume name preceded by "Volumes" */
Bram Moolenaar720c7102007-05-10 18:07:50 +00006321 /* when we are not referring to the boot volume */
Bram Moolenaar071d4272004-06-13 20:20:40 +00006322#ifdef USE_UNIXFILENAME
6323 if (file.vRefNum != dfltVol_vRefNum)
6324#endif
6325 {
6326 /* Add the volume name */
6327 STRCPY(temporaryPtr, filenamePtr);
Bram Moolenaarbbebc852005-07-18 21:47:53 +00006328 vim_strncpy(filenamePtr, &directoryName[1], directoryName[0]);
Bram Moolenaar071d4272004-06-13 20:20:40 +00006329 STRCAT(filenamePtr, ":");
6330 STRCAT(filenamePtr, temporaryPtr);
6331
6332#ifdef USE_UNIXFILENAME
6333 STRCPY(temporaryPtr, filenamePtr);
6334 filenamePtr[0] = 0; /* NULL terminate the string */
6335 STRCAT(filenamePtr, "Volumes:");
6336 STRCAT(filenamePtr, temporaryPtr);
6337#endif
6338 }
6339
6340 /* Append final path separator if it's a folder */
6341 if (folder)
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00006342 STRCAT(fname, ":");
Bram Moolenaar071d4272004-06-13 20:20:40 +00006343
6344 /* As we use Unix File Name for MacOS X convert it */
6345#ifdef USE_UNIXFILENAME
6346 /* Need to insert leading / */
6347 /* TODO: get the above code to use directly the / */
6348 STRCPY(&temporaryPtr[1], filenamePtr);
6349 temporaryPtr[0] = '/';
6350 STRCPY(filenamePtr, temporaryPtr);
6351 {
6352 char *p;
6353 for (p = fname; *p; p++)
6354 if (*p == ':')
6355 *p = '/';
6356 }
6357#endif
6358
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00006359 return (vim_strsave(fname));
Bram Moolenaar071d4272004-06-13 20:20:40 +00006360#endif
6361}
6362
Bram Moolenaar1b60e502008-03-12 13:40:54 +00006363#if (defined(USE_IM_CONTROL) || defined(PROTO)) && defined(USE_CARBONKEYHANDLER)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006364/*
6365 * Input Method Control functions.
6366 */
6367
6368/*
6369 * Notify cursor position to IM.
6370 */
6371 void
6372im_set_position(int row, int col)
6373{
Bram Moolenaar1b60e502008-03-12 13:40:54 +00006374#if 0
Bram Moolenaar071d4272004-06-13 20:20:40 +00006375 /* TODO: Implement me! */
Bram Moolenaar1b60e502008-03-12 13:40:54 +00006376 im_start_row = row;
6377 im_start_col = col;
6378#endif
6379}
6380
6381static ScriptLanguageRecord gTSLWindow;
6382static ScriptLanguageRecord gTSLInsert;
6383static ScriptLanguageRecord gTSLDefault = { 0, 0 };
6384
6385static Component gTSCWindow;
6386static Component gTSCInsert;
6387static Component gTSCDefault;
6388
6389static int im_initialized = 0;
6390
6391 static void
6392im_on_window_switch(int active)
6393{
6394 ScriptLanguageRecord *slptr = NULL;
6395 OSStatus err;
6396
6397 if (! gui.in_use)
6398 return;
6399
6400 if (im_initialized == 0)
6401 {
6402 im_initialized = 1;
6403
6404 /* save default TSM component (should be U.S.) to default */
6405 GetDefaultInputMethodOfClass(&gTSCDefault, &gTSLDefault,
6406 kKeyboardInputMethodClass);
6407 }
6408
6409 if (active == TRUE)
6410 {
6411 im_is_active = TRUE;
6412 ActivateTSMDocument(gTSMDocument);
6413 slptr = &gTSLWindow;
6414
6415 if (slptr)
6416 {
6417 err = SetDefaultInputMethodOfClass(gTSCWindow, slptr,
6418 kKeyboardInputMethodClass);
6419 if (err == noErr)
6420 err = SetTextServiceLanguage(slptr);
6421
6422 if (err == noErr)
6423 KeyScript(slptr->fScript | smKeyForceKeyScriptMask);
6424 }
6425 }
6426 else
6427 {
6428 err = GetTextServiceLanguage(&gTSLWindow);
6429 if (err == noErr)
6430 slptr = &gTSLWindow;
6431
6432 if (slptr)
6433 GetDefaultInputMethodOfClass(&gTSCWindow, slptr,
6434 kKeyboardInputMethodClass);
6435
6436 im_is_active = FALSE;
6437 DeactivateTSMDocument(gTSMDocument);
6438 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00006439}
6440
6441/*
6442 * Set IM status on ("active" is TRUE) or off ("active" is FALSE).
6443 */
6444 void
6445im_set_active(int active)
6446{
Bram Moolenaar1b60e502008-03-12 13:40:54 +00006447 ScriptLanguageRecord *slptr = NULL;
6448 OSStatus err;
6449
6450 if (! gui.in_use)
6451 return;
6452
6453 if (im_initialized == 0)
6454 {
6455 im_initialized = 1;
6456
6457 /* save default TSM component (should be U.S.) to default */
6458 GetDefaultInputMethodOfClass(&gTSCDefault, &gTSLDefault,
6459 kKeyboardInputMethodClass);
6460 }
6461
6462 if (active == TRUE)
6463 {
6464 im_is_active = TRUE;
6465 ActivateTSMDocument(gTSMDocument);
6466 slptr = &gTSLInsert;
6467
6468 if (slptr)
6469 {
6470 err = SetDefaultInputMethodOfClass(gTSCInsert, slptr,
6471 kKeyboardInputMethodClass);
6472 if (err == noErr)
6473 err = SetTextServiceLanguage(slptr);
6474
6475 if (err == noErr)
6476 KeyScript(slptr->fScript | smKeyForceKeyScriptMask);
6477 }
6478 }
6479 else
6480 {
6481 err = GetTextServiceLanguage(&gTSLInsert);
6482 if (err == noErr)
6483 slptr = &gTSLInsert;
6484
6485 if (slptr)
6486 GetDefaultInputMethodOfClass(&gTSCInsert, slptr,
6487 kKeyboardInputMethodClass);
6488
6489 /* restore to default when switch to normal mode, so than we could
6490 * enter commands easier */
6491 SetDefaultInputMethodOfClass(gTSCDefault, &gTSLDefault,
6492 kKeyboardInputMethodClass);
6493 SetTextServiceLanguage(&gTSLDefault);
6494
6495 im_is_active = FALSE;
6496 DeactivateTSMDocument(gTSMDocument);
6497 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00006498}
6499
6500/*
6501 * Get IM status. When IM is on, return not 0. Else return 0.
6502 */
6503 int
Bram Moolenaar2c7a29c2005-12-12 22:02:31 +00006504im_get_status(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006505{
Bram Moolenaar1b60e502008-03-12 13:40:54 +00006506 if (! gui.in_use)
6507 return 0;
6508
6509 return im_is_active;
Bram Moolenaar071d4272004-06-13 20:20:40 +00006510}
Bram Moolenaar79ee3152007-04-26 16:20:50 +00006511
Bram Moolenaar071d4272004-06-13 20:20:40 +00006512#endif /* defined(USE_IM_CONTROL) || defined(PROTO) */
Bram Moolenaar79ee3152007-04-26 16:20:50 +00006513
6514
6515
6516
6517#if defined(FEAT_GUI_TABLINE) || defined(PROTO)
6518// drawer implementation
6519static MenuRef contextMenu = NULL;
6520enum
6521{
6522 kTabContextMenuId = 42,
6523};
6524
6525// the caller has to CFRelease() the returned string
6526 static CFStringRef
6527getTabLabel(tabpage_T *page)
6528{
6529 get_tabline_label(page, FALSE);
6530#ifdef MACOS_CONVERT
Bram Moolenaar446cb832008-06-24 21:56:24 +00006531 return (CFStringRef)mac_enc_to_cfstring(NameBuff, STRLEN(NameBuff));
Bram Moolenaar79ee3152007-04-26 16:20:50 +00006532#else
6533 // TODO: check internal encoding?
6534 return CFStringCreateWithCString(kCFAllocatorDefault, (char *)NameBuff,
6535 kCFStringEncodingMacRoman);
6536#endif
6537}
6538
6539
6540#define DRAWER_SIZE 150
6541#define DRAWER_INSET 16
6542
6543static ControlRef dataBrowser = NULL;
6544
6545// when the tabline is hidden, vim doesn't call update_tabline(). When
Bram Moolenaarb05034a2010-09-21 17:34:31 +02006546// the tabline is shown again, show_tabline() is called before update_tabline(),
Bram Moolenaar84a05ac2013-05-06 04:24:17 +02006547// and because of this, the tab labels and vim's internal tabs are out of sync
Bram Moolenaar79ee3152007-04-26 16:20:50 +00006548// for a very short time. to prevent inconsistent state, we store the labels
6549// of the tabs, not pointers to the tabs (which are invalid for a short time).
6550static CFStringRef *tabLabels = NULL;
6551static int tabLabelsSize = 0;
6552
6553enum
6554{
6555 kTabsColumn = 'Tabs'
6556};
6557
6558 static int
6559getTabCount(void)
6560{
6561 tabpage_T *tp;
6562 int numTabs = 0;
6563
6564 for (tp = first_tabpage; tp != NULL; tp = tp->tp_next)
Bram Moolenaar1b60e502008-03-12 13:40:54 +00006565 ++numTabs;
Bram Moolenaar79ee3152007-04-26 16:20:50 +00006566 return numTabs;
6567}
6568
6569// data browser item display callback
6570 static OSStatus
6571dbItemDataCallback(ControlRef browser,
6572 DataBrowserItemID itemID,
Bram Moolenaar1b60e502008-03-12 13:40:54 +00006573 DataBrowserPropertyID property /* column id */,
6574 DataBrowserItemDataRef itemData,
Bram Moolenaar79ee3152007-04-26 16:20:50 +00006575 Boolean changeValue)
6576{
6577 OSStatus status = noErr;
6578
6579 // assert(property == kTabsColumn); // why is this violated??
6580
Bram Moolenaar84a05ac2013-05-06 04:24:17 +02006581 // changeValue is true if we have a modifiable list and data was changed.
Bram Moolenaar79ee3152007-04-26 16:20:50 +00006582 // In our case, it's always false.
6583 // (that is: if (changeValue) updateInternalData(); else return
6584 // internalData();
6585 if (!changeValue)
6586 {
6587 CFStringRef str;
6588
6589 assert(itemID - 1 >= 0 && itemID - 1 < tabLabelsSize);
6590 str = tabLabels[itemID - 1];
6591 status = SetDataBrowserItemDataText(itemData, str);
6592 }
6593 else
6594 status = errDataBrowserPropertyNotSupported;
6595
6596 return status;
6597}
6598
6599// data browser action callback
6600 static void
6601dbItemNotificationCallback(ControlRef browser,
6602 DataBrowserItemID item,
6603 DataBrowserItemNotification message)
6604{
6605 switch (message)
6606 {
6607 case kDataBrowserItemSelected:
6608 send_tabline_event(item);
6609 break;
6610 }
6611}
6612
6613// callbacks needed for contextual menu:
6614 static void
6615dbGetContextualMenuCallback(ControlRef browser,
6616 MenuRef *menu,
Bram Moolenaar1b60e502008-03-12 13:40:54 +00006617 UInt32 *helpType,
Bram Moolenaar79ee3152007-04-26 16:20:50 +00006618 CFStringRef *helpItemString,
Bram Moolenaar1b60e502008-03-12 13:40:54 +00006619 AEDesc *selection)
Bram Moolenaar79ee3152007-04-26 16:20:50 +00006620{
6621 // on mac os 9: kCMHelpItemNoHelp, but it's not the same
6622 *helpType = kCMHelpItemRemoveHelp; // OS X only ;-)
6623 *helpItemString = NULL;
6624
6625 *menu = contextMenu;
6626}
6627
6628 static void
6629dbSelectContextualMenuCallback(ControlRef browser,
6630 MenuRef menu,
6631 UInt32 selectionType,
6632 SInt16 menuID,
6633 MenuItemIndex menuItem)
6634{
6635 if (selectionType == kCMMenuItemSelected)
6636 {
6637 MenuCommand command;
6638 GetMenuItemCommandID(menu, menuItem, &command);
6639
6640 // get tab that was selected when the context menu appeared
6641 // (there is always one tab selected). TODO: check if the context menu
6642 // isn't opened on an item but on empty space (has to be possible some
6643 // way, the finder does it too ;-) )
6644 Handle items = NewHandle(0);
6645 if (items != NULL)
6646 {
6647 int numItems;
6648
6649 GetDataBrowserItems(browser, kDataBrowserNoItem, false,
6650 kDataBrowserItemIsSelected, items);
6651 numItems = GetHandleSize(items) / sizeof(DataBrowserItemID);
6652 if (numItems > 0)
6653 {
6654 int idx;
6655 DataBrowserItemID *itemsPtr;
6656
6657 HLock(items);
6658 itemsPtr = (DataBrowserItemID *)*items;
6659 idx = itemsPtr[0];
6660 HUnlock(items);
6661 send_tabline_menu_event(idx, command);
6662 }
6663 DisposeHandle(items);
6664 }
6665 }
6666}
6667
6668// focus callback of the data browser to always leave focus in vim
6669 static OSStatus
6670dbFocusCallback(EventHandlerCallRef handler, EventRef event, void *data)
6671{
6672 assert(GetEventClass(event) == kEventClassControl
6673 && GetEventKind(event) == kEventControlSetFocusPart);
6674
6675 return paramErr;
6676}
6677
6678
6679// drawer callback to resize data browser to drawer size
6680 static OSStatus
6681drawerCallback(EventHandlerCallRef handler, EventRef event, void *data)
6682{
6683 switch (GetEventKind(event))
6684 {
6685 case kEventWindowBoundsChanged: // move or resize
6686 {
6687 UInt32 attribs;
6688 GetEventParameter(event, kEventParamAttributes, typeUInt32,
6689 NULL, sizeof(attribs), NULL, &attribs);
6690 if (attribs & kWindowBoundsChangeSizeChanged) // resize
6691 {
6692 Rect r;
6693 GetWindowBounds(drawer, kWindowContentRgn, &r);
6694 SetRect(&r, 0, 0, r.right - r.left, r.bottom - r.top);
6695 SetControlBounds(dataBrowser, &r);
6696 SetDataBrowserTableViewNamedColumnWidth(dataBrowser,
6697 kTabsColumn, r.right);
6698 }
6699 }
6700 break;
6701 }
6702
6703 return eventNotHandledErr;
6704}
6705
6706// Load DataBrowserChangeAttributes() dynamically on tiger (and better).
6707// This way the code works on 10.2 and 10.3 as well (it doesn't have the
6708// blue highlights in the list view on these systems, though. Oh well.)
6709
6710
6711#import <mach-o/dyld.h>
6712
6713enum { kMyDataBrowserAttributeListViewAlternatingRowColors = (1 << 1) };
6714
6715 static OSStatus
6716myDataBrowserChangeAttributes(ControlRef inDataBrowser,
6717 OptionBits inAttributesToSet,
6718 OptionBits inAttributesToClear)
6719{
6720 long osVersion;
6721 char *symbolName;
6722 NSSymbol symbol = NULL;
6723 OSStatus (*dataBrowserChangeAttributes)(ControlRef inDataBrowser,
6724 OptionBits inAttributesToSet, OptionBits inAttributesToClear);
6725
6726 Gestalt(gestaltSystemVersion, &osVersion);
6727 if (osVersion < 0x1040) // only supported for 10.4 (and up)
6728 return noErr;
6729
6730 // C name mangling...
6731 symbolName = "_DataBrowserChangeAttributes";
6732 if (!NSIsSymbolNameDefined(symbolName)
6733 || (symbol = NSLookupAndBindSymbol(symbolName)) == NULL)
6734 return noErr;
6735
6736 dataBrowserChangeAttributes = NSAddressOfSymbol(symbol);
6737 if (dataBrowserChangeAttributes == NULL)
6738 return noErr; // well...
6739 return dataBrowserChangeAttributes(inDataBrowser,
6740 inAttributesToSet, inAttributesToClear);
6741}
6742
6743 static void
6744initialise_tabline(void)
6745{
6746 Rect drawerRect = { 0, 0, 0, DRAWER_SIZE };
6747 DataBrowserCallbacks dbCallbacks;
6748 EventTypeSpec focusEvent = {kEventClassControl, kEventControlSetFocusPart};
6749 EventTypeSpec resizeEvent = {kEventClassWindow, kEventWindowBoundsChanged};
6750 DataBrowserListViewColumnDesc colDesc;
6751
6752 // drawers have to have compositing enabled
6753 CreateNewWindow(kDrawerWindowClass,
6754 kWindowStandardHandlerAttribute
6755 | kWindowCompositingAttribute
6756 | kWindowResizableAttribute
6757 | kWindowLiveResizeAttribute,
6758 &drawerRect, &drawer);
6759
6760 SetThemeWindowBackground(drawer, kThemeBrushDrawerBackground, true);
6761 SetDrawerParent(drawer, gui.VimWindow);
6762 SetDrawerOffsets(drawer, kWindowOffsetUnchanged, DRAWER_INSET);
6763
6764
6765 // create list view embedded in drawer
6766 CreateDataBrowserControl(drawer, &drawerRect, kDataBrowserListView,
6767 &dataBrowser);
6768
6769 dbCallbacks.version = kDataBrowserLatestCallbacks;
6770 InitDataBrowserCallbacks(&dbCallbacks);
6771 dbCallbacks.u.v1.itemDataCallback =
6772 NewDataBrowserItemDataUPP(dbItemDataCallback);
6773 dbCallbacks.u.v1.itemNotificationCallback =
6774 NewDataBrowserItemNotificationUPP(dbItemNotificationCallback);
6775 dbCallbacks.u.v1.getContextualMenuCallback =
6776 NewDataBrowserGetContextualMenuUPP(dbGetContextualMenuCallback);
6777 dbCallbacks.u.v1.selectContextualMenuCallback =
6778 NewDataBrowserSelectContextualMenuUPP(dbSelectContextualMenuCallback);
6779
6780 SetDataBrowserCallbacks(dataBrowser, &dbCallbacks);
6781
6782 SetDataBrowserListViewHeaderBtnHeight(dataBrowser, 0); // no header
6783 SetDataBrowserHasScrollBars(dataBrowser, false, true); // only vertical
6784 SetDataBrowserSelectionFlags(dataBrowser,
6785 kDataBrowserSelectOnlyOne | kDataBrowserNeverEmptySelectionSet);
6786 SetDataBrowserTableViewHiliteStyle(dataBrowser,
6787 kDataBrowserTableViewFillHilite);
6788 Boolean b = false;
6789 SetControlData(dataBrowser, kControlEntireControl,
6790 kControlDataBrowserIncludesFrameAndFocusTag, sizeof(b), &b);
6791
6792 // enable blue background in data browser (this is only in 10.4 and vim
6793 // has to support older osx versions as well, so we have to load this
6794 // function dynamically)
6795 myDataBrowserChangeAttributes(dataBrowser,
6796 kMyDataBrowserAttributeListViewAlternatingRowColors, 0);
6797
6798 // install callback that keeps focus in vim and away from the data browser
6799 InstallControlEventHandler(dataBrowser, dbFocusCallback, 1, &focusEvent,
6800 NULL, NULL);
6801
6802 // install callback that keeps data browser at the size of the drawer
6803 InstallWindowEventHandler(drawer, drawerCallback, 1, &resizeEvent,
6804 NULL, NULL);
6805
6806 // add "tabs" column to data browser
6807 colDesc.propertyDesc.propertyID = kTabsColumn;
6808 colDesc.propertyDesc.propertyType = kDataBrowserTextType;
6809
6810 // add if items can be selected (?): kDataBrowserListViewSelectionColumn
6811 colDesc.propertyDesc.propertyFlags = kDataBrowserDefaultPropertyFlags;
6812
6813 colDesc.headerBtnDesc.version = kDataBrowserListViewLatestHeaderDesc;
6814 colDesc.headerBtnDesc.minimumWidth = 100;
6815 colDesc.headerBtnDesc.maximumWidth = 150;
6816 colDesc.headerBtnDesc.titleOffset = 0;
6817 colDesc.headerBtnDesc.titleString = CFSTR("Tabs");
6818 colDesc.headerBtnDesc.initialOrder = kDataBrowserOrderIncreasing;
6819 colDesc.headerBtnDesc.btnFontStyle.flags = 0; // use default font
6820 colDesc.headerBtnDesc.btnContentInfo.contentType = kControlContentTextOnly;
6821
6822 AddDataBrowserListViewColumn(dataBrowser, &colDesc, 0);
6823
6824 // create tabline popup menu required by vim docs (see :he tabline-menu)
6825 CreateNewMenu(kTabContextMenuId, 0, &contextMenu);
6826 AppendMenuItemTextWithCFString(contextMenu, CFSTR("Close"), 0,
6827 TABLINE_MENU_CLOSE, NULL);
6828 AppendMenuItemTextWithCFString(contextMenu, CFSTR("New Tab"), 0,
6829 TABLINE_MENU_NEW, NULL);
6830 AppendMenuItemTextWithCFString(contextMenu, CFSTR("Open Tab..."), 0,
6831 TABLINE_MENU_OPEN, NULL);
6832}
6833
6834
6835/*
6836 * Show or hide the tabline.
6837 */
6838 void
6839gui_mch_show_tabline(int showit)
6840{
6841 if (showit == 0)
Bram Moolenaar1b60e502008-03-12 13:40:54 +00006842 CloseDrawer(drawer, true);
Bram Moolenaar79ee3152007-04-26 16:20:50 +00006843 else
Bram Moolenaar1b60e502008-03-12 13:40:54 +00006844 OpenDrawer(drawer, kWindowEdgeRight, true);
Bram Moolenaar79ee3152007-04-26 16:20:50 +00006845}
6846
6847/*
6848 * Return TRUE when tabline is displayed.
6849 */
6850 int
6851gui_mch_showing_tabline(void)
6852{
6853 WindowDrawerState state = GetDrawerState(drawer);
6854
6855 return state == kWindowDrawerOpen || state == kWindowDrawerOpening;
6856}
6857
6858/*
6859 * Update the labels of the tabline.
6860 */
6861 void
6862gui_mch_update_tabline(void)
6863{
6864 tabpage_T *tp;
6865 int numTabs = getTabCount();
6866 int nr = 1;
6867 int curtabidx = 1;
6868
6869 // adjust data browser
6870 if (tabLabels != NULL)
6871 {
Bram Moolenaar1b60e502008-03-12 13:40:54 +00006872 int i;
Bram Moolenaar79ee3152007-04-26 16:20:50 +00006873
Bram Moolenaar1b60e502008-03-12 13:40:54 +00006874 for (i = 0; i < tabLabelsSize; ++i)
6875 CFRelease(tabLabels[i]);
6876 free(tabLabels);
Bram Moolenaar79ee3152007-04-26 16:20:50 +00006877 }
6878 tabLabels = (CFStringRef *)malloc(numTabs * sizeof(CFStringRef));
6879 tabLabelsSize = numTabs;
6880
6881 for (tp = first_tabpage; tp != NULL; tp = tp->tp_next, ++nr)
6882 {
6883 if (tp == curtab)
6884 curtabidx = nr;
Bram Moolenaar1b60e502008-03-12 13:40:54 +00006885 tabLabels[nr-1] = getTabLabel(tp);
Bram Moolenaar79ee3152007-04-26 16:20:50 +00006886 }
6887
6888 RemoveDataBrowserItems(dataBrowser, kDataBrowserNoItem, 0, NULL,
6889 kDataBrowserItemNoProperty);
6890 // data browser uses ids 1, 2, 3, ... numTabs per default, so we
6891 // can pass NULL for the id array
6892 AddDataBrowserItems(dataBrowser, kDataBrowserNoItem, numTabs, NULL,
6893 kDataBrowserItemNoProperty);
6894
6895 DataBrowserItemID item = curtabidx;
6896 SetDataBrowserSelectedItems(dataBrowser, 1, &item, kDataBrowserItemsAssign);
6897}
6898
6899/*
6900 * Set the current tab to "nr". First tab is 1.
6901 */
6902 void
6903gui_mch_set_curtab(nr)
6904 int nr;
6905{
6906 DataBrowserItemID item = nr;
6907 SetDataBrowserSelectedItems(dataBrowser, 1, &item, kDataBrowserItemsAssign);
6908
6909 // TODO: call something like this?: (or restore scroll position, or...)
6910 RevealDataBrowserItem(dataBrowser, item, kTabsColumn,
6911 kDataBrowserRevealOnly);
6912}
6913
6914#endif // FEAT_GUI_TABLINE