<feed xmlns='http://www.w3.org/2005/Atom'>
<title>mirrors/foot.git, branch releases/1.13</title>
<subtitle>A fast, lightweight and minimalistic Wayland terminal emulator</subtitle>
<id>https://git.0x0f.dev/mirrors/foot.git/atom?h=releases%2F1.13</id>
<link rel='self' href='https://git.0x0f.dev/mirrors/foot.git/atom?h=releases%2F1.13'/>
<link rel='alternate' type='text/html' href='https://git.0x0f.dev/mirrors/foot.git/'/>
<updated>2022-08-31T17:19:15Z</updated>
<entry>
<title>meson: bump version to 1.13.1</title>
<updated>2022-08-31T17:19:15Z</updated>
<author>
<name>Daniel Eklöf</name>
<email>daniel@ekloef.se</email>
</author>
<published>2022-08-31T17:19:15Z</published>
<link rel='alternate' type='text/html' href='https://git.0x0f.dev/mirrors/foot.git/commit/?id=cd1933baf12eeef82e04a926f9150ca815d54768'/>
<id>urn:sha1:cd1933baf12eeef82e04a926f9150ca815d54768</id>
<content type='text'>
</content>
</entry>
<entry>
<title>changelog: prepare for 1.13.1</title>
<updated>2022-08-31T17:17:38Z</updated>
<author>
<name>Daniel Eklöf</name>
<email>daniel@ekloef.se</email>
</author>
<published>2022-08-31T17:17:38Z</published>
<link rel='alternate' type='text/html' href='https://git.0x0f.dev/mirrors/foot.git/commit/?id=864de72b171ea6e6e002ec119f017ed57fecc0b8'/>
<id>urn:sha1:864de72b171ea6e6e002ec119f017ed57fecc0b8</id>
<content type='text'>
</content>
</entry>
<entry>
<title>url-mode: connect osc-8 links only when both ID and URI matches</title>
<updated>2022-08-31T17:16:19Z</updated>
<author>
<name>Daniel Eklöf</name>
<email>daniel@ekloef.se</email>
</author>
<published>2022-08-30T15:48:04Z</published>
<link rel='alternate' type='text/html' href='https://git.0x0f.dev/mirrors/foot.git/commit/?id=5706141d0a5250af761f29989dad8161ed1cf2b6'/>
<id>urn:sha1:5706141d0a5250af761f29989dad8161ed1cf2b6</id>
<content type='text'>
Before this, two OSC-8 links with a matching ID would be connected
even if their URIs weren’t the same. This is against the spec:

  The same id is only used for connecting character cells whose URIs
  is also the same. Character cells pointing to different URIs should
  never be underlined together when hovering over.

https://gist.github.com/egmontkob/eb114294efbcd5adb1944c9f3cb5feda#hover-underlining-and-the-id-parameter
</content>
</entry>
<entry>
<title>changelog: crash when resizing window, or scrolling</title>
<updated>2022-08-31T17:16:06Z</updated>
<author>
<name>Daniel Eklöf</name>
<email>daniel@ekloef.se</email>
</author>
<published>2022-08-29T19:04:56Z</published>
<link rel='alternate' type='text/html' href='https://git.0x0f.dev/mirrors/foot.git/commit/?id=688bf1bd59df3c692b0891aaf46b6844ea415e65'/>
<id>urn:sha1:688bf1bd59df3c692b0891aaf46b6844ea415e65</id>
<content type='text'>
</content>
</entry>
<entry>
<title>grid: reflow: assert there aren’t any open URIs on the last row</title>
<updated>2022-08-31T17:16:05Z</updated>
<author>
<name>Daniel Eklöf</name>
<email>daniel@ekloef.se</email>
</author>
<published>2022-08-29T19:03:21Z</published>
<link rel='alternate' type='text/html' href='https://git.0x0f.dev/mirrors/foot.git/commit/?id=23871d4db58d15e33e0693010373c426fc50688e'/>
<id>urn:sha1:23871d4db58d15e33e0693010373c426fc50688e</id>
<content type='text'>
</content>
</entry>
<entry>
<title>grid: reflow: don’t line-wrap the last row</title>
<updated>2022-08-31T17:16:04Z</updated>
<author>
<name>Daniel Eklöf</name>
<email>daniel@ekloef.se</email>
</author>
<published>2022-08-29T18:47:33Z</published>
<link rel='alternate' type='text/html' href='https://git.0x0f.dev/mirrors/foot.git/commit/?id=22989ef9b3c604f5ccc30a6ba3cb11263f7e1a80'/>
<id>urn:sha1:22989ef9b3c604f5ccc30a6ba3cb11263f7e1a80</id>
<content type='text'>
Before this patch, we would line-wrap the last row, just like any
other row, and then afterwards try to reverse this, by adjusting the
offset and free:ing and NULL:ing the "last row".

