src/MacVim/MMAtsuiTextView.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  * MMAtsuiTextView
  12  *
  13  * Dispatches keyboard and mouse input to the backend.  Handles drag-n-drop of
  14  * files onto window.  The rendering is done using ATSUI.
  15  *
  16  * The text view area consists of two parts:
  17  *   1. The text area - this is where text is rendered; the size is governed by
  18  *      the current number of rows and columns.
  19  *   2. The inset area - this is a border around the text area; the size is
  20  *      governed by the user defaults MMTextInset[Left|Right|Top|Bottom].
  21  *
  22  * The current size of the text view frame does not always match the desired
  23  * area, i.e. the area determined by the number of rows, columns plus text
  24  * inset.  This distinction is particularly important when the view is being
  25  * resized.
  26  */
  27
  28 #import "MMAppController.h"
  29 #import "MMAtsuiTextView.h"
  30 #import "MMTextViewHelper.h"
  31 #import "MMVimController.h"
  32 #import "MMWindowController.h"
  33 #import "Miscellaneous.h"
  34
  35
  36 // TODO: What does DRAW_TRANSP flag do?  If the background isn't drawn when
  37 // this flag is set, then sometimes the character after the cursor becomes
  38 // blank.  Everything seems to work fine by just ignoring this flag.
  39 #define DRAW_TRANSP               0x01    /* draw with transparant bg */
  40 #define DRAW_BOLD                 0x02    /* draw bold text */
  41 #define DRAW_UNDERL               0x04    /* draw underline text */
  42 #define DRAW_UNDERC               0x08    /* draw undercurl text */
  43 #define DRAW_ITALIC               0x10    /* draw italic text */
  44 #define DRAW_CURSOR               0x20
  45
  46 #define kUnderlineOffset            (-2)
  47 #define kUnderlineHeight            1
  48 #define kUndercurlHeight            2
  49 #define kUndercurlOffset            (-2)
  50 #define kUndercurlDotWidth          2
  51 #define kUndercurlDotDistance       2
  52
  53
  54 @interface NSFont (AppKitPrivate)
  55 - (ATSUFontID) _atsFontID;
  56 @end
  57
  58
  59 @interface MMAtsuiTextView (Private)
  60 - (void)initAtsuStyles;
  61 - (void)disposeAtsuStyles;
  62 - (void)updateAtsuStyles;
  63 - (MMWindowController *)windowController;
  64 - (MMVimController *)vimController;
  65 @end
  66
  67
  68 @interface MMAtsuiTextView (Drawing)
  69 - (NSPoint)originForRow:(int)row column:(int)column;
  70 - (NSRect)rectFromRow:(int)row1 column:(int)col1
  71                 toRow:(int)row2 column:(int)col2;
  72 - (NSSize)textAreaSize;
  73 - (void)resizeContentImage;
  74 - (void)beginDrawing;
  75 - (void)endDrawing;
  76 - (void)drawString:(UniChar *)string length:(UniCharCount)length
  77              atRow:(int)row column:(int)col cells:(int)cells
  78          withFlags:(int)flags foregroundColor:(NSColor *)fg
  79    backgroundColor:(NSColor *)bg specialColor:(NSColor *)sp;
  80 - (void)deleteLinesFromRow:(int)row lineCount:(int)count
  81               scrollBottom:(int)bottom left:(int)left right:(int)right
  82                      color:(NSColor *)color;
  83 - (void)insertLinesAtRow:(int)row lineCount:(int)count
  84             scrollBottom:(int)bottom left:(int)left right:(int)right
  85                    color:(NSColor *)color;
  86 - (void)clearBlockFromRow:(int)row1 column:(int)col1 toRow:(int)row2
  87                    column:(int)col2 color:(NSColor *)color;
  88 - (void)clearAll;
  89 - (void)drawInsertionPointAtRow:(int)row column:(int)col shape:(int)shape
  90                        fraction:(int)percent;
  91 - (void)drawInvertedRectAtRow:(int)row column:(int)col numRows:(int)nrows
  92                    numColumns:(int)ncols;
  93 @end
  94
  95
  96
  97     static float
  98 defaultLineHeightForFont(NSFont *font)
  99 {
 100     // HACK: -[NSFont defaultLineHeightForFont] is deprecated but since the
 101     // ATSUI renderer does not use NSLayoutManager we create one temporarily.
 102     NSLayoutManager *lm = [[NSLayoutManager alloc] init];
 103     float height = [lm defaultLineHeightForFont:font];
 104     [lm release];
 105
 106     return height;
 107 }
 108
 109 @implementation MMAtsuiTextView
 110
 111 - (id)initWithFrame:(NSRect)frame
 112 {
 113     if (!(self = [super initWithFrame:frame]))
 114         return nil;
 115
 116     // NOTE!  It does not matter which font is set here, Vim will set its
 117     // own font on startup anyway.  Just set some bogus values.
 118     font = [[NSFont userFixedPitchFontOfSize:0] retain];
 119     ascender = 0;
 120     cellSize.width = cellSize.height = 1;
 121     contentImage = nil;
 122     imageSize = NSZeroSize;
 123     insetSize = NSZeroSize;
 124
 125     // NOTE: If the default changes to 'NO' then the intialization of
 126     // p_antialias in option.c must change as well.
 127     antialias = YES;
 128
 129     helper = [[MMTextViewHelper alloc] init];
 130     [helper setTextView:self];
 131
 132     [self initAtsuStyles];
 133
 134     [self registerForDraggedTypes:[NSArray arrayWithObjects:
 135             NSFilenamesPboardType, NSStringPboardType, nil]];
 136
 137     return self;
 138 }
 139
 140 - (void)dealloc
 141 {
 142     LOG_DEALLOC
 143
 144     [self disposeAtsuStyles];
 145     [font release];  font = nil;
 146     [defaultBackgroundColor release];  defaultBackgroundColor = nil;
 147     [defaultForegroundColor release];  defaultForegroundColor = nil;
 148
 149     [helper setTextView:nil];
 150     [helper dealloc];  helper = nil;
 151
 152     [super dealloc];
 153 }
 154
 155 - (int)maxRows
 156 {
 157     return maxRows;
 158 }
 159
 160 - (int)maxColumns
 161 {
 162     return maxColumns;
 163 }
 164
 165 - (void)getMaxRows:(int*)rows columns:(int*)cols
 166 {
 167     if (rows) *rows = maxRows;
 168     if (cols) *cols = maxColumns;
 169 }
 170
 171 - (void)setMaxRows:(int)rows columns:(int)cols
 172 {
 173     // NOTE: Just remember the new values, the actual resizing is done lazily.
 174     maxRows = rows;
 175     maxColumns = cols;
 176 }
 177
 178 - (void)setDefaultColorsBackground:(NSColor *)bgColor
 179                         foreground:(NSColor *)fgColor
 180 {
 181     if (defaultBackgroundColor != bgColor) {
 182         [defaultBackgroundColor release];
 183         defaultBackgroundColor = bgColor ? [bgColor retain] : nil;
 184     }
 185
 186     if (defaultForegroundColor != fgColor) {
 187         [defaultForegroundColor release];
 188         defaultForegroundColor = fgColor ? [fgColor retain] : nil;
 189     }
 190 }
 191
 192 - (NSColor *)defaultBackgroundColor
 193 {
 194     return defaultBackgroundColor;
 195 }
 196
 197 - (NSColor *)defaultForegroundColor
 198 {
 199     return defaultForegroundColor;
 200 }
 201
 202 - (void)setTextContainerInset:(NSSize)size
 203 {
 204     insetSize = size;
 205 }
 206
 207 - (NSRect)rectForRowsInRange:(NSRange)range
 208 {
 209     NSRect rect = { 0, 0, 0, 0 };
 210     unsigned start = range.location > maxRows ? maxRows : range.location;
 211     unsigned length = range.length;
 212
 213     if (start + length > maxRows)
 214         length = maxRows - start;
 215
 216     rect.origin.y = cellSize.height * start + insetSize.height;
 217     rect.size.height = cellSize.height * length;
 218
 219     return rect;
 220 }
 221
 222 - (NSRect)rectForColumnsInRange:(NSRange)range
 223 {
 224     NSRect rect = { 0, 0, 0, 0 };
 225     unsigned start = range.location > maxColumns ? maxColumns : range.location;
 226     unsigned length = range.length;
 227
 228     if (start+length > maxColumns)
 229         length = maxColumns - start;
 230
 231     rect.origin.x = cellSize.width * start + insetSize.width;
 232     rect.size.width = cellSize.width * length;
 233
 234     return rect;
 235 }
 236
 237
 238 - (void)setFont:(NSFont *)newFont
 239 {
 240     if (newFont && font != newFont) {
 241         [font release];
 242         font = [newFont retain];
 243         ascender = roundf([font ascender]);
 244
 245         float em = [@"m" sizeWithAttributes:
 246                 [NSDictionary dictionaryWithObject:newFont
 247                                             forKey:NSFontAttributeName]].width;
 248         float cellWidthMultiplier = [[NSUserDefaults standardUserDefaults]
 249                 floatForKey:MMCellWidthMultiplierKey];
 250
 251         // NOTE! Even though NSFontFixedAdvanceAttribute is a float, it will
 252         // only render at integer sizes.  Hence, we restrict the cell width to
 253         // an integer here, otherwise the window width and the actual text
 254         // width will not match.
 255         cellSize.width = ceilf(em * cellWidthMultiplier);
 256         cellSize.height = linespace + defaultLineHeightForFont(newFont);
 257
 258         [self updateAtsuStyles];
 259     }
 260 }
 261
 262 - (void)setWideFont:(NSFont *)newFont
 263 {
 264     if (!newFont) {
 265         if (font) [self setWideFont:font];
 266     } else if (newFont != fontWide) {
 267         float pointSize = [newFont pointSize];
 268         NSFontDescriptor *desc = [newFont fontDescriptor];
 269         NSDictionary *dictWide = [NSDictionary
 270             dictionaryWithObject:[NSNumber numberWithFloat:2*cellSize.width]
 271                           forKey:NSFontFixedAdvanceAttribute];
 272         desc = [desc fontDescriptorByAddingAttributes:dictWide];
 273         fontWide = [NSFont fontWithDescriptor:desc size:pointSize];
 274         [fontWide retain];
 275     }
 276 }
 277
 278 - (NSFont *)font
 279 {
 280     return font;
 281 }
 282
 283 - (NSFont *)fontWide
 284 {
 285     return fontWide;
 286 }
 287
 288 - (NSSize)cellSize
 289 {
 290     return cellSize;
 291 }
 292
 293 - (void)setLinespace:(float)newLinespace
 294 {
 295     linespace = newLinespace;
 296
 297     // NOTE: The linespace is added to the cell height in order for a multiline
 298     // selection not to have white (background color) gaps between lines.  Also
 299     // this simplifies the code a lot because there is no need to check the
 300     // linespace when calculating the size of the text view etc.  When the
 301     // linespace is non-zero the baseline will be adjusted as well; check
 302     // MMTypesetter.
 303     cellSize.height = linespace + defaultLineHeightForFont(font);
 304 }
 305
 306
 307
 308 - (void)setShouldDrawInsertionPoint:(BOOL)on
 309 {
 310 }
 311
 312 - (void)setPreEditRow:(int)row column:(int)col
 313 {
 314     [helper setPreEditRow:row column:col];
 315 }
 316
 317 - (void)setMouseShape:(int)shape
 318 {
 319     [helper setMouseShape:shape];
 320 }
 321
 322 - (void)setAntialias:(BOOL)state
 323 {
 324     antialias = state;
 325 }
 326
 327 - (void)setImControl:(BOOL)enable
 328 {
 329     [helper setImControl:enable];
 330 }
 331
 332 - (void)keyDown:(NSEvent *)event
 333 {
 334     [helper keyDown:event];
 335 }
 336
 337 - (void)insertText:(id)string
 338 {
 339     [helper insertText:string];
 340 }
 341
 342 - (void)doCommandBySelector:(SEL)selector
 343 {
 344     [helper doCommandBySelector:selector];
 345 }
 346
 347 - (BOOL)performKeyEquivalent:(NSEvent *)event
 348 {
 349     return [helper performKeyEquivalent:event];
 350 }
 351
 352 - (BOOL)hasMarkedText
 353 {
 354     return [helper hasMarkedText];
 355 }
 356
 357 - (NSRange)markedRange
 358 {
 359     return [helper markedRange];
 360 }
 361
 362 - (NSDictionary *)markedTextAttributes
 363 {
 364     return [helper markedTextAttributes];
 365 }
 366
 367 - (void)setMarkedTextAttributes:(NSDictionary *)attr
 368 {
 369     [helper setMarkedTextAttributes:attr];
 370 }
 371
 372 - (void)setMarkedText:(id)text selectedRange:(NSRange)range
 373 {
 374     [helper setMarkedText:text selectedRange:range];
 375 }
 376
 377 - (void)unmarkText
 378 {
 379     [helper unmarkText];
 380 }
 381
 382 - (void)scrollWheel:(NSEvent *)event
 383 {
 384     [helper scrollWheel:event];
 385 }
 386
 387 - (void)mouseDown:(NSEvent *)event
 388 {
 389     [helper mouseDown:event];
 390 }
 391
 392 - (void)rightMouseDown:(NSEvent *)event
 393 {
 394     [helper mouseDown:event];
 395 }
 396
 397 - (void)otherMouseDown:(NSEvent *)event
 398 {
 399     [helper mouseDown:event];
 400 }
 401
 402 - (void)mouseUp:(NSEvent *)event
 403 {
 404     [helper mouseUp:event];
 405 }
 406
 407 - (void)rightMouseUp:(NSEvent *)event
 408 {
 409     [helper mouseUp:event];
 410 }
 411
 412 - (void)otherMouseUp:(NSEvent *)event
 413 {
 414     [helper mouseUp:event];
 415 }
 416
 417 - (void)mouseDragged:(NSEvent *)event
 418 {
 419     [helper mouseDragged:event];
 420 }
 421
 422 - (void)rightMouseDragged:(NSEvent *)event
 423 {
 424     [helper mouseDragged:event];
 425 }
 426
 427 - (void)otherMouseDragged:(NSEvent *)event
 428 {
 429     [helper mouseDragged:event];
 430 }
 431
 432 - (void)mouseMoved:(NSEvent *)event
 433 {
 434     [helper mouseMoved:event];
 435 }
 436
 437 - (void)mouseEntered:(NSEvent *)event
 438 {
 439     [helper mouseEntered:event];
 440 }
 441
 442 - (void)mouseExited:(NSEvent *)event
 443 {
 444     [helper mouseExited:event];
 445 }
 446
 447 - (void)setFrame:(NSRect)frame
 448 {
 449     [super setFrame:frame];
 450     [helper setFrame:frame];
 451 }
 452
 453 - (void)viewDidMoveToWindow
 454 {
 455     [helper viewDidMoveToWindow];
 456 }
 457
 458 - (void)viewWillMoveToWindow:(NSWindow *)newWindow
 459 {
 460     [helper viewWillMoveToWindow:newWindow];
 461 }
 462
 463 - (NSMenu*)menuForEvent:(NSEvent *)event
 464 {
 465     // HACK! Return nil to disable default popup menus (Vim provides its own).
 466     // Called when user Ctrl-clicks in the view (this is already handled in
 467     // rightMouseDown:).
 468     return nil;
 469 }
 470
 471 - (BOOL)performDragOperation:(id <NSDraggingInfo>)sender
 472 {
 473     return [helper performDragOperation:sender];
 474 }
 475
 476 - (NSDragOperation)draggingEntered:(id <NSDraggingInfo>)sender
 477 {
 478     return [helper draggingEntered:sender];
 479 }
 480
 481 - (NSDragOperation)draggingUpdated:(id <NSDraggingInfo>)sender
 482 {
 483     return [helper draggingUpdated:sender];
 484 }
 485
 486
 487
 488 - (BOOL)mouseDownCanMoveWindow
 489 {
 490     return NO;
 491 }
 492
 493 - (BOOL)isOpaque
 494 {
 495     return YES;
 496 }
 497
 498 - (BOOL)acceptsFirstResponder
 499 {
 500     return YES;
 501 }
 502
 503 - (BOOL)isFlipped
 504 {
 505     return NO;
 506 }
 507
 508 - (void)drawRect:(NSRect)rect
 509 {
 510     [defaultBackgroundColor set];
 511     NSRectFill(rect);
 512
 513     NSPoint pt = { insetSize.width, insetSize.height };
 514     [contentImage compositeToPoint:pt operation:NSCompositeCopy];
 515
 516     if ([self hasMarkedText]) {
 517         int len = [[helper markedText] length];
 518         int rows = 0;
 519         int cols = maxColumns - [helper preEditColumn];
 520         NSFont *theFont = [[self markedTextAttributes]
 521             valueForKey:NSFontAttributeName];
 522         if (theFont == [self fontWide])
 523             cols = cols / 2;
 524         int done = 0;
 525         int lend = cols > len ? len : cols;
 526         NSAttributedString *aString = [[helper markedText]
 527                 attributedSubstringFromRange:NSMakeRange(done, lend)];
 528         NSPoint pt = [self pointForRow:[helper preEditRow]
 529                                 column:[helper preEditColumn]];
 530         [aString drawAtPoint:pt];
 531         done = lend;
 532         if (done != len) {
 533             int r;
 534             rows = (len - done) / (maxColumns / 2) + 1;
 535             for (r = 1; r <= rows; r++) {
 536             lend = len - done > maxColumns / 2
 537                 ? maxColumns / 2 : len - done;
 538                 aString = [[helper markedText] attributedSubstringFromRange:
 539                         NSMakeRange(done, lend)];
 540                 NSPoint pt = [self pointForRow:[helper preEditRow]+r
 541                                         column:0];
 542                 [aString drawAtPoint:pt];
 543                 done += lend;
 544             }
 545         }
 546
 547         rows = maxRows - 1 - [helper preEditRow];
 548         cols = [helper preEditColumn];
 549         if (theFont == fontWide) {
 550             cols += ([helper imRange].location+[helper imRange].length) * 2;
 551             if (cols >= maxColumns - 1) {
 552                 rows -= cols / maxColumns;
 553                 cols = cols % 2 ? cols % maxColumns + 1 :
 554                                   cols % maxColumns;
 555             }
 556         } else {
 557             cols += ([helper imRange].location+[helper imRange].length);
 558             if (cols >= maxColumns) {
 559                 rows -= cols / maxColumns;
 560                 cols = cols % 2 ? cols % maxColumns + 1 :
 561                                   cols % maxColumns;
 562             }
 563         }
 564
 565         // TODO: Could IM be in "right-left" mode?  If so the insertion point
 566         // will be on the wrong side.
 567         [self drawInsertionPointAtRow:rows
 568                                column:cols
 569                                 shape:MMInsertionPointVertical
 570                              fraction:25];
 571     }
 572 }
 573
 574 - (BOOL) wantsDefaultClipping
 575 {
 576     return NO;
 577 }
 578
 579
 580 #define MM_DEBUG_DRAWING 0
 581
 582 - (void)performBatchDrawWithData:(NSData *)data
 583 {
 584     const void *bytes = [data bytes];
 585     const void *end = bytes + [data length];
 586
 587     if (! NSEqualSizes(imageSize, [self textAreaSize]))
 588         [self resizeContentImage];
 589
 590 #if MM_DEBUG_DRAWING
 591     NSLog(@"====> BEGIN %s", _cmd);
 592 #endif
 593     [self beginDrawing];
 594
 595     // TODO: Sanity check input
 596
 597     while (bytes < end) {
 598         int type = *((int*)bytes);  bytes += sizeof(int);
 599
 600         if (ClearAllDrawType == type) {
 601 #if MM_DEBUG_DRAWING
 602             NSLog(@"   Clear all");
 603 #endif
 604             [self clearAll];
 605         } else if (ClearBlockDrawType == type) {
 606             unsigned color = *((unsigned*)bytes);  bytes += sizeof(unsigned);
 607             int row1 = *((int*)bytes);  bytes += sizeof(int);
 608             int col1 = *((int*)bytes);  bytes += sizeof(int);
 609             int row2 = *((int*)bytes);  bytes += sizeof(int);
 610             int col2 = *((int*)bytes);  bytes += sizeof(int);
 611
 612 #if MM_DEBUG_DRAWING
 613             NSLog(@"   Clear block (%d,%d) -> (%d,%d)", row1, col1,
 614                     row2,col2);
 615 #endif
 616             [self clearBlockFromRow:row1 column:col1
 617                     toRow:row2 column:col2
 618                     color:[NSColor colorWithArgbInt:color]];
 619         } else if (DeleteLinesDrawType == type) {
 620             unsigned color = *((unsigned*)bytes);  bytes += sizeof(unsigned);
 621             int row = *((int*)bytes);  bytes += sizeof(int);
 622             int count = *((int*)bytes);  bytes += sizeof(int);
 623             int bot = *((int*)bytes);  bytes += sizeof(int);
 624             int left = *((int*)bytes);  bytes += sizeof(int);
 625             int right = *((int*)bytes);  bytes += sizeof(int);
 626
 627 #if MM_DEBUG_DRAWING
 628             NSLog(@"   Delete %d line(s) from %d", count, row);
 629 #endif
 630             [self deleteLinesFromRow:row lineCount:count
 631                     scrollBottom:bot left:left right:right
 632                            color:[NSColor colorWithArgbInt:color]];
 633         } else if (DrawStringDrawType == type) {
 634             int bg = *((int*)bytes);  bytes += sizeof(int);
 635             int fg = *((int*)bytes);  bytes += sizeof(int);
 636             int sp = *((int*)bytes);  bytes += sizeof(int);
 637             int row = *((int*)bytes);  bytes += sizeof(int);
 638             int col = *((int*)bytes);  bytes += sizeof(int);
 639             int cells = *((int*)bytes);  bytes += sizeof(int);
 640             int flags = *((int*)bytes);  bytes += sizeof(int);
 641             int len = *((int*)bytes);  bytes += sizeof(int);
 642             // UniChar *string = (UniChar*)bytes;  bytes += len;
 643             NSString *string = [[NSString alloc]
 644                     initWithBytesNoCopy:(void*)bytes
 645                                  length:len
 646                                encoding:NSUTF8StringEncoding
 647                            freeWhenDone:NO];
 648             bytes += len;
 649 #if MM_DEBUG_DRAWING
 650             NSLog(@"   Draw string at (%d,%d) length=%d flags=%d fg=0x%x "
 651                     "bg=0x%x sp=0x%x", row, col, len, flags, fg, bg, sp);
 652 #endif
 653             unichar *characters = malloc(sizeof(unichar) * [string length]);
 654             [string getCharacters:characters];
 655
 656             [self drawString:characters
 657                              length:[string length]
 658                               atRow:row
 659                              column:col
 660                               cells:cells withFlags:flags
 661                     foregroundColor:[NSColor colorWithRgbInt:fg]
 662                     backgroundColor:[NSColor colorWithArgbInt:bg]
 663                        specialColor:[NSColor colorWithRgbInt:sp]];
 664             free(characters);
 665             [string release];
 666         } else if (InsertLinesDrawType == type) {
 667             unsigned color = *((unsigned*)bytes);  bytes += sizeof(unsigned);
 668             int row = *((int*)bytes);  bytes += sizeof(int);
 669             int count = *((int*)bytes);  bytes += sizeof(int);
 670             int bot = *((int*)bytes);  bytes += sizeof(int);
 671             int left = *((int*)bytes);  bytes += sizeof(int);
 672             int right = *((int*)bytes);  bytes += sizeof(int);
 673
 674 #if MM_DEBUG_DRAWING
 675             NSLog(@"   Insert %d line(s) at row %d", count, row);
 676 #endif
 677             [self insertLinesAtRow:row lineCount:count
 678                              scrollBottom:bot left:left right:right
 679                                     color:[NSColor colorWithArgbInt:color]];
 680         } else if (DrawCursorDrawType == type) {
 681             unsigned color = *((unsigned*)bytes);  bytes += sizeof(unsigned);
 682             int row = *((int*)bytes);  bytes += sizeof(int);
 683             int col = *((int*)bytes);  bytes += sizeof(int);
 684             int shape = *((int*)bytes);  bytes += sizeof(int);
 685             int percent = *((int*)bytes);  bytes += sizeof(int);
 686
 687 #if MM_DEBUG_DRAWING
 688             NSLog(@"   Draw cursor at (%d,%d)", row, col);
 689 #endif
 690             [helper setInsertionPointColor:[NSColor colorWithRgbInt:color]];
 691             [self drawInsertionPointAtRow:row column:col shape:shape
 692                                  fraction:percent];
 693         } else if (DrawInvertedRectDrawType == type) {
 694             int row = *((int*)bytes);  bytes += sizeof(int);
 695             int col = *((int*)bytes);  bytes += sizeof(int);
 696             int nr = *((int*)bytes);  bytes += sizeof(int);
 697             int nc = *((int*)bytes);  bytes += sizeof(int);
 698             /*int invert = *((int*)bytes);*/  bytes += sizeof(int);
 699
 700 #if MM_DEBUG_DRAWING
 701             NSLog(@"   Draw inverted rect: row=%d col=%d nrows=%d ncols=%d",
 702                     row, col, nr, nc);
 703 #endif
 704             [self drawInvertedRectAtRow:row column:col numRows:nr
 705                              numColumns:nc];
 706         } else if (SetCursorPosDrawType == type) {
 707             // TODO: This is used for Voice Over support in MMTextView,
 708             // MMAtsuiTextView currently does not support Voice Over.
 709             /*cursorRow = *((int*)bytes);*/  bytes += sizeof(int);
 710             /*cursorCol = *((int*)bytes);*/  bytes += sizeof(int);
 711         } else {
 712             NSLog(@"WARNING: Unknown draw type (type=%d)", type);
 713         }
 714     }
 715
 716     [self endDrawing];
 717
 718     [self setNeedsDisplay:YES];
 719
 720     // NOTE: During resizing, Cocoa only sends draw messages before Vim's rows
 721     // and columns are changed (due to ipc delays). Force a redraw here.
 722     if ([self inLiveResize])
 723         [self display];
 724
 725 #if MM_DEBUG_DRAWING
 726     NSLog(@"<==== END   %s", _cmd);
 727 #endif
 728 }
 729
 730 - (NSSize)constrainRows:(int *)rows columns:(int *)cols toSize:(NSSize)size
 731 {
 732     // TODO:
 733     // - Rounding errors may cause size change when there should be none
 734     // - Desired rows/columns shold not be 'too small'
 735
 736     // Constrain the desired size to the given size.  Values for the minimum
 737     // rows and columns is taken from Vim.
 738     NSSize desiredSize = [self desiredSize];
 739     int desiredRows = maxRows;
 740     int desiredCols = maxColumns;
 741
 742     if (size.height != desiredSize.height) {
 743         float fh = cellSize.height;
 744         float ih = 2 * insetSize.height;
 745         if (fh < 1.0f) fh = 1.0f;
 746
 747         desiredRows = floor((size.height - ih)/fh);
 748         desiredSize.height = fh*desiredRows + ih;
 749     }
 750
 751     if (size.width != desiredSize.width) {
 752         float fw = cellSize.width;
 753         float iw = 2 * insetSize.width;
 754         if (fw < 1.0f) fw = 1.0f;
 755
 756         desiredCols = floor((size.width - iw)/fw);
 757         desiredSize.width = fw*desiredCols + iw;
 758     }
 759
 760     if (rows) *rows = desiredRows;
 761     if (cols) *cols = desiredCols;
 762
 763     return desiredSize;
 764 }
 765
 766 - (NSSize)desiredSize
 767 {
 768     // Compute the size the text view should be for the entire text area and
 769     // inset area to be visible with the present number of rows and columns.
 770     return NSMakeSize(maxColumns * cellSize.width + 2 * insetSize.width,
 771                       maxRows * cellSize.height + 2 * insetSize.height);
 772 }
 773
 774 - (NSSize)minSize
 775 {
 776     // Compute the smallest size the text view is allowed to be.
 777     return NSMakeSize(MMMinColumns * cellSize.width + 2 * insetSize.width,
 778                       MMMinRows * cellSize.height + 2 * insetSize.height);
 779 }
 780
 781 - (void)changeFont:(id)sender
 782 {
 783     NSFont *newFont = [sender convertFont:font];
 784
 785     if (newFont) {
 786         NSString *name = [newFont displayName];
 787         unsigned len = [name lengthOfBytesUsingEncoding:NSUTF8StringEncoding];
 788         if (len > 0) {
 789             NSMutableData *data = [NSMutableData data];
 790             float pointSize = [newFont pointSize];
 791
 792             [data appendBytes:&pointSize length:sizeof(float)];
 793
 794             ++len;  // include NUL byte
 795             [data appendBytes:&len length:sizeof(unsigned)];
 796             [data appendBytes:[name UTF8String] length:len];
 797
 798             [[self vimController] sendMessage:SetFontMsgID data:data];
 799         }
 800     }
 801 }
 802
 803
 804 //
 805 // NOTE: The menu items cut/copy/paste/undo/redo/select all/... must be bound
 806 // to the same actions as in IB otherwise they will not work with dialogs.  All
 807 // we do here is forward these actions to the Vim process.
 808 //
 809 - (IBAction)cut:(id)sender
 810 {
 811     [[self windowController] vimMenuItemAction:sender];
 812 }
 813
 814 - (IBAction)copy:(id)sender
 815 {
 816     [[self windowController] vimMenuItemAction:sender];
 817 }
 818
 819 - (IBAction)paste:(id)sender
 820 {
 821     [[self windowController] vimMenuItemAction:sender];
 822 }
 823
 824 - (IBAction)undo:(id)sender
 825 {
 826     [[self windowController] vimMenuItemAction:sender];
 827 }
 828
 829 - (IBAction)redo:(id)sender
 830 {
 831     [[self windowController] vimMenuItemAction:sender];
 832 }
 833
 834 - (IBAction)selectAll:(id)sender
 835 {
 836     [[self windowController] vimMenuItemAction:sender];
 837 }
 838
 839 - (BOOL)convertPoint:(NSPoint)point toRow:(int *)row column:(int *)column
 840 {
 841     // View is not flipped, instead the atsui code draws to a flipped image;
 842     // thus we need to 'flip' the coordinate here since the column number
 843     // increases in an up-to-down order.
 844     point.y = [self frame].size.height - point.y;
 845
 846     NSPoint origin = { insetSize.width, insetSize.height };
 847
 848     if (!(cellSize.width > 0 && cellSize.height > 0))
 849         return NO;
 850
 851     if (row) *row = floor((point.y-origin.y-1) / cellSize.height);
 852     if (column) *column = floor((point.x-origin.x-1) / cellSize.width);
 853
 854     return YES;
 855 }
 856
 857 - (NSPoint)pointForRow:(int)row column:(int)col
 858 {
 859     // Return the lower left coordinate of the cell at (row,column).
 860     NSPoint pt;
 861
 862     pt.x = insetSize.width + col*cellSize.width;
 863     pt.y = [self frame].size.height -
 864            (insetSize.height + (1+row)*cellSize.height);
 865
 866     return pt;
 867 }
 868
 869 - (NSRect)rectForRow:(int)row column:(int)col numRows:(int)nr
 870           numColumns:(int)nc
 871 {
 872     // Return the rect for the block which covers the specified rows and
 873     // columns.  The lower-left corner is the origin of this rect.
 874     NSRect rect;
 875
 876     rect.origin.x = insetSize.width + col*cellSize.width;
 877     rect.origin.y = [self frame].size.height -
 878                     (insetSize.height + (nr+row)*cellSize.height);
 879     rect.size.width = nc*cellSize.width;
 880     rect.size.height = nr*cellSize.height;
 881
 882     return rect;
 883 }
 884
 885 - (NSArray *)validAttributesForMarkedText
 886 {
 887     return nil;
 888 }
 889
 890 - (NSAttributedString *)attributedSubstringFromRange:(NSRange)range
 891 {
 892     return nil;
 893 }
 894
 895 - (NSUInteger)characterIndexForPoint:(NSPoint)point
 896 {
 897     return NSNotFound;
 898 }
 899
 900 // The return type of this message changed with OS X 10.5 so we need this
 901 // kludge in order to avoid compiler warnings on OS X 10.4.
 902 #if (MAC_OS_X_VERSION_MAX_ALLOWED > MAC_OS_X_VERSION_10_4)
 903 - (NSInteger)conversationIdentifier
 904 {
 905     return (NSInteger)self;
 906 }
 907 #else
 908 - (long)conversationIdentifier
 909 {
 910     return (long)self;
 911 }
 912 #endif
 913
 914 - (NSRange)selectedRange
 915 {
 916     return [helper imRange];
 917 }
 918
 919 - (NSRect)firstRectForCharacterRange:(NSRange)range
 920 {
 921     return [helper firstRectForCharacterRange:range];
 922 }
 923
 924 @end // MMAtsuiTextView
 925
 926
 927
 928
 929 @implementation MMAtsuiTextView (Private)
 930
 931 - (void)initAtsuStyles
 932 {
 933     int i;
 934     for (i = 0; i < MMMaxCellsPerChar; i++)
 935         ATSUCreateStyle(&atsuStyles[i]);
 936 }
 937
 938 - (void)disposeAtsuStyles
 939 {
 940     int i;
 941
 942     for (i = 0; i < MMMaxCellsPerChar; i++)
 943         if (atsuStyles[i] != NULL)
 944         {
 945             if (ATSUDisposeStyle(atsuStyles[i]) != noErr)
 946                 atsuStyles[i] = NULL;
 947         }
 948 }
 949
 950 - (void)updateAtsuStyles
 951 {
 952     ATSUFontID        fontID;
 953     Fixed             fontSize;
 954     Fixed             fontWidth;
 955     int               i;
 956     CGAffineTransform transform = CGAffineTransformMakeScale(1, -1);
 957     ATSStyleRenderingOptions options;
 958
 959     fontID    = [font _atsFontID];
 960     fontSize  = Long2Fix([font pointSize]);
 961     options   = kATSStyleApplyAntiAliasing;
 962
 963     ATSUAttributeTag attribTags[] =
 964     {
 965         kATSUFontTag, kATSUSizeTag, kATSUImposeWidthTag,
 966         kATSUFontMatrixTag, kATSUStyleRenderingOptionsTag,
 967         kATSUMaxATSUITagValue + 1
 968     };
 969
 970     ByteCount attribSizes[] =
 971     {
 972         sizeof(ATSUFontID), sizeof(Fixed), sizeof(fontWidth),
 973         sizeof(CGAffineTransform), sizeof(ATSStyleRenderingOptions),
 974         sizeof(font)
 975     };
 976
 977     ATSUAttributeValuePtr attribValues[] =
 978     {
 979         &fontID, &fontSize, &fontWidth, &transform, &options, &font
 980     };
 981
 982     ATSUFontFeatureType featureTypes[] = {
 983         kLigaturesType, kLigaturesType
 984     };
 985
 986     ATSUFontFeatureSelector featureSelectors[] = {
 987         kCommonLigaturesOffSelector, kRareLigaturesOffSelector
 988     };
 989
 990     for (i = 0; i < MMMaxCellsPerChar; i++)
 991     {
 992         fontWidth = Long2Fix(cellSize.width * (i + 1));
 993
 994         if (ATSUSetAttributes(atsuStyles[i],
 995                               (sizeof attribTags) / sizeof(ATSUAttributeTag),
 996                               attribTags, attribSizes, attribValues) != noErr)
 997         {
 998             ATSUDisposeStyle(atsuStyles[i]);
 999             atsuStyles[i] = NULL;
1000         }
1001
1002         // Turn off ligatures by default
1003         ATSUSetFontFeatures(atsuStyles[i],
1004                             sizeof(featureTypes) / sizeof(featureTypes[0]),
1005                             featureTypes, featureSelectors);
1006     }
1007 }
1008
1009 - (MMWindowController *)windowController
1010 {
1011     id windowController = [[self window] windowController];
1012     if ([windowController isKindOfClass:[MMWindowController class]])
1013         return (MMWindowController*)windowController;
1014     return nil;
1015 }
1016
1017 - (MMVimController *)vimController
1018 {
1019     return [[self windowController] vimController];
1020 }
1021
1022 @end // MMAtsuiTextView (Private)
1023
1024
1025
1026
1027 @implementation MMAtsuiTextView (Drawing)
1028
1029 - (NSPoint)originForRow:(int)row column:(int)col
1030 {
1031     return NSMakePoint(col * cellSize.width, row * cellSize.height);
1032 }
1033
1034 - (NSRect)rectFromRow:(int)row1 column:(int)col1
1035                 toRow:(int)row2 column:(int)col2
1036 {
1037     NSPoint origin = [self originForRow:row1 column:col1];
1038     return NSMakeRect(origin.x, origin.y,
1039                       (col2 + 1 - col1) * cellSize.width,
1040                       (row2 + 1 - row1) * cellSize.height);
1041 }
1042
1043 - (NSSize)textAreaSize
1044 {
1045     // Calculate the (desired) size of the text area, i.e. the text view area
1046     // minus the inset area.
1047     return NSMakeSize(maxColumns * cellSize.width, maxRows * cellSize.height);
1048 }
1049
1050 - (void)resizeContentImage
1051 {
1052     //NSLog(@"resizeContentImage");
1053     [contentImage release];
1054     contentImage = [[NSImage alloc] initWithSize:[self textAreaSize]];
1055     [contentImage setFlipped:YES];
1056     imageSize = [self textAreaSize];
1057 }
1058
1059 - (void)beginDrawing
1060 {
1061     [contentImage lockFocus];
1062 }
1063
1064 - (void)endDrawing
1065 {
1066     [contentImage unlockFocus];
1067 }
1068
1069 #define atsu_style_set_bool(s, t, b) \
1070     ATSUSetAttributes(s, 1, &t, &(sizeof(Boolean)), &&b);
1071 #define FILL_Y(y)    (y * cellSize.height)
1072
1073 - (void)drawString:(UniChar *)string length:(UniCharCount)length
1074              atRow:(int)row column:(int)col cells:(int)cells
1075          withFlags:(int)flags foregroundColor:(NSColor *)fg
1076    backgroundColor:(NSColor *)bg specialColor:(NSColor *)sp
1077 {
1078     // 'string' consists of 'length' utf-16 code pairs and should cover 'cells'
1079     // display cells (a normal character takes up one display cell, a wide
1080     // character takes up two)
1081     ATSUStyle       style = (flags & DRAW_WIDE) ? atsuStyles[1] : atsuStyles[0];
1082     ATSUTextLayout  layout;
1083
1084     // Font selection and rendering options for ATSUI
1085     ATSUAttributeTag      attribTags[3] = { kATSUQDBoldfaceTag,
1086                                             kATSUFontMatrixTag,
1087                                             kATSUStyleRenderingOptionsTag };
1088
1089     ByteCount             attribSizes[] = { sizeof(Boolean),
1090                                             sizeof(CGAffineTransform),
1091                                             sizeof(UInt32) };
1092     Boolean               useBold;
1093     CGAffineTransform     theTransform = CGAffineTransformMakeScale(1.0, -1.0);
1094     UInt32                useAntialias;
1095
1096     ATSUAttributeValuePtr attribValues[3] = { &useBold, &theTransform,
1097                                               &useAntialias };
1098
1099     useBold      = (flags & DRAW_BOLD) ? true : false;
1100
1101     if (flags & DRAW_ITALIC)
1102         theTransform.c = Fix2X(kATSItalicQDSkew);
1103
1104     useAntialias = antialias ? kATSStyleApplyAntiAliasing
1105                              : kATSStyleNoAntiAliasing;
1106
1107     ATSUSetAttributes(style, sizeof(attribValues) / sizeof(attribValues[0]),
1108                       attribTags, attribSizes, attribValues);
1109
1110     // NSLog(@"drawString: %d", length);
1111
1112     ATSUCreateTextLayout(&layout);
1113     ATSUSetTextPointerLocation(layout, string,
1114                                kATSUFromTextBeginning, kATSUToTextEnd,
1115                                length);
1116     ATSUSetRunStyle(layout, style, kATSUFromTextBeginning, kATSUToTextEnd);
1117
1118     NSRect rect = NSMakeRect(col * cellSize.width, row * cellSize.height,
1119                              length * cellSize.width, cellSize.height);
1120     if (flags & DRAW_WIDE)
1121         rect.size.width = rect.size.width * 2;
1122     CGContextRef context = [[NSGraphicsContext currentContext] graphicsPort];
1123
1124     ATSUAttributeTag tags[] = { kATSUCGContextTag };
1125     ByteCount sizes[] = { sizeof(CGContextRef) };
1126     ATSUAttributeValuePtr values[] = { &context };
1127     ATSUSetLayoutControls(layout, 1, tags, sizes, values);
1128
1129     if (! (flags & DRAW_TRANSP))
1130     {
1131         [bg set];
1132         NSRectFill(rect);
1133     }
1134
1135     [fg set];
1136
1137     ATSUSetTransientFontMatching(layout, TRUE);
1138     ATSUDrawText(layout,
1139                  kATSUFromTextBeginning,
1140                  kATSUToTextEnd,
1141                  X2Fix(rect.origin.x),
1142                  X2Fix(rect.origin.y + ascender));
1143     ATSUDisposeTextLayout(layout);
1144
1145     if (flags & DRAW_UNDERL)
1146     {
1147         [sp set];
1148         NSRectFill(NSMakeRect(rect.origin.x,
1149                               (row + 1) * cellSize.height + kUnderlineOffset,
1150                               rect.size.width, kUnderlineHeight));
1151     }
1152
1153     if (flags & DRAW_UNDERC)
1154     {
1155         [sp set];
1156
1157         float line_end_x = rect.origin.x + rect.size.width;
1158         int i = 0;
1159         NSRect line_rect = NSMakeRect(
1160                 rect.origin.x,
1161                 (row + 1) * cellSize.height + kUndercurlOffset,
1162                 kUndercurlDotWidth, kUndercurlHeight);
1163
1164         while (line_rect.origin.x < line_end_x)
1165         {
1166             if (i % 2)
1167                 NSRectFill(line_rect);
1168
1169             line_rect.origin.x += kUndercurlDotDistance;
1170             i++;
1171         }
1172     }
1173 }
1174
1175 - (void)scrollRect:(NSRect)rect lineCount:(int)count
1176 {
1177     NSPoint destPoint = rect.origin;
1178     destPoint.y += count * cellSize.height;
1179
1180     NSCopyBits(0, rect, destPoint);
1181 }
1182
1183 - (void)deleteLinesFromRow:(int)row lineCount:(int)count
1184               scrollBottom:(int)bottom left:(int)left right:(int)right
1185                      color:(NSColor *)color
1186 {
1187     NSRect rect = [self rectFromRow:row + count
1188                              column:left
1189                               toRow:bottom
1190                              column:right];
1191     [color set];
1192     // move rect up for count lines
1193     [self scrollRect:rect lineCount:-count];
1194     [self clearBlockFromRow:bottom - count + 1
1195                      column:left
1196                       toRow:bottom
1197                      column:right
1198                       color:color];
1199 }
1200
1201 - (void)insertLinesAtRow:(int)row lineCount:(int)count
1202             scrollBottom:(int)bottom left:(int)left right:(int)right
1203                    color:(NSColor *)color
1204 {
1205     NSRect rect = [self rectFromRow:row
1206                              column:left
1207                               toRow:bottom - count
1208                              column:right];
1209     [color set];
1210     // move rect down for count lines
1211     [self scrollRect:rect lineCount:count];
1212     [self clearBlockFromRow:row
1213                      column:left
1214                       toRow:row + count - 1
1215                      column:right
1216                       color:color];
1217 }
1218
1219 - (void)clearBlockFromRow:(int)row1 column:(int)col1 toRow:(int)row2
1220                    column:(int)col2 color:(NSColor *)color
1221 {
1222     [color set];
1223     NSRectFill([self rectFromRow:row1 column:col1 toRow:row2 column:col2]);
1224 }
1225
1226 - (void)clearAll
1227 {
1228     [defaultBackgroundColor set];
1229     NSRectFill(NSMakeRect(0, 0, imageSize.width, imageSize.height));
1230 }
1231
1232 - (void)drawInsertionPointAtRow:(int)row column:(int)col shape:(int)shape
1233                        fraction:(int)percent
1234 {
1235     NSPoint origin = [self originForRow:row column:col];
1236     NSRect rect = NSMakeRect(origin.x, origin.y,
1237                              cellSize.width, cellSize.height);
1238
1239     // NSLog(@"shape = %d, fraction: %d", shape, percent);
1240
1241     if (MMInsertionPointHorizontal == shape) {
1242         int frac = (cellSize.height * percent + 99)/100;
1243         rect.origin.y += rect.size.height - frac;
1244         rect.size.height = frac;
1245     } else if (MMInsertionPointVertical == shape) {
1246         int frac = (cellSize.width * percent + 99)/100;
1247         rect.size.width = frac;
1248     } else if (MMInsertionPointVerticalRight == shape) {
1249         int frac = (cellSize.width * percent + 99)/100;
1250         rect.origin.x += rect.size.width - frac;
1251         rect.size.width = frac;
1252     }
1253
1254     [[helper insertionPointColor] set];
1255     if (MMInsertionPointHollow == shape) {
1256         NSFrameRect(rect);
1257     } else {
1258         NSRectFill(rect);
1259     }
1260 }
1261
1262 - (void)drawInvertedRectAtRow:(int)row column:(int)col numRows:(int)nrows
1263                    numColumns:(int)ncols
1264 {
1265     // TODO: THIS CODE HAS NOT BEEN TESTED!
1266     CGContextRef cgctx = [[NSGraphicsContext currentContext] graphicsPort];
1267     CGContextSaveGState(cgctx);
1268     CGContextSetBlendMode(cgctx, kCGBlendModeDifference);
1269     CGContextSetRGBFillColor(cgctx, 1.0, 1.0, 1.0, 1.0);
1270
1271     CGRect rect = { col * cellSize.width, row * cellSize.height,
1272                     ncols * cellSize.width, nrows * cellSize.height };
1273     CGContextFillRect(cgctx, rect);
1274
1275     CGContextRestoreGState(cgctx);
1276 }
1277
1278 @end // MMAtsuiTextView (Drawing)