git.iko.soy/helix
on 6c11708 help sign in
helix/helix-tui/src/buffer.rs
844 lines 26 kB history raw
1use crate::text::{Span, Spans};
2use helix_core::unicode::width::UnicodeWidthStr;
3use std::cmp::min;
4use unicode_segmentation::UnicodeSegmentation;
6use helix_view::graphics::{Color, Modifier, Rect, Style};
8/// A buffer cell
9#[derive(Debug, Clone, PartialEq)]
10pub struct Cell {
11 pub symbol: String,
12 pub fg: Color,
13 pub bg: Color,
14 pub modifier: Modifier,
17impl Cell {
18 pub fn set_symbol(&mut self, symbol: &str) -> &mut Cell {
19 self.symbol.clear();
20 self.symbol.push_str(symbol);
21 self
22 }
24 pub fn set_char(&mut self, ch: char) -> &mut Cell {
25 self.symbol.clear();
26 self.symbol.push(ch);
27 self
28 }
30 pub fn set_fg(&mut self, color: Color) -> &mut Cell {
31 self.fg = color;
32 self
33 }
35 pub fn set_bg(&mut self, color: Color) -> &mut Cell {
36 self.bg = color;
37 self
38 }
40 pub fn set_style(&mut self, style: Style) -> &mut Cell {
41 if let Some(c) = style.fg {
42 self.fg = c;
43 }
44 if let Some(c) = style.bg {
45 self.bg = c;
46 }
47 self.modifier.insert(style.add_modifier);
48 self.modifier.remove(style.sub_modifier);
49 self
50 }
52 pub fn style(&self) -> Style {
53 Style::default()
54 .fg(self.fg)
55 .bg(self.bg)
56 .add_modifier(self.modifier)
57 }
59 pub fn reset(&mut self) {
60 self.symbol.clear();
61 self.symbol.push(' ');
62 self.fg = Color::Reset;
63 self.bg = Color::Reset;
64 self.modifier = Modifier::empty();
65 }
68impl Default for Cell {
69 fn default() -> Cell {
70 Cell {
71 symbol: " ".into(),
72 fg: Color::Reset,
73 bg: Color::Reset,
74 modifier: Modifier::empty(),
75 }
76 }
79/// A buffer that maps to the desired content of the terminal after the draw call
80///
81/// No widget in the library interacts directly with the terminal. Instead each of them is required
82/// to draw their state to an intermediate buffer. It is basically a grid where each cell contains
83/// a grapheme, a foreground color and a background color. This grid will then be used to output
84/// the appropriate escape sequences and characters to draw the UI as the user has defined it.
85///
86/// # Examples:
87///
88/// ```
89/// use helix_tui::buffer::{Buffer, Cell};
90/// use helix_view::graphics::{Rect, Color, Style, Modifier};
91///
92/// let mut buf = Buffer::empty(Rect{x: 0, y: 0, width: 10, height: 5});
93/// buf[(0, 2)].set_symbol("x");
94/// assert_eq!(buf[(0, 2)].symbol, "x");
95/// buf.set_string(3, 0, "string", Style::default().fg(Color::Red).bg(Color::White));
96/// assert_eq!(buf[(5, 0)], Cell{
97/// symbol: String::from("r"),
98/// fg: Color::Red,
99/// bg: Color::White,
100/// modifier: Modifier::empty()
101/// });
102/// buf[(5, 0)].set_char('x');
103/// assert_eq!(buf[(5, 0)].symbol, "x");
104/// ```
105#[derive(Debug, Default, Clone, PartialEq)]
106pub struct Buffer {
107 /// The area represented by this buffer
108 pub area: Rect,
109 /// The content of the buffer. The length of this Vec should always be equal to area.width *
110 /// area.height
111 pub content: Vec<Cell>,
114impl Buffer {
115 /// Returns a Buffer with all cells set to the default one
116 pub fn empty(area: Rect) -> Buffer {
117 let cell: Cell = Default::default();
118 Buffer::filled(area, &cell)
119 }
121 /// Returns a Buffer with all cells initialized with the attributes of the given Cell
122 pub fn filled(area: Rect, cell: &Cell) -> Buffer {
123 let size = area.area() as usize;
124 let mut content = Vec::with_capacity(size);
125 for _ in 0..size {
126 content.push(cell.clone());
127 }
128 Buffer { area, content }
129 }
131 /// Returns a Buffer containing the given lines
132 pub fn with_lines<S>(lines: Vec<S>) -> Buffer
133 where
134 S: AsRef<str>,
135 {
136 let height = lines.len() as u16;
137 let width = lines
138 .iter()
139 .map(|i| i.as_ref().width() as u16)
140 .max()
141 .unwrap_or_default();
142 let mut buffer = Buffer::empty(Rect {
143 x: 0,
144 y: 0,
145 width,
146 height,
147 });
148 for (y, line) in lines.iter().enumerate() {
149 buffer.set_string(0, y as u16, line, Style::default());
150 }
151 buffer
152 }
154 /// Returns the content of the buffer as a slice
155 pub fn content(&self) -> &[Cell] {
156 &self.content
157 }
159 /// Returns the area covered by this buffer
160 pub fn area(&self) -> &Rect {
161 &self.area
162 }
164 /// Returns a reference to Cell at the given coordinates
165 pub fn get(&self, x: u16, y: u16) -> Option<&Cell> {
166 self.index_of_opt(x, y).map(|i| &self.content[i])
167 }
169 /// Returns a mutable reference to Cell at the given coordinates
170 pub fn get_mut(&mut self, x: u16, y: u16) -> Option<&mut Cell> {
171 self.index_of_opt(x, y).map(|i| &mut self.content[i])
172 }
174 /// Tells whether the global (x, y) coordinates are inside the Buffer's area.
175 ///
176 /// Global coordinates are offset by the Buffer's area offset (`x`/`y`).
177 ///
178 /// # Examples
179 ///
180 /// ```
181 /// # use helix_tui::buffer::Buffer;
182 /// # use helix_view::graphics::Rect;
183 /// let rect = Rect::new(200, 100, 10, 10);
184 /// let buffer = Buffer::empty(rect);
185 /// // Global coordinates inside the Buffer's area
186 /// assert!(buffer.in_bounds(209, 100));
187 /// // Global coordinates outside the Buffer's area
188 /// assert!(!buffer.in_bounds(210, 100));
189 /// ```
190 ///
191 /// Global coordinates are offset by the Buffer's area offset (`x`/`y`).
192 pub fn in_bounds(&self, x: u16, y: u16) -> bool {
193 x >= self.area.left()
194 && x < self.area.right()
195 && y >= self.area.top()
196 && y < self.area.bottom()
197 }
199 /// Returns the index in the Vec<Cell> for the given global (x, y) coordinates.
200 ///
201 /// Global coordinates are offset by the Buffer's area offset (`x`/`y`).
202 ///
203 /// # Examples
204 ///
205 /// ```
206 /// # use helix_tui::buffer::Buffer;
207 /// # use helix_view::graphics::Rect;
208 /// let rect = Rect::new(200, 100, 10, 10);
209 /// let buffer = Buffer::empty(rect);
210 /// // Global coordinates to the top corner of this Buffer's area
211 /// assert_eq!(buffer.index_of(200, 100), 0);
212 /// ```
213 ///
214 /// # Panics
215 ///
216 /// Panics when given an coordinate that is outside of this Buffer's area.
217 pub fn index_of(&self, x: u16, y: u16) -> usize {
218 debug_assert!(
219 self.in_bounds(x, y),
220 "Trying to access position outside the buffer: x={}, y={}, area={:?}",
221 x,
222 y,
223 self.area
224 );
225 ((y - self.area.y) * self.area.width + (x - self.area.x)) as usize
226 }
228 /// Returns the index in the Vec<Cell> for the given global (x, y) coordinates,
229 /// or `None` if the coordinates are outside the buffer's area.
230 fn index_of_opt(&self, x: u16, y: u16) -> Option<usize> {
231 if self.in_bounds(x, y) {
232 Some(self.index_of(x, y))
233 } else {
234 None
235 }
236 }
238 /// Returns the (global) coordinates of a cell given its index
239 ///
240 /// Global coordinates are offset by the Buffer's area offset (`x`/`y`).
241 ///
242 /// # Examples
243 ///
244 /// ```
245 /// # use helix_tui::buffer::Buffer;
246 /// # use helix_view::graphics::Rect;
247 /// let rect = Rect::new(200, 100, 10, 10);
248 /// let buffer = Buffer::empty(rect);
249 /// assert_eq!(buffer.pos_of(0), (200, 100));
250 /// assert_eq!(buffer.pos_of(14), (204, 101));
251 /// ```
252 ///
253 /// # Panics
254 ///
255 /// Panics when given an index that is outside the Buffer's content.
256 pub fn pos_of(&self, i: usize) -> (u16, u16) {
257 debug_assert!(
258 i < self.content.len(),
259 "Trying to get the coords of a cell outside the buffer: i={} len={}",
260 i,
261 self.content.len()
262 );
263 (
264 self.area.x + i as u16 % self.area.width,
265 self.area.y + i as u16 / self.area.width,
266 )
267 }
269 /// Print a string, starting at the position (x, y)
270 pub fn set_string<S>(&mut self, x: u16, y: u16, string: S, style: Style)
271 where
272 S: AsRef<str>,
273 {
274 self.set_stringn(x, y, string, usize::MAX, style);
275 }
277 /// Print at most the first n characters of a string if enough space is available
278 /// until the end of the line
279 pub fn set_stringn<S>(
280 &mut self,
281 x: u16,
282 y: u16,
283 string: S,
284 width: usize,
285 style: Style,
286 ) -> (u16, u16)
287 where
288 S: AsRef<str>,
289 {
290 self.set_string_truncated(x, y, string, width, style, false, false)
291 }
293 /// Print at most the first `width` characters of a string if enough space is available
294 /// until the end of the line. If `ellipsis` is true appends a `…` at the end of
295 /// truncated lines. If `truncate_start` is `true`, truncate the beginning of the string
296 /// instead of the end.
297 #[allow(clippy::too_many_arguments)]
298 pub fn set_string_truncated<S>(
299 &mut self,
300 x: u16,
301 y: u16,
302 string: S,
303 width: usize,
304 style: Style,
305 ellipsis: bool,
306 truncate_start: bool,
307 ) -> (u16, u16)
308 where
309 S: AsRef<str>,
310 {
311 // prevent panic if out of range
312 if !self.in_bounds(x, y) || width == 0 {
313 return (x, y);
314 }
316 let mut index = self.index_of(x, y);
317 let mut x_offset = x as usize;
318 let width = if ellipsis { width - 1 } else { width };
319 let graphemes = UnicodeSegmentation::graphemes(string.as_ref(), true);
320 let max_offset = min(self.area.right() as usize, width.saturating_add(x as usize));
321 if !truncate_start {
322 for s in graphemes {
323 let width = s.width();
324 if width == 0 {
325 continue;
326 }
327 // `x_offset + width > max_offset` could be integer overflow on 32-bit machines if we
328 // change dimenstions to usize or u32 and someone resizes the terminal to 1x2^32.
329 if width > max_offset.saturating_sub(x_offset) {
330 break;
331 }
333 self.content[index].set_symbol(s);
334 self.content[index].set_style(style);
335 // Reset following cells if multi-width (they would be hidden by the grapheme),
336 for i in index + 1..index + width {
337 self.content[i].reset();
338 }
339 index += width;
340 x_offset += width;
341 }
342 if ellipsis && x_offset - (x as usize) < string.as_ref().width() {
343 self.content[index].set_symbol("…");
344 }
345 } else {
346 let mut start_index = self.index_of(x, y);
347 let mut index = self.index_of(max_offset as u16, y);
349 let total_width = string.as_ref().width();
350 let truncated = total_width > width;
351 if ellipsis && truncated {
352 self.content[start_index].set_symbol("…");
353 start_index += 1;
354 }
355 if !truncated {
356 index -= width - total_width;
357 }
358 for s in graphemes.rev() {
359 let width = s.width();
360 if width == 0 {
361 continue;
362 }
363 let start = index - width;
364 if start < start_index {
365 break;
366 }
367 self.content[start].set_symbol(s);
368 self.content[start].set_style(style);
369 for i in start + 1..index {
370 self.content[i].reset();
371 }
372 index -= width;
373 }
374 }
375 (x_offset as u16, y)
376 }
378 pub fn set_spans<'a>(&mut self, x: u16, y: u16, spans: &Spans<'a>, width: u16) -> (u16, u16) {
379 let mut remaining_width = width;
380 let mut x = x;
381 for span in &spans.0 {
382 if remaining_width == 0 {
383 break;
384 }
385 let pos = self.set_stringn(
386 x,
387 y,
388 span.content.as_ref(),
389 remaining_width as usize,
390 span.style,
391 );
392 let w = pos.0.saturating_sub(x);
393 x = pos.0;
394 remaining_width = remaining_width.saturating_sub(w);
395 }
396 (x, y)
397 }
399 pub fn set_span<'a>(&mut self, x: u16, y: u16, span: &Span<'a>, width: u16) -> (u16, u16) {
400 self.set_stringn(x, y, span.content.as_ref(), width as usize, span.style)
401 }
403 #[deprecated(
404 since = "0.10.0",
405 note = "You should use styling capabilities of `Buffer::set_style`"
406 )]
407 pub fn set_background(&mut self, area: Rect, color: Color) {
408 for y in area.top()..area.bottom() {
409 for x in area.left()..area.right() {
410 self[(x, y)].set_bg(color);
411 }
412 }
413 }
415 pub fn set_style(&mut self, area: Rect, style: Style) {
416 for y in area.top()..area.bottom() {
417 for x in area.left()..area.right() {
418 self[(x, y)].set_style(style);
419 }
420 }
421 }
423 /// Resize the buffer so that the mapped area matches the given area and that the buffer
424 /// length is equal to area.width * area.height
425 pub fn resize(&mut self, area: Rect) {
426 let length = area.area() as usize;
427 if self.content.len() > length {
428 self.content.truncate(length);
429 } else {
430 self.content.resize(length, Default::default());
431 }
432 self.area = area;
433 }
435 /// Reset all cells in the buffer
436 pub fn reset(&mut self) {
437 for c in &mut self.content {
438 c.reset();
439 }
440 }
442 /// Clear an area in the buffer
443 pub fn clear(&mut self, area: Rect) {
444 for x in area.left()..area.right() {
445 for y in area.top()..area.bottom() {
446 self[(x, y)].reset();
447 }
448 }
449 }
451 /// Clear an area in the buffer with a default style.
452 pub fn clear_with(&mut self, area: Rect, style: Style) {
453 for x in area.left()..area.right() {
454 for y in area.top()..area.bottom() {
455 let cell = &mut self[(x, y)];
456 cell.reset();
457 cell.set_style(style);
458 }
459 }
460 }
462 /// Merge an other buffer into this one
463 pub fn merge(&mut self, other: &Buffer) {
464 let area = self.area.union(other.area);
465 let cell: Cell = Default::default();
466 self.content.resize(area.area() as usize, cell.clone());
468 // Move original content to the appropriate space
469 let size = self.area.area() as usize;
470 for i in (0..size).rev() {
471 let (x, y) = self.pos_of(i);
472 // New index in content
473 let k = ((y - area.y) * area.width + x - area.x) as usize;
474 if i != k {
475 self.content[k] = self.content[i].clone();
476 self.content[i] = cell.clone();
477 }
478 }
480 // Push content of the other buffer into this one (may erase previous
481 // data)
482 let size = other.area.area() as usize;
483 for i in 0..size {
484 let (x, y) = other.pos_of(i);
485 // New index in content
486 let k = ((y - area.y) * area.width + x - area.x) as usize;
487 self.content[k] = other.content[i].clone();
488 }
489 self.area = area;
490 }
492 /// Builds a minimal sequence of coordinates and Cells necessary to update the UI from
493 /// self to other.
494 ///
495 /// We're assuming that buffers are well-formed, that is no double-width cell is followed by
496 /// a non-blank cell.
497 ///
498 /// # Multi-width characters handling:
499 ///
500 /// ```text
501 /// (Index:) `01`
502 /// Prev: `コ`
503 /// Next: `aa`
504 /// Updates: `0: a, 1: a'
505 /// ```
506 ///
507 /// ```text
508 /// (Index:) `01`
509 /// Prev: `a `
510 /// Next: `コ`
511 /// Updates: `0: コ` (double width symbol at index 0 - skip index 1)
512 /// ```
513 ///
514 /// ```text
515 /// (Index:) `012`
516 /// Prev: `aaa`
517 /// Next: `aコ`
518 /// Updates: `0: a, 1: コ` (double width symbol at index 1 - skip index 2)
519 /// ```
520 pub fn diff<'a>(&self, other: &'a Buffer) -> Vec<(u16, u16, &'a Cell)> {
521 let previous_buffer = &self.content;
522 let next_buffer = &other.content;
523 let width = self.area.width;
525 let mut updates: Vec<(u16, u16, &Cell)> = vec![];
526 // Cells invalidated by drawing/replacing preceeding multi-width characters:
527 let mut invalidated: usize = 0;
528 // Cells from the current buffer to skip due to preceeding multi-width characters taking their
529 // place (the skipped cells should be blank anyway):
530 let mut to_skip: usize = 0;
531 for (i, (current, previous)) in next_buffer.iter().zip(previous_buffer.iter()).enumerate() {
532 if (current != previous || invalidated > 0) && to_skip == 0 {
533 let x = i as u16 % width;
534 let y = i as u16 / width;
535 updates.push((x, y, &next_buffer[i]));
536 }
538 let current_width = current.symbol.width();
539 to_skip = current_width.saturating_sub(1);
541 let affected_width = std::cmp::max(current_width, previous.symbol.width());
542 invalidated = std::cmp::max(affected_width, invalidated).saturating_sub(1);
543 }
544 updates
545 }
548impl std::ops::Index<(u16, u16)> for Buffer {
549 type Output = Cell;
551 fn index(&self, (x, y): (u16, u16)) -> &Self::Output {
552 let i = self.index_of(x, y);
553 &self.content[i]
554 }
557impl std::ops::IndexMut<(u16, u16)> for Buffer {
558 fn index_mut(&mut self, (x, y): (u16, u16)) -> &mut Self::Output {
559 let i = self.index_of(x, y);
560 &mut self.content[i]
561 }
564#[cfg(test)]
565mod tests {
566 use super::*;
568 fn cell(s: &str) -> Cell {
569 let mut cell = Cell::default();
570 cell.set_symbol(s);
571 cell
572 }
574 #[test]
575 fn it_translates_to_and_from_coordinates() {
576 let rect = Rect::new(200, 100, 50, 80);
577 let buf = Buffer::empty(rect);
579 // First cell is at the upper left corner.
580 assert_eq!(buf.pos_of(0), (200, 100));
581 assert_eq!(buf.index_of(200, 100), 0);
583 // Last cell is in the lower right.
584 assert_eq!(buf.pos_of(buf.content.len() - 1), (249, 179));
585 assert_eq!(buf.index_of(249, 179), buf.content.len() - 1);
586 }
588 #[test]
589 #[should_panic(expected = "outside the buffer")]
590 #[cfg(debug_assertions)]
591 fn pos_of_panics_on_out_of_bounds() {
592 let rect = Rect::new(0, 0, 10, 10);
593 let buf = Buffer::empty(rect);
595 // There are a total of 100 cells; zero-indexed means that 100 would be the 101st cell.
596 buf.pos_of(100);
597 }
599 #[test]
600 #[should_panic(expected = "outside the buffer")]
601 #[cfg(debug_assertions)]
602 fn index_of_panics_on_out_of_bounds() {
603 let rect = Rect::new(0, 0, 10, 10);
604 let buf = Buffer::empty(rect);
606 // width is 10; zero-indexed means that 10 would be the 11th cell.
607 buf.index_of(10, 0);
608 }
610 #[test]
611 fn buffer_set_string() {
612 let area = Rect::new(0, 0, 5, 1);
613 let mut buffer = Buffer::empty(area);
615 // Zero-width
616 buffer.set_stringn(0, 0, "aaa", 0, Style::default());
617 assert_eq!(buffer, Buffer::with_lines(vec![" "]));
619 buffer.set_string(0, 0, "aaa", Style::default());
620 assert_eq!(buffer, Buffer::with_lines(vec!["aaa "]));
622 // Width limit:
623 buffer.set_stringn(0, 0, "bbbbbbbbbbbbbb", 4, Style::default());
624 assert_eq!(buffer, Buffer::with_lines(vec!["bbbb "]));
626 buffer.set_string(0, 0, "12345", Style::default());
627 assert_eq!(buffer, Buffer::with_lines(vec!["12345"]));
629 // Width truncation:
630 buffer.set_string(0, 0, "123456", Style::default());
631 assert_eq!(buffer, Buffer::with_lines(vec!["12345"]));
632 }
634 #[test]
635 fn buffer_set_string_zero_width() {
636 let area = Rect::new(0, 0, 1, 1);
637 let mut buffer = Buffer::empty(area);
639 // Leading grapheme with zero width
640 let s = "\u{1}a";
641 buffer.set_stringn(0, 0, s, 1, Style::default());
642 assert_eq!(buffer, Buffer::with_lines(vec!["a"]));
644 // Trailing grapheme with zero with
645 let s = "a\u{1}";
646 buffer.set_stringn(0, 0, s, 1, Style::default());
647 assert_eq!(buffer, Buffer::with_lines(vec!["a"]));
648 }
650 #[test]
651 fn buffer_set_string_double_width() {
652 let area = Rect::new(0, 0, 5, 1);
653 let mut buffer = Buffer::empty(area);
654 buffer.set_string(0, 0, "コン", Style::default());
655 assert_eq!(buffer, Buffer::with_lines(vec!["コン "]));
657 // Only 1 space left.
658 buffer.set_string(0, 0, "コンピ", Style::default());
659 assert_eq!(buffer, Buffer::with_lines(vec!["コン "]));
660 }
662 #[test]
663 fn buffer_with_lines() {
664 let buffer =
665 Buffer::with_lines(vec!["┌────────┐", "│コンピュ│", "│ーa 上で│", "└────────┘"]);
666 assert_eq!(buffer.area.x, 0);
667 assert_eq!(buffer.area.y, 0);
668 assert_eq!(buffer.area.width, 10);
669 assert_eq!(buffer.area.height, 4);
670 }
672 #[test]
673 fn buffer_diffing_empty_empty() {
674 let area = Rect::new(0, 0, 40, 40);
675 let prev = Buffer::empty(area);
676 let next = Buffer::empty(area);
677 let diff = prev.diff(&next);
678 assert_eq!(diff, vec![]);
679 }
681 #[test]
682 fn buffer_diffing_empty_filled() {
683 let area = Rect::new(0, 0, 40, 40);
684 let prev = Buffer::empty(area);
685 let next = Buffer::filled(area, Cell::default().set_symbol("a"));
686 let diff = prev.diff(&next);
687 assert_eq!(diff.len(), 40 * 40);
688 }
690 #[test]
691 fn buffer_diffing_filled_filled() {
692 let area = Rect::new(0, 0, 40, 40);
693 let prev = Buffer::filled(area, Cell::default().set_symbol("a"));
694 let next = Buffer::filled(area, Cell::default().set_symbol("a"));
695 let diff = prev.diff(&next);
696 assert_eq!(diff, vec![]);
697 }
699 #[test]
700 fn buffer_diffing_single_width() {
701 let prev = Buffer::with_lines(vec![
702 " ",
703 "┌Title─┐ ",
704 "│ │ ",
705 "│ │ ",
706 "└──────┘ ",
707 ]);
708 let next = Buffer::with_lines(vec![
709 " ",
710 "┌TITLE─┐ ",
711 "│ │ ",
712 "│ │ ",
713 "└──────┘ ",
714 ]);
715 let diff = prev.diff(&next);
716 assert_eq!(
717 diff,
718 vec![
719 (2, 1, &cell("I")),
720 (3, 1, &cell("T")),
721 (4, 1, &cell("L")),
722 (5, 1, &cell("E")),
723 ]
724 );
725 }
727 #[test]
728 #[rustfmt::skip]
729 fn buffer_diffing_multi_width() {
730 let prev = Buffer::with_lines(vec![
731 "┌Title─┐ ",
732 "└──────┘ ",
733 ]);
734 let next = Buffer::with_lines(vec![
735 "┌称号──┐ ",
736 "└──────┘ ",
737 ]);
738 let diff = prev.diff(&next);
739 assert_eq!(
740 diff,
741 vec![
742 (1, 0, &cell("称")),
743 // Skipped "i"
744 (3, 0, &cell("号")),
745 // Skipped "l"
746 (5, 0, &cell("─")),
747 ]
748 );
749 }
751 #[test]
752 fn buffer_diffing_multi_width_offset() {
753 let prev = Buffer::with_lines(vec!["┌称号──┐"]);
754 let next = Buffer::with_lines(vec!["┌─称号─┐"]);
756 let diff = prev.diff(&next);
757 assert_eq!(
758 diff,
759 vec![(1, 0, &cell("─")), (2, 0, &cell("称")), (4, 0, &cell("号")),]
760 );
761 }
763 #[test]
764 fn buffer_merge() {
765 let mut one = Buffer::filled(
766 Rect {
767 x: 0,
768 y: 0,
769 width: 2,
770 height: 2,
771 },
772 Cell::default().set_symbol("1"),
773 );
774 let two = Buffer::filled(
775 Rect {
776 x: 0,
777 y: 2,
778 width: 2,
779 height: 2,
780 },
781 Cell::default().set_symbol("2"),
782 );
783 one.merge(&two);
784 assert_eq!(one, Buffer::with_lines(vec!["11", "11", "22", "22"]));
785 }
787 #[test]
788 fn buffer_merge2() {
789 let mut one = Buffer::filled(
790 Rect {
791 x: 2,
792 y: 2,
793 width: 2,
794 height: 2,
795 },
796 Cell::default().set_symbol("1"),
797 );
798 let two = Buffer::filled(
799 Rect {
800 x: 0,
801 y: 0,
802 width: 2,
803 height: 2,
804 },
805 Cell::default().set_symbol("2"),
806 );
807 one.merge(&two);
808 assert_eq!(
809 one,
810 Buffer::with_lines(vec!["22 ", "22 ", " 11", " 11"])
811 );
812 }
814 #[test]
815 fn buffer_merge3() {
816 let mut one = Buffer::filled(
817 Rect {
818 x: 3,
819 y: 3,
820 width: 2,
821 height: 2,
822 },
823 Cell::default().set_symbol("1"),
824 );
825 let two = Buffer::filled(
826 Rect {
827 x: 1,
828 y: 1,
829 width: 3,
830 height: 4,
831 },
832 Cell::default().set_symbol("2"),
833 );
834 one.merge(&two);
835 let mut merged = Buffer::with_lines(vec!["222 ", "222 ", "2221", "2221"]);
836 merged.area = Rect {
837 x: 1,
838 y: 1,
839 width: 4,
840 height: 4,
841 };
842 assert_eq!(one, merged);
843 }