diff --git a/docs/changelog.rst b/docs/changelog.rst index 5530312ac..27af59039 100644 --- a/docs/changelog.rst +++ b/docs/changelog.rst @@ -252,10 +252,13 @@ Detailed list of changes - X11: Report X errors instead of exiting, fixing exits when clipboard requestors destroy their window early (:iss:`9248`) -- Linux: Fix glyphs that are slightly wider than their cell, such as the - texture healing alternates of the Monaspace and 0xProto fonts, being rendered +- Fix glyphs that are slightly wider than their cell, such as the texture + healing alternates of the Monaspace and 0xProto fonts, being rendered smaller than the surrounding text at some font sizes +- macOS: Fix accents and breathing marks that hang to the left of wide glyphs, + such as polytonic Greek capitals, being cut off + 0.50.0 [2026-11-03] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ diff --git a/kitty/core_text.m b/kitty/core_text.m index 5c3d2716f..005ea2b58 100644 --- a/kitty/core_text.m +++ b/kitty/core_text.m @@ -755,12 +755,12 @@ face_from_descriptor(PyObject *descriptor, FONTS_DATA_HANDLE fg) { } PyObject * -face_from_path(const char *path, int UNUSED index, FONTS_DATA_HANDLE fg UNUSED) { +face_from_path(const char *path, int UNUSED index, FONTS_DATA_HANDLE fg) { RAII_CoreFoundation(CFStringRef, s, CFStringCreateWithCString(NULL, path, kCFStringEncodingUTF8)); RAII_CoreFoundation(CFURLRef, url, CFURLCreateWithFileSystemPath(kCFAllocatorDefault, s, kCFURLPOSIXPathStyle, false)); RAII_CoreFoundation(CGDataProviderRef, dp, CGDataProviderCreateWithURL(url)); RAII_CoreFoundation(CGFontRef, cg_font, CGFontCreateWithDataProvider(dp)); - RAII_CoreFoundation(CTFontRef, ct_font, CTFontCreateWithGraphicsFont(cg_font, 0.0, NULL, NULL)); + RAII_CoreFoundation(CTFontRef, ct_font, CTFontCreateWithGraphicsFont(cg_font, fg ? scaled_point_sz(fg) : 0.0, NULL, NULL)); return (PyObject *)ct_face(ct_font, NULL); } @@ -1185,14 +1185,51 @@ do_render( ensure_render_space(canvas_width, cell_height, num_glyphs); CGRect br = CTFontGetBoundingRectsForGlyphs(ct_font, kCTFontOrientationHorizontal, buffers.glyphs, buffers.boxes, num_glyphs); const bool debug_rendering = false; - if (allow_resize) { - // Resize glyphs that would bleed into neighboring cells, by scaling the font size - float right = 0; - for (unsigned i = 0; i < num_glyphs; i++) right = MAX(right, buffers.boxes[i].origin.x + buffers.boxes[i].size.width); - if (!bold && !italic && right > canvas_width + 1) { - if (debug_rendering) printf("resizing glyphs, right: %f canvas_width: %u\n", right, canvas_width); + CGFloat x = 0, y = 0; + CGFloat scale = CTFontGetSize(ct_font) / units_per_em; + for (unsigned i = 0; i < num_glyphs; i++) { + buffers.positions[i].x = x + hb_positions[i].x_offset * scale; + buffers.positions[i].y = y + hb_positions[i].y_offset * scale; + if (debug_rendering) + printf( + "x=%f y=%f origin=%f width=%f x_advance=%f x_offset=%f y_advance=%f y_offset=%f\n", + buffers.positions[i].x, + buffers.positions[i].y, + buffers.boxes[i].origin.x, + buffers.boxes[i].size.width, + hb_positions[i].x_advance * scale, + hb_positions[i].x_offset * scale, + hb_positions[i].y_advance * scale, + hb_positions[i].y_offset * scale); + x += hb_positions[i].x_advance * scale; + y += hb_positions[i].y_advance * scale; + } + // The horizontal extent of the ink of the glyphs, as positioned in the + // canvas, and the width of the widest glyph + CGFloat left = canvas_width, right = 0, max_width = 0; + for (unsigned i = 0; i < num_glyphs; i++) { + if (buffers.boxes[i].size.width <= 0) continue; + left = MIN(left, buffers.positions[i].x + buffers.boxes[i].origin.x); + right = MAX(right, buffers.positions[i].x + buffers.boxes[i].origin.x + buffers.boxes[i].size.width); + max_width = MAX(max_width, buffers.boxes[i].size.width); + } + CGFloat dx = 0; + if (right > left) { + // Glyphs are checked individually, so that combining marks hanging + // outside the cell dont cause the base glyph to be shrunk + CGFloat extra = max_width - canvas_width; + // there exist fonts that have glyphs a little wider than their + // advances, such as wide letters that borrow space from a narrow + // neighbor. Rather than rescale, which looks bad, we just crop the + // glyph to the cell. The allowance is 2/9 of the cell width, with a + // minimum of 2px, the same as in the FreeType renderer. + // See https://github.com/kovidgoyal/kitty/issues/352 + const bool crop = num_cells == 1 && (extra <= 2 || extra * 9 <= cell_width * 2); + if (allow_resize && !bold && !italic && extra > 1 && !crop) { + // Resize glyphs that would bleed into neighboring cells, by scaling the font size + if (debug_rendering) printf("resizing glyphs, max_width: %f canvas_width: %u\n", max_width, canvas_width); CGFloat sz = CTFontGetSize(ct_font); - sz *= canvas_width / right; + sz *= canvas_width / max_width; CTFontRef new_font = CTFontCreateCopyWithAttributes(ct_font, sz, NULL, NULL); bool ret = do_render( new_font, @@ -1214,25 +1251,18 @@ do_render( CFRelease(new_font); return ret; } - } - CGFloat x = 0, y = 0; - CGFloat scale = CTFontGetSize(ct_font) / units_per_em; - for (unsigned i = 0; i < num_glyphs; i++) { - buffers.positions[i].x = x + hb_positions[i].x_offset * scale; - buffers.positions[i].y = y + hb_positions[i].y_offset * scale; - if (debug_rendering) - printf( - "x=%f y=%f origin=%f width=%f x_advance=%f x_offset=%f y_advance=%f y_offset=%f\n", - buffers.positions[i].x, - buffers.positions[i].y, - buffers.boxes[i].origin.x, - buffers.boxes[i].size.width, - hb_positions[i].x_advance * scale, - hb_positions[i].x_offset * scale, - hb_positions[i].y_advance * scale, - hb_positions[i].y_offset * scale); - x += hb_positions[i].x_advance * scale; - y += hb_positions[i].y_advance * scale; + // Colored glyphs are placed by render_color_glyph() + if (!*was_colored) { + if (!allow_resize && left < 0) { + // A rescaled glyph, such as a letter with marks that hang to + // the left of its cell, shift it so the marks are not cut off + dx = -left; + } else if (right > canvas_width && left > 0 && num_glyphs < 4) { + // Move the glyphs back into the canvas, as far as their left bearing allows + dx = -MIN(left, right - canvas_width); + } + for (unsigned i = 0; i < num_glyphs; i++) buffers.positions[i].x += dx; + } } if (*was_colored) { render_color_glyph(ct_font, (uint8_t *)canvas, info[0].codepoint, cell_width * num_cells, cell_height, baseline); @@ -1245,7 +1275,7 @@ do_render( ri->rendered_width = (unsigned)ceil(x); ri->x = 0; // FiraCode ligatures result in negative origins - if (br.origin.x > 0) ri->x = (int)br.origin.x; + if (br.origin.x + dx > 0) ri->x = (int)(br.origin.x + dx); return true; } diff --git a/kitty/fonts.c b/kitty/fonts.c index f9faf1202..590917b48 100644 --- a/kitty/fonts.c +++ b/kitty/fonts.c @@ -2670,13 +2670,29 @@ concat_cells(PyObject UNUSED *self, PyObject *args) { PyObject *ans = PyBytes_FromStringAndSize(NULL, (size_t)4 * cell_width * cell_height * num_cells); if (ans == NULL) return PyErr_NoMemory(); pixel *dest = (pixel *)PyBytes_AS_STRING(ans); + RAII_ALLOC(uint8_t, rgba, is_32_bit ? malloc((size_t)4 * cell_width) : NULL); + if (is_32_bit && !rgba) { + Py_DECREF(ans); + return PyErr_NoMemory(); + } for (r = 0; r < cell_height; r++) { for (c = 0; c < num_cells; c++) { void *s = ((uint8_t *)PyBytes_AS_STRING(PyTuple_GET_ITEM(cells, c))); if (is_32_bit) { + // sprite pixels are 0xRRGGBBAA, convert them to RGBA bytes pixel *src = (pixel *)s + cell_width * r; - for (i = 0; i < cell_width; i++) dest[i] = (pixel)bgcolor; - blend_over_opaque((uint8_t *)dest, 4, (const uint8_t *)src, cell_width); + uint8_t *d = (uint8_t *)dest; + for (i = 0; i < cell_width; i++) { + rgba[4 * i] = (src[i] >> 24) & 0xff; + rgba[4 * i + 1] = (src[i] >> 16) & 0xff; + rgba[4 * i + 2] = (src[i] >> 8) & 0xff; + rgba[4 * i + 3] = src[i] & 0xff; + d[4 * i] = (bgcolor >> 16) & 0xff; + d[4 * i + 1] = (bgcolor >> 8) & 0xff; + d[4 * i + 2] = bgcolor & 0xff; + d[4 * i + 3] = 0xff; + } + blend_over_opaque(d, 4, rgba, cell_width); dest += cell_width; } else { uint8_t *src = (uint8_t *)s + cell_width * r; diff --git a/kitty_tests/fonts.py b/kitty_tests/fonts.py index ad82acd7f..5878708ca 100644 --- a/kitty_tests/fonts.py +++ b/kitty_tests/fonts.py @@ -505,19 +505,31 @@ class Rendering(FontBaseTest): _, rw, rh = without_matrix.render_codepoint(0x1F40D) self.assertGreater(mh, 0.5 * rh, f'color emoji shrunk by FC_MATRIX: {mh}px vs {rh}px (#10144)') - def glyph_ink_height(self, font_name, char, ppem): - "The number of pixel rows char occupies when drawn in a single cell" + def test_concat_cells(self): + from kitty.fast_data_types import concat_cells + + # sprite pixels are 0xRRGGBBAA and the result is opaque RGBA bytes + cell = array.array('I', (0xFF000080, 0xFFFFFF00, 0x00FF00FF)).tobytes() + self.ae(concat_cells(3, 1, True, (cell,)), bytes((0x80, 0, 0, 0xFF, 0, 0, 0, 0xFF, 0, 0xFF, 0, 0xFF))) + self.ae(concat_cells(1, 1, True, (cell[:4], cell[4:8])), bytes((0x80, 0, 0, 0xFF, 0, 0, 0, 0xFF))) + self.ae(concat_cells(2, 1, True, (cell[:8],), 0x0000FF), bytes((0x80, 0, 0x7F, 0xFF, 0, 0, 0xFF, 0xFF))) + + def glyph_ink(self, font_name, char, ppem): + "The number of pixel rows and columns char occupies when drawn in a single cell, and the cell width" with setup_for_testing(size=ppem, dpi=72.0, main_face_path=self.path_for_font(font_name)) as (sprites, cell_width, cell_height): s = Screen(None, 1, 4) s.draw(char) line = s.line(0) test_render_line(line) pos = sprite_idx_to_pos(line.sprite_at(0) & 0x7FFFFFFF, setup_for_testing.xnum, setup_for_testing.ynum) - pixels = array.array('I', sprites[pos]) - rows = [y for y in range(cell_height) if any(pixels[y * cell_width : (y + 1) * cell_width])] - return rows[-1] - rows[0] + 1 if rows else 0 + # the low byte of each pixel is its alpha, the color bits are set even for empty pixels on macOS + alpha = bytes(p & 0xFF for p in array.array('I', sprites[pos])) + rows = [y for y in range(cell_height) if any(alpha[y * cell_width : (y + 1) * cell_width])] + cols = [x for x in range(cell_width) if any(alpha[x::cell_width])] + height = rows[-1] - rows[0] + 1 if rows else 0 + width = cols[-1] - cols[0] + 1 if cols else 0 + return height, width, cell_width - @unittest.skipIf(is_macos, 'The rule under test is in the FreeType renderer') def test_small_glyph_overhang_is_not_rescaled(self): # Fonts have glyphs whose outlines overhang their advance a little, such # as the texture healing alternates of Monaspace and 0xProto. These must @@ -532,15 +544,22 @@ class Rendering(FontBaseTest): ('iosevka-regular.ttf', 'ꭦ', 120, 112), ): with self.subTest(font=font_name, char=char): - self.assertGreaterEqual(self.glyph_ink_height(font_name, char, ppem), full_height) + self.assertGreaterEqual(self.glyph_ink(font_name, char, ppem)[0], full_height) - @unittest.skipIf(is_macos, 'The rule under test is in the FreeType renderer') def test_large_glyph_overhang_is_rescaled(self): # Ὦ has its breathing mark and accent to the left of the letter, outside # its cell, so cropping would cut them off. Its outline is 1594 units # wide and 1766 tall with an advance of 1229, so scaled to fit the cell - # it is at most 1766 * (1229 / 1594) * 32 / 2048 = 21.3 pixels tall. - self.assertLessEqual(self.glyph_ink_height('LiberationMono-Regular.ttf', 'Ὦ', 32), 22) + # it is at most 1766 * (1229 / 1594) * 32 / 2048 = 21.3 pixels tall, + # which, depending on where it falls relative to the pixel grid, covers + # at most 23 rows. Drawn at full size it covers at least 27. + height, width, cell_width = self.glyph_ink('LiberationMono-Regular.ttf', 'Ὦ', 32) + self.assertLessEqual(height, 23) + if is_macos: + # The rescaled glyph is moved into the cell so that the marks are + # not cut off and it spans the whole cell. The FreeType renderer + # still crops whatever lies to the left of the cell. + self.assertGreaterEqual(width, cell_width - 1) def test_shaping(self):