From e05f23b3b99993e9932e961942f3a465ee7277a7 Mon Sep 17 00:00:00 2001
From: Yee Cheng Chin <ychin.git@gmail.com>
Date: Fri, 20 Jan 2023 18:25:15 -0800
Subject: [PATCH 1/4] Rename the "preserve line spacing" setting to "use macOS
 calculation"

The setting was added to "preserve" the font's original line spacing
intents, but after further investigation I cannot find why Apple's
calculation for font line spacing to be so wide. Furthermore it's quite
odd because the default line spacing is wide, but the only thing that
setting does is by re-initializing the font under Core Text (instead of
using NSFont like the default) using CTFont and somehow the issue is
fixed. Inspecting font metrics (using ttx) also didn't seem to give any
hints why the spacing are so wide (e.g. ascent / descent / line gap etc
all look fine). A StackOverflow comment seems to suggest that Apple is
simply adding a 1.2x scale to some fonts
(https://stackoverflow.com/questions/5511830/how-does-line-spacing-work-in-core-text-and-why-is-it-different-from-nslayoutm)
which seems to match the observation. My guess is that Apple looks at
some fonts and think they are too aggressive in their font metrics
design and "helpfully" introduces a 1.2x multiplier to space them out,
where Core Text is lower level than AppKit and therefore does not have
this auto-inflation.

By renaming the option it should make it clearer that this is a somewhat
arbitrary distinction instead of it being an inherent property of the
font.
---
 src/MacVim/Base.lproj/Preferences.xib | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/MacVim/Base.lproj/Preferences.xib b/src/MacVim/Base.lproj/Preferences.xib
index 228c305069..3bad81f8bb 100644
--- a/src/MacVim/Base.lproj/Preferences.xib
+++ b/src/MacVim/Base.lproj/Preferences.xib
@@ -425,8 +425,8 @@
                         <button id="A48-s0-kdR" userLabel="Preserve Line Spacing">
                             <rect key="frame" x="189" y="-1" width="244" height="18"/>
                             <autoresizingMask key="autoresizingMask" flexibleMinY="YES"/>
-                            <string key="toolTip">Some fonts have non-standard built-in line spacings (anything other than 1). If this is checked, MacVim will use the font's specified line spacing to calculate line height. Otherwise, it will just set it to 1, which helps if you would like a more compact spacing without having to install another font.</string>
-                            <buttonCell key="cell" type="check" title="Preserve font line spacing" bezelStyle="regularSquare" imagePosition="left" alignment="left" inset="2" id="SeR-yl-Gtz" userLabel="Preserve Line Spacing">
+                            <string key="toolTip">macOS can sometimes use a conservative approach to calculating line spacing for a font (by setting a 1.2 line spacing). This could potentially lead to line spacing feeling too wide. Unchecking this will use a tighter calculation and use a 1.0 line spacing instead.</string>
+                            <buttonCell key="cell" type="check" title="Use macOS line spacing calculation" bezelStyle="regularSquare" imagePosition="left" alignment="left" inset="2" id="SeR-yl-Gtz" userLabel="Preserve Line Spacing">
                                 <behavior key="behavior" changeContents="YES" doesNotDimImage="YES" lightByContents="YES"/>
                                 <font key="font" metaFont="system"/>
                             </buttonCell>

From 49e7a1da766368a0c38da7d5d907a5925826d438 Mon Sep 17 00:00:00 2001
From: Yee Cheng Chin <ychin.git@gmail.com>
Date: Fri, 20 Jan 2023 18:25:16 -0800
Subject: [PATCH 2/4] Remove the ceil() call around fontDescent in Core Text
 renderer

I have looked and I do not believe there is a good reason to do this
rounding up at all. I believe the motivation is to align the baseline
with the pixel boundary, but I don't believe that is necessary, given
that Core Text will properly perform the correct antialiasing for us.
Most texts aren't directly aligned at the baseline anyway. Before, that
ceil() option is a reason why sometimes fonts would feel pushed upwards,
clipping emojis to the top, and creating a lopsided effect for fonts
like Fira Code (h11), since we draw the boxes aligned to the line
height at the bottom of the descender, meaning the ceil() has an effect
of pushing the text up.
---
 src/MacVim/MMCoreTextView.m | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/MacVim/MMCoreTextView.m b/src/MacVim/MMCoreTextView.m
index 85a169fcc5..0dbf22e2e2 100644
--- a/src/MacVim/MMCoreTextView.m
+++ b/src/MacVim/MMCoreTextView.m
@@ -434,7 +434,7 @@ - (void)setFont:(NSFont *)newFont
     } else {
         font = [newFont retain];
     }
-    fontDescent = ceil(CTFontGetDescent((CTFontRef)font));
+    fontDescent = CTFontGetDescent((CTFontRef)font);
     fontAscent = CTFontGetAscent((CTFontRef)font);
     fontXHeight = CTFontGetXHeight((CTFontRef)font);
 

