src/MacVim/MMTextViewHelper.m

   1 /* vi:set ts=8 sts=4 sw=4 ft=objc:
   2  *
   3  * VIM - Vi IMproved            by Bram Moolenaar
   4  *                              MacVim GUI port by Bjorn Winckler
   5  *
   6  * Do ":help uganda"  in Vim to read copying and usage conditions.
   7  * Do ":help credits" in Vim to see a list of people who contributed.
   8  * See README.txt for an overview of the Vim source code.
   9  */
  10 /*
  11  * MMTextViewHelper
  12  *
  13  * Contains code shared between the different text renderers.  Unfortunately it
  14  * is not possible to let the text renderers inherit from this class since
  15  * MMTextView needs to inherit from NSTextView whereas MMAtsuiTextView needs to
  16  * inherit from NSView.
  17  */
  18
  19 #import "MMTextView.h"
  20 #import "MMTextViewHelper.h"
  21 #import "MMVimController.h"
  22 #import "MMWindowController.h"
  23 #import "Miscellaneous.h"
  24
  25
  26 // The max/min drag timer interval in seconds
  27 static NSTimeInterval MMDragTimerMaxInterval = 0.3;
  28 static NSTimeInterval MMDragTimerMinInterval = 0.01;
  29
  30 // The number of pixels in which the drag timer interval changes
  31 static float MMDragAreaSize = 73.0f;
  32
  33
  34 @interface MMTextViewHelper (Private)
  35 - (MMWindowController *)windowController;
  36 - (MMVimController *)vimController;
  37 - (void)doKeyDown:(NSString *)key;
  38 - (void)doInsertText:(NSString *)text;
  39 - (void)checkImState;
  40 - (void)hideMouseCursor;
  41 - (void)startDragTimerWithInterval:(NSTimeInterval)t;
  42 - (void)dragTimerFired:(NSTimer *)timer;
  43 - (void)setCursor;
  44 - (NSRect)trackingRect;
  45 - (BOOL)inputManagerHandleMouseEvent:(NSEvent *)event;
  46 - (void)sendMarkedText:(NSString *)text position:(unsigned)pos;
  47 @end
  48
  49
  50
  51
  52 #if (MAC_OS_X_VERSION_MAX_ALLOWED > MAC_OS_X_VERSION_10_4)
  53     static BOOL
  54 KeyboardInputSourcesEqual(TISInputSourceRef a, TISInputSourceRef b)
  55 {
  56     // Define two sources to be equal iff both are non-NULL and they have
  57     // identical source ID strings.
  58
  59     if (!(a && b))
  60         return NO;
  61
  62     NSString *as = TISGetInputSourceProperty(a, kTISPropertyInputSourceID);
  63     NSString *bs = TISGetInputSourceProperty(b, kTISPropertyInputSourceID);
  64
  65     return [as isEqualToString:bs];
  66 }
  67 #endif
  68
  69
  70 @implementation MMTextViewHelper
  71
  72 - (void)dealloc
  73 {
  74     ASLogDebug(@"");
  75
  76     [insertionPointColor release];  insertionPointColor = nil;
  77     [markedText release];  markedText = nil;
  78     [markedTextAttributes release];  markedTextAttributes = nil;
  79
  80 #if (MAC_OS_X_VERSION_MAX_ALLOWED > MAC_OS_X_VERSION_10_4)
  81     if (asciiImSource) {
  82         CFRelease(asciiImSource);
  83         asciiImSource = NULL;
  84     }
  85     if (lastImSource) {
  86         CFRelease(lastImSource);
  87         lastImSource = NULL;
  88     }
  89 #endif
  90
  91     [super dealloc];
  92 }
  93
  94 - (void)setTextView:(id)view
  95 {
  96     // Only keep a weak reference to owning text view.
  97     textView = view;
  98 }
  99
 100 - (void)setInsertionPointColor:(NSColor *)color
 101 {
 102     if (color != insertionPointColor) {
 103         [insertionPointColor release];
 104         insertionPointColor = [color retain];
 105     }
 106 }
 107
 108 - (NSColor *)insertionPointColor
 109 {
 110     return insertionPointColor;
 111 }
 112
 113 - (void)keyDown:(NSEvent *)event
 114 {
 115     ASLogDebug(@"%@", event);
 116
 117     // NOTE: Keyboard handling is complicated by the fact that we must call
 118     // interpretKeyEvents: otherwise key equivalents set up by input methods do
 119     // not work (e.g. Ctrl-Shift-; would not work under Kotoeri).
 120
 121     // NOTE: insertText: and doCommandBySelector: may need to extract data from
 122     // the key down event so keep a local reference to the event.  This is
 123     // released and set to nil at the end of this method.  Don't make any early
 124     // returns from this method without releasing and resetting this reference!
 125     currentEvent = [event retain];
 126
 127     if ([self hasMarkedText]) {
 128         // HACK! Need to redisplay manually otherwise the marked text may not
 129         // be correctly displayed (e.g. it is still visible after pressing Esc
 130         // even though the text has been unmarked).
 131         [textView setNeedsDisplay:YES];
 132     }
 133
 134     [self hideMouseCursor];
 135
 136     unsigned flags = [event modifierFlags];
 137     id mmta = [[[self vimController] vimState] objectForKey:@"p_mmta"];
 138     NSString *string = [event characters];
 139     NSString *unmod  = [event charactersIgnoringModifiers];
 140
 141     // Alt key presses should not be interpreted if the 'macmeta' option is
 142     // set.  We still have to call interpretKeyEvents: for keys
 143     // like Enter, Esc, etc. to work as usual so only skip interpretation for
 144     // ASCII chars in the range after space (0x20) and before backspace (0x7f).
 145     // Note that this implies that 'mmta' (if enabled) breaks input methods
 146     // when the Alt key is held.
 147     if ((flags & NSAlternateKeyMask) && [mmta boolValue] && [unmod length] == 1
 148             && [unmod characterAtIndex:0] > 0x20
 149             && [unmod characterAtIndex:0] < 0x7f) {
 150         ASLogDebug(@"MACMETA key, don't interpret it");
 151         string = unmod;
 152     } else {
 153         // HACK!  interpretKeyEvents: may call insertText: or
 154         // doCommandBySelector:, or it may swallow the key (most likely the
 155         // current input method used it).  In the first two cases we have to
 156         // manually set the below flag to NO if the key wasn't handled.
 157         interpretKeyEventsSwallowedKey = YES;
 158         [textView interpretKeyEvents:[NSArray arrayWithObject:event]];
 159         if (interpretKeyEventsSwallowedKey)
 160             string = nil;
 161         else if (flags & NSCommandKeyMask) {
 162             // HACK! When Command is held we have to more or less guess whether
 163             // we should use characters or charactersIgnoringModifiers.  The
 164             // following heuristic seems to work but it may have to change.
 165             // Note that the Shift and Alt flags may be cleared before passing
 166             // the event on to Vim (see doKeyDown:).
 167             if ((flags & NSShiftKeyMask && !(flags & NSAlternateKeyMask))
 168                     || flags & NSControlKeyMask)
 169                 string = unmod;
 170         }
 171     }
 172
 173     if (string)
 174         [self doKeyDown:string];
 175
 176     // NOTE: Check IM state _after_ key has been interpreted or we'll pick up
 177     // the old IM state when it has been switched via a keyboard shortcut.
 178     if (imControl)
 179         [self checkImState];
 180
 181     [currentEvent release];
 182     currentEvent = nil;
 183 }
 184
 185 - (void)insertText:(id)string
 186 {
 187     if ([self hasMarkedText]) {
 188         [self sendMarkedText:nil position:0];
 189
 190         // NOTE: If this call is left out then the marked text isn't properly
 191         // erased when Return is used to accept the text.
 192         // The input manager only ever sets new marked text, it never actually
 193         // calls to have it unmarked.  It seems that whenever insertText: is
 194         // called the input manager expects the marked text to be unmarked
 195         // automatically, hence the explicit unmarkText: call here.
 196         [self unmarkText];
 197     }
 198
 199     // NOTE: 'string' is either an NSString or an NSAttributedString.  Since we
 200     // do not support attributes, simply pass the corresponding NSString in the
 201     // latter case.
 202     if ([string isKindOfClass:[NSAttributedString class]])
 203         string = [string string];
 204
 205     //int len = [string length];
 206     //ASLogDebug(@"len=%d char[0]=%#x char[1]=%#x string='%@'", [string length],
 207     //        [string characterAtIndex:0],
 208     //        len > 1 ? [string characterAtIndex:1] : 0, string);
 209
 210     [self doInsertText:string];
 211 }
 212
 213 - (void)doCommandBySelector:(SEL)sel
 214 {
 215     ASLogDebug(@"%@", NSStringFromSelector(sel));
 216
 217     // Translate Ctrl-2 -> Ctrl-@ (see also Resources/KeyBinding.plist)
 218     if (@selector(keyCtrlAt:) == sel)
 219         [self doKeyDown:@"\x00"];
 220     // Translate Ctrl-6 -> Ctrl-^ (see also Resources/KeyBinding.plist)
 221     else if (@selector(keyCtrlHat:) == sel)
 222         [self doKeyDown:@"\x1e"];
 223     //
 224     // Check for selectors from AppKit.framework/StandardKeyBinding.dict and
 225     // send the corresponding key directly on to the backend.  The reason for
 226     // not just letting all of these fall through is that -[NSEvent characters]
 227     // sometimes includes marked text as well as the actual key, but the marked
 228     // text is also passed to insertText:.  For example, pressing Ctrl-i Return
 229     // on a US keyboard would call insertText:@"^" but the key event for the
 230     // Return press will contain "^\x0d" -- if we fell through the result would
 231     // be that "^^\x0d" got sent to the backend (i.e. one extra "^" would
 232     // appear).
 233     // For this reason we also have to make sure that there are key bindings to
 234     // all combinations of modifier with certain keys (these are set up in
 235     // KeyBinding.plist in the Resources folder).
 236     else if (@selector(insertTab:) == sel ||
 237              @selector(selectNextKeyView:) == sel ||
 238              @selector(insertTabIgnoringFieldEditor:) == sel)
 239         [self doKeyDown:@"\x09"];
 240     else if (@selector(insertNewline:) == sel ||
 241              @selector(insertLineBreak:) == sel ||
 242              @selector(insertNewlineIgnoringFieldEditor:) == sel)
 243         [self doKeyDown:@"\x0d"];
 244     else if (@selector(cancelOperation:) == sel ||
 245              @selector(complete:) == sel)
 246         [self doKeyDown:@"\x1b"];
 247     else if (@selector(insertBackTab:) == sel ||
 248              @selector(selectPreviousKeyView:) == sel)
 249         [self doKeyDown:@"\x19"];
 250     else if (@selector(deleteBackward:) == sel ||
 251              @selector(deleteWordBackward:) == sel ||
 252              @selector(deleteBackwardByDecomposingPreviousCharacter:) == sel ||
 253              @selector(deleteToBeginningOfLine:) == sel)
 254         [self doKeyDown:@"\x08"];
 255     else if (@selector(keySpace:) == sel)
 256         [self doKeyDown:@" "];
 257     else if (@selector(cancel:) == sel)
 258         kill([[self vimController] pid], SIGINT);
 259     else interpretKeyEventsSwallowedKey = NO;
 260 }
 261
 262 - (BOOL)performKeyEquivalent:(NSEvent *)event
 263 {
 264     ASLogDebug(@"");
 265     if ([event type] != NSKeyDown)
 266         return NO;
 267
 268     // NOTE: Key equivalent handling was fixed in Leopard.  That is, an
 269     // unhandled key equivalent is passed to keyDown: -- contrast this with
 270     // pre-Leopard where unhandled key equivalents would simply disappear
 271     // (hence the ugly hack below for Tiger).
 272     if (floor(NSAppKitVersionNumber) > NSAppKitVersionNumber10_4)
 273         return NO;
 274
 275     // HACK! KeyCode 50 represent the key which switches between windows
 276     // within an application (like Cmd+Tab is used to switch between
 277     // applications).  Return NO here, else the window switching does not work.
 278     if ([event keyCode] == 50)
 279         return NO;
 280
 281     // HACK! The -[NSRespoder cancelOperation:] indicates that Cmd-. is handled
 282     // in a special way by the key window.  Indeed, if we pass this event on to
 283     // keyDown: it will result in doCommandBySelector: being called with
 284     // cancelOperation: as selector, otherwise it is called with cancel: as the
 285     // selector (and we respond to cancel: there).
 286     int flags = [event modifierFlags] & NSDeviceIndependentModifierFlagsMask;
 287     NSString *unmod = [event charactersIgnoringModifiers];
 288     if (flags == NSCommandKeyMask && [unmod isEqual:@"."])
 289         return NO;
 290
 291     // HACK! Let the main menu try to handle any key down event, before
 292     // passing it on to vim, otherwise key equivalents for menus will
 293     // effectively be disabled.
 294     if ([[NSApp mainMenu] performKeyEquivalent:event])
 295         return YES;
 296
 297     // HACK! Pass the event on or it may disappear (Tiger does not pass Cmd-key
 298     // events to keyDown:).
 299     [self keyDown:event];
 300     return YES;
 301 }
 302
 303 - (void)scrollWheel:(NSEvent *)event
 304 {
 305     if ([self hasMarkedText]) {
 306         // We must clear the marked text since the cursor may move if the
 307         // marked text moves outside the view as a result of scrolling.
 308         [self sendMarkedText:nil position:0];
 309         [self unmarkText];
 310         [[NSInputManager currentInputManager] markedTextAbandoned:self];
 311     }
 312
 313     if ([event deltaY] == 0)
 314         return;
 315
 316     int row, col;
 317     NSPoint pt = [textView convertPoint:[event locationInWindow] fromView:nil];
 318     if ([textView convertPoint:pt toRow:&row column:&col]) {
 319         int flags = [event modifierFlags];
 320         float dy = [event deltaY];
 321         NSMutableData *data = [NSMutableData data];
 322
 323         [data appendBytes:&row length:sizeof(int)];
 324         [data appendBytes:&col length:sizeof(int)];
 325         [data appendBytes:&flags length:sizeof(int)];
 326         [data appendBytes:&dy length:sizeof(float)];
 327
 328         [[self vimController] sendMessage:ScrollWheelMsgID data:data];
 329     }
 330 }
 331
 332 - (void)mouseDown:(NSEvent *)event
 333 {
 334     if ([self inputManagerHandleMouseEvent:event])
 335         return;
 336
 337     int row, col;
 338     NSPoint pt = [textView convertPoint:[event locationInWindow] fromView:nil];
 339     if (![textView convertPoint:pt toRow:&row column:&col])
 340         return;
 341
 342     int button = [event buttonNumber];
 343     int flags = [event modifierFlags];
 344     int count = [event clickCount];
 345     NSMutableData *data = [NSMutableData data];
 346
 347     // If desired, intepret Ctrl-Click as a right mouse click.
 348     BOOL translateCtrlClick = [[NSUserDefaults standardUserDefaults]
 349             boolForKey:MMTranslateCtrlClickKey];
 350     flags = flags & NSDeviceIndependentModifierFlagsMask;
 351     if (translateCtrlClick && button == 0 &&
 352             (flags == NSControlKeyMask ||
 353              flags == (NSControlKeyMask|NSAlphaShiftKeyMask))) {
 354         button = 1;
 355         flags &= ~NSControlKeyMask;
 356     }
 357
 358     [data appendBytes:&row length:sizeof(int)];
 359     [data appendBytes:&col length:sizeof(int)];
 360     [data appendBytes:&button length:sizeof(int)];
 361     [data appendBytes:&flags length:sizeof(int)];
 362     [data appendBytes:&count length:sizeof(int)];
 363
 364     [[self vimController] sendMessage:MouseDownMsgID data:data];
 365 }
 366
 367 - (void)mouseUp:(NSEvent *)event
 368 {
 369     if ([self inputManagerHandleMouseEvent:event])
 370         return;
 371
 372     int row, col;
 373     NSPoint pt = [textView convertPoint:[event locationInWindow] fromView:nil];
 374     if (![textView convertPoint:pt toRow:&row column:&col])
 375         return;
 376
 377     int flags = [event modifierFlags];
 378     NSMutableData *data = [NSMutableData data];
 379
 380     [data appendBytes:&row length:sizeof(int)];
 381     [data appendBytes:&col length:sizeof(int)];
 382     [data appendBytes:&flags length:sizeof(int)];
 383
 384     [[self vimController] sendMessage:MouseUpMsgID data:data];
 385
 386     isDragging = NO;
 387 }
 388
 389 - (void)mouseDragged:(NSEvent *)event
 390 {
 391     if ([self inputManagerHandleMouseEvent:event])
 392         return;
 393
 394     int flags = [event modifierFlags];
 395     int row, col;
 396     NSPoint pt = [textView convertPoint:[event locationInWindow] fromView:nil];
 397     if (![textView convertPoint:pt toRow:&row column:&col])
 398         return;
 399
 400     // Autoscrolling is done in dragTimerFired:
 401     if (!isAutoscrolling) {
 402         NSMutableData *data = [NSMutableData data];
 403
 404         [data appendBytes:&row length:sizeof(int)];
 405         [data appendBytes:&col length:sizeof(int)];
 406         [data appendBytes:&flags length:sizeof(int)];
 407
 408         [[self vimController] sendMessage:MouseDraggedMsgID data:data];
 409     }
 410
 411     dragPoint = pt;
 412     dragRow = row;
 413     dragColumn = col;
 414     dragFlags = flags;
 415
 416     if (!isDragging) {
 417         [self startDragTimerWithInterval:.5];
 418         isDragging = YES;
 419     }
 420 }
 421
 422 - (void)mouseMoved:(NSEvent *)event
 423 {
 424     if ([self inputManagerHandleMouseEvent:event])
 425         return;
 426
 427     // HACK! NSTextView has a nasty habit of resetting the cursor to the
 428     // default I-beam cursor at random moments.  The only reliable way we know
 429     // of to work around this is to set the cursor each time the mouse moves.
 430     [self setCursor];
 431
 432     NSPoint pt = [textView convertPoint:[event locationInWindow] fromView:nil];
 433     int row, col;
 434     if (![textView convertPoint:pt toRow:&row column:&col])
 435         return;
 436
 437     // HACK! It seems impossible to get the tracking rects set up before the
 438     // view is visible, which means that the first mouseEntered: or
 439     // mouseExited: events are never received.  This forces us to check if the
 440     // mouseMoved: event really happened over the text.
 441     int rows, cols;
 442     [textView getMaxRows:&rows columns:&cols];
 443     if (row >= 0 && row < rows && col >= 0 && col < cols) {
 444         NSMutableData *data = [NSMutableData data];
 445
 446         [data appendBytes:&row length:sizeof(int)];
 447         [data appendBytes:&col length:sizeof(int)];
 448
 449         [[self vimController] sendMessage:MouseMovedMsgID data:data];
 450     }
 451 }
 452
 453 - (void)mouseEntered:(NSEvent *)event
 454 {
 455     // NOTE: This event is received even when the window is not key; thus we
 456     // have to take care not to enable mouse moved events unless our window is
 457     // key.
 458     if ([[textView window] isKeyWindow]) {
 459         [[textView window] setAcceptsMouseMovedEvents:YES];
 460     }
 461 }
 462
 463 - (void)mouseExited:(NSEvent *)event
 464 {
 465     [[textView window] setAcceptsMouseMovedEvents:NO];
 466
 467     // NOTE: This event is received even when the window is not key; if the
 468     // mouse shape is set when our window is not key, the hollow (unfocused)
 469     // cursor will become a block (focused) cursor.
 470     if ([[textView window] isKeyWindow]) {
 471         int shape = 0;
 472         NSMutableData *data = [NSMutableData data];
 473         [data appendBytes:&shape length:sizeof(int)];
 474         [[self vimController] sendMessage:SetMouseShapeMsgID data:data];
 475     }
 476 }
 477
 478 - (void)setFrame:(NSRect)frame
 479 {
 480     // When the frame changes we also need to update the tracking rect.
 481     [textView removeTrackingRect:trackingRectTag];
 482     trackingRectTag = [textView addTrackingRect:[self trackingRect]
 483                                           owner:textView
 484                                        userData:NULL
 485                                    assumeInside:YES];
 486 }
 487
 488 - (void)viewDidMoveToWindow
 489 {
 490     // Set a tracking rect which covers the text.
 491     // NOTE: While the mouse cursor is in this rect the view will receive
 492     // 'mouseMoved:' events so that Vim can take care of updating the mouse
 493     // cursor.
 494     if ([textView window]) {
 495         [[textView window] setAcceptsMouseMovedEvents:YES];
 496         trackingRectTag = [textView addTrackingRect:[self trackingRect]
 497                                               owner:textView
 498                                            userData:NULL
 499                                        assumeInside:YES];
 500     }
 501 }
 502
 503 - (void)viewWillMoveToWindow:(NSWindow *)newWindow
 504 {
 505     // Remove tracking rect if view moves or is removed.
 506     if ([textView window] && trackingRectTag) {
 507         [textView removeTrackingRect:trackingRectTag];
 508         trackingRectTag = 0;
 509     }
 510 }
 511
 512 - (BOOL)performDragOperation:(id <NSDraggingInfo>)sender
 513 {
 514     NSPasteboard *pboard = [sender draggingPasteboard];
 515
 516     if ([[pboard types] containsObject:NSStringPboardType]) {
 517         NSString *string = [pboard stringForType:NSStringPboardType];
 518         [[self vimController] dropString:string];
 519         return YES;
 520     } else if ([[pboard types] containsObject:NSFilenamesPboardType]) {
 521         NSArray *files = [pboard propertyListForType:NSFilenamesPboardType];
 522         [[self vimController] dropFiles:files forceOpen:NO];
 523         return YES;
 524     }
 525
 526     return NO;
 527 }
 528
 529 - (NSDragOperation)draggingEntered:(id <NSDraggingInfo>)sender
 530 {
 531     NSDragOperation sourceDragMask = [sender draggingSourceOperationMask];
 532     NSPasteboard *pboard = [sender draggingPasteboard];
 533
 534     if ( [[pboard types] containsObject:NSFilenamesPboardType]
 535             && (sourceDragMask & NSDragOperationCopy) )
 536         return NSDragOperationCopy;
 537     if ( [[pboard types] containsObject:NSStringPboardType]
 538             && (sourceDragMask & NSDragOperationCopy) )
 539         return NSDragOperationCopy;
 540
 541     return NSDragOperationNone;
 542 }
 543
 544 - (NSDragOperation)draggingUpdated:(id <NSDraggingInfo>)sender
 545 {
 546     NSDragOperation sourceDragMask = [sender draggingSourceOperationMask];
 547     NSPasteboard *pboard = [sender draggingPasteboard];
 548
 549     if ( [[pboard types] containsObject:NSFilenamesPboardType]
 550             && (sourceDragMask & NSDragOperationCopy) )
 551         return NSDragOperationCopy;
 552     if ( [[pboard types] containsObject:NSStringPboardType]
 553             && (sourceDragMask & NSDragOperationCopy) )
 554         return NSDragOperationCopy;
 555
 556     return NSDragOperationNone;
 557 }
 558
 559 - (void)setMouseShape:(int)shape
 560 {
 561     mouseShape = shape;
 562     [self setCursor];
 563 }
 564
 565 - (void)changeFont:(id)sender
 566 {
 567     NSFont *newFont = [sender convertFont:[textView font]];
 568     NSFont *newFontWide = [sender convertFont:[textView fontWide]];
 569
 570     if (newFont) {
 571         NSString *name = [newFont displayName];
 572         NSString *wideName = [newFontWide displayName];
 573         unsigned len = [name lengthOfBytesUsingEncoding:NSUTF8StringEncoding];
 574         unsigned wideLen = [wideName lengthOfBytesUsingEncoding:
 575                                                         NSUTF8StringEncoding];
 576         if (len > 0) {
 577             NSMutableData *data = [NSMutableData data];
 578             float pointSize = [newFont pointSize];
 579
 580             [data appendBytes:&pointSize length:sizeof(float)];
 581
 582             ++len;  // include NUL byte
 583             [data appendBytes:&len length:sizeof(unsigned)];
 584             [data appendBytes:[name UTF8String] length:len];
 585
 586             if (wideLen > 0) {
 587                 ++wideLen;  // include NUL byte
 588                 [data appendBytes:&wideLen length:sizeof(unsigned)];
 589                 [data appendBytes:[wideName UTF8String] length:wideLen];
 590             } else {
 591                 [data appendBytes:&wideLen length:sizeof(unsigned)];
 592             }
 593
 594             [[self vimController] sendMessage:SetFontMsgID data:data];
 595         }
 596     }
 597 }
 598
 599 - (BOOL)hasMarkedText
 600 {
 601     return markedRange.length > 0 ? YES : NO;
 602 }
 603
 604 - (NSRange)markedRange
 605 {
 606     if ([self hasMarkedText])
 607         return markedRange;
 608     else
 609         return NSMakeRange(NSNotFound, 0);
 610 }
 611
 612 - (NSDictionary *)markedTextAttributes
 613 {
 614     return markedTextAttributes;
 615 }
 616
 617 - (void)setMarkedTextAttributes:(NSDictionary *)attr
 618 {
 619     ASLogDebug(@"%@", attr);
 620     if (attr != markedTextAttributes) {
 621         [markedTextAttributes release];
 622         markedTextAttributes = [attr retain];
 623     }
 624 }
 625
 626 - (void)setMarkedText:(id)text selectedRange:(NSRange)range
 627 {
 628     ASLogDebug(@"text='%@' range=%@", text, NSStringFromRange(range));
 629     [self unmarkText];
 630
 631     if ([self useInlineIm]) {
 632         if ([text isKindOfClass:[NSAttributedString class]])
 633             text = [text string];
 634
 635         if ([text length] > 0) {
 636             markedRange = NSMakeRange(0, [text length]);
 637             imRange = range;
 638         }
 639
 640         [self sendMarkedText:text position:range.location];
 641         return;
 642     }
 643
 644 #ifdef INCLUDE_OLD_IM_CODE
 645     if (!(text && [text length] > 0))
 646         return;
 647
 648     // HACK! Determine if the marked text is wide or normal width.  This seems
 649     // to always use 'wide' when there are both wide and normal width
 650     // characters.
 651     NSString *string = text;
 652     NSFont *theFont = [textView font];
 653     if ([text isKindOfClass:[NSAttributedString class]]) {
 654         theFont = [textView fontWide];
 655         string = [text string];
 656     }
 657
 658     // TODO: Use special colors for marked text.
 659     [self setMarkedTextAttributes:
 660         [NSDictionary dictionaryWithObjectsAndKeys:
 661             theFont, NSFontAttributeName,
 662             [textView defaultBackgroundColor], NSBackgroundColorAttributeName,
 663             [textView defaultForegroundColor], NSForegroundColorAttributeName,
 664             nil]];
 665
 666     markedText = [[NSMutableAttributedString alloc]
 667            initWithString:string
 668                attributes:[self markedTextAttributes]];
 669
 670     markedRange = NSMakeRange(0, [markedText length]);
 671     if (markedRange.length) {
 672         [markedText addAttribute:NSUnderlineStyleAttributeName
 673                            value:[NSNumber numberWithInt:1]
 674                            range:markedRange];
 675     }
 676     imRange = range;
 677     if (range.length) {
 678         [markedText addAttribute:NSUnderlineStyleAttributeName
 679                            value:[NSNumber numberWithInt:2]
 680                            range:range];
 681     }
 682
 683     [textView setNeedsDisplay:YES];
 684 #endif // INCLUDE_OLD_IM_CODE
 685 }
 686
 687 - (void)unmarkText
 688 {
 689     ASLogDebug(@"");
 690     imRange = NSMakeRange(0, 0);
 691     markedRange = NSMakeRange(NSNotFound, 0);
 692     [markedText release];
 693     markedText = nil;
 694 }
 695
 696 - (NSMutableAttributedString *)markedText
 697 {
 698     return markedText;
 699 }
 700
 701 - (void)setPreEditRow:(int)row column:(int)col
 702 {
 703     preEditRow = row;
 704     preEditColumn = col;
 705 }
 706
 707 - (int)preEditRow
 708 {
 709     return preEditRow;
 710 }
 711
 712 - (int)preEditColumn
 713 {
 714     return preEditColumn;
 715 }
 716
 717 - (void)setImRange:(NSRange)range
 718 {
 719     imRange = range;
 720 }
 721
 722 - (NSRange)imRange
 723 {
 724     return imRange;
 725 }
 726
 727 - (void)setMarkedRange:(NSRange)range
 728 {
 729     markedRange = range;
 730 }
 731
 732 - (NSRect)firstRectForCharacterRange:(NSRange)range
 733 {
 734     // This method is called when the input manager wants to pop up an
 735     // auxiliary window.  The position where this should be is controlled by
 736     // Vim by sending SetPreEditPositionMsgID so compute a position based on
 737     // the pre-edit (row,column) pair.
 738     int col = preEditColumn;
 739     int row = preEditRow + 1;
 740
 741     NSFont *theFont = [[textView markedTextAttributes]
 742             valueForKey:NSFontAttributeName];
 743     if (theFont == [textView fontWide]) {
 744         col += imRange.location * 2;
 745         if (col >= [textView maxColumns] - 1) {
 746             row += (col / [textView maxColumns]);
 747             col = col % 2 ? col % [textView maxColumns] + 1 :
 748                             col % [textView maxColumns];
 749         }
 750     } else {
 751         col += imRange.location;
 752         if (col >= [textView maxColumns]) {
 753             row += (col / [textView maxColumns]);
 754             col = col % [textView maxColumns];
 755         }
 756     }
 757
 758     NSRect rect = [textView rectForRow:row
 759                                 column:col
 760                                numRows:1
 761                             numColumns:range.length];
 762
 763     rect.origin = [textView convertPoint:rect.origin toView:nil];
 764     rect.origin = [[textView window] convertBaseToScreen:rect.origin];
 765
 766     return rect;
 767 }
 768
 769 - (void)setImControl:(BOOL)enable
 770 {
 771     // This flag corresponds to the (negation of the) 'imd' option.  When
 772     // enabled changes to the input method are detected and forwarded to the
 773     // backend.  On >=10.5 and later we do not forward changes to the input
 774     // method, instead we let Vim be in complete control.
 775
 776 #if (MAC_OS_X_VERSION_MAX_ALLOWED > MAC_OS_X_VERSION_10_4)
 777     // The TIS symbols are weakly linked.
 778     if (NULL != TISCopyCurrentKeyboardInputSource) {
 779         // We get here when compiled on =>10.5 and running on >=10.5.
 780
 781         if (asciiImSource) {
 782             CFRelease(asciiImSource);
 783             asciiImSource = NULL;
 784         }
 785         if (lastImSource) {
 786             CFRelease(lastImSource);
 787             lastImSource = NULL;
 788         }
 789         if (enable) {
 790             // Save current input source for use when IM is active and get an
 791             // ASCII source for use when IM is deactivated (by Vim).
 792             asciiImSource = TISCopyCurrentASCIICapableKeyboardInputSource();
 793             lastImSource = TISCopyCurrentKeyboardInputSource();
 794         }
 795     }
 796 #endif
 797
 798     // The imControl flag is only used on 10.4 -- on >=10.5 we wait for Vim to
 799     // call activateIm: and never explicitly check if the input source changes.
 800     imControl = enable;
 801     ASLogInfo(@"IM control %sabled", enable ? "en" : "dis");
 802 }
 803
 804 - (void)activateIm:(BOOL)enable
 805 {
 806     ASLogInfo(@"Activate IM=%d", enable);
 807
 808 #if (MAC_OS_X_VERSION_MAX_ALLOWED > MAC_OS_X_VERSION_10_4)
 809     // The TIS symbols are weakly linked.
 810     if (NULL != TISCopyCurrentKeyboardInputSource) {
 811         // We get here when compiled on >=10.5 and running on >=10.5.
 812
 813         TISInputSourceRef ref = NULL;
 814         if (enable) {
 815             // Enable IM: switch back to input source used when IM was last on.
 816             ref = lastImSource;
 817         } else {
 818             // Disable IM: switch back to ASCII input source that was used when
 819             // IM was last off.
 820             ref = asciiImSource;
 821
 822             TISInputSourceRef cur = TISCopyCurrentKeyboardInputSource();
 823             if (!KeyboardInputSourcesEqual(asciiImSource, cur)) {
 824                 // Remember current input source so we can switch back to it
 825                 // when IM is once more enabled.  Note that Vim will call this
 826                 // method with "enable=NO" even when the ASCII input source is
 827                 // in use which is why we only remember the current input
 828                 // source unless it is the ASCII source.
 829                 ASLogDebug(@"Remember last input source: %@",
 830                     TISGetInputSourceProperty(cur, kTISPropertyInputSourceID));
 831                 if (lastImSource) CFRelease(lastImSource);
 832                 lastImSource = cur;
 833             } else {
 834                 CFRelease(cur);
 835                 cur = NULL;
 836             }
 837         }
 838
 839         if (ref) {
 840             ASLogDebug(@"Change input source: %@",
 841                     TISGetInputSourceProperty(ref, kTISPropertyInputSourceID));
 842             TISSelectInputSource(ref);
 843         }
 844
 845         return;
 846     }
 847
 848     // We get here when compiled on >=10.5 but running on 10.4 -- fall through
 849     // and use old IM code...
 850 #endif
 851 #if (MAC_OS_X_VERSION_MIN_REQUIRED <= MAC_OS_X_VERSION_10_4)
 852     // NOTE: The IM code is delegated to the frontend since calling it in
 853     // the backend caused weird bugs (second dock icon appearing etc.).
 854     KeyScript(enable ? smKeySysScript : smKeyRoman);
 855 #endif
 856 }
 857
 858 - (BOOL)useInlineIm
 859 {
 860 #ifdef INCLUDE_OLD_IM_CODE
 861     NSUserDefaults *ud = [NSUserDefaults standardUserDefaults];
 862     return [ud boolForKey:MMUseInlineImKey];
 863 #else
 864     return YES;
 865 #endif // INCLUDE_OLD_IM_CODE
 866 }
 867
 868 @end // MMTextViewHelper
 869
 870
 871
 872
 873 @implementation MMTextViewHelper (Private)
 874
 875 - (MMWindowController *)windowController
 876 {
 877     id windowController = [[textView window] windowController];
 878     if ([windowController isKindOfClass:[MMWindowController class]])
 879         return (MMWindowController*)windowController;
 880     return nil;
 881 }
 882
 883 - (MMVimController *)vimController
 884 {
 885     return [[self windowController] vimController];
 886 }
 887
 888 - (void)doKeyDown:(NSString *)key
 889 {
 890     if (!currentEvent) {
 891         ASLogDebug(@"No current event; ignore key");
 892         return;
 893     }
 894
 895     const char *chars = [key UTF8String];
 896     unsigned length = [key lengthOfBytesUsingEncoding:NSUTF8StringEncoding];
 897     unsigned keyCode = [currentEvent keyCode];
 898     unsigned flags = [currentEvent modifierFlags];
 899
 900     if (flags & NSCommandKeyMask) {
 901         // The Shift flag is already included in the key when the Command key
 902         // is held.  The same goes for Alt, unless Ctrl is held or 'macmeta' is
 903         // set.
 904         flags &= ~NSShiftKeyMask;
 905         if (!(flags & NSControlKeyMask)) {
 906             id mmta = [[[self vimController] vimState] objectForKey:@"p_mmta"];
 907             if (![mmta boolValue])
 908                 flags &= ~NSAlternateKeyMask;
 909         }
 910     }
 911
 912     // The low 16 bits are not used for modifier flags by NSEvent.  Use
 913     // these bits for custom flags.
 914     flags &= NSDeviceIndependentModifierFlagsMask;
 915     if ([currentEvent isARepeat])
 916         flags |= 1;
 917
 918     NSMutableData *data = [NSMutableData data];
 919     [data appendBytes:&flags length:sizeof(unsigned)];
 920     [data appendBytes:&keyCode length:sizeof(unsigned)];
 921     [data appendBytes:&length length:sizeof(unsigned)];
 922     if (length > 0)
 923         [data appendBytes:chars length:length];
 924
 925     [[self vimController] sendMessage:KeyDownMsgID data:data];
 926 }
 927
 928 - (void)doInsertText:(NSString *)text
 929 {
 930     unsigned length = [text lengthOfBytesUsingEncoding:NSUTF8StringEncoding];
 931     if (0 == length)
 932         return;
 933
 934     const char *chars = [text UTF8String];
 935     unsigned keyCode = 0;
 936     unsigned flags = 0;
 937
 938     // HACK! insertText: can be called from outside a keyDown: event in which
 939     // case currentEvent is nil.  This happens e.g. when the "Special
 940     // Characters" palette is used to insert text.  In this situation we assume
 941     // that the key is not a repeat (if there was a palette that did auto
 942     // repeat of input we might have to rethink this).
 943     if (currentEvent) {
 944         // HACK! Keys on the numeric key pad are treated as special keys by Vim
 945         // so we need to pass on key code and modifier flags in this situation.
 946         unsigned mods = [currentEvent modifierFlags];
 947         if (mods & NSNumericPadKeyMask) {
 948             flags = mods & NSDeviceIndependentModifierFlagsMask;
 949             keyCode = [currentEvent keyCode];
 950         }
 951
 952         if ([currentEvent isARepeat])
 953             flags |= 1;
 954     }
 955
 956     NSMutableData *data = [NSMutableData data];
 957     [data appendBytes:&flags length:sizeof(unsigned)];
 958     [data appendBytes:&keyCode length:sizeof(unsigned)];
 959     [data appendBytes:&length length:sizeof(unsigned)];
 960     [data appendBytes:chars length:length];
 961
 962     [[self vimController] sendMessage:KeyDownMsgID data:data];
 963 }
 964
 965 - (void)checkImState
 966 {
 967 #if (MAC_OS_X_VERSION_MIN_REQUIRED <= MAC_OS_X_VERSION_10_4)
 968 #if (MAC_OS_X_VERSION_MAX_ALLOWED > MAC_OS_X_VERSION_10_4)
 969     if (NULL != TISCopyCurrentKeyboardInputSource)
 970         return; // Compiled for >=10.4, running on >=10.5
 971 #endif
 972     // Compiled for >=10.4, running on 10.4
 973
 974     // IM is active whenever the current script is the system script and the
 975     // system script isn't roman.  (Hence IM can only be active when using
 976     // non-roman scripts.)
 977
 978     // NOTE: The IM code is delegated to the frontend since calling it in the
 979     // backend caused weird bugs (second dock icon appearing etc.).
 980     SInt32 currentScript = GetScriptManagerVariable(smKeyScript);
 981     SInt32 systemScript = GetScriptManagerVariable(smSysScript);
 982     BOOL state = currentScript != smRoman && currentScript == systemScript;
 983     if (imState != state) {
 984         imState = state;
 985         int msgid = state ? ActivatedImMsgID : DeactivatedImMsgID;
 986         [[self vimController] sendMessage:msgid data:nil];
 987     }
 988 #endif
 989 }
 990
 991 - (void)hideMouseCursor
 992 {
 993     // Check 'mousehide' option
 994     id mh = [[[self vimController] vimState] objectForKey:@"p_mh"];
 995     if (mh && ![mh boolValue])
 996         [NSCursor setHiddenUntilMouseMoves:NO];
 997     else
 998         [NSCursor setHiddenUntilMouseMoves:YES];
 999 }
