Skip to main content

view/
view_data_updater.rs

1use super::{ViewData, ViewLine};
2
3/// An updater utility for a `ViewData`.
4#[derive(Debug)]
5pub struct ViewDataUpdater<'view_data> {
6	modified: bool,
7	view_data: &'view_data mut ViewData,
8}
9
10impl<'view_data> ViewDataUpdater<'view_data> {
11	pub(crate) fn new(view_data: &'view_data mut ViewData) -> Self {
12		Self {
13			view_data,
14			modified: false,
15		}
16	}
17
18	/// Clear content of the view data.
19	#[inline]
20	pub fn clear(&mut self) {
21		self.modified = true;
22		self.view_data.clear();
23	}
24
25	/// Clear just the body of the view data.
26	#[inline]
27	pub fn clear_body(&mut self) {
28		self.modified = true;
29		self.view_data.clear_body();
30	}
31
32	/// Set the line that must be visible during render.
33	#[inline]
34	pub fn ensure_line_visible(&mut self, row_index: usize) {
35		self.modified = true;
36		self.view_data.ensure_line_visible(row_index);
37	}
38
39	/// Set the column to must be visible during render.
40	#[inline]
41	pub fn ensure_column_visible(&mut self, column_index: usize) {
42		self.modified = true;
43		self.view_data.ensure_column_visible(column_index);
44	}
45
46	/// Set if to show title.
47	#[inline]
48	pub fn set_show_title(&mut self, show: bool) {
49		self.modified = true;
50		self.view_data.set_show_title(show);
51	}
52
53	/// Set if to show help.
54	#[inline]
55	pub fn set_show_help(&mut self, show: bool) {
56		self.modified = true;
57		self.view_data.set_show_help(show);
58	}
59
60	/// Push a new leading line to the view data.
61	#[inline]
62	pub fn push_leading_line(&mut self, view_line: ViewLine) {
63		self.modified = true;
64		self.view_data.push_leading_line(view_line);
65	}
66
67	/// Push a new body line to the view data.
68	#[inline]
69	pub fn push_line(&mut self, view_line: ViewLine) {
70		self.modified = true;
71		self.view_data.push_line(view_line);
72	}
73
74	/// Push a set of new body lines to the view data automatically split on newlines.
75	#[inline]
76	pub fn push_lines(&mut self, lines: &str) {
77		self.modified = true;
78
79		for line in lines.lines() {
80			self.view_data.push_line(ViewLine::from(line));
81		}
82	}
83
84	/// Push a new trailing line to the view data.
85	#[inline]
86	pub fn push_trailing_line(&mut self, view_line: ViewLine) {
87		self.modified = true;
88		self.view_data.push_trailing_line(view_line);
89	}
90
91	/// Set the scroll position retain value of the view data.
92	#[inline]
93	pub fn set_retain_scroll_position(&mut self, value: bool) {
94		self.modified = true;
95		self.view_data.set_retain_scroll_position(value);
96	}
97
98	/// Reset the scroll position of the view data.
99	#[inline]
100	pub fn reset_scroll_position(&mut self) {
101		self.modified = true;
102		self.view_data.reset_scroll_position();
103	}
104
105	#[inline]
106	pub(crate) const fn is_modified(&self) -> bool {
107		self.modified
108	}
109}
110
111#[cfg(test)]
112mod tests {
113	use super::*;
114
115	#[test]
116	fn clear() {
117		let mut view_data = ViewData::new(|_| {});
118		view_data.push_line(ViewLine::new_empty_line());
119		let mut updater = ViewDataUpdater::new(&mut view_data);
120		updater.clear();
121		assert!(updater.is_modified());
122		assert!(view_data.is_empty());
123	}
124
125	#[test]
126	fn clear_body() {
127		let mut view_data = ViewData::new(|_| {});
128		view_data.push_line(ViewLine::new_empty_line());
129		view_data.push_leading_line(ViewLine::new_empty_line());
130		let mut updater = ViewDataUpdater::new(&mut view_data);
131		updater.clear_body();
132		assert!(updater.is_modified());
133		assert!(view_data.get_lines().is_empty());
134		assert_eq!(view_data.get_leading_lines().len(), 1);
135	}
136
137	#[test]
138	fn ensure_line_visible() {
139		let mut view_data = ViewData::new(|_| {});
140		let mut updater = ViewDataUpdater::new(&mut view_data);
141		updater.ensure_line_visible(10);
142		assert!(updater.is_modified());
143		assert_eq!(view_data.get_visible_row().unwrap(), 10);
144	}
145
146	#[test]
147	fn ensure_column_visible() {
148		let mut view_data = ViewData::new(|_| {});
149		let mut updater = ViewDataUpdater::new(&mut view_data);
150		updater.ensure_column_visible(10);
151		assert!(updater.is_modified());
152		assert_eq!(view_data.get_visible_column().unwrap(), 10);
153	}
154
155	#[test]
156	fn set_show_title() {
157		let mut view_data = ViewData::new(|_| {});
158		let mut updater = ViewDataUpdater::new(&mut view_data);
159		updater.set_show_title(true);
160		assert!(updater.is_modified());
161		assert!(view_data.show_title());
162	}
163
164	#[test]
165	fn set_show_help() {
166		let mut view_data = ViewData::new(|_| {});
167		let mut updater = ViewDataUpdater::new(&mut view_data);
168		updater.set_show_help(true);
169		assert!(updater.is_modified());
170		assert!(view_data.show_help());
171	}
172
173	#[test]
174	fn push_leading_line() {
175		let mut view_data = ViewData::new(|_| {});
176		let mut updater = ViewDataUpdater::new(&mut view_data);
177		updater.push_leading_line(ViewLine::new_empty_line());
178		assert!(updater.is_modified());
179		assert_eq!(view_data.get_leading_lines().len(), 1);
180	}
181
182	#[test]
183	fn push_line() {
184		let mut view_data = ViewData::new(|_| {});
185		let mut updater = ViewDataUpdater::new(&mut view_data);
186		updater.push_line(ViewLine::new_empty_line());
187		assert!(updater.is_modified());
188		assert_eq!(view_data.get_lines().len(), 1);
189	}
190
191	#[test]
192	fn push_trailing_line() {
193		let mut view_data = ViewData::new(|_| {});
194		let mut updater = ViewDataUpdater::new(&mut view_data);
195		updater.push_trailing_line(ViewLine::new_empty_line());
196		assert!(updater.is_modified());
197		assert_eq!(view_data.get_trailing_lines().len(), 1);
198	}
199
200	#[test]
201	fn set_retain_scroll_position() {
202		let mut view_data = ViewData::new(|_| {});
203		let mut updater = ViewDataUpdater::new(&mut view_data);
204		updater.set_retain_scroll_position(false);
205		assert!(updater.is_modified());
206		assert!(!view_data.retain_scroll_position());
207	}
208
209	#[test]
210	fn reset_scroll_position() {
211		let mut view_data = ViewData::new(|_| {});
212		let previous_scroll_version = view_data.get_scroll_version();
213		let mut updater = ViewDataUpdater::new(&mut view_data);
214		updater.reset_scroll_position();
215		assert!(updater.is_modified());
216		assert_ne!(view_data.get_scroll_version(), previous_scroll_version);
217	}
218}