From fe2305ddf5b466a934ab68e739f10d9557031551 Mon Sep 17 00:00:00 2001
From: Yee Cheng Chin <ychin.git@gmail.com>
Date: Fri, 20 Jan 2023 18:25:16 -0800
Subject: [PATCH 3/4] Fix composing characters renderered at an offset
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

MacVim previously didn't really render composing characters with
multiple glyphs correctly. For simple ones like 'â' it would work fine
because Core Text just generates one glyph for it, but for more
complicated ones like 'x⃗' the renderer didn't properly query the advance
of the glyphs to put them at the correct position. Refactor the logic to
keep track of the current cell/glyphs and make sure to track the
advances fo the glyphs so the composing chars' glyphs would be laid out
properly on top of the cell.

We need to be careful with the tracking, because in Vim we force the
text rendering to be monospaced, and so we maintain the tracking within
a single grapheme (which can consist of multiple glyphs), but when we
move to the next grapheme we reset the position so we can get proper
monospaced rendering even for non-monospaced texts like CJK or stylized
texts.

Fix #995
Fix #1172
---
 src/MacVim/MMCoreTextView.m | 112 +++++++++++++++++++++++++++++++-----
 1 file changed, 97 insertions(+), 15 deletions(-)

diff --git a/src/MacVim/MMCoreTextView.m b/src/MacVim/MMCoreTextView.m
index 0dbf22e2e2..92841d3568 100644
--- a/src/MacVim/MMCoreTextView.m
+++ b/src/MacVim/MMCoreTextView.m
@@ -142,6 +142,10 @@ - (void)invertBlockFromRow:(int)row column:(int)col numRows:(int)nrows
     int fraction;
 } GridCellInsertionPoint;
 