1000
1001 - (void)startDragTimerWithInterval:(NSTimeInterval)t
1002 {
1003     [NSTimer scheduledTimerWithTimeInterval:t target:self
1004                                    selector:@selector(dragTimerFired:)
1005                                    userInfo:nil repeats:NO];
1006 }
1007
1008 - (void)dragTimerFired:(NSTimer *)timer
1009 {
1010     // TODO: Autoscroll in horizontal direction?
1011     static unsigned tick = 1;
1012
1013     isAutoscrolling = NO;
1014
1015     if (isDragging && (dragRow < 0 || dragRow >= [textView maxRows])) {
1016         // HACK! If the mouse cursor is outside the text area, then send a
1017         // dragged event.  However, if row&col hasn't changed since the last
1018         // dragged event, Vim won't do anything (see gui_send_mouse_event()).
1019         // Thus we fiddle with the column to make sure something happens.
1020         int col = dragColumn + (dragRow < 0 ? -(tick % 2) : +(tick % 2));
1021         NSMutableData *data = [NSMutableData data];
1022
1023         [data appendBytes:&dragRow length:sizeof(int)];
1024         [data appendBytes:&col length:sizeof(int)];
1025         [data appendBytes:&dragFlags length:sizeof(int)];
1026
1027         [[self vimController] sendMessage:MouseDraggedMsgID data:data];
1028
1029         isAutoscrolling = YES;
1030     }
1031
1032     if (isDragging) {
1033         // Compute timer interval depending on how far away the mouse cursor is
1034         // from the text view.
1035         NSRect rect = [self trackingRect];
1036         float dy = 0;
1037         if (dragPoint.y < rect.origin.y) dy = rect.origin.y - dragPoint.y;
1038         else if (dragPoint.y > NSMaxY(rect)) dy = dragPoint.y - NSMaxY(rect);
1039         if (dy > MMDragAreaSize) dy = MMDragAreaSize;
1040
1041         NSTimeInterval t = MMDragTimerMaxInterval -
1042             dy*(MMDragTimerMaxInterval-MMDragTimerMinInterval)/MMDragAreaSize;
1043
1044         [self startDragTimerWithInterval:t];
1045     }
1046
1047     ++tick;
1048 }
1049
1050 - (void)setCursor
1051 {
1052     static NSCursor *customIbeamCursor = nil;
1053
1054     if (!customIbeamCursor) {
1055         // Use a custom Ibeam cursor that has better contrast against dark
1056         // backgrounds.
1057         // TODO: Is the hotspot ok?
1058         NSImage *ibeamImage = [NSImage imageNamed:@"ibeam"];
1059         if (ibeamImage) {
1060             NSSize size = [ibeamImage size];
1061             NSPoint hotSpot = { size.width*.5f, size.height*.5f };
1062
1063             customIbeamCursor = [[NSCursor alloc]
1064                     initWithImage:ibeamImage hotSpot:hotSpot];
1065         }
1066         if (!customIbeamCursor) {
1067             ASLogWarn(@"Failed to load custom Ibeam cursor");
1068             customIbeamCursor = [NSCursor IBeamCursor];
1069         }
1070     }
1071
1072     // This switch should match mshape_names[] in misc2.c.
1073     //
1074     // TODO: Add missing cursor shapes.
1075     switch (mouseShape) {
1076         case 2: [customIbeamCursor set]; break;
1077         case 3: case 4: [[NSCursor resizeUpDownCursor] set]; break;
1078         case 5: case 6: [[NSCursor resizeLeftRightCursor] set]; break;
1079         case 9: [[NSCursor crosshairCursor] set]; break;
1080         case 10: [[NSCursor pointingHandCursor] set]; break;
1081         case 11: [[NSCursor openHandCursor] set]; break;
1082         default:
1083             [[NSCursor arrowCursor] set]; break;
1084     }
1085
1086     // Shape 1 indicates that the mouse cursor should be hidden.
1087     if (1 == mouseShape)
1088         [NSCursor setHiddenUntilMouseMoves:YES];
1089 }
1090
1091 - (NSRect)trackingRect
1092 {
1093     NSRect rect = [textView frame];
1094     NSUserDefaults *ud = [NSUserDefaults standardUserDefaults];
1095     int left = [ud integerForKey:MMTextInsetLeftKey];
1096     int top = [ud integerForKey:MMTextInsetTopKey];
1097     int right = [ud integerForKey:MMTextInsetRightKey];
1098     int bot = [ud integerForKey:MMTextInsetBottomKey];
1099
1100     rect.origin.x = left;
1101     rect.origin.y = top;
1102     rect.size.width -= left + right - 1;
1103     rect.size.height -= top + bot - 1;
1104
1105     return rect;
1106 }
1107
1108 - (BOOL)inputManagerHandleMouseEvent:(NSEvent *)event
1109 {
1110     // NOTE: The input manager usually handles events like mouse clicks (e.g.
1111     // the Kotoeri manager "commits" the text on left clicks).
1112
1113     if (event) {
1114         NSInputManager *imgr = [NSInputManager currentInputManager];
1115         if ([imgr wantsToHandleMouseEvents])
1116             return [imgr handleMouseEvent:event];
1117     }
1118
1119     return NO;
1120 }
1121
1122 - (void)sendMarkedText:(NSString *)text position:(unsigned)pos
1123 {
1124     if (![self useInlineIm])
1125         return;
1126
1127     NSMutableData *data = [NSMutableData data];
1128     unsigned len = text == nil ? 0
1129                     : [text lengthOfBytesUsingEncoding:NSUTF8StringEncoding];
1130
1131     [data appendBytes:&pos length:sizeof(unsigned)];
1132     [data appendBytes:&len length:sizeof(unsigned)];
1133     if (len > 0) {
1134         [data appendBytes:[text UTF8String] length:len];
1135         [data appendBytes:"\x00" length:1];
1136     }
1137
1138     [[self vimController] sendMessage:SetMarkedTextMsgID data:data];
1139 }
1140
1141 @end // MMTextViewHelper (Private)