STRLCPY/alacritty

Fix damage computation on boundaries

Given that the Rect started to use signed integers saturating_sub
became irrelevant and no clamp to zero were performed. This commit
uses max instead to fix it.

Kirill Chibisov committed with GitHub 1 year ago

6566dd3d

1 parent 79860622

Total 3 files Show one by one

■ ■ ■ ■ ■ ■

Cargo.lock

		skipped 675 lines
676	676
677	677		[[package]]
678	678		name = "glutin"
679		-	version = "0.30.2"
	679	+	version = "0.30.3"
680	680		source = "registry+https://github.com/rust-lang/crates.io-index"
681		-	checksum = "0282c380a3adb52ae095e5847cc575c6bf79d296dcbf333e00be4a3fca07235e"
	681	+	checksum = "524d807cd49a0c56a53ef9a6738cd15e7c8c4e9d37a3b7fdb3c250c1cd5bf7a3"
682	682		dependencies = [
683	683		"bitflags",
684	684		"cfg_aliases",
		skipped 1506 lines

■ ■ ■ ■ ■ ■

alacritty/Cargo.toml

		skipped 28 lines
29	29		serde = { version = "1", features = ["derive"] }
30	30		serde_yaml = "0.8"
31	31		serde_json = "1"
32		-	glutin = { version = "0.30.2", default-features = false, features = ["egl", "wgl"] }
	32	+	glutin = { version = "0.30.3", default-features = false, features = ["egl", "wgl"] }
33	33		winit = { version = "0.27.4", default-features = false, features = ["serde"] }
34	34		notify-debouncer-mini = { version = "0.2.1", default-features = false }
35	35		parking_lot = "0.12.0"
		skipped 59 lines

■ ■ ■ ■ ■ ■

alacritty/src/display/damage.rs

		skipped 29 lines
30	30
31	31		// Make sure to damage near cells to include wide chars.
32	32		#[inline]
33		-	fn overdamage(&self, mut rect: Rect) -> Rect {
34		-	let size_info = &self.size_info;
35		-	rect.x = rect.x.saturating_sub(size_info.cell_width() as i32);
	33	+	fn overdamage(size_info: &SizeInfo<u32>, mut rect: Rect) -> Rect {
	34	+	rect.x = (rect.x - size_info.cell_width() as i32).max(0);
36	35		rect.width = cmp::min(
37	36		size_info.width() as i32 - rect.x,
38	37		rect.width + 2 * size_info.cell_width() as i32,
39	38		);
40		-	rect.y = rect.y.saturating_sub(size_info.cell_height() as i32 / 2);
	39	+	rect.y = (rect.y - size_info.cell_height() as i32 / 2).max(0);
41	40		rect.height = cmp::min(
42	41		size_info.height() as i32 - rect.y,
43	42		rect.height + size_info.cell_height() as i32,
		skipped 8 lines
52	51
53	52		fn next(&mut self) -> Option<Rect> {
54	53		let line = self.damaged_lines.next()?;
55		-	let mut total_damage_rect = self.overdamage(self.rect_for_line(line));
	54	+	let size_info = &self.size_info;
	55	+	let mut total_damage_rect = Self::overdamage(size_info, self.rect_for_line(line));
56	56
57	57		// Merge rectangles which overlap with each other.
58	58		while let Some(line) = self.damaged_lines.peek().copied() {
59		-	let next_rect = self.overdamage(self.rect_for_line(line));
	59	+	let next_rect = Self::overdamage(size_info, self.rect_for_line(line));
60	60		if !rects_overlap(total_damage_rect, next_rect) {
61	61		break;
62	62		}
		skipped 30 lines
93	93		Rect::new(left_x, y_bottom, right_x - left_x, y_top - y_bottom)
94	94		}
95	95
	96	+	#[cfg(test)]
	97	+	mod tests {
	98	+	use super::*;
	99	+
	100	+	#[test]
	101	+	fn damage_rect_math() {
	102	+	let rect_side = 10;
	103	+	let cell_size = 4;
	104	+	let bound = 100;
	105	+
	106	+	let size_info: SizeInfo<u32> = SizeInfo::new(
	107	+	bound as f32,
	108	+	bound as f32,
	109	+	cell_size as f32,
	110	+	cell_size as f32,
	111	+	2.,
	112	+	2.,
	113	+	true,
	114	+	)
	115	+	.into();
	116	+
	117	+	// Test min clamping.
	118	+	let rect = Rect::new(0, 0, rect_side, rect_side);
	119	+	let rect = RenderDamageIterator::overdamage(&size_info, rect);
	120	+	assert_eq!(Rect::new(0, 0, rect_side + 2 * cell_size, 10 + cell_size), rect);
	121	+
	122	+	// Test max clamping.
	123	+	let rect = Rect::new(bound, bound, rect_side, rect_side);
	124	+	let rect = RenderDamageIterator::overdamage(&size_info, rect);
	125	+	assert_eq!(
	126	+	Rect::new(bound - cell_size, bound - cell_size / 2, cell_size, cell_size / 2),
	127	+	rect
	128	+	);
	129	+
	130	+	// Test no clamping.
	131	+	let rect = Rect::new(bound / 2, bound / 2, rect_side, rect_side);
	132	+	let rect = RenderDamageIterator::overdamage(&size_info, rect);
	133	+	assert_eq!(
	134	+	Rect::new(
	135	+	bound / 2 - cell_size,
	136	+	bound / 2 - cell_size / 2,
	137	+	rect_side + 2 * cell_size,
	138	+	rect_side + cell_size
	139	+	),
	140	+	rect
	141	+	);
	142	+	}
	143	+	}
	144	+