+/// A cell in the grid. Each cell represents a grapheme, which could consist of one or more
+/// characters. If textFlags contains DRAW_WIDE, then it's a 'wide' cell, which means a grapheme
+/// takes up two cell spaces to render (e.g. emoji or CJK characters). When this is the case, the
+/// next cell in the grid should be ignored and skipped.
 typedef struct {
     // Note: All objects should be weak references.
     // Fields are grouped by draw order.
@@ -160,7 +164,7 @@ - (void)invertBlockFromRow:(int)row column:(int)col numRows:(int)nrows
     unsigned fg;
     unsigned sp;
     int textFlags;
-    NSString* string; // Owned by characterStrings.
+    NSString* string; ///< Owned by characterStrings. Length would be >1 if there are composing chars.
 } GridCell;
 
 typedef struct {
@@ -786,14 +790,19 @@ - (void)drawRect:(NSRect)rect
         __block CFRange lineStringRange = {};
         __block GridCell lastStringCell = {};
         void (^flushLineString)() = ^{
+            // This function flushes the current pending line out to be rendered. When ligature is
+            // enabled it could be quite long.  Otherwise, lineString would be just one cell/grapheme. Note
+            // that even one cell can have lineString.length > 1 and also multiple glyphs due to
+            // composing characters (limited by Vim's 'maxcombine').
             if (!lineString.length)
                 return;
-            CGPoint positionsByIndex[lineString.length];
+            size_t cellOffsetByIndex[lineString.length];
             for (size_t i = 0, stringIndex = 0; i < lineStringRange.length; i++) {
                 GridCell cell = *grid_cell(&grid, r, lineStringRange.location + i);
                 size_t cell_length = cell.string.length;
-                for (size_t j = 0; j < cell_length; j++)
-                    positionsByIndex[stringIndex++] = CGPointMake(i * cellSize.width, 0);
+                for (size_t j = 0; j < cell_length; j++) {
+                    cellOffsetByIndex[stringIndex++] = i;
+                }
                 if (cell.textFlags & DRAW_WIDE)
                     i++;
             }
@@ -807,26 +816,98 @@ - (void)drawRect:(NSRect)rect
             if ([glyphRuns count] == 0) {
                 ASLogDebug(@"CTLineGetGlyphRuns no glyphs for: %@", lineString);
             }
+
+            CGSize accumAdvance = CGSizeZero; // Accumulated advance for the currently cell's glyphs (we can get more than one glyph when we have composing chars)
+            CGPoint expectedGlyphPosition = CGPointZero; // The expected layout glyph position produced by CTLine
+            size_t curCell = -1; // The current cell offset within lineStrangeRange
+
             for (id obj in glyphRuns) {
                 CTRunRef run = (CTRunRef)obj;
                 CFIndex glyphCount = CTRunGetGlyphCount(run);
-                CFIndex indices[glyphCount];
+
+                CTFontRef runFont = CFDictionaryGetValue(CTRunGetAttributes(run), kCTFontAttributeName);
+                if (!runFont) {
+                    ASLogDebug(@"Null font for rendering. glyphCount: %ld", (long)glyphCount);
+                }
+
                 CGPoint positions[glyphCount];
-                CGGlyph glyphs[glyphCount];
-                CTRunGetStringIndices(run, CFRangeMake(0, 0), indices);
-                CTRunGetGlyphs(run, CFRangeMake(0, 0), glyphs);
+
+                CFIndex indices_storage[glyphCount];
+                const CFIndex* indices = NULL;
+                if ((indices = CTRunGetStringIndicesPtr(run)) == NULL) {
+                    CTRunGetStringIndices(run, CFRangeMake(0, 0), indices_storage);
+                    indices = indices_storage;
+                }
+
+                const CGGlyph* glyphs = NULL;
+                CGGlyph glyphs_storage[glyphCount];
+                if ((glyphs = CTRunGetGlyphsPtr(run)) == NULL) {
+                    CTRunGetGlyphs(run, CFRangeMake(0, 0), glyphs_storage);
+                    glyphs = glyphs_storage;
+                }
+
+                const CGSize* advances = NULL;
+                CGSize advances_storage[glyphCount];
+                if ((advances = CTRunGetAdvancesPtr(run)) == NULL) {
+                    CTRunGetAdvances(run, CFRangeMake(0, 0), advances_storage);
+                    advances = advances_storage;
+                }
+
+                const CGPoint* layoutPositions = CTRunGetPositionsPtr(run);
+                CGPoint layoutPositions_storage[glyphCount];
+                if (layoutPositions == NULL) {
+                    CTRunGetPositions(run, CFRangeMake(0, 0), layoutPositions_storage);
+                    layoutPositions = layoutPositions_storage;
+                }
+
                 for (CFIndex i = 0; i < glyphCount; i++) {
                     if (indices[i] >= lineStringLength) {
                         ASLogDebug(@"Invalid glyph pos index: %ld, len: %lu", (long)indices[i], (unsigned long)lineStringLength);
                         continue;
                     }
-                    positions[i] = positionsByIndex[indices[i]];
-                }
-                CTFontRef font = CFDictionaryGetValue(CTRunGetAttributes(run), kCTFontAttributeName);
-                if (!font) {
-                    ASLogDebug(@"Null font for rendering. glyphCount: %ld", (long)glyphCount);
+                    if (curCell != -1 && curCell == cellOffsetByIndex[indices[i]]) {
+                        // We are still in the same cell/grapheme as last glyph. This usually only happens
+                        // when we have 1 or more composing characters (e.g. U+20E3 or U+20D7), and
+                        // Core Text decides to render them as separate glyphs instead of a single
+                        // one (e.g. 'â' will result in a single glyph instead).
+                        //
+                        // Don't do anything to allow the last glyph's advance to accumulate.
+                    } else {
+                        // We are in a new cell/grapheme with a new string to render. This is the
+                        // normal case.
+                        // In this situation we reset the accumulated advances because we render
+                        // every cell aligned to the grid and force everything to a monospace.
+                        accumAdvance = CGSizeZero;
+                        curCell = cellOffsetByIndex[indices[i]];
+                    }
+
+                    // Align the position to the grid cell. Ignore what the typesetter wants (we
+                    // should be using a monospace font anyway, but if you are say entering CJK
+                    // characters font substitution will result in a non-monospaced typesetting)
+                    const CGPoint curCellPosition = CGPointMake(curCell * cellSize.width, 0);
+                    positions[i] = curCellPosition;
+
+                    // Add the accumulated advances, which would be non-zero if this is not the
+                    // first glyph for this cell/character (due to composing chars).
+                    positions[i].x += accumAdvance.width;
+                    positions[i].y += accumAdvance.height;
+
+                    // The expected glyph position should usually match what the layout wants to do.
+                    // Sometimes though the typesetter will offset it slightly (e.g. when rendering
+                    // 'x゙⃣', the first 'x' will be offsetted to give space to the later composing
+                    // chars. Since we are manually rendering to curCellPosition to align to a grid,
+                    // we take the offset and apply that instead of directly using layoutPositions.
+                    positions[i].x += (layoutPositions[i].x - expectedGlyphPosition.x);
+                    positions[i].y += (layoutPositions[i].y - expectedGlyphPosition.y);
+
+                    // Accumulate the glyph's advance
+                    accumAdvance.width += advances[i].width;
+                    accumAdvance.height += advances[i].height;
+                    expectedGlyphPosition.x += advances[i].width;
+                    expectedGlyphPosition.y += advances[i].height;
+
                 }
-                CTFontDrawGlyphs(font, glyphs, positions, glyphCount, ctx);
+                CTFontDrawGlyphs(runFont, glyphs, positions, glyphCount, ctx);
             }
 
             CGContextSetBlendMode(ctx, kCGBlendModeCopy);
@@ -976,7 +1057,8 @@ - (void)drawRect:(NSRect)rect
 
             // Text strikethrough
             // We delay the rendering of strikethrough and only do it as a second-pass since we want to draw them on top
-            // of text, and text rendering is currently delayed via flushLineString().
+            // of text, and text rendering is currently delayed via flushLineString(). This is important for things like
+            // emojis where the color of the text is different from the underline's color.
             if (cell.textFlags & DRAW_STRIKE) {
                 hasStrikeThrough = YES;
             }

From d1c8e612fe44304b8b2f45a98edfd8dc9279d0ee Mon Sep 17 00:00:00 2001
From: Yee Cheng Chin <ychin.git@gmail.com>
Date: Fri, 20 Jan 2023 18:25:16 -0800
Subject: [PATCH 4/4] Fix CoreText clipping issues with tall texts
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This fixes the issue where particularly tall characters will get clipped
at the row boundary. This happens because even though a font describes
the line height with font metrics, individual glyphs do not have to
respect them, and we can see with emoji rendering sometimes they can
poke upwards past the line height. Also, it's trivially easy to
construct composing characters that become really tall, e.g. "x゙̂⃗", or
Tibetan scripts like "ཧཱུྃ".

To fix this, we do the following:

1. Remove the explicit clipping call at rendering.

2. Fix partial redraw to not lead to clipping / corruption. This is
   quite tricky, because let's say we have a character that is tall
   enough to touch other lines, if those lines are redraw but not the
   line with the tall char, the redraw will paint over the parts of the
   glyphs poking through. Alternatively if we redraw the line with the
   tall chars we also need to expand the redraw region to make sure
   other lines get repainted as well. To fix this properly, we should do
   a proper glyph calculation when we receive the draw command before we
   issue before we call `setNeedsDisplayInRect`, but since right now we
   only extract glyph info later (during drawRect call), it's too late.
   We just do the hacky solution by storing a variable
   `redrawExpandRows` that tracks how many lines to expand for all
   lines. It's a little hacky since this will affect all lines
   permanently regardless if they have tall characters or not. The
   proper fix may come later as an optimization (or when we do hardware
   rendering via Metal).

3. Re-order the rendering so we have a two pass system, where we first
   draw the background fill color for all rows, then the text. This
   helps prevent things like Vim's window split or cursorline from
   obscuring the text.

4. Add a preference to turn on clipping (old behavior). This helps
   prevent odd issues with really tall texts (e.g. Zalgo text) making it
   hard to see what's going on. The preference `MMRendererClipToRow` is
   not exposed in UI for now as it's a relatively niche. It will be
   exposed later when we have a dedicated render tab in settings.

Note that a lot of these characters only show their full height by doing
`set maxcombine=8` because the default (2) is quite low.

Part of the fix for #995
---
 runtime/doc/gui_mac.txt      |   1 +
 runtime/doc/tags             |   1 +
 src/MacVim/MMAppController.m |   1 +
 src/MacVim/MMCoreTextView.h  |   8 +-
 src/MacVim/MMCoreTextView.m  | 223 +++++++++++++++++++++++++----------
 src/MacVim/Miscellaneous.h   |   1 +
 src/MacVim/Miscellaneous.m   |   1 +
 7 files changed, 171 insertions(+), 65 deletions(-)

diff --git a/runtime/doc/gui_mac.txt b/runtime/doc/gui_mac.txt
index e7902617b5..49de234ab2 100644
--- a/runtime/doc/gui_mac.txt
+++ b/runtime/doc/gui_mac.txt
@@ -290,6 +290,7 @@ KEY				VALUE ~
 *MMNoTitleBarWindow*		hide title bar [bool]
 *MMTitlebarAppearsTransparent*	enable a transparent titlebar [bool]
 *MMAppearanceModeSelection*	dark mode selection (|macvim-dark-mode|)[bool]
+*MMRendererClipToRow*		clip tall characters to the row they are on [bool]
 *MMSmoothResize*		allow smooth resizing of MacVim window [bool]
 *MMShareFindPboard*		share search text to Find Pasteboard [bool]
 *MMShowAddTabButton*		enable "add tab" button on tabline [bool]
diff --git a/runtime/doc/tags b/runtime/doc/tags
index 52dbb33981..3bd65cf74f 100644
--- a/runtime/doc/tags
+++ b/runtime/doc/tags
@@ -5498,6 +5498,7 @@ MMNoFontSubstitution	gui_mac.txt	/*MMNoFontSubstitution*
 MMNoTitleBarWindow	gui_mac.txt	/*MMNoTitleBarWindow*
 MMNonNativeFullScreenSafeAreaBehavior	gui_mac.txt	/*MMNonNativeFullScreenSafeAreaBehavior*
 MMNonNativeFullScreenShowMenu	gui_mac.txt	/*MMNonNativeFullScreenShowMenu*
+MMRendererClipToRow	gui_mac.txt	/*MMRendererClipToRow*
 MMShareFindPboard	gui_mac.txt	/*MMShareFindPboard*
 MMShowAddTabButton	gui_mac.txt	/*MMShowAddTabButton*
 MMSmoothResize	gui_mac.txt	/*MMSmoothResize*
diff --git a/src/MacVim/MMAppController.m b/src/MacVim/MMAppController.m
index 8e8af1c87e..5aaaae931b 100644
--- a/src/MacVim/MMAppController.m
+++ b/src/MacVim/MMAppController.m
@@ -260,6 +260,7 @@ + (void)initialize
         [NSNumber numberWithBool:YES],    MMShareFindPboardKey,
         [NSNumber numberWithBool:NO],     MMSmoothResizeKey,
         [NSNumber numberWithBool:NO],     MMCmdLineAlignBottomKey,
+        [NSNumber numberWithBool:NO],     MMRendererClipToRowKey,
         [NSNumber numberWithBool:YES],    MMAllowForceClickLookUpKey,
         [NSNumber numberWithBool:NO],     MMUpdaterPrereleaseChannelKey,
         nil];
diff --git a/src/MacVim/MMCoreTextView.h b/src/MacVim/MMCoreTextView.h
index 9cce724dee..f698d55bbd 100644
--- a/src/MacVim/MMCoreTextView.h
+++ b/src/MacVim/MMCoreTextView.h
@@ -12,6 +12,8 @@
 
 @class MMTextViewHelper;
 
+NS_ASSUME_NONNULL_BEGIN
+
 
 /// The main text view that manages drawing Vim's content using Core Text, and
 /// handles input. We are using this instead of NSTextView because of the
@@ -84,7 +86,7 @@
 //
 // NSFontChanging methods
 //
-- (void)changeFont:(id)sender;
+- (void)changeFont:(nullable id)sender;
 
 //
 // NSMenuItemValidation
@@ -100,7 +102,7 @@
 - (IBAction)paste:(id)sender;
 - (IBAction)undo:(id)sender;
 - (IBAction)redo:(id)sender;
-- (IBAction)selectAll:(id)sender;
+- (IBAction)selectAll:(nullable id)sender;
 
 //
 // MMTextStorage methods
@@ -186,3 +188,5 @@
 @interface MMCoreTextView (ToolTip)
 - (void)setToolTipAtMousePoint:(NSString *)string;
 @end
+
+NS_ASSUME_NONNULL_END
diff --git a/src/MacVim/MMCoreTextView.m b/src/MacVim/MMCoreTextView.m
index 92841d3568..0aa27eb866 100644
--- a/src/MacVim/MMCoreTextView.m
+++ b/src/MacVim/MMCoreTextView.m
@@ -225,6 +225,16 @@ @implementation MMCoreTextView {
 
     BOOL alignCmdLineToBottom; ///< Whether to pin the Vim command-line to the bottom of the window
     int cmdlineRow; ///< Row number (0-indexed) where the cmdline starts. Used for pinning it to the bottom if desired.
+
+    /// Number of rows to expand when redrawing to make sure we don't clip tall
+    /// characters whose glyphs extend beyond the bottom/top of the cell.
+    ///
+    /// Note: This is a short-term hacky solution as it permanently increases
+    /// the number of rows to expand every time we redraw. Eventually we should
+    /// calculate each line's glyphs' bounds before issuing a redraw and use
+    /// that to determine the accurate redraw bounds instead. Currently we
+    /// calculate the glyph run too late (inside the draw call itself).
+    unsigned int redrawExpandRows;
 }
 
 - (instancetype)initWithFrame:(NSRect)frame
@@ -255,6 +265,7 @@ - (instancetype)initWithFrame:(NSRect)frame
 
     alignCmdLineToBottom = NO; // this would be updated to the user preferences later
     cmdlineRow = -1; // this would be updated by Vim
+    redrawExpandRows = 0; // start at 0, until we see a tall character. and then we expand it.
 
     return self;
 }
@@ -739,11 +750,16 @@ - (BOOL)isFlipped
 
 - (void)setNeedsDisplayFromRow:(int)row column:(int)col toRow:(int)row2
                         column:(int)col2 {
+    row -= redrawExpandRows;
+    row2 += redrawExpandRows;
     [self setNeedsDisplayInRect:[self rectForRow:row column:0 numRows:row2-row+1 numColumns:maxColumns]];
 }
 
 - (void)drawRect:(NSRect)rect
 {
+    NSUserDefaults *ud = [NSUserDefaults standardUserDefaults];
+    const BOOL clipTextToRow = [ud boolForKey:MMRendererClipToRowKey]; // Specify whether to clip tall characters by the row boundary.
+
     NSGraphicsContext *context = [NSGraphicsContext currentContext];
 #if MAC_OS_X_VERSION_MIN_REQUIRED >= MAC_OS_X_VERSION_10_10
     CGContextRef ctx = context.CGContext;
@@ -777,14 +793,101 @@ - (void)drawRect:(NSRect)rect
 
     CGContextFillRect(ctx, rect);
 
-    for (size_t r = 0; r < grid.rows; r++) {
-        const CGRect rowRect = [self rectForRow:r column:0 numRows:1 numColumns:grid.cols];
-        const CGRect rowClipRect = CGRectIntersection(rowRect, rect);
-        if (CGRectIsNull(rowClipRect))
-            continue;
-        CGContextSaveGState(ctx);
-        CGContextClipToRect(ctx, rowClipRect);
-        
+    // Function to draw all rows
+    void (^drawAllRows)(void (^)(CGContextRef,CGRect,int)) = ^(void (^drawFunc)(CGContextRef,CGRect,int)){
+        for (size_t r = 0; r < grid.rows; r++) {
+            const CGRect rowRect = [self rectForRow:(int)r
+                                             column:0
+                                            numRows:1
+                                         numColumns:grid.cols];
+
+            // Expand the clip rect to include some above/below rows in case we have tall characters.
+            const CGRect rowExpandedRect = [self rectForRow:(int)(r-redrawExpandRows)
+                                                     column:0
+                                                    numRows:(1+redrawExpandRows*2)
+                                                 numColumns:grid.cols];
+
+            const CGRect rowClipRect = CGRectIntersection(rowExpandedRect, rect);
+            if (CGRectIsNull(rowClipRect))
+                continue;
+            CGContextSaveGState(ctx);
+            if (clipTextToRow)
+                CGContextClipToRect(ctx, rowClipRect);
+
+            drawFunc(ctx, rowRect, (int)r);
+
+            CGContextRestoreGState(ctx);
+        }
+    };
+
+    // Function to draw a row of background colors, signs, and cursor rect. These should go below
+    // any text.
+    void (^drawBackgroundAndCursorFunc)(CGContextRef,CGRect,int) = ^(CGContextRef ctx, CGRect rowRect, int r){
+        for (int c = 0; c < grid.cols; c++) {
+            GridCell cell = *grid_cell(&grid, r, c);
+            CGRect cellRect = {{rowRect.origin.x + cellSize.width * c, rowRect.origin.y}, cellSize};
+            if (cell.textFlags & DRAW_WIDE)
+                cellRect.size.width *= 2;
+            if (cell.inverted) {
+                cell.bg ^= 0xFFFFFF;
+                cell.fg ^= 0xFFFFFF;
+                cell.sp ^= 0xFFFFFF;
+            }
+
+            // Fill background
+            if (cell.bg != defaultBg && ALPHA(cell.bg) > 0) {
+                CGRect fillCellRect = cellRect;
+
+                if (c == grid.cols - 1 || (c == grid.cols - 2 && (cell.textFlags & DRAW_WIDE))) {
+                    // Fill a little extra to the right if this is the last
+                    // column, and the frame size isn't exactly the same size
+                    // as the grid (due to smooth resizing, etc). This makes it
+                    // look less ugly and more consisten. See rectForRow:'s
+                    // implementation for extra comments.
+                    CGFloat extraWidth = rowRect.origin.x + rowRect.size.width - (cellRect.size.width + cellRect.origin.x);
+                    fillCellRect.size.width += extraWidth;
+                }
+
+                CGContextSetFillColor(ctx, COMPONENTS(cell.bg));
+                CGContextFillRect(ctx, fillCellRect);
+            }
+
+            // Handle signs
+            if (cell.sign) {
+                CGRect signRect = cellRect;
+                signRect.size.width *= 2;
+                [cell.sign drawInRect:signRect
+                             fromRect:(NSRect){{0, 0}, cell.sign.size}
+                            operation:(cell.inverted ? NSCompositingOperationDifference : NSCompositingOperationSourceOver)
+                             fraction:1.0];
+            }
+
+            // Insertion point (cursor)
+            if (cell.insertionPoint.color && cell.insertionPoint.fraction) {
+                float frac = cell.insertionPoint.fraction / 100.0;
+                NSRect rect = cellRect;
+                if (MMInsertionPointHorizontal == cell.insertionPoint.shape) {
+                    rect.size.height = cellSize.height * frac;
+                } else if (MMInsertionPointVertical == cell.insertionPoint.shape) {
+                    rect.size.width = cellSize.width * frac;
+                } else if (MMInsertionPointVerticalRight == cell.insertionPoint.shape) {
+                    rect.size.width = cellSize.width * frac;
+                    rect.origin.x += cellRect.size.width - rect.size.width;
+                }
+                rect = [self backingAlignedRect:rect options:NSAlignAllEdgesInward];
+                
+                [[NSColor colorWithArgbInt:cell.insertionPoint.color] set];
+                if (MMInsertionPointHollow == cell.insertionPoint.shape) {
+                    [NSBezierPath strokeRect:NSInsetRect(rect, 0.5, 0.5)];
+                } else {
+                    NSRectFill(rect);
+                }
+            }
+        }
+    };
+
+    // Function to draw a row of text with their corresponding text styles.
+    void (^drawTextFunc)(CGContextRef,CGRect,int) = ^(CGContextRef ctx, CGRect rowRect, int r){
         __block NSMutableString *lineString = nil;
         __block CGFloat lineStringStart = 0;
         __block CFRange lineStringRange = {};
@@ -797,7 +900,7 @@ - (void)drawRect:(NSRect)rect
             if (!lineString.length)
                 return;
             size_t cellOffsetByIndex[lineString.length];
-            for (size_t i = 0, stringIndex = 0; i < lineStringRange.length; i++) {
+            for (int i = 0, stringIndex = 0; i < lineStringRange.length; i++) {
                 GridCell cell = *grid_cell(&grid, r, lineStringRange.location + i);
                 size_t cell_length = cell.string.length;
                 for (size_t j = 0; j < cell_length; j++) {
@@ -860,6 +963,38 @@ - (void)drawRect:(NSRect)rect
                     layoutPositions = layoutPositions_storage;
                 }
 
+                const int maxRedrawExpandRows = clipTextToRow ? 0 : 3; // Hard-code a sane maximum for now to prevent degenerate edge cases
+                if (redrawExpandRows < maxRedrawExpandRows) {
+                    // Check if we encounter any glyphs in this line that are too tall and would be
+                    // clipped / not redrawn properly. If we encounter that, increase
+                    // redrawExpandRows and redraw.
+                    // Note: This is kind of a hacky solution. See comments for redrawExpandRows.
+                    CGRect lineBounds = CTRunGetImageBounds(run, ctx, CFRangeMake(0,0));
+                    if (!CGRectIsNull(lineBounds)) {
+                        unsigned int newRedrawExpandRows = 0;
+                        if (lineBounds.origin.y < rowRect.origin.y) {
+                            newRedrawExpandRows = (int)ceil((rowRect.origin.y - lineBounds.origin.y) / cellSize.height);
+                        }
+                        if (lineBounds.origin.y + lineBounds.size.height > rowRect.origin.y + cellSize.height) {
+                            int rowsAbove = (int)ceil(((lineBounds.origin.y + lineBounds.size.height) - (rowRect.origin.y + cellSize.height)) / cellSize.height);
+                            if (rowsAbove > newRedrawExpandRows) {
+                                newRedrawExpandRows = rowsAbove;
+                            }
+                        }
+
+                        if (newRedrawExpandRows > redrawExpandRows) {
+                            redrawExpandRows = newRedrawExpandRows;
+                            if (redrawExpandRows > maxRedrawExpandRows) {
+                                redrawExpandRows = maxRedrawExpandRows;
+                            }
+                            [self setNeedsDisplay:YES];
+                        }
+                    }
+                }
+                else {
+                    redrawExpandRows = maxRedrawExpandRows;
+                }
+
                 for (CFIndex i = 0; i < glyphCount; i++) {
                     if (indices[i] >= lineStringLength) {
                         ASLogDebug(@"Invalid glyph pos index: %ld, len: %lu", (long)indices[i], (unsigned long)lineStringLength);
@@ -916,7 +1051,7 @@ - (void)drawRect:(NSRect)rect
 
         BOOL hasStrikeThrough = NO;
 
-        for (size_t c = 0; c < grid.cols; c++) {
+        for (int c = 0; c < grid.cols; c++) {
             GridCell cell = *grid_cell(&grid, r, c);
             CGRect cellRect = {{rowRect.origin.x + cellSize.width * c, rowRect.origin.y}, cellSize};
             if (cell.textFlags & DRAW_WIDE)
@@ -927,56 +1062,6 @@ - (void)drawRect:(NSRect)rect
                 cell.sp ^= 0xFFFFFF;
             }
 
-            // Fill background
-            if (cell.bg != defaultBg && ALPHA(cell.bg) > 0) {
-                CGRect fillCellRect = cellRect;
-
-                if (c == grid.cols - 1 || (c == grid.cols - 2 && (cell.textFlags & DRAW_WIDE))) {
-                    // Fill a little extra to the right if this is the last
-                    // column, and the frame size isn't exactly the same size
-                    // as the grid (due to smooth resizing, etc). This makes it
-                    // look less ugly and more consisten. See rectForRow:'s
-                    // implementation for extra comments.
-                    CGFloat extraWidth = rowRect.origin.x + rowRect.size.width - (cellRect.size.width + cellRect.origin.x);
-                    fillCellRect.size.width += extraWidth;
-                }
-
-                CGContextSetFillColor(ctx, COMPONENTS(cell.bg));
-                CGContextFillRect(ctx, fillCellRect);
-            }
-
-            // Handle signs
-            if (cell.sign) {
-                CGRect signRect = cellRect;
-                signRect.size.width *= 2;
-                [cell.sign drawInRect:signRect
-                             fromRect:(NSRect){{0, 0}, cell.sign.size}
-                            operation:(cell.inverted ? NSCompositingOperationDifference : NSCompositingOperationSourceOver)
-                             fraction:1.0];
-            }
-
-            // Insertion point (cursor)
-            if (cell.insertionPoint.color && cell.insertionPoint.fraction) {
-                float frac = cell.insertionPoint.fraction / 100.0;
-                NSRect rect = cellRect;
-                if (MMInsertionPointHorizontal == cell.insertionPoint.shape) {
-                    rect.size.height = cellSize.height * frac;
-                } else if (MMInsertionPointVertical == cell.insertionPoint.shape) {
-                    rect.size.width = cellSize.width * frac;
-                } else if (MMInsertionPointVerticalRight == cell.insertionPoint.shape) {
-                    rect.size.width = cellSize.width * frac;
-                    rect.origin.x += cellRect.size.width - rect.size.width;
-                }
-                rect = [self backingAlignedRect:rect options:NSAlignAllEdgesInward];
-                
-                [[NSColor colorWithArgbInt:cell.insertionPoint.color] set];
-                if (MMInsertionPointHollow == cell.insertionPoint.shape) {
-                    [NSBezierPath strokeRect:NSInsetRect(rect, 0.5, 0.5)];
-                } else {
-                    NSRectFill(rect);
-                }
-            }
-
             // Text underline styles. We only allow one of them to be active.
             // Note: We are not currently using underlineThickness or underlinePosition. Should fix to use them.
             const CGFloat underlineY = 0.4*fontDescent; // Just a hard-coded value for now. Should fix to use underlinePosition.
@@ -1089,7 +1174,7 @@ - (void)drawRect:(NSRect)rect
         if (hasStrikeThrough) {
             // Second pass to render strikethrough. Unfortunately have to duplicate a little bit of code here to loop
             // through the cells.
-            for (size_t c = 0; c < grid.cols; c++) {
+            for (int c = 0; c < grid.cols; c++) {
                 GridCell cell = *grid_cell(&grid, r, c);
                 CGRect cellRect = {{rowRect.origin.x + cellSize.width * c, rowRect.origin.y}, cellSize};
                 if (cell.textFlags & DRAW_WIDE)
@@ -1109,9 +1194,21 @@ - (void)drawRect:(NSRect)rect
 
             }
         }
+    };
+
+    // Render passes:
+
+    // 1. Draw background color and cursor rect.
+    drawAllRows(drawBackgroundAndCursorFunc);
+
+    // 2. Draw text.
+    // We need to do this in a separate pass in case some characters are taller than a cell. This
+    // could easily happen when we have composed characters (e.g. T゙̂⃗) that either goes below or above
+    // the cell boundary. We draw the background colors in 1st pass to make sure all the texts will
+    // be drawn on top of them. Also see redrawExpandRows which handles making such tall characters
+    // redraw/clip correctly.
+    drawAllRows(drawTextFunc);
 
-        CGContextRestoreGState(ctx);
-    }
     if (thinStrokes) {
         CGContextSetFontSmoothingStyle(ctx, originalSmoothingStyle);
     }
diff --git a/src/MacVim/Miscellaneous.h b/src/MacVim/Miscellaneous.h
index 3a244c6f1f..b59aef25bd 100644
--- a/src/MacVim/Miscellaneous.h
+++ b/src/MacVim/Miscellaneous.h
@@ -61,6 +61,7 @@ extern NSString *MMNonNativeFullScreenShowMenuKey;
 extern NSString *MMNonNativeFullScreenSafeAreaBehaviorKey;
 extern NSString *MMSmoothResizeKey;
 extern NSString *MMCmdLineAlignBottomKey;
+extern NSString *MMRendererClipToRowKey;
 extern NSString *MMAllowForceClickLookUpKey;
 extern NSString *MMUpdaterPrereleaseChannelKey;
 
diff --git a/src/MacVim/Miscellaneous.m b/src/MacVim/Miscellaneous.m
index 6b8406bef9..37054301e8 100644
--- a/src/MacVim/Miscellaneous.m
+++ b/src/MacVim/Miscellaneous.m
@@ -57,6 +57,7 @@
 NSString *MMNonNativeFullScreenSafeAreaBehaviorKey = @"MMNonNativeFullScreenSafeAreaBehavior";
 NSString *MMSmoothResizeKey               = @"MMSmoothResize";
 NSString *MMCmdLineAlignBottomKey         = @"MMCmdLineAlignBottom";
+NSString *MMRendererClipToRowKey      = @"MMRendererClipToRow";
 NSString *MMAllowForceClickLookUpKey      = @"MMAllowForceClickLookUp";
 NSString *MMUpdaterPrereleaseChannelKey   = @"MMUpdaterPrereleaseChannel";