The problem with this is if the scrollback is full. In this case, the
row we’re freeing is the first row in the scrollback history. This
means we’ll crash as soon as the viewport is moved to the top of the
scrollback.

The fix is fairly, simple. Skip the post-processing logic, and instead
detect when we’re line-wrapping the last row, and skip the call to
line_wrap().

This way, the last row in the new grid corresponds to the last row in
the old grid.
</content>
</entry>
<entry>
<title>grid: when setting the new viewport, ensure it’s correctly bounded</title>
<updated>2022-08-31T17:16:02Z</updated>
<author>
<name>Daniel Eklöf</name>
<email>daniel@ekloef.se</email>
</author>
<published>2022-08-29T18:46:19Z</published>
<link rel='alternate' type='text/html' href='https://git.0x0f.dev/mirrors/foot.git/commit/?id=649d56a4e5142c9ab8ea24f4d1acbd4a49d534f9'/>
<id>urn:sha1:649d56a4e5142c9ab8ea24f4d1acbd4a49d534f9</id>
<content type='text'>
Do this by using scrollback relative coordinates, and ensure the new
viewport is not larger than (grid_rows - screen_rows), as that would
mean the viewport crosses the scrollback wrap-around.
</content>
</entry>
<entry>
<title>selection: mark_selected_region(): use an enum to encode how the cells are to be updated</title>
<updated>2022-08-31T17:15:54Z</updated>
<author>
<name>Daniel Eklöf</name>
<email>daniel@ekloef.se</email>
</author>
<published>2022-08-26T19:07:20Z</published>
<link rel='alternate' type='text/html' href='https://git.0x0f.dev/mirrors/foot.git/commit/?id=d810e4fc8eb3123e427f1453b269ced9608222c9'/>
<id>urn:sha1:d810e4fc8eb3123e427f1453b269ced9608222c9</id>
<content type='text'>
</content>
</entry>
<entry>
<title>selection: restore &lt;= 1.12 behavior in block selection wrt empty cells</title>
<updated>2022-08-31T17:15:51Z</updated>
<author>
<name>Daniel Eklöf</name>
<email>daniel@ekloef.se</email>
</author>
<published>2022-08-26T15:48:00Z</published>
<link rel='alternate' type='text/html' href='https://git.0x0f.dev/mirrors/foot.git/commit/?id=2354298ecac8e08ecce8ff8b208cda0f0c6f5257'/>
<id>urn:sha1:2354298ecac8e08ecce8ff8b208cda0f0c6f5257</id>
<content type='text'>
That is, highlight empty cells, regardless of whether they’re trailing
or not.
</content>
</entry>
<entry>
<title>ci (sr.ht): pull directly from git.sr.ht</title>
<updated>2022-08-31T17:15:48Z</updated>
<author>
<name>Daniel Eklöf</name>
<email>daniel@ekloef.se</email>
</author>
<published>2022-08-23T14:38:39Z</published>
<link rel='alternate' type='text/html' href='https://git.0x0f.dev/mirrors/foot.git/commit/?id=03d3887e6bb964e9599ce84f5e1548df224371fd'/>
<id>urn:sha1:03d3887e6bb964e9599ce84f5e1548df224371fd</id>
<content type='text'>
</content>
</entry>
<entry>
<title>selection: once again highlight non-trailing empty cells</title>
<updated>2022-08-31T17:15:44Z</updated>
<author>
<name>Daniel Eklöf</name>
<email>daniel@ekloef.se</email>
</author>
<published>2022-08-22T18:14:06Z</published>
<link rel='alternate' type='text/html' href='https://git.0x0f.dev/mirrors/foot.git/commit/?id=6f1cf6fc56b906fb050009f587a5440188a69b80'/>
<id>urn:sha1:6f1cf6fc56b906fb050009f587a5440188a69b80</id>
<content type='text'>
Foot 1.13.0 introduced a regression where non-trailing empty cells
were highlighted inconsistently (cells that shouldn’t be highlighted,
were, seemingly at random).

86663522d5915c0fdb2b8b132bacc247fcfd1fb8 “fixed” this by never
highlighting *any* empty cells.

This meant the behavior, compared to foot 1.12 and earlier,
changed. In foot 1.12 and older versions, non-trailing empty cells
were highlighted, as long as the selection covered at least one of the
trailing non-empty cells.

This patch restores that behavior.

To understand how this works, lets first take a look at how selection
works:

When a selection is made, and updated (i.e. the mouse is dragged, or
the selection is extended through RMB etc), we need to (un)tag and dirty
the cells that are a) newly selected, or b) newly deselected. That is,
we look at the diff between the “old” and the “new” selection, and
only update those cells.

This is for performance reasons: iterating the entire selection is not
feasible with large selections. However, it also means we cannot
reason about empty cells; we simply don’t know if an empty cells is a
trailing empty cell, or a non-trailing one.

Then, when we render a frame, we iterate all the *visible*
and *selected* cells, once again tagging them as selected (this is
needed since a selected cell might have lost its selected tag if the
cell was written to, by the client application, after the selection
was made).

At this point, we *can* reason about empty cells.

So, to restore the highlighting behavior to that of foot 1.12, we do
this:

When working with the selection diffs when a selection is updated, we
don’t special case empty cells at all. Thus, all empty cells covered
by the selection is highlighted, and dirtied.

But, when rendering the frame, we _do_ special case them. The only
difference (compared to foot 1.12) is that we *must*
explicitly *clear* the selection tag, and dirty the empty cells. This
is to ensure the empty cells that were incorrectly highlighted by the
selection update algorithm, isn’t rendered as that.

This does have a slight performance impact, as empty cells are now
always re-rendered. The impact should however be small.
</content>
</entry>
<entry>
<title>selection: never highlight selected, empty cells</title>
<updated>2022-08-31T17:14:18Z</updated>
<author>
<name>Daniel Eklöf</name>
<email>daniel@ekloef.se</email>
</author>
<published>2022-08-17T15:36:10Z</published>
<link rel='alternate' type='text/html' href='https://git.0x0f.dev/mirrors/foot.git/commit/?id=736babcdbc10a20e9d620638adc2fec230a81e71'/>
<id>urn:sha1:736babcdbc10a20e9d620638adc2fec230a81e71</id>
<content type='text'>
This fixes a regression, where empty cells "between" non-empty
cells (i.e. non-trailing empty cells) sometimes were incorrectly
highlighted.

The idea has always been to highlight exactly those cells that will
get extracted when they’re copied. This means we’ve not highlighted
trailing empty cells, but we _have_ highlighted other empty cells,
since they are converted to spaces when copied (whereas trailing empty
cells are skipped).

fa2d9f86996467ba33cc381f810ea966a4323381 changed how a selection is
updated. That is, which cells gets marked as selected, and which ones
gets unmarked.

Since we no longer walk all the cells, but instead work with pixman
regions representing selection diffs, we can no longer determine (with
certainty) which empty cells should be selected and which shouldn’t.

Before this patch (but after
fa2d9f86996467ba33cc381f810ea966a4323381), we sometimes incorrectly
highlighted empty cells that should not have been highlighted. This
happened when we’ve first (correctly) highlighted a region of empty
cells, but then shrink the selection such that all those empty cells
should be de-selected.

This patch changes the selection behavior to *never* highlight empty
cells. This fixes the regression, but also means slightly different
behavior, compared to pre-fa2d9f86996467ba33cc381f810ea966a4323381.

The other alternative is to always highlight all empty cells. But,
since I personally like the fact that we’re skipping trailing empty
cells, I prefer the approach taken by this patch.
</content>
</entry>
<entry>
<title>ci: codespell: ignore ‘zar’ (user who contributed)</title>
<updated>2022-08-31T17:14:03Z</updated>
<author>
<name>Daniel Eklöf</name>
<email>daniel@ekloef.se</email>
</author>
<published>2022-08-20T16:25:05Z</published>
<link rel='alternate' type='text/html' href='https://git.0x0f.dev/mirrors/foot.git/commit/?id=ccef435736a5364c63cfe6c1d64e7c4f5a66a0b5'/>
<id>urn:sha1:ccef435736a5364c63cfe6c1d64e7c4f5a66a0b5</id>
<content type='text'>
</content>
</entry>
<entry>
<title>input: ignore pointer motion events on unknown surfaces</title>
<updated>2022-08-12T14:15:55Z</updated>
<author>
<name>Daniel Eklöf</name>
<email>daniel@ekloef.se</email>
</author>
<published>2022-08-12T14:13:25Z</published>
<link rel='alternate' type='text/html' href='https://git.0x0f.dev/mirrors/foot.git/commit/?id=20b8ca1601a8a80770110860ae70d4487c95081b'/>
<id>urn:sha1:20b8ca1601a8a80770110860ae70d4487c95081b</id>
<content type='text'>
In some cases, the compositor sends a pointer enter event with a NULL
surface. It’s unclear if this is a compositor bug, or a race (where
the compositor sends an enter event on a CSD surface at the same time
foot unmaps the CSDs). Regardless, this causes seat-&gt;mouse_focus to be
unset, which triggers a crash in foot on the next pointer motion
event.

