src/MacVim/MMTextView.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 #import "MMTextView.h"
  12 #import "MMTextStorage.h"
  13 #import "MMWindowController.h"
  14 #import "MMVimController.h"
  15 #import "MacVim.h"
  16
  17
  18
  19 // The max/min drag timer interval in seconds
  20 static NSTimeInterval MMDragTimerMaxInterval = .3f;
  21 static NSTimeInterval MMDragTimerMinInterval = .01f;
  22
  23 // The number of pixels in which the drag timer interval changes
  24 static float MMDragAreaSize = 73.0f;
  25
  26 static char MMKeypadEnter[2] = { 'K', 'A' };
  27 static NSString *MMKeypadEnterString = @"KA";
  28
  29
  30
  31 @interface MMTextView (Private)
  32 - (BOOL)convertPoint:(NSPoint)point toRow:(int *)row column:(int *)column;
  33 - (BOOL)convertRow:(int)row column:(int)column toPoint:(NSPoint *)point;
  34 - (NSRect)trackingRect;
  35 - (void)dispatchKeyEvent:(NSEvent *)event;
  36 - (MMVimController *)vimController;
  37 - (void)startDragTimerWithInterval:(NSTimeInterval)t;
  38 - (void)dragTimerFired:(NSTimer *)timer;
  39 - (void)sendKeyDown:(const char *)chars length:(int)len modifiers:(int)flags;
  40 @end
  41
  42
  43
  44 @implementation MMTextView
  45
  46 - (void)dealloc
  47 {
  48     if (markedTextField) {
  49         [[markedTextField window] autorelease];
  50         [markedTextField release];
  51         markedTextField = nil;
  52     }
  53
  54     [lastMouseDownEvent release];
  55     [super dealloc];
  56 }
  57
  58 - (NSEvent *)lastMouseDownEvent
  59 {
  60     return lastMouseDownEvent;
  61 }
  62
  63 - (BOOL)shouldDrawInsertionPoint
  64 {
  65     // NOTE: The insertion point is drawn manually in drawRect:.  It would be
  66     // nice to be able to use the insertion point related methods of
  67     // NSTextView, but it seems impossible to get them to work properly (search
  68     // the cocoabuilder archives).
  69     return NO;
  70 }
  71
  72 - (void)setShouldDrawInsertionPoint:(BOOL)on
  73 {
  74     shouldDrawInsertionPoint = on;
  75 }
  76
  77 - (void)drawInsertionPointAtRow:(int)row column:(int)col shape:(int)shape
  78                        fraction:(int)percent color:(NSColor *)color
  79 {
  80     //NSLog(@"drawInsertionPointAtRow:%d column:%d shape:%d color:%@",
  81     //        row, col, shape, color);
  82
  83     // This only stores where to draw the insertion point, the actual drawing
  84     // is done in drawRect:.
  85     shouldDrawInsertionPoint = YES;
  86     insertionPointRow = row;
  87     insertionPointColumn = col;
  88     insertionPointShape = shape;
  89     insertionPointFraction = percent;
  90
  91     [self setInsertionPointColor:color];
  92 }
  93
  94 - (void)hideMarkedTextField
  95 {
  96     if (markedTextField) {
  97         NSWindow *win = [markedTextField window];
  98         [win close];
  99         [markedTextField setStringValue:@""];
 100     }
 101 }
 102
 103 - (BOOL)isOpaque
 104 {
 105     return NO;
 106 }
 107
 108 - (void)drawRect:(NSRect)rect
 109 {
 110     [super drawRect:rect];
 111
 112     if (shouldDrawInsertionPoint) {
 113         MMTextStorage *ts = (MMTextStorage*)[self textStorage];
 114         NSLayoutManager *lm = [self layoutManager];
 115         NSTextContainer *tc = [self textContainer];
 116
 117         // Given (row,column), calculate the bounds of the glyph at that spot.
 118         // We use the layout manager because this gives us exactly the size and
 119         // location of the glyph so that we can match the insertion point to
 120         // it.
 121         unsigned charIdx = [ts characterIndexForRow:insertionPointRow
 122                                              column:insertionPointColumn];
 123         NSRange glyphRange =
 124             [lm glyphRangeForCharacterRange:NSMakeRange(charIdx,1)
 125                        actualCharacterRange:NULL];
 126         NSRect ipRect = [lm boundingRectForGlyphRange:glyphRange
 127                                       inTextContainer:tc];
 128         ipRect.origin.x += [self textContainerOrigin].x;
 129         ipRect.origin.y += [self textContainerOrigin].y;
 130
 131         if (MMInsertionPointHorizontal == insertionPointShape) {
 132             int frac = ([ts cellSize].height * insertionPointFraction + 99)/100;
 133             ipRect.origin.y += ipRect.size.height - frac;
 134             ipRect.size.height = frac;
 135         } else if (MMInsertionPointVertical == insertionPointShape) {
 136             int frac = ([ts cellSize].width* insertionPointFraction + 99)/100;
 137             ipRect.size.width = frac;
 138         }
 139
 140         [[self insertionPointColor] set];
 141         if (MMInsertionPointHollow == insertionPointShape) {
 142             NSFrameRect(ipRect);
 143         } else {
 144             NSRectFill(ipRect);
 145         }
 146
 147         // NOTE: We only draw the cursor once and rely on Vim to say when it
 148         // should be drawn again.
 149         shouldDrawInsertionPoint = NO;
 150
 151         //NSLog(@"%s draw insertion point %@ shape=%d color=%@", _cmd,
 152         //        NSStringFromRect(ipRect), insertionPointShape,
 153         //        [self insertionPointColor]);
 154     }
 155 #if 0
 156     // this code invalidates the shadow, so we don't
 157     // get shifting ghost text on scroll and resize
 158     // but makes speed unusable
 159     MMTextStorage *ts = (MMTextStorage*)[self textStorage];
 160     if ([ts defaultBackgroundAlpha] < 1.0f) {
 161         if (floor(NSAppKitVersionNumber) <= NSAppKitVersionNumber10_1)
 162         {
 163             [[self window] setHasShadow:NO];
 164             [[self window] setHasShadow:YES];
 165         }
 166         else
 167             [[self window] invalidateShadow];
 168
 169     }
 170 #endif
 171 }
 172
 173 - (void)keyDown:(NSEvent *)event
 174 {
 175     //NSLog(@"%s %@", _cmd, event);
 176     // HACK! If a modifier is held, don't pass the event along to
 177     // interpretKeyEvents: since some keys are bound to multiple commands which
 178     // means doCommandBySelector: is called several times.
 179     //
 180     // TODO: Figure out a way to disable Cocoa key bindings entirely, without
 181     // affecting input management.
 182
 183     if ([event modifierFlags] & NSControlKeyMask)
 184         [self dispatchKeyEvent:event];
 185     else
 186         [super keyDown:event];
 187 }
 188
 189 - (void)insertText:(id)string
 190 {
 191     //NSLog(@"%s %@", _cmd, string);
 192     // NOTE!  This method is called for normal key presses but also for
 193     // Option-key presses --- even when Ctrl is held as well as Option.  When
 194     // Ctrl is held, the AppKit translates the character to a Ctrl+key stroke,
 195     // so 'string' need not be a printable character!  In this case it still
 196     // works to pass 'string' on to Vim as a printable character (since
 197     // modifiers are already included and should not be added to the input
 198     // buffer using CSI, K_MODIFIER).
 199
 200     [self hideMarkedTextField];
 201
 202     NSEvent *event = [NSApp currentEvent];
 203
 204     // HACK!  In order to be able to bind to <S-Space>, <S-M-Tab>, etc. we have
 205     // to watch for them here.
 206     if ([event type] == NSKeyDown
 207             && [[event charactersIgnoringModifiers] length] > 0
 208             && [event modifierFlags]
 209                 & (NSShiftKeyMask|NSControlKeyMask|NSAlternateKeyMask)) {
 210         unichar c = [[event charactersIgnoringModifiers] characterAtIndex:0];
 211
 212         // <S-M-Tab> translates to 0x19
 213         if (' ' == c || 0x19 == c) {
 214             [self dispatchKeyEvent:event];
 215             return;
 216         }
 217     }
 218
 219     // TODO: Support 'mousehide' (check p_mh)
 220     [NSCursor setHiddenUntilMouseMoves:YES];
 221
 222     // NOTE: 'string' is either an NSString or an NSAttributedString.  Since we
 223     // do not support attributes, simply pass the corresponding NSString in the
 224     // latter case.
 225     if ([string isKindOfClass:[NSAttributedString class]])
 226         string = [string string];
 227
 228     [[self vimController] sendMessage:InsertTextMsgID
 229                  data:[string dataUsingEncoding:NSUTF8StringEncoding]];
 230 }
 231
 232
 233 - (void)doCommandBySelector:(SEL)selector
 234 {
 235     //NSLog(@"%s %@", _cmd, NSStringFromSelector(selector));
 236     // By ignoring the selector we effectively disable the key binding
 237     // mechanism of Cocoa.  Hopefully this is what the user will expect
 238     // (pressing Ctrl+P would otherwise result in moveUp: instead of previous
 239     // match, etc.).
 240     //
 241     // We usually end up here if the user pressed Ctrl+key (but not
 242     // Ctrl+Option+key).
 243
 244     NSEvent *event = [NSApp currentEvent];
 245
 246     if (selector == @selector(cancelOperation:)
 247             || selector == @selector(insertNewline:)) {
 248         // HACK! If there was marked text which got abandoned as a result of
 249         // hitting escape or enter, then 'insertText:' is called with the
 250         // abandoned text but '[event characters]' includes the abandoned text
 251         // as well.  Since 'dispatchKeyEvent:' looks at '[event characters]' we
 252         // must intercept these keys here or the abandonded text gets inserted
 253         // twice.
 254         NSString *key = [event charactersIgnoringModifiers];
 255         const char *chars = [key UTF8String];
 256         int len = [key lengthOfBytesUsingEncoding:NSUTF8StringEncoding];
 257
 258         if (0x3 == chars[0]) {
 259             // HACK! AppKit turns enter (not return) into Ctrl-C, so we need to
 260             // handle it separately (else Ctrl-C doesn't work).
 261             len = sizeof(MMKeypadEnter)/sizeof(MMKeypadEnter[0]);
 262             chars = MMKeypadEnter;
 263         }
 264
 265         [self sendKeyDown:chars length:len modifiers:[event modifierFlags]];
 266     } else {
 267         [self dispatchKeyEvent:event];
 268     }
 269 }
 270
 271 - (BOOL)performKeyEquivalent:(NSEvent *)event
 272 {
 273     //NSLog(@"%s %@", _cmd, event);
 274     // Called for Cmd+key keystrokes, function keys, arrow keys, page
 275     // up/down, home, end.
 276     //
 277     // NOTE: This message cannot be ignored since Cmd+letter keys never are
 278     // passed to keyDown:.  It seems as if the main menu consumes Cmd-key
 279     // strokes, unless the key is a function key.
 280
 281     // NOTE: If the event that triggered this method represents a function key
 282     // down then we do nothing, otherwise the input method never gets the key
 283     // stroke (some input methods use e.g. arrow keys).  The function key down
 284     // event will still reach Vim though (via keyDown:).  The exceptions to
 285     // this rule are: PageUp/PageDown (keycode 116/121).
 286     int flags = [event modifierFlags];
 287     if ([event type] != NSKeyDown || flags & NSFunctionKeyMask
 288             && !(116 == [event keyCode] || 121 == [event keyCode]))
 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!  KeyCode 50 represent the key which switches between windows
 298     // within an application (like Cmd+Tab is used to switch between
 299     // applications).  Return NO here, else the window switching does not work.
 300     //
 301     // Will this hack work for all languages / keyboard layouts?
 302     if ([event keyCode] == 50)
 303         return NO;
 304
 305     //NSLog(@"%s%@", _cmd, event);
 306
 307     NSString *chars = [event characters];
 308     NSString *unmodchars = [event charactersIgnoringModifiers];
 309     int len = [unmodchars lengthOfBytesUsingEncoding:NSUTF8StringEncoding];
 310     NSMutableData *data = [NSMutableData data];
 311
 312     if (len <= 0)
 313         return NO;
 314
 315     // If 'chars' and 'unmodchars' differs when shift flag is present, then we
 316     // can clear the shift flag as it is already included in 'unmodchars'.
 317     // Failing to clear the shift flag means <D-Bar> turns into <S-D-Bar> (on
 318     // an English keyboard).
 319     if (flags & NSShiftKeyMask && ![chars isEqual:unmodchars])
 320         flags &= ~NSShiftKeyMask;
 321
 322     if (0x3 == [unmodchars characterAtIndex:0]) {
 323         // HACK! AppKit turns enter (not return) into Ctrl-C, so we need to
 324         // handle it separately (else Cmd-enter turns into Ctrl-C).
 325         unmodchars = MMKeypadEnterString;
 326         len = [unmodchars lengthOfBytesUsingEncoding:NSUTF8StringEncoding];
 327     }
 328
 329     [data appendBytes:&flags length:sizeof(int)];
 330     [data appendBytes:&len length:sizeof(int)];
 331     [data appendBytes:[unmodchars UTF8String] length:len];
 332
 333     [[self vimController] sendMessage:CmdKeyMsgID data:data];
 334
 335     return YES;
 336 }
 337
 338 - (BOOL)hasMarkedText
 339 {
 340     //NSLog(@"%s", _cmd);
 341     return markedTextField && [[markedTextField stringValue] length] > 0;
 342 }
 343
 344 - (NSRange)markedRange
 345 {
 346     //NSLog(@"%s", _cmd);
 347     // HACK! If a valid range is returned, then NSTextView changes the
 348     // background color of the returned range.  Since marked text is displayed
 349     // in a separate popup window this behaviour is not wanted.  By setting the
 350     // location of the returned range to NSNotFound NSTextView does nothing.
 351     // This hack is continued in 'firstRectForCharacterRange:'.
 352     return NSMakeRange(NSNotFound, 0);
 353 }
 354
 355 - (void)setMarkedText:(id)text selectedRange:(NSRange)range
 356 {
 357     //NSLog(@"setMarkedText:'%@' selectedRange:%@", text,
 358     //        NSStringFromRange(range));
 359
 360     MMTextStorage *ts = (MMTextStorage*)[self textStorage];
 361     if (!ts) return;
 362
 363     if (!markedTextField) {
 364         // Create a text field and put it inside a floating panel.  This field
 365         // is used to display marked text.
 366         NSSize cellSize = [ts cellSize];
 367         NSRect cellRect = { 0, 0, cellSize.width, cellSize.height };
 368
 369         markedTextField = [[NSTextField alloc] initWithFrame:cellRect];
 370         [markedTextField setEditable:NO];
 371         [markedTextField setSelectable:NO];
 372         [markedTextField setBezeled:NO];
 373         [markedTextField setBordered:YES];
 374
 375         NSPanel *panel = [[NSPanel alloc]
 376             initWithContentRect:cellRect
 377                       styleMask:NSBorderlessWindowMask|NSUtilityWindowMask
 378                         backing:NSBackingStoreBuffered
 379                           defer:YES];
 380
 381         //[panel setHidesOnDeactivate:NO];
 382         [panel setFloatingPanel:YES];
 383         [panel setBecomesKeyOnlyIfNeeded:YES];
 384         [panel setContentView:markedTextField];
 385     }
 386
 387     if (text && [text length] > 0) {
 388         [markedTextField setFont:[ts font]];
 389         if ([text isKindOfClass:[NSAttributedString class]])
 390             [markedTextField setAttributedStringValue:text];
 391         else
 392             [markedTextField setStringValue:text];
 393
 394         [markedTextField sizeToFit];
 395         NSSize size = [markedTextField frame].size;
 396
 397         // Convert coordinates (row,col) -> view -> window base -> screen
 398         NSPoint origin;
 399         if (![self convertRow:insertionPointRow+1 column:insertionPointColumn
 400                      toPoint:&origin])
 401             return;
 402         origin = [self convertPoint:origin toView:nil];
 403         origin = [[self window] convertBaseToScreen:origin];
 404
 405         NSWindow *win = [markedTextField window];
 406         [win setContentSize:size];
 407         [win setFrameOrigin:origin];
 408         [win orderFront:nil];
 409     } else {
 410         [self hideMarkedTextField];
 411     }
 412 }
 413
 414 - (void)unmarkText
 415 {
 416     //NSLog(@"%s", _cmd);
 417     [self hideMarkedTextField];
 418 }
 419
 420 - (NSRect)firstRectForCharacterRange:(NSRange)range
 421 {
 422     //NSLog(@"%s%@", _cmd, NSStringFromRange(range));
 423
 424     MMTextStorage *ts = (MMTextStorage*)[self textStorage];
 425     NSLayoutManager *lm = [self layoutManager];
 426     NSTextContainer *tc = [self textContainer];
 427
 428     // HACK! Since we always return marked text to have location NSNotFound,
 429     // this method will be called with 'range.location == NSNotFound' whenever
 430     // the input manager tries to position a popup window near the insertion
 431     // point.  For this reason we compute where the insertion point is and
 432     // return a rect which contains it.
 433     if (!(ts && lm && tc) || NSNotFound != range.location)
 434         return [super firstRectForCharacterRange:range];
 435
 436     unsigned charIdx = [ts characterIndexForRow:insertionPointRow
 437                                          column:insertionPointColumn];
 438     NSRange glyphRange =
 439         [lm glyphRangeForCharacterRange:NSMakeRange(charIdx,1)
 440                    actualCharacterRange:NULL];
 441     NSRect ipRect = [lm boundingRectForGlyphRange:glyphRange
 442                                   inTextContainer:tc];
 443     ipRect.origin.x += [self textContainerOrigin].x;
 444     ipRect.origin.y += [self textContainerOrigin].y + [ts cellSize].height;
 445
 446     ipRect.origin = [self convertPoint:ipRect.origin toView:nil];
 447     ipRect.origin = [[self window] convertBaseToScreen:ipRect.origin];
 448
 449     return ipRect;
 450 }
 451
 452 - (void)scrollWheel:(NSEvent *)event
 453 {
 454     if ([event deltaY] == 0)
 455         return;
 456
 457     int row, col;
 458     NSPoint pt = [self convertPoint:[event locationInWindow] fromView:nil];
 459     if (![self convertPoint:pt toRow:&row column:&col])
 460         return;
 461
 462     int flags = [event modifierFlags];
 463     float dy = [event deltaY];
 464     NSMutableData *data = [NSMutableData data];
 465
 466     [data appendBytes:&row length:sizeof(int)];
 467     [data appendBytes:&col length:sizeof(int)];
 468     [data appendBytes:&flags length:sizeof(int)];
 469     [data appendBytes:&dy length:sizeof(float)];
 470
 471     [[self vimController] sendMessage:ScrollWheelMsgID data:data];
 472 }
 473
 474 - (void)mouseDown:(NSEvent *)event
 475 {
 476     int row, col;
 477     NSPoint pt = [self convertPoint:[event locationInWindow] fromView:nil];
 478     if (![self convertPoint:pt toRow:&row column:&col])
 479         return;
 480
 481     lastMouseDownEvent = [event copy];
 482
 483     int button = [event buttonNumber];
 484     int flags = [event modifierFlags];
 485     int count = [event clickCount];
 486     NSMutableData *data = [NSMutableData data];
 487
 488     // If desired, intepret Ctrl-Click as a right mouse click.
 489     if ([[NSUserDefaults standardUserDefaults]
 490             boolForKey:MMTranslateCtrlClickKey]
 491             && button == 0 && flags & NSControlKeyMask) {
 492         button = 1;
 493         flags &= ~NSControlKeyMask;
 494     }
 495
 496     [data appendBytes:&row length:sizeof(int)];
 497     [data appendBytes:&col length:sizeof(int)];
 498     [data appendBytes:&button length:sizeof(int)];
 499     [data appendBytes:&flags length:sizeof(int)];
 500     [data appendBytes:&count length:sizeof(int)];
 501
 502     [[self vimController] sendMessage:MouseDownMsgID data:data];
 503 }
 504
 505 - (void)rightMouseDown:(NSEvent *)event
 506 {
 507     [self mouseDown:event];
 508 }
 509
 510 - (void)otherMouseDown:(NSEvent *)event
 511 {
 512     [self mouseDown:event];
 513 }
 514
 515 - (void)mouseUp:(NSEvent *)event
 516 {
 517     int row, col;
 518     NSPoint pt = [self convertPoint:[event locationInWindow] fromView:nil];
 519     if (![self convertPoint:pt toRow:&row column:&col])
 520         return;
 521
 522     int flags = [event modifierFlags];
 523     NSMutableData *data = [NSMutableData data];
 524
 525     [data appendBytes:&row length:sizeof(int)];
 526     [data appendBytes:&col length:sizeof(int)];
 527     [data appendBytes:&flags length:sizeof(int)];
 528
 529     [[self vimController] sendMessage:MouseUpMsgID data:data];
 530
 531     isDragging = NO;
 532 }
 533
 534 - (void)rightMouseUp:(NSEvent *)event
 535 {
 536     [self mouseUp:event];
 537 }
 538
 539 - (void)otherMouseUp:(NSEvent *)event
 540 {
 541     [self mouseUp:event];
 542 }
 543
 544 - (void)mouseDragged:(NSEvent *)event
 545 {
 546     int flags = [event modifierFlags];
 547     int row, col;
 548     NSPoint pt = [self convertPoint:[event locationInWindow] fromView:nil];
 549     if (![self convertPoint:pt toRow:&row column:&col])
 550         return;
 551
 552     // Autoscrolling is done in dragTimerFired:
 553     if (!isAutoscrolling) {
 554         NSMutableData *data = [NSMutableData data];
 555
 556         [data appendBytes:&row length:sizeof(int)];
 557         [data appendBytes:&col length:sizeof(int)];
 558         [data appendBytes:&flags length:sizeof(int)];
 559
 560         [[self vimController] sendMessage:MouseDraggedMsgID data:data];
 561     }
 562
 563     dragPoint = pt;
 564     dragRow = row; dragColumn = col; dragFlags = flags;
 565     if (!isDragging) {
 566         [self startDragTimerWithInterval:.5];
 567         isDragging = YES;
 568     }
 569 }
 570
 571 - (void)rightMouseDragged:(NSEvent *)event
 572 {
 573     [self mouseDragged:event];
 574 }
 575
 576 - (void)otherMouseDragged:(NSEvent *)event
 577 {
 578     [self mouseDragged:event];
 579 }
 580
 581 - (void)mouseMoved:(NSEvent *)event
 582 {
 583     MMTextStorage *ts = (MMTextStorage*)[self textStorage];
 584     if (!ts) return;
 585
 586     NSPoint pt = [self convertPoint:[event locationInWindow] fromView:nil];
 587     int row, col;
 588     if (![self convertPoint:pt toRow:&row column:&col])
 589         return;
 590
 591     // HACK! It seems impossible to get the tracking rects set up before the
 592     // view is visible, which means that the first mouseEntered: or
 593     // mouseExited: events are never received.  This forces us to check if the
 594     // mouseMoved: event really happened over the text.
 595     int rows, cols;
 596     [ts getMaxRows:&rows columns:&cols];
 597     if (row >= 0 && row < rows && col >= 0 && col < cols) {
 598         NSMutableData *data = [NSMutableData data];
 599
 600         [data appendBytes:&row length:sizeof(int)];
 601         [data appendBytes:&col length:sizeof(int)];
 602
 603         [[self vimController] sendMessage:MouseMovedMsgID data:data];
 604     }
 605 }
 606
 607 - (void)mouseEntered:(NSEvent *)event
 608 {
 609     //NSLog(@"%s", _cmd);
 610
 611     // NOTE: This event is received even when the window is not key; thus we
 612     // have to take care not to enable mouse moved events unless our window is
 613     // key.
 614     if ([[self window] isKeyWindow])
 615         [[self window] setAcceptsMouseMovedEvents:YES];
 616 }
 617
 618 - (void)mouseExited:(NSEvent *)event
 619 {
 620     //NSLog(@"%s", _cmd);
 621
 622     [[self window] setAcceptsMouseMovedEvents:NO];
 623
 624     // NOTE: This event is received even when the window is not key; if the
 625     // mouse shape is set when our window is not key, the hollow (unfocused)
 626     // cursor will become a block (focused) cursor.
 627     if ([[self window] isKeyWindow]) {
 628         int shape = 0;
 629         NSMutableData *data = [NSMutableData data];
 630         [data appendBytes:&shape length:sizeof(int)];
 631         [[self vimController] sendMessage:SetMouseShapeMsgID data:data];
 632     }
 633 }
 634
 635 - (void)setFrame:(NSRect)frame
 636 {
 637     //NSLog(@"%s", _cmd);
 638
 639     // When the frame changes we also need to update the tracking rect.
 640     [super setFrame:frame];
 641     [self removeTrackingRect:trackingRectTag];
 642     trackingRectTag = [self addTrackingRect:[self trackingRect] owner:self
 643                                    userData:NULL assumeInside:YES];
 644 }
 645
 646 - (void)viewDidMoveToWindow
 647 {
 648     //NSLog(@"%s (window=%@)", _cmd, [self window]);
 649
 650     // Set a tracking rect which covers the text.
 651     // NOTE: While the mouse cursor is in this rect the view will receive
 652     // 'mouseMoved:' events so that Vim can take care of updating the mouse
 653     // cursor.
 654     if ([self window]) {
 655         [[self window] setAcceptsMouseMovedEvents:YES];
 656         trackingRectTag = [self addTrackingRect:[self trackingRect] owner:self
 657                                        userData:NULL assumeInside:YES];
 658     }
 659 }
 660
 661 - (void)viewWillMoveToWindow:(NSWindow *)newWindow
 662 {
 663     //NSLog(@"%s%@", _cmd, newWindow);
 664
 665     // Remove tracking rect if view moves or is removed.
 666     if ([self window] && trackingRectTag) {
 667         [self removeTrackingRect:trackingRectTag];
 668         trackingRectTag = 0;
 669     }
 670 }
 671
 672 - (NSMenu*)menuForEvent:(NSEvent *)event
 673 {
 674     // HACK! Return nil to disable NSTextView's popup menus (Vim provides its
 675     // own).  Called when user Ctrl-clicks in the view (this is already handled
 676     // in rightMouseDown:).
 677     return nil;
 678 }
 679
 680 - (NSArray *)acceptableDragTypes
 681 {
 682     return [NSArray arrayWithObjects:NSFilenamesPboardType,
 683            NSStringPboardType, nil];
 684 }
 685
 686 - (BOOL)performDragOperation:(id <NSDraggingInfo>)sender
 687 {
 688     NSPasteboard *pboard = [sender draggingPasteboard];
 689
 690     if ([[pboard types] containsObject:NSStringPboardType]) {
 691         NSString *string = [pboard stringForType:NSStringPboardType];
 692         [[self vimController] dropString:string];
 693         return YES;
 694     } else if ([[pboard types] containsObject:NSFilenamesPboardType]) {
 695         NSArray *files = [pboard propertyListForType:NSFilenamesPboardType];
 696         [[self vimController] dropFiles:files];
 697         return YES;
 698     }
 699
 700     return NO;
 701 }
 702
 703 - (NSDragOperation)draggingEntered:(id <NSDraggingInfo>)sender
 704 {
 705     NSDragOperation sourceDragMask = [sender draggingSourceOperationMask];
 706     NSPasteboard *pboard = [sender draggingPasteboard];
 707
 708     if ( [[pboard types] containsObject:NSFilenamesPboardType]
 709             && (sourceDragMask & NSDragOperationCopy) )
 710         return NSDragOperationCopy;
 711     if ( [[pboard types] containsObject:NSStringPboardType]
 712             && (sourceDragMask & NSDragOperationCopy) )
 713         return NSDragOperationCopy;
 714
 715     return NSDragOperationNone;
 716 }
 717
 718 - (NSDragOperation)draggingUpdated:(id <NSDraggingInfo>)sender
 719 {
 720     NSDragOperation sourceDragMask = [sender draggingSourceOperationMask];
 721     NSPasteboard *pboard = [sender draggingPasteboard];
 722
 723     if ( [[pboard types] containsObject:NSFilenamesPboardType]
 724             && (sourceDragMask & NSDragOperationCopy) )
 725         return NSDragOperationCopy;
 726     if ( [[pboard types] containsObject:NSStringPboardType]
 727             && (sourceDragMask & NSDragOperationCopy) )
 728         return NSDragOperationCopy;
 729
 730     return NSDragOperationNone;
 731 }
 732
 733 - (void)changeFont:(id)sender
 734 {
 735     MMTextStorage *ts = (MMTextStorage*)[self textStorage];
 736     if (!ts) return;
 737
 738     NSFont *oldFont = [ts font];
 739     NSFont *newFont = [sender convertFont:oldFont];
 740
 741     if (newFont) {
 742         NSString *name = [newFont displayName];
 743         unsigned len = [name lengthOfBytesUsingEncoding:NSUTF8StringEncoding];
 744         if (len > 0) {
 745             NSMutableData *data = [NSMutableData data];
 746             float pointSize = [newFont pointSize];
 747
 748             [data appendBytes:&pointSize length:sizeof(float)];
 749
 750             ++len;  // include NUL byte
 751             [data appendBytes:&len length:sizeof(unsigned)];
 752             [data appendBytes:[name UTF8String] length:len];
 753
 754             [[self vimController] sendMessage:SetFontMsgID data:data];
 755         }
 756     }
 757 }
 758
 759 - (void)resetCursorRects
 760 {
 761     // No need to set up cursor rects since Vim handles cursor changes.
 762 }
 763
 764 - (void)updateFontPanel
 765 {
 766     // The font panel is updated whenever the font is set.
 767 }
 768
 769 - (void)viewDidEndLiveResize
 770 {
 771     id windowController = [[self window] windowController];
 772     [windowController liveResizeDidEnd];
 773 }
 774
 775 @end // MMTextView
 776
 777
 778
 779
 780 @implementation MMTextView (Private)
 781
 782 - (BOOL)convertPoint:(NSPoint)point toRow:(int *)row column:(int *)column
 783 {
 784 #if 0
 785     NSLayoutManager *lm = [self layoutManager];
 786     NSTextContainer *tc = [self textContainer];
 787     MMTextStorage *ts = (MMTextStorage*)[self textStorage];
 788
 789     if (!(lm && tc && ts))
 790         return NO;
 791
 792     unsigned glyphIdx = [lm glyphIndexForPoint:point inTextContainer:tc];
 793     unsigned charIdx = [lm characterIndexForGlyphAtIndex:glyphIdx];
 794
 795     int mod = [ts maxColumns] + 1;
 796
 797     if (row) *row = (int)(charIdx / mod);
 798     if (column) *column = (int)(charIdx % mod);
 799
 800     NSLog(@"convertPoint:%@ toRow:%d column:%d", NSStringFromPoint(point),
 801             *row, *column);
 802
 803     return YES;
 804 #else
 805     MMTextStorage *ts = (MMTextStorage*)[self textStorage];
 806     NSSize cellSize = [ts cellSize];
 807     if (!(cellSize.width > 0 && cellSize.height > 0))
 808         return NO;
 809     NSPoint origin = [self textContainerOrigin];
 810
 811     if (row) *row = floor((point.y-origin.y-1) / cellSize.height);
 812     if (column) *column = floor((point.x-origin.x-1) / cellSize.width);
 813
 814     //NSLog(@"convertPoint:%@ toRow:%d column:%d", NSStringFromPoint(point),
 815     //        *row, *column);
 816
 817     return YES;
 818 #endif
 819 }
 820
 821 - (BOOL)convertRow:(int)row column:(int)column toPoint:(NSPoint *)point
 822 {
 823     MMTextStorage *ts = (MMTextStorage*)[self textStorage];
 824     NSSize cellSize = [ts cellSize];
 825     if (!(point && cellSize.width > 0 && cellSize.height > 0))
 826         return NO;
 827
 828     *point = [self textContainerOrigin];
 829     point->x += column * cellSize.width;
 830     point->y += row * cellSize.height;
 831
 832     return YES;
 833 }
 834
 835 - (NSRect)trackingRect
 836 {
 837     NSRect rect = [self frame];
 838     NSUserDefaults *ud = [NSUserDefaults standardUserDefaults];
 839     int left = [ud integerForKey:MMTextInsetLeftKey];
 840     int top = [ud integerForKey:MMTextInsetTopKey];
 841     int right = [ud integerForKey:MMTextInsetRightKey];
 842     int bot = [ud integerForKey:MMTextInsetBottomKey];
 843
 844     rect.origin.x = left;
 845     rect.origin.y = top;
 846     rect.size.width -= left + right - 1;
 847     rect.size.height -= top + bot - 1;
 848
 849     return rect;
 850 }
 851
 852 - (void)dispatchKeyEvent:(NSEvent *)event
 853 {
 854     // Only handle the command if it came from a keyDown event
 855     if ([event type] != NSKeyDown)
 856         return;
 857
 858     NSString *chars = [event characters];
 859     NSString *unmodchars = [event charactersIgnoringModifiers];
 860     unichar c = [chars characterAtIndex:0];
 861     unichar imc = [unmodchars characterAtIndex:0];
 862     int len = 0;
 863     const char *bytes = 0;
 864     int mods = [event modifierFlags];
 865
 866     //NSLog(@"%s chars[0]=0x%x unmodchars[0]=0x%x (chars=%@ unmodchars=%@)",
 867     //        _cmd, c, imc, chars, unmodchars);
 868
 869     if (' ' == imc && 0xa0 != c) {
 870         // HACK!  The AppKit turns <C-Space> into <C-@> which is not standard
 871         // Vim behaviour, so bypass this problem.  (0xa0 is <M-Space>, which
 872         // should be passed on as is.)
 873         len = [unmodchars lengthOfBytesUsingEncoding:NSUTF8StringEncoding];
 874         bytes = [unmodchars UTF8String];
 875     } else if (imc == c && '2' == c) {
 876         // HACK!  Translate Ctrl+2 to <C-@>.
 877         static char ctrl_at = 0;
 878         len = 1;  bytes = &ctrl_at;
 879     } else if (imc == c && '6' == c) {
 880         // HACK!  Translate Ctrl+6 to <C-^>.
 881         static char ctrl_hat = 0x1e;
 882         len = 1;  bytes = &ctrl_hat;
 883     } else if (c == 0x19 && imc == 0x19) {
 884         // HACK! AppKit turns back tab into Ctrl-Y, so we need to handle it
 885         // separately (else Ctrl-Y doesn't work).
 886         static char tab = 0x9;
 887         len = 1;  bytes = &tab;  mods |= NSShiftKeyMask;
 888     } else {
 889         len = [chars lengthOfBytesUsingEncoding:NSUTF8StringEncoding];
 890         bytes = [chars UTF8String];
 891     }
 892
 893     [self sendKeyDown:bytes length:len modifiers:mods];
 894 }
 895
 896 - (MMVimController *)vimController
 897 {
 898     id windowController = [[self window] windowController];
 899
 900     // TODO: Make sure 'windowController' is a MMWindowController before type
 901     // casting.
 902     return [(MMWindowController*)windowController vimController];
 903 }
 904
 905 - (void)startDragTimerWithInterval:(NSTimeInterval)t
 906 {
 907     [NSTimer scheduledTimerWithTimeInterval:t target:self
 908                                    selector:@selector(dragTimerFired:)
 909                                    userInfo:nil repeats:NO];
 910 }
 911
 912 - (void)dragTimerFired:(NSTimer *)timer
 913 {
 914     // TODO: Autoscroll in horizontal direction?
 915     static unsigned tick = 1;
 916     MMTextStorage *ts = (MMTextStorage *)[self textStorage];
 917
 918     isAutoscrolling = NO;
 919
 920     if (isDragging && ts && (dragRow < 0 || dragRow >= [ts maxRows])) {
 921         // HACK! If the mouse cursor is outside the text area, then send a
 922         // dragged event.  However, if row&col hasn't changed since the last
 923         // dragged event, Vim won't do anything (see gui_send_mouse_event()).
 924         // Thus we fiddle with the column to make sure something happens.
 925         int col = dragColumn + (dragRow < 0 ? -(tick % 2) : +(tick % 2));
 926         NSMutableData *data = [NSMutableData data];
 927
 928         [data appendBytes:&dragRow length:sizeof(int)];
 929         [data appendBytes:&col length:sizeof(int)];
 930         [data appendBytes:&dragFlags length:sizeof(int)];
 931
 932         [[self vimController] sendMessage:MouseDraggedMsgID data:data];
 933
 934         isAutoscrolling = YES;
 935     }
 936
 937     if (isDragging) {
 938         // Compute timer interval depending on how far away the mouse cursor is
 939         // from the text view.
 940         NSRect rect = [self trackingRect];
 941         float dy = 0;
 942         if (dragPoint.y < rect.origin.y) dy = rect.origin.y - dragPoint.y;
 943         else if (dragPoint.y > NSMaxY(rect)) dy = dragPoint.y - NSMaxY(rect);
 944         if (dy > MMDragAreaSize) dy = MMDragAreaSize;
 945
 946         NSTimeInterval t = MMDragTimerMaxInterval -
 947             dy*(MMDragTimerMaxInterval-MMDragTimerMinInterval)/MMDragAreaSize;
 948
 949         [self startDragTimerWithInterval:t];
 950     }
 951
 952     ++tick;
 953 }
 954
 955 - (void)sendKeyDown:(const char *)chars length:(int)len modifiers:(int)flags
 956 {
 957     if (chars && len > 0) {
 958         NSMutableData *data = [NSMutableData data];
 959
 960         [data appendBytes:&flags length:sizeof(int)];
 961         [data appendBytes:&len length:sizeof(int)];
 962         [data appendBytes:chars length:len];
 963
 964         // TODO: Support 'mousehide' (check p_mh)
 965         [NSCursor setHiddenUntilMouseMoves:YES];
 966
 967         //NSLog(@"%s len=%d chars=0x%x", _cmd, len, chars[0]);
 968         [[self vimController] sendMessage:KeyDownMsgID data:data];
 969     }
 970 }
 971
 972 @end // MMTextView (Private)