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  * MMTextView
  12  *
  13  * Dispatches keyboard and mouse input to the backend.  Handles drag-n-drop of
  14  * files onto window.
  15  *
  16  * Support for input managers is somewhat hacked together.  Marked text is
  17  * drawn "pseudo-inline"; it will simply draw on top of existing text and it
  18  * does not respect Vim-window boundaries.
  19  */
  20
  21 #import "MMAppController.h"
  22 #import "MMTextStorage.h"
  23 #import "MMTextView.h"
  24 #import "MMTextViewHelper.h"
  25 #import "MMTypesetter.h"
  26 #import "MMVimController.h"
  27 #import "MMWindowController.h"
  28 #import "Miscellaneous.h"
  29
  30
  31
  32 // This is taken from gui.h
  33 #define DRAW_CURSOR 0x20
  34
  35
  36
  37 @interface MMTextView (Private)
  38 - (MMWindowController *)windowController;
  39 - (MMVimController *)vimController;
  40 - (void)setShouldDrawInsertionPoint:(BOOL)on;
  41 - (void)drawInsertionPointAtRow:(int)row column:(int)col shape:(int)shape
  42                        fraction:(int)percent;
  43 - (void)drawInvertedRectAtRow:(int)row column:(int)col numRows:(int)nrows
  44                    numColumns:(int)ncols invert:(int)invert;
  45 @end
  46
  47
  48
  49 @implementation MMTextView
  50
  51 - (id)initWithFrame:(NSRect)frame
  52 {
  53     // Set up a Cocoa text system.  Note that the textStorage is released in
  54     // -[MMVimView dealloc].
  55     MMTextStorage *textStorage = [[MMTextStorage alloc] init];
  56     NSLayoutManager *lm = [[NSLayoutManager alloc] init];
  57     NSTextContainer *tc = [[NSTextContainer alloc] initWithContainerSize:
  58                     NSMakeSize(1.0e7,1.0e7)];
  59
  60     NSString *typesetterString = [[NSUserDefaults standardUserDefaults]
  61             stringForKey:MMTypesetterKey];
  62     if ([typesetterString isEqual:@"MMTypesetter"]) {
  63         NSTypesetter *typesetter = [[MMTypesetter alloc] init];
  64         [lm setTypesetter:typesetter];
  65         [typesetter release];
  66     } else if ([typesetterString isEqual:@"MMTypesetter2"]) {
  67         NSTypesetter *typesetter = [[MMTypesetter2 alloc] init];
  68         [lm setTypesetter:typesetter];
  69         [typesetter release];
  70     } else {
  71         // Only MMTypesetter supports different cell width multipliers.
  72         [[NSUserDefaults standardUserDefaults]
  73                 setFloat:1.0 forKey:MMCellWidthMultiplierKey];
  74     }
  75
  76     // The characters in the text storage are in display order, so disable
  77     // bidirectional text processing (this call is 10.4 only).
  78     [[lm typesetter] setBidiProcessingEnabled:NO];
  79
  80     [tc setWidthTracksTextView:NO];
  81     [tc setHeightTracksTextView:NO];
  82     [tc setLineFragmentPadding:0];
  83
  84     [textStorage addLayoutManager:lm];
  85     [lm addTextContainer:tc];
  86
  87     // The text storage retains the layout manager which in turn retains
  88     // the text container.
  89     [tc autorelease];
  90     [lm autorelease];
  91
  92     // NOTE: This will make the text storage the principal owner of the text
  93     // system.  Releasing the text storage will in turn release the layout
  94     // manager, the text container, and finally the text view (self).  This
  95     // complicates deallocation somewhat, see -[MMVimView dealloc].
  96     if (![super initWithFrame:frame textContainer:tc]) {
  97         [textStorage release];
  98         return nil;
  99     }
 100
 101     helper = [[MMTextViewHelper alloc] init];
 102     [helper setTextView:self];
 103
 104     // NOTE: If the default changes to 'NO' then the intialization of
 105     // p_antialias in option.c must change as well.
 106     antialias = YES;
 107
 108     return self;
 109 }
 110
 111 - (void)dealloc
 112 {
 113     LOG_DEALLOC
 114
 115     if (invertRects) {
 116         free(invertRects);
 117         invertRects = NULL;
 118         numInvertRects = 0;
 119     }
 120
 121     [helper setTextView:nil];
 122     [helper dealloc];  helper = nil;
 123
 124     [super dealloc];
 125 }
 126
 127 - (BOOL)shouldDrawInsertionPoint
 128 {
 129     // NOTE: The insertion point is drawn manually in drawRect:.  It would be
 130     // nice to be able to use the insertion point related methods of
 131     // NSTextView, but it seems impossible to get them to work properly (search
 132     // the cocoabuilder archives).
 133     return NO;
 134 }
 135
 136 - (void)setPreEditRow:(int)row column:(int)col
 137 {
 138     [helper setPreEditRow:row column:col];
 139 }
 140
 141 #define MM_DEBUG_DRAWING 0
 142
 143 - (void)performBatchDrawWithData:(NSData *)data
 144 {
 145     MMTextStorage *textStorage = (MMTextStorage *)[self textStorage];
 146     if (!textStorage)
 147         return;
 148
 149     const void *bytes = [data bytes];
 150     const void *end = bytes + [data length];
 151     int cursorRow = -1, cursorCol = 0;
 152
 153 #if MM_DEBUG_DRAWING
 154     NSLog(@"====> BEGIN %s", _cmd);
 155 #endif
 156     [textStorage beginEditing];
 157
 158     // TODO: Sanity check input
 159
 160     while (bytes < end) {
 161         int type = *((int*)bytes);  bytes += sizeof(int);
 162
 163         if (ClearAllDrawType == type) {
 164 #if MM_DEBUG_DRAWING
 165             NSLog(@"   Clear all");
 166 #endif
 167             [textStorage clearAll];
 168         } else if (ClearBlockDrawType == type) {
 169             unsigned color = *((unsigned*)bytes);  bytes += sizeof(unsigned);
 170             int row1 = *((int*)bytes);  bytes += sizeof(int);
 171             int col1 = *((int*)bytes);  bytes += sizeof(int);
 172             int row2 = *((int*)bytes);  bytes += sizeof(int);
 173             int col2 = *((int*)bytes);  bytes += sizeof(int);
 174
 175 #if MM_DEBUG_DRAWING
 176             NSLog(@"   Clear block (%d,%d) -> (%d,%d)", row1, col1,
 177                     row2,col2);
 178 #endif
 179             [textStorage clearBlockFromRow:row1 column:col1
 180                     toRow:row2 column:col2
 181                     color:[NSColor colorWithArgbInt:color]];
 182         } else if (DeleteLinesDrawType == type) {
 183             unsigned color = *((unsigned*)bytes);  bytes += sizeof(unsigned);
 184             int row = *((int*)bytes);  bytes += sizeof(int);
 185             int count = *((int*)bytes);  bytes += sizeof(int);
 186             int bot = *((int*)bytes);  bytes += sizeof(int);
 187             int left = *((int*)bytes);  bytes += sizeof(int);
 188             int right = *((int*)bytes);  bytes += sizeof(int);
 189
 190 #if MM_DEBUG_DRAWING
 191             NSLog(@"   Delete %d line(s) from %d", count, row);
 192 #endif
 193             [textStorage deleteLinesFromRow:row lineCount:count
 194                     scrollBottom:bot left:left right:right
 195                            color:[NSColor colorWithArgbInt:color]];
 196         } else if (DrawStringDrawType == type) {
 197             int bg = *((int*)bytes);  bytes += sizeof(int);
 198             int fg = *((int*)bytes);  bytes += sizeof(int);
 199             int sp = *((int*)bytes);  bytes += sizeof(int);
 200             int row = *((int*)bytes);  bytes += sizeof(int);
 201             int col = *((int*)bytes);  bytes += sizeof(int);
 202             int cells = *((int*)bytes);  bytes += sizeof(int);
 203             int flags = *((int*)bytes);  bytes += sizeof(int);
 204             int len = *((int*)bytes);  bytes += sizeof(int);
 205             NSString *string = [[NSString alloc]
 206                     initWithBytes:(void*)bytes length:len
 207                          encoding:NSUTF8StringEncoding];
 208             bytes += len;
 209
 210 #if MM_DEBUG_DRAWING
 211             NSLog(@"   Draw string at (%d,%d) length=%d flags=%d fg=0x%x "
 212                     "bg=0x%x sp=0x%x (%@)", row, col, len, flags, fg, bg, sp,
 213                     len > 0 ? [string substringToIndex:1] : @"");
 214 #endif
 215             // NOTE: If this is a call to draw the (block) cursor, then cancel
 216             // any previous request to draw the insertion point, or it might
 217             // get drawn as well.
 218             if (flags & DRAW_CURSOR)
 219                 [self setShouldDrawInsertionPoint:NO];
 220
 221             [textStorage drawString:string
 222                               atRow:row column:col cells:cells
 223                           withFlags:flags
 224                     foregroundColor:[NSColor colorWithRgbInt:fg]
 225                     backgroundColor:[NSColor colorWithArgbInt:bg]
 226                        specialColor:[NSColor colorWithRgbInt:sp]];
 227
 228             [string release];
 229         } else if (InsertLinesDrawType == type) {
 230             unsigned color = *((unsigned*)bytes);  bytes += sizeof(unsigned);
 231             int row = *((int*)bytes);  bytes += sizeof(int);
 232             int count = *((int*)bytes);  bytes += sizeof(int);
 233             int bot = *((int*)bytes);  bytes += sizeof(int);
 234             int left = *((int*)bytes);  bytes += sizeof(int);
 235             int right = *((int*)bytes);  bytes += sizeof(int);
 236
 237 #if MM_DEBUG_DRAWING
 238             NSLog(@"   Insert %d line(s) at row %d", count, row);
 239 #endif
 240             [textStorage insertLinesAtRow:row lineCount:count
 241                              scrollBottom:bot left:left right:right
 242                                     color:[NSColor colorWithArgbInt:color]];
 243         } else if (DrawCursorDrawType == type) {
 244             unsigned color = *((unsigned*)bytes);  bytes += sizeof(unsigned);
 245             int row = *((int*)bytes);  bytes += sizeof(int);
 246             int col = *((int*)bytes);  bytes += sizeof(int);
 247             int shape = *((int*)bytes);  bytes += sizeof(int);
 248             int percent = *((int*)bytes);  bytes += sizeof(int);
 249
 250 #if MM_DEBUG_DRAWING
 251             NSLog(@"   Draw cursor at (%d,%d)", row, col);
 252 #endif
 253             [helper setInsertionPointColor:[NSColor colorWithRgbInt:color]];
 254             [self drawInsertionPointAtRow:row column:col shape:shape
 255                                  fraction:percent];
 256         } else if (DrawInvertedRectDrawType == type) {
 257             int row = *((int*)bytes);  bytes += sizeof(int);
 258             int col = *((int*)bytes);  bytes += sizeof(int);
 259             int nr = *((int*)bytes);  bytes += sizeof(int);
 260             int nc = *((int*)bytes);  bytes += sizeof(int);
 261             int invert = *((int*)bytes);  bytes += sizeof(int);
 262
 263 #if MM_DEBUG_DRAWING
 264             NSLog(@"   Draw inverted rect: row=%d col=%d nrows=%d ncols=%d",
 265                     row, col, nr, nc);
 266 #endif
 267             [self drawInvertedRectAtRow:row column:col numRows:nr numColumns:nc
 268                                  invert:invert];
 269         } else if (SetCursorPosDrawType == type) {
 270             cursorRow = *((int*)bytes);  bytes += sizeof(int);
 271             cursorCol = *((int*)bytes);  bytes += sizeof(int);
 272         } else {
 273             NSLog(@"WARNING: Unknown draw type (type=%d)", type);
 274         }
 275     }
 276
 277     [textStorage endEditing];
 278
 279     if (cursorRow >= 0) {
 280         unsigned off = [textStorage characterIndexForRow:cursorRow
 281                                                   column:cursorCol];
 282         unsigned maxoff = [[textStorage string] length];
 283         if (off > maxoff) off = maxoff;
 284
 285         [self setSelectedRange:NSMakeRange(off, 0)];
 286     }
 287
 288     // NOTE: During resizing, Cocoa only sends draw messages before Vim's rows
 289     // and columns are changed (due to ipc delays). Force a redraw here.
 290     [self displayIfNeeded];
 291
 292 #if MM_DEBUG_DRAWING
 293     NSLog(@"<==== END   %s", _cmd);
 294 #endif
 295 }
 296
 297 - (void)setMouseShape:(int)shape
 298 {
 299     [helper setMouseShape:shape];
 300 }
 301
 302 - (void)setAntialias:(BOOL)state
 303 {
 304     antialias = state;
 305 }
 306
 307 - (NSFont *)font
 308 {
 309     return [(MMTextStorage*)[self textStorage] font];
 310 }
 311
 312 - (void)setFont:(NSFont *)newFont
 313 {
 314     [(MMTextStorage*)[self textStorage] setFont:newFont];
 315 }
 316
 317 - (NSFont *)fontWide
 318 {
 319     return [(MMTextStorage*)[self textStorage] fontWide];
 320 }
 321
 322 - (void)setWideFont:(NSFont *)newFont
 323 {
 324     [(MMTextStorage*)[self textStorage] setWideFont:newFont];
 325 }
 326
 327 - (NSSize)cellSize
 328 {
 329     return [(MMTextStorage*)[self textStorage] cellSize];
 330 }
 331
 332 - (void)setLinespace:(float)newLinespace
 333 {
 334     return [(MMTextStorage*)[self textStorage] setLinespace:newLinespace];
 335 }
 336
 337 - (int)maxRows
 338 {
 339     MMTextStorage *ts = (MMTextStorage *)[self textStorage];
 340     return [ts maxRows];
 341 }
 342
 343 - (int)maxColumns
 344 {
 345     MMTextStorage *ts = (MMTextStorage *)[self textStorage];
 346     return [ts maxColumns];
 347 }
 348
 349 - (void)getMaxRows:(int*)rows columns:(int*)cols
 350 {
 351     return [(MMTextStorage*)[self textStorage] getMaxRows:rows columns:cols];
 352 }
 353
 354 - (void)setMaxRows:(int)rows columns:(int)cols
 355 {
 356     return [(MMTextStorage*)[self textStorage] setMaxRows:rows columns:cols];
 357 }
 358
 359 - (NSRect)rectForRowsInRange:(NSRange)range
 360 {
 361     return [(MMTextStorage*)[self textStorage] rectForRowsInRange:range];
 362 }
 363
 364 - (NSRect)rectForColumnsInRange:(NSRange)range
 365 {
 366     return [(MMTextStorage*)[self textStorage] rectForColumnsInRange:range];
 367 }
 368
 369 - (void)setDefaultColorsBackground:(NSColor *)bgColor
 370                         foreground:(NSColor *)fgColor
 371 {
 372     [self setBackgroundColor:bgColor];
 373     return [(MMTextStorage*)[self textStorage]
 374             setDefaultColorsBackground:bgColor foreground:fgColor];
 375 }
 376
 377 - (NSColor *)defaultBackgroundColor
 378 {
 379     return [(MMTextStorage*)[self textStorage] defaultBackgroundColor];
 380 }
 381
 382 - (NSColor *)defaultForegroundColor
 383 {
 384     return [(MMTextStorage*)[self textStorage] defaultForegroundColor];
 385 }
 386
 387 - (NSSize)constrainRows:(int *)rows columns:(int *)cols toSize:(NSSize)size
 388 {
 389     NSUserDefaults *ud = [NSUserDefaults standardUserDefaults];
 390     int right = [ud integerForKey:MMTextInsetRightKey];
 391     int bot = [ud integerForKey:MMTextInsetBottomKey];
 392
 393     size.width -= [self textContainerOrigin].x + right;
 394     size.height -= [self textContainerOrigin].y + bot;
 395
 396     NSSize newSize = [(MMTextStorage*)[self textStorage] fitToSize:size
 397                                                               rows:rows
 398                                                            columns:cols];
 399
 400     newSize.width += [self textContainerOrigin].x + right;
 401     newSize.height += [self textContainerOrigin].y + bot;
 402
 403     return newSize;
 404 }
 405
 406 - (NSSize)desiredSize
 407 {
 408     NSSize size = [(MMTextStorage*)[self textStorage] size];
 409
 410     NSUserDefaults *ud = [NSUserDefaults standardUserDefaults];
 411     int right = [ud integerForKey:MMTextInsetRightKey];
 412     int bot = [ud integerForKey:MMTextInsetBottomKey];
 413
 414     size.width += [self textContainerOrigin].x + right;
 415     size.height += [self textContainerOrigin].y + bot;
 416
 417     return size;
 418 }
 419
 420 - (NSSize)minSize
 421 {
 422     NSSize cellSize = [(MMTextStorage*)[self textStorage] cellSize];
 423     NSSize size = { MMMinColumns*cellSize.width, MMMinRows*cellSize.height };
 424
 425     NSUserDefaults *ud = [NSUserDefaults standardUserDefaults];
 426     int right = [ud integerForKey:MMTextInsetRightKey];
 427     int bot = [ud integerForKey:MMTextInsetBottomKey];
 428
 429     size.width += [self textContainerOrigin].x + right;
 430     size.height += [self textContainerOrigin].y + bot;
 431
 432     return size;
 433 }
 434
 435 - (BOOL)convertPoint:(NSPoint)point toRow:(int *)row column:(int *)column
 436 {
 437     MMTextStorage *ts = (MMTextStorage*)[self textStorage];
 438     NSSize cellSize = [ts cellSize];
 439     if (!(cellSize.width > 0 && cellSize.height > 0))
 440         return NO;
 441     NSPoint origin = [self textContainerOrigin];
 442
 443     if (row) *row = floor((point.y-origin.y-1) / cellSize.height);
 444     if (column) *column = floor((point.x-origin.x-1) / cellSize.width);
 445
 446     //NSLog(@"convertPoint:%@ toRow:%d column:%d", NSStringFromPoint(point),
 447     //        *row, *column);
 448
 449     return YES;
 450 }
 451
 452 - (NSPoint)pointForRow:(int)row column:(int)col
 453 {
 454     // Return the upper-left coordinate for (row,column).
 455     // NOTE: The coordinate system is flipped!
 456     NSPoint pt = [self textContainerOrigin];
 457     MMTextStorage *ts = (MMTextStorage*)[self textStorage];
 458     NSSize cellSize = [ts cellSize];
 459
 460     pt.x += col * cellSize.width;
 461     pt.y += row * cellSize.height;
 462
 463     return pt;
 464 }
 465
 466 - (NSRect)rectForRow:(int)row column:(int)col numRows:(int)nr
 467           numColumns:(int)nc
 468 {
 469     // Return the rect for the block which covers the specified rows and
 470     // columns.  The upper-left corner is the origin of this rect.
 471     // NOTE: The coordinate system is flipped!
 472     NSRect rect;
 473     MMTextStorage *ts = (MMTextStorage*)[self textStorage];
 474     NSSize cellSize = [ts cellSize];
 475
 476     rect.origin = [self textContainerOrigin];
 477     rect.origin.x += col * cellSize.width;
 478     rect.origin.y += row * cellSize.height;
 479     rect.size.width = cellSize.width * nc;
 480     rect.size.height = cellSize.height * nr;
 481
 482     return rect;
 483 }
 484
 485 - (BOOL)isOpaque
 486 {
 487     return NO;
 488 }
 489
 490 - (void)drawRect:(NSRect)rect
 491 {
 492     NSGraphicsContext *context = [NSGraphicsContext currentContext];
 493     [context setShouldAntialias:antialias];
 494
 495     [super drawRect:rect];
 496
 497     if (invertRects) {
 498         CGContextRef cgctx = (CGContextRef)[context graphicsPort];
 499         CGContextSaveGState(cgctx);
 500         CGContextSetBlendMode(cgctx, kCGBlendModeDifference);
 501         CGContextSetRGBFillColor(cgctx, 1.0, 1.0, 1.0, 1.0);
 502
 503         int i;
 504         CGRect *rect = (CGRect*)invertRects;
 505         for (i = 0; i < numInvertRects; ++i)
 506             CGContextFillRect(cgctx, rect[i]);
 507
 508         CGContextRestoreGState(cgctx);
 509
 510         free(invertRects);
 511         invertRects = NULL;
 512         numInvertRects = 0;
 513     }
 514
 515     if ([self hasMarkedText]) {
 516         shouldDrawInsertionPoint = YES;
 517         MMTextStorage *ts = (MMTextStorage*)[self textStorage];
 518         NSSize inset = [self textContainerInset];
 519
 520         // HACK! Get the baseline of the zeroth glyph and use that as the
 521         // baseline for the marked text.  (Is there a better way to figure out
 522         // what baseline NSTextView uses?)
 523         NSLayoutManager *lm = [self layoutManager];
 524         NSTypesetter *tsr = [lm typesetter];
 525         float baseline = [tsr baselineOffsetInLayoutManager:lm glyphIndex:0];
 526
 527         // Also adjust for 'linespace' option (TODO: Why not .5*linespace?)
 528         baseline -= floor([ts linespace]);
 529
 530         inset.height -= baseline;
 531
 532         int len = [[helper markedText] length];
 533         // The following implementation should be re-written with
 534         // more efficient way...
 535
 536         // Calculate how many wide-font characters can be inserted at
 537         // a first line, and draw those characters.
 538         int cols = ([ts actualColumns] - insertionPointColumn);
 539         NSFont *theFont = [[self markedTextAttributes]
 540                 valueForKey:NSFontAttributeName];
 541         if (theFont == [ts fontWide])
 542             cols = cols / 2;
 543         int done = 0;
 544         int lend = cols > len ? len : cols;
 545         NSAttributedString *aString = [[helper markedText]
 546                 attributedSubstringFromRange:NSMakeRange(done, lend)];
 547         [aString drawAtPoint:NSMakePoint(
 548                 [helper preEditColumn]*[ts cellSize].width + inset.width,
 549                 [helper preEditRow]*[ts cellSize].height + inset.height)];
 550
 551         done = lend;
 552         // Check whether there're charecters that aren't drawn at
 553         // the first line. If everything is already done, the follow
 554         // check fails.
 555         if (done != len) {
 556             int r;
 557             // Calculate How many rows are needed to draw all the left
 558             // characters.
 559             int rows = (len - done) / ([ts actualColumns] / 2) + 1;
 560             for (r = 1; r <= rows; r++) {
 561                 lend = len - done > [ts actualColumns] / 2
 562                         ? [ts actualColumns] / 2 : len - done;
 563                 aString = [[helper markedText] attributedSubstringFromRange:
 564                         NSMakeRange(done, lend)];
 565                 [aString drawAtPoint:NSMakePoint(
 566                         inset.width,
 567                         ([helper preEditRow] + r)*[ts cellSize].height
 568                             + inset.height)];
 569                 done += lend;
 570             }
 571         }
 572     }
 573
 574     if (shouldDrawInsertionPoint) {
 575         MMTextStorage *ts = (MMTextStorage*)[self textStorage];
 576
 577         NSRect ipRect = [ts boundingRectForCharacterAtRow:[helper preEditRow]
 578                                                    column:[helper preEditColumn]];
 579         ipRect.origin.x += [self textContainerOrigin].x;
 580         ipRect.origin.y += [self textContainerOrigin].y;
 581
 582         // Draw insertion point inside marked text.
 583         if ([self hasMarkedText]) {
 584             NSFont *theFont = [[self markedTextAttributes]
 585                     valueForKey:NSFontAttributeName];
 586             if (theFont == [ts font])
 587                 ipRect.origin.x += [ts cellSize].width *
 588                                    ([helper imRange].location +
 589                                    [helper imRange].length);
 590             else
 591                 ipRect.origin.x += [ts cellSize].width * 2 *
 592                                    ([helper imRange].location +
 593                                    [helper imRange].length);
 594         }
 595
 596         if (MMInsertionPointHorizontal == insertionPointShape) {
 597             int frac = ([ts cellSize].height * insertionPointFraction + 99)/100;
 598             ipRect.origin.y += ipRect.size.height - frac;
 599             ipRect.size.height = frac;
 600         } else if (MMInsertionPointVertical == insertionPointShape) {
 601             int frac = ([ts cellSize].width * insertionPointFraction + 99)/100;
 602             ipRect.size.width = frac;
 603         } else if (MMInsertionPointVerticalRight == insertionPointShape) {
 604             int frac = ([ts cellSize].width * insertionPointFraction + 99)/100;
 605             ipRect.origin.x += ipRect.size.width - frac;
 606             ipRect.size.width = frac;
 607         }
 608
 609         [[helper insertionPointColor] set];
 610         if (MMInsertionPointHollow == insertionPointShape) {
 611             NSFrameRect(ipRect);
 612         } else {
 613             NSRectFill(ipRect);
 614         }
 615
 616         // NOTE: We only draw the cursor once and rely on Vim to say when it
 617         // should be drawn again.
 618         shouldDrawInsertionPoint = NO;
 619
 620         //NSLog(@"%s draw insertion point %@ shape=%d color=%@", _cmd,
 621         //        NSStringFromRect(ipRect), insertionPointShape,
 622         //        [helper insertionPointColor]);
 623     }
 624
 625 #if 0
 626     // this code invalidates the shadow, so we don't
 627     // get shifting ghost text on scroll and resize
 628     // but makes speed unusable
 629     MMTextStorage *ts = (MMTextStorage*)[self textStorage];
 630     if ([ts defaultBackgroundAlpha] < 1.0f) {
 631         if (floor(NSAppKitVersionNumber) <= NSAppKitVersionNumber10_1)
 632         {
 633             [[self window] setHasShadow:NO];
 634             [[self window] setHasShadow:YES];
 635         }
 636         else
 637             [[self window] invalidateShadow];
 638
 639     }
 640 #endif
 641 }
 642
 643 - (void)keyDown:(NSEvent *)event
 644 {
 645     [helper keyDown:event];
 646 }
 647
 648 - (void)insertText:(id)string
 649 {
 650     [helper insertText:string];
 651 }
 652
 653 - (void)doCommandBySelector:(SEL)selector
 654 {
 655     [helper doCommandBySelector:selector];
 656 }
 657
 658 - (BOOL)performKeyEquivalent:(NSEvent *)event
 659 {
 660     return [helper performKeyEquivalent:event];
 661 }
 662
 663 - (BOOL)hasMarkedText
 664 {
 665     return [helper hasMarkedText];
 666 }
 667
 668 - (NSRange)markedRange
 669 {
 670     return [helper markedRange];
 671 }
 672
 673 - (NSDictionary *)markedTextAttributes
 674 {
 675     return [helper markedTextAttributes];
 676 }
 677
 678 - (void)setMarkedTextAttributes:(NSDictionary *)attr
 679 {
 680     [helper setMarkedTextAttributes:attr];
 681 }
 682
 683 - (void)setMarkedText:(id)text selectedRange:(NSRange)range
 684 {
 685     [helper setMarkedText:text selectedRange:range];
 686 }
 687
 688 - (void)unmarkText
 689 {
 690     [helper unmarkText];
 691 }
 692
 693 - (NSRect)firstRectForCharacterRange:(NSRange)range
 694 {
 695     return [helper firstRectForCharacterRange:range];
 696 }
 697
 698 - (void)scrollWheel:(NSEvent *)event
 699 {
 700     [helper scrollWheel:event];
 701 }
 702
 703 - (void)mouseDown:(NSEvent *)event
 704 {
 705     [helper mouseDown:event];
 706 }
 707
 708 - (void)rightMouseDown:(NSEvent *)event
 709 {
 710     [helper mouseDown:event];
 711 }
 712
 713 - (void)otherMouseDown:(NSEvent *)event
 714 {
 715     [helper mouseDown:event];
 716 }
 717
 718 - (void)mouseUp:(NSEvent *)event
 719 {
 720     [helper mouseUp:event];
 721 }
 722
 723 - (void)rightMouseUp:(NSEvent *)event
 724 {
 725     [helper mouseUp:event];
 726 }
 727
 728 - (void)otherMouseUp:(NSEvent *)event
 729 {
 730     [helper mouseUp:event];
 731 }
 732
 733 - (void)mouseDragged:(NSEvent *)event
 734 {
 735     [helper mouseDragged:event];
 736 }
 737
 738 - (void)rightMouseDragged:(NSEvent *)event
 739 {
 740     [helper mouseDragged:event];
 741 }
 742
 743 - (void)otherMouseDragged:(NSEvent *)event
 744 {
 745     [helper mouseDragged:event];
 746 }
 747
 748 - (void)mouseMoved:(NSEvent *)event
 749 {
 750     [helper mouseMoved:event];
 751 }
 752
 753 - (void)mouseEntered:(NSEvent *)event
 754 {
 755     [helper mouseEntered:event];
 756 }
 757
 758 - (void)mouseExited:(NSEvent *)event
 759 {
 760     [helper mouseExited:event];
 761 }
 762
 763 - (void)setFrame:(NSRect)frame
 764 {
 765     [super setFrame:frame];
 766     [helper setFrame:frame];
 767 }
 768
 769 - (void)viewDidMoveToWindow
 770 {
 771     [helper viewDidMoveToWindow];
 772 }
 773
 774 - (void)viewWillMoveToWindow:(NSWindow *)newWindow
 775 {
 776     [helper viewWillMoveToWindow:newWindow];
 777 }
 778
 779 - (NSMenu*)menuForEvent:(NSEvent *)event
 780 {
 781     // HACK! Return nil to disable NSTextView's popup menus (Vim provides its
 782     // own).  Called when user Ctrl-clicks in the view (this is already handled
 783     // in rightMouseDown:).
 784     return nil;
 785 }
 786
 787 - (NSArray *)acceptableDragTypes
 788 {
 789     return [NSArray arrayWithObjects:NSFilenamesPboardType,
 790            NSStringPboardType, nil];
 791 }
 792
 793 - (BOOL)performDragOperation:(id <NSDraggingInfo>)sender
 794 {
 795     return [helper performDragOperation:sender];
 796 }
 797
 798 - (NSDragOperation)draggingEntered:(id <NSDraggingInfo>)sender
 799 {
 800     return [helper draggingEntered:sender];
 801 }
 802
 803 - (NSDragOperation)draggingUpdated:(id <NSDraggingInfo>)sender
 804 {
 805     return [helper draggingUpdated:sender];
 806 }
 807
 808 - (void)changeFont:(id)sender
 809 {
 810     MMTextStorage *ts = (MMTextStorage*)[self textStorage];
 811     if (!ts) return;
 812
 813     NSFont *oldFont = [ts font];
 814     NSFont *newFont = [sender convertFont:oldFont];
 815
 816     if (newFont) {
 817         NSString *name = [newFont displayName];
 818         unsigned len = [name lengthOfBytesUsingEncoding:NSUTF8StringEncoding];
 819         if (len > 0) {
 820             NSMutableData *data = [NSMutableData data];
 821             float pointSize = [newFont pointSize];
 822
 823             [data appendBytes:&pointSize length:sizeof(float)];
 824
 825             ++len;  // include NUL byte
 826             [data appendBytes:&len length:sizeof(unsigned)];
 827             [data appendBytes:[name UTF8String] length:len];
 828
 829             [[self vimController] sendMessage:SetFontMsgID data:data];
 830         }
 831     }
 832 }
 833
 834 - (void)resetCursorRects
 835 {
 836     // No need to set up cursor rects since Vim handles cursor changes.
 837 }
 838
 839 - (void)updateFontPanel
 840 {
 841     // The font panel is updated whenever the font is set.
 842 }
 843
 844
 845 //
 846 // NOTE: The menu items cut/copy/paste/undo/redo/select all/... must be bound
 847 // to the same actions as in IB otherwise they will not work with dialogs.  All
 848 // we do here is forward these actions to the Vim process.
 849 //
 850 - (IBAction)cut:(id)sender
 851 {
 852     [[self windowController] vimMenuItemAction:sender];
 853 }
 854
 855 - (IBAction)copy:(id)sender
 856 {
 857     [[self windowController] vimMenuItemAction:sender];
 858 }
 859
 860 - (IBAction)paste:(id)sender
 861 {
 862     [[self windowController] vimMenuItemAction:sender];
 863 }
 864
 865 - (IBAction)undo:(id)sender
 866 {
 867     [[self windowController] vimMenuItemAction:sender];
 868 }
 869
 870 - (IBAction)redo:(id)sender
 871 {
 872     [[self windowController] vimMenuItemAction:sender];
 873 }
 874
 875 - (IBAction)selectAll:(id)sender
 876 {
 877     [[self windowController] vimMenuItemAction:sender];
 878 }
 879
 880 - (BOOL)validateMenuItem:(NSMenuItem *)item
 881 {
 882     if ([item action] == @selector(cut:)
 883             || [item action] == @selector(copy:)
 884             || [item action] == @selector(paste:)
 885             || [item action] == @selector(undo:)
 886             || [item action] == @selector(redo:)
 887             || [item action] == @selector(selectAll:))
 888         return [item tag];
 889
 890     return YES;
 891 }
 892
 893 @end // MMTextView
 894
 895
 896
 897
 898 @implementation MMTextView (Private)
 899
 900 - (MMWindowController *)windowController
 901 {
 902     id windowController = [[self window] windowController];
 903     if ([windowController isKindOfClass:[MMWindowController class]])
 904         return (MMWindowController*)windowController;
 905     return nil;
 906 }
 907
 908 - (MMVimController *)vimController
 909 {
 910     return [[self windowController] vimController];
 911 }
 912
 913 - (void)setShouldDrawInsertionPoint:(BOOL)on
 914 {
 915     shouldDrawInsertionPoint = on;
 916 }
 917
 918 - (void)drawInsertionPointAtRow:(int)row column:(int)col shape:(int)shape
 919                        fraction:(int)percent
 920 {
 921     // This only stores where to draw the insertion point, the actual drawing
 922     // is done in drawRect:.
 923     shouldDrawInsertionPoint = YES;
 924     insertionPointRow = row;
 925     insertionPointColumn = col;
 926     insertionPointShape = shape;
 927     insertionPointFraction = percent;
 928 }
 929
 930 - (void)drawInvertedRectAtRow:(int)row column:(int)col numRows:(int)nrows
 931                    numColumns:(int)ncols invert:(int)invert
 932 {
 933     if (invert) {
 934         // The result should be inverted.
 935         int n = numInvertRects++;
 936         invertRects = reallocf(invertRects,
 937                                numInvertRects*sizeof(NSRect));
 938         if (NULL != invertRects) {
 939             invertRects[n] = [self rectForRow:row column:col numRows:nrows
 940                                    numColumns:ncols];
 941             [self setNeedsDisplayInRect:invertRects[n]];
 942         } else {
 943             n = numInvertRects = 0;
 944         }
 945     } else {
 946         // The result should look normal; all we need to do is to mark
 947         // the rect for redrawing and Cocoa will redraw the text.
 948         NSRect rect = [self rectForRow:row column:col numRows:nrows
 949                             numColumns:ncols];
 950         [self setNeedsDisplayInRect:rect];
 951     }
 952 }
 953
 954 @end // MMTextView (Private)