This patch does two things:

a) log a warning when we receive a pointer event with a NULL surface
b) ignore motion events where seat-&gt;mouse_focus is NULL
</content>
</entry>
<entry>
<title>wayland: #ifdef on XDG_TOPLEVEL_CONFIGURE_BOUNDS_SINCE_VERSION</title>
<updated>2022-08-12T14:15:53Z</updated>
<author>
<name>Daniel Eklöf</name>
<email>daniel@ekloef.se</email>
</author>
<published>2022-08-12T14:12:36Z</published>
<link rel='alternate' type='text/html' href='https://git.0x0f.dev/mirrors/foot.git/commit/?id=5697348b461f4dec4daf67c62336bb357149baf7'/>
<id>urn:sha1:5697348b461f4dec4daf67c62336bb357149baf7</id>
<content type='text'>
This enables us to compile against wayland-protocols &lt; 1.25
</content>
</entry>
<entry>
<title>render: apply a dimmed overlay while in Unicode input mode</title>
<updated>2022-08-12T14:15:50Z</updated>
<author>
<name>Daniel Eklöf</name>
<email>daniel@ekloef.se</email>
</author>
<published>2022-08-08T14:31:28Z</published>
<link rel='alternate' type='text/html' href='https://git.0x0f.dev/mirrors/foot.git/commit/?id=1cf22846a0e333c61d5db50c260fd897143c6a83'/>
<id>urn:sha1:1cf22846a0e333c61d5db50c260fd897143c6a83</id>
<content type='text'>
</content>
</entry>
<entry>
<title>changelog: add new ‘unreleased’ section</title>
<updated>2022-08-12T14:15:47Z</updated>
<author>
<name>Daniel Eklöf</name>
<email>daniel@ekloef.se</email>
</author>
<published>2022-08-07T07:38:25Z</published>
<link rel='alternate' type='text/html' href='https://git.0x0f.dev/mirrors/foot.git/commit/?id=157b64098a0832d66b5f8d206a14aa2c1342334b'/>
<id>urn:sha1:157b64098a0832d66b5f8d206a14aa2c1342334b</id>
<content type='text'>
</content>
</entry>
<entry>
<title>meson: bump version to 1.13.0</title>
<updated>2022-08-07T07:32:02Z</updated>
<author>
<name>Daniel Eklöf</name>
<email>daniel@ekloef.se</email>
</author>
<published>2022-08-07T07:32:02Z</published>
<link rel='alternate' type='text/html' href='https://git.0x0f.dev/mirrors/foot.git/commit/?id=e0465d3a7a0b8d6962462a505f2f8b32c2ee74bc'/>
<id>urn:sha1:e0465d3a7a0b8d6962462a505f2f8b32c2ee74bc</id>
<content type='text'>
</content>
</entry>
<entry>
<title>changelog: prepare for 1.13.0</title>
<updated>2022-08-07T07:31:56Z</updated>
<author>
<name>Daniel Eklöf</name>
<email>daniel@ekloef.se</email>
</author>
<published>2022-08-07T07:31:56Z</published>
<link rel='alternate' type='text/html' href='https://git.0x0f.dev/mirrors/foot.git/commit/?id=e3eefdacde0182aa2c5e56cf450e3abac094e852'/>
<id>urn:sha1:e3eefdacde0182aa2c5e56cf450e3abac094e852</id>
<content type='text'>
</content>
</entry>
<entry>
<title>grid: get rid of empty row at the bottom after reflowing</title>
<updated>2022-08-05T16:26:37Z</updated>
<author>
<name>Daniel Eklöf</name>
<email>daniel@ekloef.se</email>
</author>
<published>2022-08-05T16:26:37Z</published>
<link rel='alternate' type='text/html' href='https://git.0x0f.dev/mirrors/foot.git/commit/?id=aaf5894ad9272698cfafeb8e299b925fb9554417'/>
<id>urn:sha1:aaf5894ad9272698cfafeb8e299b925fb9554417</id>
<content type='text'>
When the window is resized and we reflow the text, we ended up
inserting an empty row at the bottom.

This happens whenever the actual last row has a hard linebreak (which
almost always is the case); we then end the reflow with a line break,
causing an extra, empty, row to be allocated and inserted.

This patch fixes this by detecting when:

1) the last row is empty
2) the next to last row has a hard line break

In this case, we roll back the last line break, by adjusting the new
offset we just calculated, and free:ing the empty row.

TODO: it would be nice if we could detect this in the reflow loop
instead, and avoid doing the last line break all together. I haven’t
yet been able to find a way to do this correctly.

Closes #1108
</content>
</entry>
</feed>
