]>
Commit | Line | Data |
---|---|---|
ef75664d AG |
1 | To: vim-dev@vim.org |
2 | Subject: Patch 7.1.275 | |
3 | Fcc: outbox | |
4 | From: Bram Moolenaar <Bram@moolenaar.net> | |
5 | Mime-Version: 1.0 | |
6 | Content-Type: text/plain; charset=ISO-8859-1 | |
7 | Content-Transfer-Encoding: 8bit | |
8 | ------------ | |
9 | ||
10 | Patch 7.1.275 (extra) | |
11 | Problem: Mac: ATSUI and 'antialias' don't work properly together. | |
12 | Solution: Fix this and the input method. (Jjgod Jiang) | |
13 | Files: src/vim.h, src/gui_mac.c | |
14 | ||
15 | ||
16 | *** ../vim-7.1.274/src/vim.h Wed Feb 20 12:22:59 2008 | |
17 | --- src/vim.h Wed Mar 12 13:18:58 2008 | |
18 | *************** | |
19 | *** 461,468 **** | |
20 | /* | |
21 | * Check input method control. | |
22 | */ | |
23 | ! #if defined(FEAT_XIM) || \ | |
24 | ! (defined(FEAT_GUI) && (defined(FEAT_MBYTE_IME) || defined(GLOBAL_IME))) | |
25 | # define USE_IM_CONTROL | |
26 | #endif | |
27 | ||
28 | --- 461,469 ---- | |
29 | /* | |
30 | * Check input method control. | |
31 | */ | |
32 | ! #if defined(FEAT_XIM) \ | |
33 | ! || (defined(FEAT_GUI) && (defined(FEAT_MBYTE_IME) || defined(GLOBAL_IME))) \ | |
34 | ! || defined(FEAT_GUI_MAC) | |
35 | # define USE_IM_CONTROL | |
36 | #endif | |
37 | ||
38 | *** ../vim-7.1.274/src/gui_mac.c Sat Sep 29 13:15:29 2007 | |
39 | --- src/gui_mac.c Wed Mar 12 13:40:57 2008 | |
40 | *************** | |
41 | *** 59,65 **** | |
42 | --- 59,91 ---- | |
43 | ||
44 | #ifdef MACOS_CONVERT | |
45 | # define USE_CARBONKEYHANDLER | |
46 | + | |
47 | + static int im_is_active = FALSE; | |
48 | + #if 0 | |
49 | + static int im_start_row = 0; | |
50 | + static int im_start_col = 0; | |
51 | + #endif | |
52 | + | |
53 | + #define NR_ELEMS(x) (sizeof(x) / sizeof(x[0])) | |
54 | + | |
55 | + static TSMDocumentID gTSMDocument; | |
56 | + | |
57 | + static void im_on_window_switch(int active); | |
58 | static EventHandlerUPP keyEventHandlerUPP = NULL; | |
59 | + static EventHandlerUPP winEventHandlerUPP = NULL; | |
60 | + | |
61 | + static pascal OSStatus gui_mac_handle_window_activate( | |
62 | + EventHandlerCallRef nextHandler, EventRef theEvent, void *data); | |
63 | + | |
64 | + static pascal OSStatus gui_mac_handle_text_input( | |
65 | + EventHandlerCallRef nextHandler, EventRef theEvent, void *data); | |
66 | + | |
67 | + static pascal OSStatus gui_mac_update_input_area( | |
68 | + EventHandlerCallRef nextHandler, EventRef theEvent); | |
69 | + | |
70 | + static pascal OSStatus gui_mac_unicode_key_event( | |
71 | + EventHandlerCallRef nextHandler, EventRef theEvent); | |
72 | + | |
73 | #endif | |
74 | ||
75 | ||
76 | *************** | |
77 | *** 137,143 **** | |
78 | --- 166,176 ---- | |
79 | ||
80 | #ifdef MACOS_CONVERT | |
81 | # define USE_ATSUI_DRAWING | |
82 | + int p_macatsui_last; | |
83 | ATSUStyle gFontStyle; | |
84 | + # ifdef FEAT_MBYTE | |
85 | + ATSUStyle gWideFontStyle; | |
86 | + # endif | |
87 | Boolean gIsFontFallbackSet; | |
88 | #endif | |
89 | ||
90 | *************** | |
91 | *** 265,270 **** | |
92 | --- 298,308 ---- | |
93 | static WindowRef drawer = NULL; // TODO: put into gui.h | |
94 | #endif | |
95 | ||
96 | + #ifdef USE_ATSUI_DRAWING | |
97 | + static void gui_mac_set_font_attributes(GuiFont font); | |
98 | + static void gui_mac_dispose_atsui_style(void); | |
99 | + #endif | |
100 | + | |
101 | /* | |
102 | * ------------------------------------------------------------ | |
103 | * Conversion Utility | |
104 | *************** | |
105 | *** 1935,1946 **** | |
106 | /* Dim scrollbars */ | |
107 | if (whichWindow == gui.VimWindow) | |
108 | { | |
109 | ! ControlRef rootControl; | |
110 | ! GetRootControl(gui.VimWindow, &rootControl); | |
111 | ! if ((event->modifiers) & activeFlag) | |
112 | ! ActivateControl(rootControl); | |
113 | ! else | |
114 | ! DeactivateControl(rootControl); | |
115 | } | |
116 | ||
117 | /* Activate */ | |
118 | --- 1973,1984 ---- | |
119 | /* Dim scrollbars */ | |
120 | if (whichWindow == gui.VimWindow) | |
121 | { | |
122 | ! ControlRef rootControl; | |
123 | ! GetRootControl(gui.VimWindow, &rootControl); | |
124 | ! if ((event->modifiers) & activeFlag) | |
125 | ! ActivateControl(rootControl); | |
126 | ! else | |
127 | ! DeactivateControl(rootControl); | |
128 | } | |
129 | ||
130 | /* Activate */ | |
131 | *************** | |
132 | *** 1976,1990 **** | |
133 | * Handle the key | |
134 | */ | |
135 | #ifdef USE_CARBONKEYHANDLER | |
136 | ||
137 | ! static int dialog_busy = FALSE; /* TRUE when gui_mch_dialog() wants the keys */ | |
138 | ||
139 | # define INLINE_KEY_BUFFER_SIZE 80 | |
140 | static pascal OSStatus | |
141 | ! gui_mac_doKeyEventCarbon( | |
142 | EventHandlerCallRef nextHandler, | |
143 | ! EventRef theEvent, | |
144 | ! void *data) | |
145 | { | |
146 | /* Multibyte-friendly key event handler */ | |
147 | OSStatus err = -1; | |
148 | --- 2014,2100 ---- | |
149 | * Handle the key | |
150 | */ | |
151 | #ifdef USE_CARBONKEYHANDLER | |
152 | + static pascal OSStatus | |
153 | + gui_mac_handle_window_activate( | |
154 | + EventHandlerCallRef nextHandler, | |
155 | + EventRef theEvent, | |
156 | + void *data) | |
157 | + { | |
158 | + UInt32 eventClass = GetEventClass(theEvent); | |
159 | + UInt32 eventKind = GetEventKind(theEvent); | |
160 | + | |
161 | + if (eventClass == kEventClassWindow) | |
162 | + { | |
163 | + switch (eventKind) | |
164 | + { | |
165 | + case kEventWindowActivated: | |
166 | + #if defined(USE_IM_CONTROL) | |
167 | + im_on_window_switch(TRUE); | |
168 | + #endif | |
169 | + return noErr; | |
170 | + | |
171 | + case kEventWindowDeactivated: | |
172 | + #if defined(USE_IM_CONTROL) | |
173 | + im_on_window_switch(FALSE); | |
174 | + #endif | |
175 | + return noErr; | |
176 | + } | |
177 | + } | |
178 | + | |
179 | + return eventNotHandledErr; | |
180 | + } | |
181 | + | |
182 | + static pascal OSStatus | |
183 | + gui_mac_handle_text_input( | |
184 | + EventHandlerCallRef nextHandler, | |
185 | + EventRef theEvent, | |
186 | + void *data) | |
187 | + { | |
188 | + UInt32 eventClass = GetEventClass(theEvent); | |
189 | + UInt32 eventKind = GetEventKind(theEvent); | |
190 | + | |
191 | + if (eventClass != kEventClassTextInput) | |
192 | + return eventNotHandledErr; | |
193 | ||
194 | ! if ((kEventTextInputUpdateActiveInputArea != eventKind) && | |
195 | ! (kEventTextInputUnicodeForKeyEvent != eventKind) && | |
196 | ! (kEventTextInputOffsetToPos != eventKind) && | |
197 | ! (kEventTextInputPosToOffset != eventKind) && | |
198 | ! (kEventTextInputGetSelectedText != eventKind)) | |
199 | ! return eventNotHandledErr; | |
200 | ! | |
201 | ! switch (eventKind) | |
202 | ! { | |
203 | ! case kEventTextInputUpdateActiveInputArea: | |
204 | ! return gui_mac_update_input_area(nextHandler, theEvent); | |
205 | ! case kEventTextInputUnicodeForKeyEvent: | |
206 | ! return gui_mac_unicode_key_event(nextHandler, theEvent); | |
207 | ! | |
208 | ! case kEventTextInputOffsetToPos: | |
209 | ! case kEventTextInputPosToOffset: | |
210 | ! case kEventTextInputGetSelectedText: | |
211 | ! break; | |
212 | ! } | |
213 | ! | |
214 | ! return eventNotHandledErr; | |
215 | ! } | |
216 | ! | |
217 | ! static pascal | |
218 | ! OSStatus gui_mac_update_input_area( | |
219 | ! EventHandlerCallRef nextHandler, | |
220 | ! EventRef theEvent) | |
221 | ! { | |
222 | ! return eventNotHandledErr; | |
223 | ! } | |
224 | ! | |
225 | ! static int dialog_busy = FALSE; /* TRUE when gui_mch_dialog() wants the | |
226 | ! keys */ | |
227 | ||
228 | # define INLINE_KEY_BUFFER_SIZE 80 | |
229 | static pascal OSStatus | |
230 | ! gui_mac_unicode_key_event( | |
231 | EventHandlerCallRef nextHandler, | |
232 | ! EventRef theEvent) | |
233 | { | |
234 | /* Multibyte-friendly key event handler */ | |
235 | OSStatus err = -1; | |
236 | *************** | |
237 | *** 2000,2006 **** | |
238 | char_u *to = NULL; | |
239 | Boolean isSpecial = FALSE; | |
240 | int i; | |
241 | ! EventRef keyEvent; | |
242 | ||
243 | /* Mask the mouse (as per user setting) */ | |
244 | if (p_mh) | |
245 | --- 2110,2116 ---- | |
246 | char_u *to = NULL; | |
247 | Boolean isSpecial = FALSE; | |
248 | int i; | |
249 | ! EventRef keyEvent; | |
250 | ||
251 | /* Mask the mouse (as per user setting) */ | |
252 | if (p_mh) | |
253 | *************** | |
254 | *** 2008,2046 **** | |
255 | ||
256 | /* Don't use the keys when the dialog wants them. */ | |
257 | if (dialog_busy) | |
258 | ! return eventNotHandledErr; | |
259 | ||
260 | if (noErr != GetEventParameter(theEvent, kEventParamTextInputSendText, | |
261 | ! typeUnicodeText, NULL, 0, &actualSize, NULL)) | |
262 | ! return eventNotHandledErr; | |
263 | ||
264 | text = (UniChar *)alloc(actualSize); | |
265 | if (!text) | |
266 | ! return eventNotHandledErr; | |
267 | ||
268 | err = GetEventParameter(theEvent, kEventParamTextInputSendText, | |
269 | ! typeUnicodeText, NULL, actualSize, NULL, text); | |
270 | require_noerr(err, done); | |
271 | ||
272 | err = GetEventParameter(theEvent, kEventParamTextInputSendKeyboardEvent, | |
273 | ! typeEventRef, NULL, sizeof(EventRef), NULL, &keyEvent); | |
274 | require_noerr(err, done); | |
275 | ||
276 | err = GetEventParameter(keyEvent, kEventParamKeyModifiers, | |
277 | ! typeUInt32, NULL, sizeof(UInt32), NULL, &modifiers); | |
278 | require_noerr(err, done); | |
279 | ||
280 | err = GetEventParameter(keyEvent, kEventParamKeyCode, | |
281 | ! typeUInt32, NULL, sizeof(UInt32), NULL, &key_sym); | |
282 | require_noerr(err, done); | |
283 | ||
284 | err = GetEventParameter(keyEvent, kEventParamKeyMacCharCodes, | |
285 | ! typeChar, NULL, sizeof(char), NULL, &charcode); | |
286 | require_noerr(err, done); | |
287 | ||
288 | #ifndef USE_CMD_KEY | |
289 | if (modifiers & cmdKey) | |
290 | ! goto done; /* Let system handle Cmd+... */ | |
291 | #endif | |
292 | ||
293 | key_char = charcode; | |
294 | --- 2118,2156 ---- | |
295 | ||
296 | /* Don't use the keys when the dialog wants them. */ | |
297 | if (dialog_busy) | |
298 | ! return eventNotHandledErr; | |
299 | ||
300 | if (noErr != GetEventParameter(theEvent, kEventParamTextInputSendText, | |
301 | ! typeUnicodeText, NULL, 0, &actualSize, NULL)) | |
302 | ! return eventNotHandledErr; | |
303 | ||
304 | text = (UniChar *)alloc(actualSize); | |
305 | if (!text) | |
306 | ! return eventNotHandledErr; | |
307 | ||
308 | err = GetEventParameter(theEvent, kEventParamTextInputSendText, | |
309 | ! typeUnicodeText, NULL, actualSize, NULL, text); | |
310 | require_noerr(err, done); | |
311 | ||
312 | err = GetEventParameter(theEvent, kEventParamTextInputSendKeyboardEvent, | |
313 | ! typeEventRef, NULL, sizeof(EventRef), NULL, &keyEvent); | |
314 | require_noerr(err, done); | |
315 | ||
316 | err = GetEventParameter(keyEvent, kEventParamKeyModifiers, | |
317 | ! typeUInt32, NULL, sizeof(UInt32), NULL, &modifiers); | |
318 | require_noerr(err, done); | |
319 | ||
320 | err = GetEventParameter(keyEvent, kEventParamKeyCode, | |
321 | ! typeUInt32, NULL, sizeof(UInt32), NULL, &key_sym); | |
322 | require_noerr(err, done); | |
323 | ||
324 | err = GetEventParameter(keyEvent, kEventParamKeyMacCharCodes, | |
325 | ! typeChar, NULL, sizeof(char), NULL, &charcode); | |
326 | require_noerr(err, done); | |
327 | ||
328 | #ifndef USE_CMD_KEY | |
329 | if (modifiers & cmdKey) | |
330 | ! goto done; /* Let system handle Cmd+... */ | |
331 | #endif | |
332 | ||
333 | key_char = charcode; | |
334 | *************** | |
335 | *** 2048,2131 **** | |
336 | ||
337 | /* Find the special key (eg., for cursor keys) */ | |
338 | if (actualSize <= sizeof(UniChar) && | |
339 | ! ((text[0] < 0x20) || (text[0] == 0x7f))) | |
340 | { | |
341 | ! for (i = 0; special_keys[i].key_sym != (KeySym)0; ++i) | |
342 | ! if (special_keys[i].key_sym == key_sym) | |
343 | ! { | |
344 | ! key_char = TO_SPECIAL(special_keys[i].vim_code0, | |
345 | ! special_keys[i].vim_code1); | |
346 | ! key_char = simplify_key(key_char, | |
347 | ! (int *)&vimModifiers); | |
348 | ! isSpecial = TRUE; | |
349 | ! break; | |
350 | ! } | |
351 | } | |
352 | ||
353 | /* Intercept CMD-. and CTRL-c */ | |
354 | if (((modifiers & controlKey) && key_char == 'c') || | |
355 | ! ((modifiers & cmdKey) && key_char == '.')) | |
356 | ! got_int = TRUE; | |
357 | ||
358 | if (!isSpecial) | |
359 | { | |
360 | ! /* remove SHIFT for keys that are already shifted, e.g., | |
361 | ! * '(' and '*' */ | |
362 | ! if (key_char < 0x100 && !isalpha(key_char) && isprint(key_char)) | |
363 | ! vimModifiers &= ~MOD_MASK_SHIFT; | |
364 | ! | |
365 | ! /* remove CTRL from keys that already have it */ | |
366 | ! if (key_char < 0x20) | |
367 | ! vimModifiers &= ~MOD_MASK_CTRL; | |
368 | ! | |
369 | ! /* don't process unicode characters here */ | |
370 | ! if (!IS_SPECIAL(key_char)) | |
371 | ! { | |
372 | ! /* Following code to simplify and consolidate vimModifiers | |
373 | ! * taken liberally from gui_w48.c */ | |
374 | ! key_char = simplify_key(key_char, (int *)&vimModifiers); | |
375 | ! | |
376 | ! /* Interpret META, include SHIFT, etc. */ | |
377 | ! key_char = extract_modifiers(key_char, (int *)&vimModifiers); | |
378 | ! if (key_char == CSI) | |
379 | ! key_char = K_CSI; | |
380 | ! | |
381 | ! if (IS_SPECIAL(key_char)) | |
382 | ! isSpecial = TRUE; | |
383 | ! } | |
384 | } | |
385 | ||
386 | if (vimModifiers) | |
387 | { | |
388 | ! result[len++] = CSI; | |
389 | ! result[len++] = KS_MODIFIER; | |
390 | ! result[len++] = vimModifiers; | |
391 | } | |
392 | ||
393 | if (isSpecial && IS_SPECIAL(key_char)) | |
394 | { | |
395 | ! result[len++] = CSI; | |
396 | ! result[len++] = K_SECOND(key_char); | |
397 | ! result[len++] = K_THIRD(key_char); | |
398 | } | |
399 | else | |
400 | { | |
401 | ! encLen = actualSize; | |
402 | ! to = mac_utf16_to_enc(text, actualSize, &encLen); | |
403 | ! if (to) | |
404 | ! { | |
405 | ! /* This is basically add_to_input_buf_csi() */ | |
406 | ! for (i = 0; i < encLen && len < (INLINE_KEY_BUFFER_SIZE-1); ++i) | |
407 | ! { | |
408 | ! result[len++] = to[i]; | |
409 | ! if (to[i] == CSI) | |
410 | ! { | |
411 | ! result[len++] = KS_EXTRA; | |
412 | ! result[len++] = (int)KE_CSI; | |
413 | ! } | |
414 | ! } | |
415 | ! vim_free(to); | |
416 | ! } | |
417 | } | |
418 | ||
419 | add_to_input_buf(result, len); | |
420 | --- 2158,2241 ---- | |
421 | ||
422 | /* Find the special key (eg., for cursor keys) */ | |
423 | if (actualSize <= sizeof(UniChar) && | |
424 | ! ((text[0] < 0x20) || (text[0] == 0x7f))) | |
425 | { | |
426 | ! for (i = 0; special_keys[i].key_sym != (KeySym)0; ++i) | |
427 | ! if (special_keys[i].key_sym == key_sym) | |
428 | ! { | |
429 | ! key_char = TO_SPECIAL(special_keys[i].vim_code0, | |
430 | ! special_keys[i].vim_code1); | |
431 | ! key_char = simplify_key(key_char, | |
432 | ! (int *)&vimModifiers); | |
433 | ! isSpecial = TRUE; | |
434 | ! break; | |
435 | ! } | |
436 | } | |
437 | ||
438 | /* Intercept CMD-. and CTRL-c */ | |
439 | if (((modifiers & controlKey) && key_char == 'c') || | |
440 | ! ((modifiers & cmdKey) && key_char == '.')) | |
441 | ! got_int = TRUE; | |
442 | ||
443 | if (!isSpecial) | |
444 | { | |
445 | ! /* remove SHIFT for keys that are already shifted, e.g., | |
446 | ! * '(' and '*' */ | |
447 | ! if (key_char < 0x100 && !isalpha(key_char) && isprint(key_char)) | |
448 | ! vimModifiers &= ~MOD_MASK_SHIFT; | |
449 | ! | |
450 | ! /* remove CTRL from keys that already have it */ | |
451 | ! if (key_char < 0x20) | |
452 | ! vimModifiers &= ~MOD_MASK_CTRL; | |
453 | ! | |
454 | ! /* don't process unicode characters here */ | |
455 | ! if (!IS_SPECIAL(key_char)) | |
456 | ! { | |
457 | ! /* Following code to simplify and consolidate vimModifiers | |
458 | ! * taken liberally from gui_w48.c */ | |
459 | ! key_char = simplify_key(key_char, (int *)&vimModifiers); | |
460 | ! | |
461 | ! /* Interpret META, include SHIFT, etc. */ | |
462 | ! key_char = extract_modifiers(key_char, (int *)&vimModifiers); | |
463 | ! if (key_char == CSI) | |
464 | ! key_char = K_CSI; | |
465 | ! | |
466 | ! if (IS_SPECIAL(key_char)) | |
467 | ! isSpecial = TRUE; | |
468 | ! } | |
469 | } | |
470 | ||
471 | if (vimModifiers) | |
472 | { | |
473 | ! result[len++] = CSI; | |
474 | ! result[len++] = KS_MODIFIER; | |
475 | ! result[len++] = vimModifiers; | |
476 | } | |
477 | ||
478 | if (isSpecial && IS_SPECIAL(key_char)) | |
479 | { | |
480 | ! result[len++] = CSI; | |
481 | ! result[len++] = K_SECOND(key_char); | |
482 | ! result[len++] = K_THIRD(key_char); | |
483 | } | |
484 | else | |
485 | { | |
486 | ! encLen = actualSize; | |
487 | ! to = mac_utf16_to_enc(text, actualSize, &encLen); | |
488 | ! if (to) | |
489 | ! { | |
490 | ! /* This is basically add_to_input_buf_csi() */ | |
491 | ! for (i = 0; i < encLen && len < (INLINE_KEY_BUFFER_SIZE-1); ++i) | |
492 | ! { | |
493 | ! result[len++] = to[i]; | |
494 | ! if (to[i] == CSI) | |
495 | ! { | |
496 | ! result[len++] = KS_EXTRA; | |
497 | ! result[len++] = (int)KE_CSI; | |
498 | ! } | |
499 | ! } | |
500 | ! vim_free(to); | |
501 | ! } | |
502 | } | |
503 | ||
504 | add_to_input_buf(result, len); | |
505 | *************** | |
506 | *** 2135,2144 **** | |
507 | vim_free(text); | |
508 | if (err == noErr) | |
509 | { | |
510 | ! /* Fake event to wake up WNE (required to get | |
511 | ! * key repeat working */ | |
512 | ! PostEvent(keyUp, 0); | |
513 | ! return noErr; | |
514 | } | |
515 | ||
516 | return eventNotHandledErr; | |
517 | --- 2245,2254 ---- | |
518 | vim_free(text); | |
519 | if (err == noErr) | |
520 | { | |
521 | ! /* Fake event to wake up WNE (required to get | |
522 | ! * key repeat working */ | |
523 | ! PostEvent(keyUp, 0); | |
524 | ! return noErr; | |
525 | } | |
526 | ||
527 | return eventNotHandledErr; | |
528 | *************** | |
529 | *** 2334,2340 **** | |
530 | /* prevent that the vim window size changes if it's activated by a | |
531 | click into the tab pane */ | |
532 | if (whichWindow == drawer) | |
533 | ! return; | |
534 | #endif | |
535 | ||
536 | switch (thePart) | |
537 | --- 2444,2450 ---- | |
538 | /* prevent that the vim window size changes if it's activated by a | |
539 | click into the tab pane */ | |
540 | if (whichWindow == drawer) | |
541 | ! return; | |
542 | #endif | |
543 | ||
544 | switch (thePart) | |
545 | *************** | |
546 | *** 2569,2579 **** | |
547 | if (IsShowContextualMenuClick(event)) | |
548 | { | |
549 | # if 0 | |
550 | ! gui_mac_handle_contextual_menu(event); | |
551 | # else | |
552 | ! gui_mac_doMouseDownEvent(event); | |
553 | # endif | |
554 | ! return; | |
555 | } | |
556 | ||
557 | /* Handle normal event */ | |
558 | --- 2679,2689 ---- | |
559 | if (IsShowContextualMenuClick(event)) | |
560 | { | |
561 | # if 0 | |
562 | ! gui_mac_handle_contextual_menu(event); | |
563 | # else | |
564 | ! gui_mac_doMouseDownEvent(event); | |
565 | # endif | |
566 | ! return; | |
567 | } | |
568 | ||
569 | /* Handle normal event */ | |
570 | *************** | |
571 | *** 2832,2838 **** | |
572 | # else | |
573 | /* OSErr GetApplicationBundleFSSpec(FSSpecPtr theFSSpecPtr) | |
574 | * of TN2015 | |
575 | - * This technic remove the ../Contents/MacOS/etc part | |
576 | */ | |
577 | (void)GetCurrentProcess(&psn); | |
578 | /* if (err != noErr) return err; */ | |
579 | --- 2942,2947 ---- | |
580 | *************** | |
581 | *** 2933,2942 **** | |
582 | /* TODO: Move most of this stuff toward gui_mch_init */ | |
583 | Rect windRect; | |
584 | MenuHandle pomme; | |
585 | - EventTypeSpec eventTypeSpec; | |
586 | EventHandlerRef mouseWheelHandlerRef; | |
587 | #ifdef USE_CARBONKEYHANDLER | |
588 | ! EventHandlerRef keyEventHandlerRef; | |
589 | #endif | |
590 | ControlRef rootControl; | |
591 | ||
592 | --- 3042,3050 ---- | |
593 | /* TODO: Move most of this stuff toward gui_mch_init */ | |
594 | Rect windRect; | |
595 | MenuHandle pomme; | |
596 | EventHandlerRef mouseWheelHandlerRef; | |
597 | #ifdef USE_CARBONKEYHANDLER | |
598 | ! EventTypeSpec eventTypeSpec; | |
599 | #endif | |
600 | ControlRef rootControl; | |
601 | ||
602 | *************** | |
603 | *** 3042,3057 **** | |
604 | } | |
605 | ||
606 | #ifdef USE_CARBONKEYHANDLER | |
607 | ! eventTypeSpec.eventClass = kEventClassTextInput; | |
608 | ! eventTypeSpec.eventKind = kEventUnicodeForKeyEvent; | |
609 | ! keyEventHandlerUPP = NewEventHandlerUPP(gui_mac_doKeyEventCarbon); | |
610 | ! if (noErr != InstallApplicationEventHandler(keyEventHandlerUPP, 1, | |
611 | ! &eventTypeSpec, NULL, &keyEventHandlerRef)) | |
612 | { | |
613 | - keyEventHandlerRef = NULL; | |
614 | DisposeEventHandlerUPP(keyEventHandlerUPP); | |
615 | keyEventHandlerUPP = NULL; | |
616 | } | |
617 | #endif | |
618 | ||
619 | /* | |
620 | --- 3150,3196 ---- | |
621 | } | |
622 | ||
623 | #ifdef USE_CARBONKEYHANDLER | |
624 | ! InterfaceTypeList supportedServices = { kUnicodeDocument }; | |
625 | ! NewTSMDocument(1, supportedServices, &gTSMDocument, 0); | |
626 | ! | |
627 | ! /* We don't support inline input yet, use input window by default */ | |
628 | ! UseInputWindow(gTSMDocument, TRUE); | |
629 | ! | |
630 | ! /* Should we activate the document by default? */ | |
631 | ! // ActivateTSMDocument(gTSMDocument); | |
632 | ! | |
633 | ! EventTypeSpec textEventTypes[] = { | |
634 | ! { kEventClassTextInput, kEventTextInputUpdateActiveInputArea }, | |
635 | ! { kEventClassTextInput, kEventTextInputUnicodeForKeyEvent }, | |
636 | ! { kEventClassTextInput, kEventTextInputPosToOffset }, | |
637 | ! { kEventClassTextInput, kEventTextInputOffsetToPos }, | |
638 | ! }; | |
639 | ! | |
640 | ! keyEventHandlerUPP = NewEventHandlerUPP(gui_mac_handle_text_input); | |
641 | ! if (noErr != InstallApplicationEventHandler(keyEventHandlerUPP, | |
642 | ! NR_ELEMS(textEventTypes), | |
643 | ! textEventTypes, NULL, NULL)) | |
644 | { | |
645 | DisposeEventHandlerUPP(keyEventHandlerUPP); | |
646 | keyEventHandlerUPP = NULL; | |
647 | } | |
648 | + | |
649 | + EventTypeSpec windowEventTypes[] = { | |
650 | + { kEventClassWindow, kEventWindowActivated }, | |
651 | + { kEventClassWindow, kEventWindowDeactivated }, | |
652 | + }; | |
653 | + | |
654 | + /* Install window event handler to support TSMDocument activate and | |
655 | + * deactivate */ | |
656 | + winEventHandlerUPP = NewEventHandlerUPP(gui_mac_handle_window_activate); | |
657 | + if (noErr != InstallWindowEventHandler(gui.VimWindow, | |
658 | + winEventHandlerUPP, | |
659 | + NR_ELEMS(windowEventTypes), | |
660 | + windowEventTypes, NULL, NULL)) | |
661 | + { | |
662 | + DisposeEventHandlerUPP(winEventHandlerUPP); | |
663 | + winEventHandlerUPP = NULL; | |
664 | + } | |
665 | #endif | |
666 | ||
667 | /* | |
668 | *************** | |
669 | *** 3107,3112 **** | |
670 | --- 3246,3264 ---- | |
671 | return OK; | |
672 | } | |
673 | ||
674 | + #ifdef USE_ATSUI_DRAWING | |
675 | + static void | |
676 | + gui_mac_dispose_atsui_style(void) | |
677 | + { | |
678 | + if (p_macatsui && gFontStyle) | |
679 | + ATSUDisposeStyle(gFontStyle); | |
680 | + #ifdef FEAT_MBYTE | |
681 | + if (p_macatsui && gWideFontStyle) | |
682 | + ATSUDisposeStyle(gWideFontStyle); | |
683 | + #endif | |
684 | + } | |
685 | + #endif | |
686 | + | |
687 | void | |
688 | gui_mch_exit(int rc) | |
689 | { | |
690 | *************** | |
691 | *** 3122,3129 **** | |
692 | DisposeEventHandlerUPP(mouseWheelHandlerUPP); | |
693 | ||
694 | #ifdef USE_ATSUI_DRAWING | |
695 | ! if (p_macatsui && gFontStyle) | |
696 | ! ATSUDisposeStyle(gFontStyle); | |
697 | #endif | |
698 | ||
699 | /* Exit to shell? */ | |
700 | --- 3274,3286 ---- | |
701 | DisposeEventHandlerUPP(mouseWheelHandlerUPP); | |
702 | ||
703 | #ifdef USE_ATSUI_DRAWING | |
704 | ! gui_mac_dispose_atsui_style(); | |
705 | ! #endif | |
706 | ! | |
707 | ! #ifdef USE_CARBONKEYHANDLER | |
708 | ! FixTSMDocument(gTSMDocument); | |
709 | ! DeactivateTSMDocument(gTSMDocument); | |
710 | ! DeleteTSMDocument(gTSMDocument); | |
711 | #endif | |
712 | ||
713 | /* Exit to shell? */ | |
714 | *************** | |
715 | *** 3263,3268 **** | |
716 | --- 3420,3445 ---- | |
717 | return selected_font; | |
718 | } | |
719 | ||
720 | + #ifdef USE_ATSUI_DRAWING | |
721 | + static void | |
722 | + gui_mac_create_atsui_style(void) | |
723 | + { | |
724 | + if (p_macatsui && gFontStyle == NULL) | |
725 | + { | |
726 | + if (ATSUCreateStyle(&gFontStyle) != noErr) | |
727 | + gFontStyle = NULL; | |
728 | + } | |
729 | + #ifdef FEAT_MBYTE | |
730 | + if (p_macatsui && gWideFontStyle == NULL) | |
731 | + { | |
732 | + if (ATSUCreateStyle(&gWideFontStyle) != noErr) | |
733 | + gWideFontStyle = NULL; | |
734 | + } | |
735 | + #endif | |
736 | + | |
737 | + p_macatsui_last = p_macatsui; | |
738 | + } | |
739 | + #endif | |
740 | ||
741 | /* | |
742 | * Initialise vim to use the font with the given name. Return FAIL if the font | |
743 | *************** | |
744 | *** 3280,3290 **** | |
745 | char_u used_font_name[512]; | |
746 | ||
747 | #ifdef USE_ATSUI_DRAWING | |
748 | ! if (p_macatsui && gFontStyle == NULL) | |
749 | ! { | |
750 | ! if (ATSUCreateStyle(&gFontStyle) != noErr) | |
751 | ! gFontStyle = NULL; | |
752 | ! } | |
753 | #endif | |
754 | ||
755 | if (font_name == NULL) | |
756 | --- 3457,3463 ---- | |
757 | char_u used_font_name[512]; | |
758 | ||
759 | #ifdef USE_ATSUI_DRAWING | |
760 | ! gui_mac_create_atsui_style(); | |
761 | #endif | |
762 | ||
763 | if (font_name == NULL) | |
764 | *************** | |
765 | *** 3348,3396 **** | |
766 | gui.char_height = font_info.ascent + font_info.descent + p_linespace; | |
767 | ||
768 | #ifdef USE_ATSUI_DRAWING | |
769 | - ATSUFontID fontID; | |
770 | - Fixed fontSize; | |
771 | - ATSStyleRenderingOptions fontOptions; | |
772 | - | |
773 | if (p_macatsui && gFontStyle) | |
774 | ! { | |
775 | ! fontID = font & 0xFFFF; | |
776 | ! fontSize = Long2Fix(font >> 16); | |
777 | ! | |
778 | ! /* No antialiasing by default (do not attempt to touch antialising | |
779 | ! * options on pre-Jaguar) */ | |
780 | ! fontOptions = | |
781 | ! (gMacSystemVersion >= 0x1020) ? | |
782 | ! kATSStyleNoAntiAliasing : | |
783 | ! kATSStyleNoOptions; | |
784 | ! | |
785 | ! ATSUAttributeTag attribTags[] = | |
786 | ! { | |
787 | ! kATSUFontTag, kATSUSizeTag, kATSUStyleRenderingOptionsTag, | |
788 | ! kATSUMaxATSUITagValue+1 | |
789 | ! }; | |
790 | ! ByteCount attribSizes[] = | |
791 | ! { | |
792 | ! sizeof(ATSUFontID), sizeof(Fixed), | |
793 | ! sizeof(ATSStyleRenderingOptions), sizeof font | |
794 | ! }; | |
795 | ! ATSUAttributeValuePtr attribValues[] = | |
796 | ! { | |
797 | ! &fontID, &fontSize, &fontOptions, &font | |
798 | ! }; | |
799 | ! | |
800 | ! /* Convert font id to ATSUFontID */ | |
801 | ! if (FMGetFontFromFontFamilyInstance(fontID, 0, &fontID, NULL) == noErr) | |
802 | ! { | |
803 | ! if (ATSUSetAttributes(gFontStyle, | |
804 | ! (sizeof attribTags)/sizeof(ATSUAttributeTag), | |
805 | ! attribTags, attribSizes, attribValues) != noErr) | |
806 | ! { | |
807 | ! ATSUDisposeStyle(gFontStyle); | |
808 | ! gFontStyle = NULL; | |
809 | ! } | |
810 | ! } | |
811 | ! } | |
812 | #endif | |
813 | ||
814 | return OK; | |
815 | --- 3521,3528 ---- | |
816 | gui.char_height = font_info.ascent + font_info.descent + p_linespace; | |
817 | ||
818 | #ifdef USE_ATSUI_DRAWING | |
819 | if (p_macatsui && gFontStyle) | |
820 | ! gui_mac_set_font_attributes(font); | |
821 | #endif | |
822 | ||
823 | return OK; | |
824 | *************** | |
825 | *** 3447,3452 **** | |
826 | --- 3579,3646 ---- | |
827 | } | |
828 | #endif | |
829 | ||
830 | + #ifdef USE_ATSUI_DRAWING | |
831 | + static void | |
832 | + gui_mac_set_font_attributes(GuiFont font) | |
833 | + { | |
834 | + ATSUFontID fontID; | |
835 | + Fixed fontSize; | |
836 | + Fixed fontWidth; | |
837 | + | |
838 | + fontID = font & 0xFFFF; | |
839 | + fontSize = Long2Fix(font >> 16); | |
840 | + fontWidth = Long2Fix(gui.char_width); | |
841 | + | |
842 | + ATSUAttributeTag attribTags[] = | |
843 | + { | |
844 | + kATSUFontTag, kATSUSizeTag, kATSUImposeWidthTag, | |
845 | + kATSUMaxATSUITagValue + 1 | |
846 | + }; | |
847 | + | |
848 | + ByteCount attribSizes[] = | |
849 | + { | |
850 | + sizeof(ATSUFontID), sizeof(Fixed), sizeof(fontWidth), | |
851 | + sizeof(font) | |
852 | + }; | |
853 | + | |
854 | + ATSUAttributeValuePtr attribValues[] = | |
855 | + { | |
856 | + &fontID, &fontSize, &fontWidth, &font | |
857 | + }; | |
858 | + | |
859 | + if (FMGetFontFromFontFamilyInstance(fontID, 0, &fontID, NULL) == noErr) | |
860 | + { | |
861 | + if (ATSUSetAttributes(gFontStyle, | |
862 | + (sizeof attribTags) / sizeof(ATSUAttributeTag), | |
863 | + attribTags, attribSizes, attribValues) != noErr) | |
864 | + { | |
865 | + # ifndef NDEBUG | |
866 | + fprintf(stderr, "couldn't set font style\n"); | |
867 | + # endif | |
868 | + ATSUDisposeStyle(gFontStyle); | |
869 | + gFontStyle = NULL; | |
870 | + } | |
871 | + | |
872 | + #ifdef FEAT_MBYTE | |
873 | + if (has_mbyte) | |
874 | + { | |
875 | + /* FIXME: we should use a more mbyte sensitive way to support | |
876 | + * wide font drawing */ | |
877 | + fontWidth = Long2Fix(gui.char_width * 2); | |
878 | + | |
879 | + if (ATSUSetAttributes(gWideFontStyle, | |
880 | + (sizeof attribTags) / sizeof(ATSUAttributeTag), | |
881 | + attribTags, attribSizes, attribValues) != noErr) | |
882 | + { | |
883 | + ATSUDisposeStyle(gWideFontStyle); | |
884 | + gWideFontStyle = NULL; | |
885 | + } | |
886 | + } | |
887 | + #endif | |
888 | + } | |
889 | + } | |
890 | + #endif | |
891 | + | |
892 | /* | |
893 | * Set the current text font. | |
894 | */ | |
895 | *************** | |
896 | *** 3456,3518 **** | |
897 | #ifdef USE_ATSUI_DRAWING | |
898 | GuiFont currFont; | |
899 | ByteCount actualFontByteCount; | |
900 | - ATSUFontID fontID; | |
901 | - Fixed fontSize; | |
902 | - ATSStyleRenderingOptions fontOptions; | |
903 | ||
904 | if (p_macatsui && gFontStyle) | |
905 | { | |
906 | /* Avoid setting same font again */ | |
907 | ! if (ATSUGetAttribute(gFontStyle, kATSUMaxATSUITagValue+1, sizeof font, | |
908 | ! &currFont, &actualFontByteCount) == noErr && | |
909 | ! actualFontByteCount == (sizeof font)) | |
910 | { | |
911 | if (currFont == font) | |
912 | return; | |
913 | } | |
914 | ||
915 | ! fontID = font & 0xFFFF; | |
916 | ! fontSize = Long2Fix(font >> 16); | |
917 | ! /* Respect p_antialias setting only for wide font. | |
918 | ! * The reason for doing this at the moment is a bit complicated, | |
919 | ! * but it's mainly because a) latin (non-wide) aliased fonts | |
920 | ! * look bad in OS X 10.3.x and below (due to a bug in ATS), and | |
921 | ! * b) wide multibyte input does not suffer from that problem. */ | |
922 | ! /*fontOptions = | |
923 | ! (p_antialias && (font == gui.wide_font)) ? | |
924 | ! kATSStyleNoOptions : kATSStyleNoAntiAliasing; | |
925 | ! */ | |
926 | ! /*fontOptions = kATSStyleAntiAliasing;*/ | |
927 | ! | |
928 | ! ATSUAttributeTag attribTags[] = | |
929 | ! { | |
930 | ! kATSUFontTag, kATSUSizeTag, kATSUStyleRenderingOptionsTag, | |
931 | ! kATSUMaxATSUITagValue+1 | |
932 | ! }; | |
933 | ! ByteCount attribSizes[] = | |
934 | ! { | |
935 | ! sizeof(ATSUFontID), sizeof(Fixed), | |
936 | ! sizeof(ATSStyleRenderingOptions), sizeof font | |
937 | ! }; | |
938 | ! ATSUAttributeValuePtr attribValues[] = | |
939 | ! { | |
940 | ! &fontID, &fontSize, &fontOptions, &font | |
941 | ! }; | |
942 | ! | |
943 | ! if (FMGetFontFromFontFamilyInstance(fontID, 0, &fontID, NULL) == noErr) | |
944 | ! { | |
945 | ! if (ATSUSetAttributes(gFontStyle, | |
946 | ! (sizeof attribTags)/sizeof(ATSUAttributeTag), | |
947 | ! attribTags, attribSizes, attribValues) != noErr) | |
948 | ! { | |
949 | ! # ifndef NDEBUG | |
950 | ! fprintf(stderr, "couldn't set font style\n"); | |
951 | ! # endif | |
952 | ! ATSUDisposeStyle(gFontStyle); | |
953 | ! gFontStyle = NULL; | |
954 | ! } | |
955 | ! } | |
956 | ! | |
957 | } | |
958 | ||
959 | if (p_macatsui && !gIsFontFallbackSet) | |
960 | --- 3650,3668 ---- | |
961 | #ifdef USE_ATSUI_DRAWING | |
962 | GuiFont currFont; | |
963 | ByteCount actualFontByteCount; | |
964 | ||
965 | if (p_macatsui && gFontStyle) | |
966 | { | |
967 | /* Avoid setting same font again */ | |
968 | ! if (ATSUGetAttribute(gFontStyle, kATSUMaxATSUITagValue + 1, | |
969 | ! sizeof(font), &currFont, &actualFontByteCount) == noErr | |
970 | ! && actualFontByteCount == (sizeof font)) | |
971 | { | |
972 | if (currFont == font) | |
973 | return; | |
974 | } | |
975 | ||
976 | ! gui_mac_set_font_attributes(font); | |
977 | } | |
978 | ||
979 | if (p_macatsui && !gIsFontFallbackSet) | |
980 | *************** | |
981 | *** 3536,3542 **** | |
982 | &fallbackFonts, | |
983 | NULL) == noErr) | |
984 | { | |
985 | ! ATSUSetFontFallbacks((sizeof fallbackFonts)/sizeof(ATSUFontID), &fallbackFonts, kATSUSequentialFallbacksPreferred); | |
986 | } | |
987 | /* | |
988 | ATSUAttributeValuePtr fallbackValues[] = { }; | |
989 | --- 3686,3694 ---- | |
990 | &fallbackFonts, | |
991 | NULL) == noErr) | |
992 | { | |
993 | ! ATSUSetFontFallbacks((sizeof fallbackFonts)/sizeof(ATSUFontID), | |
994 | ! &fallbackFonts, | |
995 | ! kATSUSequentialFallbacksPreferred); | |
996 | } | |
997 | /* | |
998 | ATSUAttributeValuePtr fallbackValues[] = { }; | |
999 | *************** | |
1000 | *** 3921,3927 **** | |
1001 | ||
1002 | /* - ATSUI automatically antialiases text (Someone) | |
1003 | * - for some reason it does not work... (Jussi) */ | |
1004 | ! | |
1005 | /* | |
1006 | * When antialiasing we're using srcOr mode, we have to clear the block | |
1007 | * before drawing the text. | |
1008 | --- 4073,4082 ---- | |
1009 | ||
1010 | /* - ATSUI automatically antialiases text (Someone) | |
1011 | * - for some reason it does not work... (Jussi) */ | |
1012 | ! #ifdef MAC_ATSUI_DEBUG | |
1013 | ! fprintf(stderr, "row = %d, col = %d, len = %d: '%c'\n", | |
1014 | ! row, col, len, len == 1 ? s[0] : ' '); | |
1015 | ! #endif | |
1016 | /* | |
1017 | * When antialiasing we're using srcOr mode, we have to clear the block | |
1018 | * before drawing the text. | |
1019 | *************** | |
1020 | *** 3956,3990 **** | |
1021 | } | |
1022 | ||
1023 | { | |
1024 | - /* Use old-style, non-antialiased QuickDraw text rendering. */ | |
1025 | TextMode(srcCopy); | |
1026 | TextFace(normal); | |
1027 | ||
1028 | ! /* SelectFont(hdc, gui.currFont); */ | |
1029 | ! | |
1030 | if (flags & DRAW_TRANSP) | |
1031 | { | |
1032 | TextMode(srcOr); | |
1033 | } | |
1034 | ||
1035 | MoveTo(TEXT_X(col), TEXT_Y(row)); | |
1036 | - ATSUTextLayout textLayout; | |
1037 | ||
1038 | ! if (ATSUCreateTextLayoutWithTextPtr(tofree, | |
1039 | ! kATSUFromTextBeginning, kATSUToTextEnd, | |
1040 | ! utf16_len, | |
1041 | ! (gFontStyle ? 1 : 0), &utf16_len, | |
1042 | ! (gFontStyle ? &gFontStyle : NULL), | |
1043 | ! &textLayout) == noErr) | |
1044 | { | |
1045 | ! ATSUSetTransientFontMatching(textLayout, TRUE); | |
1046 | ||
1047 | ! ATSUDrawText(textLayout, | |
1048 | ! kATSUFromTextBeginning, kATSUToTextEnd, | |
1049 | ! kATSUUseGrafPortPenLoc, kATSUUseGrafPortPenLoc); | |
1050 | ||
1051 | ATSUDisposeTextLayout(textLayout); | |
1052 | } | |
1053 | } | |
1054 | ||
1055 | if (flags & DRAW_UNDERC) | |
1056 | --- 4111,4232 ---- | |
1057 | } | |
1058 | ||
1059 | { | |
1060 | TextMode(srcCopy); | |
1061 | TextFace(normal); | |
1062 | ||
1063 | ! /* SelectFont(hdc, gui.currFont); */ | |
1064 | if (flags & DRAW_TRANSP) | |
1065 | { | |
1066 | TextMode(srcOr); | |
1067 | } | |
1068 | ||
1069 | MoveTo(TEXT_X(col), TEXT_Y(row)); | |
1070 | ||
1071 | ! if (gFontStyle && flags & DRAW_BOLD) | |
1072 | { | |
1073 | ! Boolean attValue = true; | |
1074 | ! ATSUAttributeTag attribTags[] = { kATSUQDBoldfaceTag }; | |
1075 | ! ByteCount attribSizes[] = { sizeof(Boolean) }; | |
1076 | ! ATSUAttributeValuePtr attribValues[] = { &attValue }; | |
1077 | ||
1078 | ! ATSUSetAttributes(gFontStyle, 1, attribTags, attribSizes, attribValues); | |
1079 | ! } | |
1080 | ! | |
1081 | ! #ifdef FEAT_MBYTE | |
1082 | ! if (has_mbyte) | |
1083 | ! { | |
1084 | ! int n, width_in_cell, last_width_in_cell; | |
1085 | ! UniCharArrayOffset offset = 0; | |
1086 | ! UniCharCount yet_to_draw = 0; | |
1087 | ! ATSUTextLayout textLayout; | |
1088 | ! ATSUStyle textStyle; | |
1089 | ! | |
1090 | ! last_width_in_cell = 1; | |
1091 | ! ATSUCreateTextLayout(&textLayout); | |
1092 | ! ATSUSetTextPointerLocation(textLayout, tofree, | |
1093 | ! kATSUFromTextBeginning, | |
1094 | ! kATSUToTextEnd, utf16_len); | |
1095 | ! /* | |
1096 | ! ATSUSetRunStyle(textLayout, gFontStyle, | |
1097 | ! kATSUFromTextBeginning, kATSUToTextEnd); */ | |
1098 | ! | |
1099 | ! /* Compute the length in display cells. */ | |
1100 | ! for (n = 0; n < len; n += MB_BYTE2LEN(s[n])) | |
1101 | ! { | |
1102 | ! width_in_cell = (*mb_ptr2cells)(s + n); | |
1103 | ! | |
1104 | ! /* probably we are switching from single byte character | |
1105 | ! * to multibyte characters (which requires more than one | |
1106 | ! * cell to draw) */ | |
1107 | ! if (width_in_cell != last_width_in_cell) | |
1108 | ! { | |
1109 | ! #ifdef MAC_ATSUI_DEBUG | |
1110 | ! fprintf(stderr, "\tn = %2d, (%d-%d), offset = %d, yet_to_draw = %d\n", | |
1111 | ! n, last_width_in_cell, width_in_cell, offset, yet_to_draw); | |
1112 | ! #endif | |
1113 | ! textStyle = last_width_in_cell > 1 ? gWideFontStyle | |
1114 | ! : gFontStyle; | |
1115 | ! | |
1116 | ! ATSUSetRunStyle(textLayout, textStyle, offset, yet_to_draw); | |
1117 | ! offset += yet_to_draw; | |
1118 | ! yet_to_draw = 0; | |
1119 | ! last_width_in_cell = width_in_cell; | |
1120 | ! } | |
1121 | ||
1122 | + yet_to_draw++; | |
1123 | + } | |
1124 | + | |
1125 | + if (yet_to_draw) | |
1126 | + { | |
1127 | + #ifdef MAC_ATSUI_DEBUG | |
1128 | + fprintf(stderr, "\tn = %2d, (%d-%d), offset = %d, yet_to_draw = %d\n", | |
1129 | + n, last_width_in_cell, width_in_cell, offset, yet_to_draw); | |
1130 | + #endif | |
1131 | + /* finish the rest style */ | |
1132 | + textStyle = width_in_cell > 1 ? gWideFontStyle : gFontStyle; | |
1133 | + ATSUSetRunStyle(textLayout, textStyle, offset, kATSUToTextEnd); | |
1134 | + } | |
1135 | + | |
1136 | + ATSUSetTransientFontMatching(textLayout, TRUE); | |
1137 | + ATSUDrawText(textLayout, | |
1138 | + kATSUFromTextBeginning, kATSUToTextEnd, | |
1139 | + kATSUUseGrafPortPenLoc, kATSUUseGrafPortPenLoc); | |
1140 | ATSUDisposeTextLayout(textLayout); | |
1141 | } | |
1142 | + else | |
1143 | + #endif | |
1144 | + { | |
1145 | + ATSUTextLayout textLayout; | |
1146 | + | |
1147 | + if (ATSUCreateTextLayoutWithTextPtr(tofree, | |
1148 | + kATSUFromTextBeginning, kATSUToTextEnd, | |
1149 | + utf16_len, | |
1150 | + (gFontStyle ? 1 : 0), &utf16_len, | |
1151 | + (gFontStyle ? &gFontStyle : NULL), | |
1152 | + &textLayout) == noErr) | |
1153 | + { | |
1154 | + ATSUSetTransientFontMatching(textLayout, TRUE); | |
1155 | + | |
1156 | + ATSUDrawText(textLayout, | |
1157 | + kATSUFromTextBeginning, kATSUToTextEnd, | |
1158 | + kATSUUseGrafPortPenLoc, kATSUUseGrafPortPenLoc); | |
1159 | + | |
1160 | + ATSUDisposeTextLayout(textLayout); | |
1161 | + } | |
1162 | + } | |
1163 | + | |
1164 | + /* drawing is done, now reset bold to normal */ | |
1165 | + if (gFontStyle && flags & DRAW_BOLD) | |
1166 | + { | |
1167 | + Boolean attValue = false; | |
1168 | + | |
1169 | + ATSUAttributeTag attribTags[] = { kATSUQDBoldfaceTag }; | |
1170 | + ByteCount attribSizes[] = { sizeof(Boolean) }; | |
1171 | + ATSUAttributeValuePtr attribValues[] = { &attValue }; | |
1172 | + | |
1173 | + ATSUSetAttributes(gFontStyle, 1, attribTags, attribSizes, | |
1174 | + attribValues); | |
1175 | + } | |
1176 | } | |
1177 | ||
1178 | if (flags & DRAW_UNDERC) | |
1179 | *************** | |
1180 | *** 3998,4003 **** | |
1181 | --- 4240,4252 ---- | |
1182 | gui_mch_draw_string(int row, int col, char_u *s, int len, int flags) | |
1183 | { | |
1184 | #if defined(USE_ATSUI_DRAWING) | |
1185 | + if (p_macatsui == 0 && p_macatsui_last != 0) | |
1186 | + /* switch from macatsui to nomacatsui */ | |
1187 | + gui_mac_dispose_atsui_style(); | |
1188 | + else if (p_macatsui != 0 && p_macatsui_last == 0) | |
1189 | + /* switch from nomacatsui to macatsui */ | |
1190 | + gui_mac_create_atsui_style(); | |
1191 | + | |
1192 | if (p_macatsui) | |
1193 | draw_string_ATSUI(row, col, s, len, flags); | |
1194 | else | |
1195 | *************** | |
1196 | *** 4228,4239 **** | |
1197 | */ | |
1198 | /* TODO: reduce wtime accordinly??? */ | |
1199 | if (wtime > -1) | |
1200 | ! sleeppyTick = 60*wtime/1000; | |
1201 | else | |
1202 | sleeppyTick = 32767; | |
1203 | if (WaitNextEventWrp(mask, &event, sleeppyTick, dragRgn)) | |
1204 | { | |
1205 | ! gui_mac_handle_event(&event); | |
1206 | if (input_available()) | |
1207 | { | |
1208 | allow_scrollbar = FALSE; | |
1209 | --- 4477,4489 ---- | |
1210 | */ | |
1211 | /* TODO: reduce wtime accordinly??? */ | |
1212 | if (wtime > -1) | |
1213 | ! sleeppyTick = 60 * wtime / 1000; | |
1214 | else | |
1215 | sleeppyTick = 32767; | |
1216 | + | |
1217 | if (WaitNextEventWrp(mask, &event, sleeppyTick, dragRgn)) | |
1218 | { | |
1219 | ! gui_mac_handle_event(&event); | |
1220 | if (input_available()) | |
1221 | { | |
1222 | allow_scrollbar = FALSE; | |
1223 | *************** | |
1224 | *** 6031,6037 **** | |
1225 | #endif | |
1226 | } | |
1227 | ||
1228 | ! #if defined(USE_IM_CONTROL) || defined(PROTO) | |
1229 | /* | |
1230 | * Input Method Control functions. | |
1231 | */ | |
1232 | --- 6346,6352 ---- | |
1233 | #endif | |
1234 | } | |
1235 | ||
1236 | ! #if (defined(USE_IM_CONTROL) || defined(PROTO)) && defined(USE_CARBONKEYHANDLER) | |
1237 | /* | |
1238 | * Input Method Control functions. | |
1239 | */ | |
1240 | *************** | |
1241 | *** 6042,6048 **** | |
1242 | --- 6357,6427 ---- | |
1243 | void | |
1244 | im_set_position(int row, int col) | |
1245 | { | |
1246 | + #if 0 | |
1247 | /* TODO: Implement me! */ | |
1248 | + im_start_row = row; | |
1249 | + im_start_col = col; | |
1250 | + #endif | |
1251 | + } | |
1252 | + | |
1253 | + static ScriptLanguageRecord gTSLWindow; | |
1254 | + static ScriptLanguageRecord gTSLInsert; | |
1255 | + static ScriptLanguageRecord gTSLDefault = { 0, 0 }; | |
1256 | + | |
1257 | + static Component gTSCWindow; | |
1258 | + static Component gTSCInsert; | |
1259 | + static Component gTSCDefault; | |
1260 | + | |
1261 | + static int im_initialized = 0; | |
1262 | + | |
1263 | + static void | |
1264 | + im_on_window_switch(int active) | |
1265 | + { | |
1266 | + ScriptLanguageRecord *slptr = NULL; | |
1267 | + OSStatus err; | |
1268 | + | |
1269 | + if (! gui.in_use) | |
1270 | + return; | |
1271 | + | |
1272 | + if (im_initialized == 0) | |
1273 | + { | |
1274 | + im_initialized = 1; | |
1275 | + | |
1276 | + /* save default TSM component (should be U.S.) to default */ | |
1277 | + GetDefaultInputMethodOfClass(&gTSCDefault, &gTSLDefault, | |
1278 | + kKeyboardInputMethodClass); | |
1279 | + } | |
1280 | + | |
1281 | + if (active == TRUE) | |
1282 | + { | |
1283 | + im_is_active = TRUE; | |
1284 | + ActivateTSMDocument(gTSMDocument); | |
1285 | + slptr = &gTSLWindow; | |
1286 | + | |
1287 | + if (slptr) | |
1288 | + { | |
1289 | + err = SetDefaultInputMethodOfClass(gTSCWindow, slptr, | |
1290 | + kKeyboardInputMethodClass); | |
1291 | + if (err == noErr) | |
1292 | + err = SetTextServiceLanguage(slptr); | |
1293 | + | |
1294 | + if (err == noErr) | |
1295 | + KeyScript(slptr->fScript | smKeyForceKeyScriptMask); | |
1296 | + } | |
1297 | + } | |
1298 | + else | |
1299 | + { | |
1300 | + err = GetTextServiceLanguage(&gTSLWindow); | |
1301 | + if (err == noErr) | |
1302 | + slptr = &gTSLWindow; | |
1303 | + | |
1304 | + if (slptr) | |
1305 | + GetDefaultInputMethodOfClass(&gTSCWindow, slptr, | |
1306 | + kKeyboardInputMethodClass); | |
1307 | + | |
1308 | + im_is_active = FALSE; | |
1309 | + DeactivateTSMDocument(gTSMDocument); | |
1310 | + } | |
1311 | } | |
1312 | ||
1313 | /* | |
1314 | *************** | |
1315 | *** 6051,6057 **** | |
1316 | void | |
1317 | im_set_active(int active) | |
1318 | { | |
1319 | ! KeyScript(active ? smKeySysScript : smKeyRoman); | |
1320 | } | |
1321 | ||
1322 | /* | |
1323 | --- 6430,6486 ---- | |
1324 | void | |
1325 | im_set_active(int active) | |
1326 | { | |
1327 | ! ScriptLanguageRecord *slptr = NULL; | |
1328 | ! OSStatus err; | |
1329 | ! | |
1330 | ! if (! gui.in_use) | |
1331 | ! return; | |
1332 | ! | |
1333 | ! if (im_initialized == 0) | |
1334 | ! { | |
1335 | ! im_initialized = 1; | |
1336 | ! | |
1337 | ! /* save default TSM component (should be U.S.) to default */ | |
1338 | ! GetDefaultInputMethodOfClass(&gTSCDefault, &gTSLDefault, | |
1339 | ! kKeyboardInputMethodClass); | |
1340 | ! } | |
1341 | ! | |
1342 | ! if (active == TRUE) | |
1343 | ! { | |
1344 | ! im_is_active = TRUE; | |
1345 | ! ActivateTSMDocument(gTSMDocument); | |
1346 | ! slptr = &gTSLInsert; | |
1347 | ! | |
1348 | ! if (slptr) | |
1349 | ! { | |
1350 | ! err = SetDefaultInputMethodOfClass(gTSCInsert, slptr, | |
1351 | ! kKeyboardInputMethodClass); | |
1352 | ! if (err == noErr) | |
1353 | ! err = SetTextServiceLanguage(slptr); | |
1354 | ! | |
1355 | ! if (err == noErr) | |
1356 | ! KeyScript(slptr->fScript | smKeyForceKeyScriptMask); | |
1357 | ! } | |
1358 | ! } | |
1359 | ! else | |
1360 | ! { | |
1361 | ! err = GetTextServiceLanguage(&gTSLInsert); | |
1362 | ! if (err == noErr) | |
1363 | ! slptr = &gTSLInsert; | |
1364 | ! | |
1365 | ! if (slptr) | |
1366 | ! GetDefaultInputMethodOfClass(&gTSCInsert, slptr, | |
1367 | ! kKeyboardInputMethodClass); | |
1368 | ! | |
1369 | ! /* restore to default when switch to normal mode, so than we could | |
1370 | ! * enter commands easier */ | |
1371 | ! SetDefaultInputMethodOfClass(gTSCDefault, &gTSLDefault, | |
1372 | ! kKeyboardInputMethodClass); | |
1373 | ! SetTextServiceLanguage(&gTSLDefault); | |
1374 | ! | |
1375 | ! im_is_active = FALSE; | |
1376 | ! DeactivateTSMDocument(gTSMDocument); | |
1377 | ! } | |
1378 | } | |
1379 | ||
1380 | /* | |
1381 | *************** | |
1382 | *** 6060,6068 **** | |
1383 | int | |
1384 | im_get_status(void) | |
1385 | { | |
1386 | ! SInt32 script = GetScriptManagerVariable(smKeyScript); | |
1387 | ! return (script != smRoman | |
1388 | ! && script == GetScriptManagerVariable(smSysScript)) ? 1 : 0; | |
1389 | } | |
1390 | ||
1391 | #endif /* defined(USE_IM_CONTROL) || defined(PROTO) */ | |
1392 | --- 6489,6498 ---- | |
1393 | int | |
1394 | im_get_status(void) | |
1395 | { | |
1396 | ! if (! gui.in_use) | |
1397 | ! return 0; | |
1398 | ! | |
1399 | ! return im_is_active; | |
1400 | } | |
1401 | ||
1402 | #endif /* defined(USE_IM_CONTROL) || defined(PROTO) */ | |
1403 | *************** | |
1404 | *** 6118,6124 **** | |
1405 | int numTabs = 0; | |
1406 | ||
1407 | for (tp = first_tabpage; tp != NULL; tp = tp->tp_next) | |
1408 | ! ++numTabs; | |
1409 | return numTabs; | |
1410 | } | |
1411 | ||
1412 | --- 6548,6554 ---- | |
1413 | int numTabs = 0; | |
1414 | ||
1415 | for (tp = first_tabpage; tp != NULL; tp = tp->tp_next) | |
1416 | ! ++numTabs; | |
1417 | return numTabs; | |
1418 | } | |
1419 | ||
1420 | *************** | |
1421 | *** 6126,6133 **** | |
1422 | static OSStatus | |
1423 | dbItemDataCallback(ControlRef browser, | |
1424 | DataBrowserItemID itemID, | |
1425 | ! DataBrowserPropertyID property /* column id */, | |
1426 | ! DataBrowserItemDataRef itemData, | |
1427 | Boolean changeValue) | |
1428 | { | |
1429 | OSStatus status = noErr; | |
1430 | --- 6556,6563 ---- | |
1431 | static OSStatus | |
1432 | dbItemDataCallback(ControlRef browser, | |
1433 | DataBrowserItemID itemID, | |
1434 | ! DataBrowserPropertyID property /* column id */, | |
1435 | ! DataBrowserItemDataRef itemData, | |
1436 | Boolean changeValue) | |
1437 | { | |
1438 | OSStatus status = noErr; | |
1439 | *************** | |
1440 | *** 6170,6178 **** | |
1441 | static void | |
1442 | dbGetContextualMenuCallback(ControlRef browser, | |
1443 | MenuRef *menu, | |
1444 | ! UInt32 *helpType, | |
1445 | CFStringRef *helpItemString, | |
1446 | ! AEDesc *selection) | |
1447 | { | |
1448 | // on mac os 9: kCMHelpItemNoHelp, but it's not the same | |
1449 | *helpType = kCMHelpItemRemoveHelp; // OS X only ;-) | |
1450 | --- 6600,6608 ---- | |
1451 | static void | |
1452 | dbGetContextualMenuCallback(ControlRef browser, | |
1453 | MenuRef *menu, | |
1454 | ! UInt32 *helpType, | |
1455 | CFStringRef *helpItemString, | |
1456 | ! AEDesc *selection) | |
1457 | { | |
1458 | // on mac os 9: kCMHelpItemNoHelp, but it's not the same | |
1459 | *helpType = kCMHelpItemRemoveHelp; // OS X only ;-) | |
1460 | *************** | |
1461 | *** 6395,6403 **** | |
1462 | gui_mch_show_tabline(int showit) | |
1463 | { | |
1464 | if (showit == 0) | |
1465 | ! CloseDrawer(drawer, true); | |
1466 | else | |
1467 | ! OpenDrawer(drawer, kWindowEdgeRight, true); | |
1468 | } | |
1469 | ||
1470 | /* | |
1471 | --- 6825,6833 ---- | |
1472 | gui_mch_show_tabline(int showit) | |
1473 | { | |
1474 | if (showit == 0) | |
1475 | ! CloseDrawer(drawer, true); | |
1476 | else | |
1477 | ! OpenDrawer(drawer, kWindowEdgeRight, true); | |
1478 | } | |
1479 | ||
1480 | /* | |
1481 | *************** | |
1482 | *** 6425,6435 **** | |
1483 | // adjust data browser | |
1484 | if (tabLabels != NULL) | |
1485 | { | |
1486 | ! int i; | |
1487 | ||
1488 | ! for (i = 0; i < tabLabelsSize; ++i) | |
1489 | ! CFRelease(tabLabels[i]); | |
1490 | ! free(tabLabels); | |
1491 | } | |
1492 | tabLabels = (CFStringRef *)malloc(numTabs * sizeof(CFStringRef)); | |
1493 | tabLabelsSize = numTabs; | |
1494 | --- 6855,6865 ---- | |
1495 | // adjust data browser | |
1496 | if (tabLabels != NULL) | |
1497 | { | |
1498 | ! int i; | |
1499 | ||
1500 | ! for (i = 0; i < tabLabelsSize; ++i) | |
1501 | ! CFRelease(tabLabels[i]); | |
1502 | ! free(tabLabels); | |
1503 | } | |
1504 | tabLabels = (CFStringRef *)malloc(numTabs * sizeof(CFStringRef)); | |
1505 | tabLabelsSize = numTabs; | |
1506 | *************** | |
1507 | *** 6438,6444 **** | |
1508 | { | |
1509 | if (tp == curtab) | |
1510 | curtabidx = nr; | |
1511 | ! tabLabels[nr-1] = getTabLabel(tp); | |
1512 | } | |
1513 | ||
1514 | RemoveDataBrowserItems(dataBrowser, kDataBrowserNoItem, 0, NULL, | |
1515 | --- 6868,6874 ---- | |
1516 | { | |
1517 | if (tp == curtab) | |
1518 | curtabidx = nr; | |
1519 | ! tabLabels[nr-1] = getTabLabel(tp); | |
1520 | } | |
1521 | ||
1522 | RemoveDataBrowserItems(dataBrowser, kDataBrowserNoItem, 0, NULL, | |
1523 | *** ../vim-7.1.274/src/version.c Wed Mar 12 13:45:34 2008 | |
1524 | --- src/version.c Wed Mar 12 14:31:37 2008 | |
1525 | *************** | |
1526 | *** 668,669 **** | |
1527 | --- 668,671 ---- | |
1528 | { /* Add new patch number below this line */ | |
1529 | + /**/ | |
1530 | + 275, | |
1531 | /**/ | |
1532 | ||
1533 | -- | |
1534 | hundred-and-one symptoms of being an internet addict: | |
1535 | 115. You are late picking up your kid from school and try to explain | |
1536 | to the teacher you were stuck in Web traffic. | |
1537 | ||
1538 | /// Bram Moolenaar -- Bram@Moolenaar.net -- http://www.Moolenaar.net \\\ | |
1539 | /// sponsor Vim, vote for features -- http://www.Vim.org/sponsor/ \\\ | |
1540 | \\\ download, build and distribute -- http://www.A-A-P.org /// | |
1541 | \\\ help me help AIDS victims -- http://ICCF-Holland.org /// |