Unify the grid line indexing types

Previously Alacritty was using two different ways to reference lines in
the terminal. Either a `usize`, or a `Line(usize)`. These indexing
systems both served different purposes, but made it difficult to reason
about logic involving these systems because of its inconsistency.

To resolve this issue, a single new `Line(i32)` type has been
introduced.  All existing references to lines and points now rely on
this definition of a line.

The indexing starts at the top of the terminal region with the line 0,
which matches the line 1 used by escape sequences. Each line in the
history becomes increasingly negative and the bottommost line is equal
to the number of visible lines minus one.

Having a system which goes into the negatives allows following the
escape sequence's indexing system closely, while at the same time making
it trivial to implement `Ord` for points.

The Alacritty UI crate is the only place which has a different indexing
system, since rendering and input puts the zero line at the top of the
viewport, rather than the top of the terminal region.

All instances which refer to a number of lines/columns instead of just a
single Line/Column have also been changed to use a `usize` instead. This
way a Line/Column will always refer to a specific place in the grid and
no confusion is created by having a count of lines as a possible index
into the grid storage.

1 files changed, 12 insertions, 12 deletions

diff --git a/alacritty_terminal/src/grid/row.rs b/alacritty_terminal/src/grid/row.rs
index e48103a6..c932e83f 100644
--- a/alacritty_terminal/src/grid/row.rs
+++ b/alacritty_terminal/src/grid/row.rs
@@ -34,22 +34,22 @@ impl<T: Clone + Default> Row<T> {
     /// Create a new terminal row.
     ///
     /// Ideally the `template` should be `Copy` in all performance sensitive scenarios.
-    pub fn new(columns: Column) -> Row<T> {
-        debug_assert!(columns.0 >= 1);
+    pub fn new(columns: usize) -> Row<T> {
+        debug_assert!(columns >= 1);
 
-        let mut inner: Vec<T> = Vec::with_capacity(columns.0);
+        let mut inner: Vec<T> = Vec::with_capacity(columns);
 
         // This is a slightly optimized version of `std::vec::Vec::resize`.
         unsafe {
             let mut ptr = inner.as_mut_ptr();
 
-            for _ in 1..columns.0 {
+            for _ in 1..columns {
                 ptr::write(ptr, T::default());
                 ptr = ptr.offset(1);
             }
             ptr::write(ptr, T::default());
 
-            inner.set_len(columns.0);
+            inner.set_len(columns);
         }
 
         Row { inner, occ: 0 }
@@ -57,31 +57,31 @@ impl<T: Clone + Default> Row<T> {
 
     /// Increase the number of columns in the row.
     #[inline]
-    pub fn grow(&mut self, cols: Column) {
-        if self.inner.len() >= cols.0 {
+    pub fn grow(&mut self, columns: usize) {
+        if self.inner.len() >= columns {
             return;
         }
 
-        self.inner.resize_with(cols.0, T::default);
+        self.inner.resize_with(columns, T::default);
     }
 
     /// Reduce the number of columns in the row.
     ///
     /// This will return all non-empty cells that were removed.
-    pub fn shrink(&mut self, cols: Column) -> Option<Vec<T>>
+    pub fn shrink(&mut self, columns: usize) -> Option<Vec<T>>
     where
         T: GridCell,
     {
-        if self.inner.len() <= cols.0 {
+        if self.inner.len() <= columns {
             return None;
         }
 
         // Split off cells for a new row.
-        let mut new_row = self.inner.split_off(cols.0);
+        let mut new_row = self.inner.split_off(columns);
         let index = new_row.iter().rposition(|c| !c.is_empty()).map(|i| i + 1).unwrap_or(0);
         new_row.truncate(index);
 
-        self.occ = min(self.occ, cols.0);
+        self.occ = min(self.occ, columns);
 
         if new_row.is_empty() {
             None