Fix terminal mode (#129)

* Don't crash when using 90° rotation

* Fix another crash

* Rotate characters

* Run cargo fmt

* Remove incorrect comment

* Reset cursor on rotation

* Handle display offset, clean up reset_pos

* Remove outdated note

* Remove outdated todo

* Fix formatting

* Remove outdated note from Builder

* Add changelog entries

* Fix things broken by rebase

Author: bugadani

CHANGELOG.md

@@ -13,6 +13,7 @@
 
 ### Changed
 
+- **(breaking)** [#129](https://github.com/jamwaffles/ssd1306/pull/129) `TerminalMode::set_rotation` now resets the cursor position
 - **(breaking)** [#125](https://github.com/jamwaffles/ssd1306/pull/125) Redesigned display size handling.
 - **(breaking)** [#126](https://github.com/jamwaffles/ssd1306/pull/126) Moved `reset` method to `DisplayModeTrait`. If the prelude is not used, add either `use ssd1306::prelude::*` or `ssd1306::mode::displaymode::DisplayModeTrait` to your imports.
 - **(breaking)** [#119](https://github.com/jamwaffles/ssd1306/pull/119) Remove `DisplayMode` and `RawMode`
@@ -21,6 +22,10 @@
 - **(breaking)** [#116](https://github.com/jamwaffles/ssd1306/pull/116) Replace custom I2C and SPI interfaces by generic [`display-interface`](https://crates.io/crates/display-interface)
 - **(breaking)** [#113](https://github.com/jamwaffles/ssd1306/pull/113) Removed public `send_bounded_data` from DisplayInterface and implementations
 
+### Fixed
+
+- [#129](https://github.com/jamwaffles/ssd1306/pull/129) Fixed `Rotate90` and `Rotate270` rotation modes for `TerminalMode`
+
 ## [0.3.1] - 2020-03-21
 
 ### Fixed

src/builder.rs

@@ -113,9 +113,7 @@ where
         }
     }
 
-    /// Set the rotation of the display to one of four values. Defaults to no rotation. Note that
-    /// 90º and 270º rotations are not supported by
-    /// [`TerminalMode`](../mode/terminal/struct.TerminalMode.html).
+    /// Set the rotation of the display to one of four values. Defaults to no rotation.
     pub fn with_rotation(self, rotation: DisplayRotation) -> Self {
         Self { rotation, ..self }
     }

src/displayrotation.rs

@@ -1,10 +1,6 @@
 //! Display rotation
 
-// TODO: Add to prelude
 /// Display rotation.
-///
-/// Note that 90º and 270º rotations are not supported by
-// [`TerminalMode`](../mode/terminal/struct.TerminalMode.html).
 #[derive(Clone, Copy)]
 pub enum DisplayRotation {
     /// No rotation, normal display

src/mode/terminal.rs

@@ -3,7 +3,6 @@
 //! This mode uses the 7x7 pixel [MarioChrome](https://github.com/techninja/MarioChron/) font to
 //! draw characters to the display without needing a framebuffer. It will write characters from top
 //! left to bottom right in an 8x8 pixel grid, restarting at the top left of the display once full.
-//! The display itself takes care of wrapping lines.
 //!
 //! ```rust
 //! # use ssd1306::test_helpers::I2cStub;
@@ -241,10 +240,18 @@ where
                 self.ensure_cursor()?.set_position(0, cur_line);
             }
             _ => {
-                // Send the pixel data to the display
-                self.properties
-                    .draw(&Self::char_to_bitmap(c))
-                    .terminal_err()?;
+                let bitmap = match self.properties.get_rotation() {
+                    DisplayRotation::Rotate0 | DisplayRotation::Rotate180 => {
+                        Self::char_to_bitmap(c)
+                    }
+                    DisplayRotation::Rotate90 | DisplayRotation::Rotate270 => {
+                        let bitmap = Self::char_to_bitmap(c);
+                        Self::rotate_bitmap(bitmap)
+                    }
+                };
+
+                self.properties.draw(&bitmap).terminal_err()?;
+
                 // Increment character counter and potentially wrap line
                 self.advance_cursor()?;
             }
@@ -265,9 +272,12 @@ where
     }
 
     /// Set the display rotation
+    ///
+    /// This method resets the cursor but does not clear the screen.
     pub fn set_rotation(&mut self, rot: DisplayRotation) -> Result<(), TerminalModeError> {
-        // we don't need to touch the cursor because rotating 90º or 270º currently just flips
-        self.properties.set_rotation(rot).terminal_err()
+        self.properties.set_rotation(rot).terminal_err()?;
+        // Need to reset cursor position, otherwise coordinates can become invalid
+        self.reset_pos()
     }
 
     /// Turn the display on or off. The display can be drawn to and retains all
@@ -298,29 +308,49 @@ where
         if column >= width || row >= height {
             Err(OutOfBounds)
         } else {
-            self.properties.set_column(column * 8).terminal_err()?;
-            self.properties.set_row(row * 8).terminal_err()?;
+            match self.properties.get_rotation() {
+                DisplayRotation::Rotate0 | DisplayRotation::Rotate180 => {
+                    self.properties
+                        .set_column(DSIZE::OFFSETX + column * 8)
+                        .terminal_err()?;
+                    self.properties
+                        .set_row(DSIZE::OFFSETY + row * 8)
+                        .terminal_err()?;
+                }
+                DisplayRotation::Rotate90 | DisplayRotation::Rotate270 => {
+                    self.properties
+                        .set_column(DSIZE::OFFSETX + row * 8)
+                        .terminal_err()?;
+                    self.properties
+                        .set_row(DSIZE::OFFSETY + column * 8)
+                        .terminal_err()?;
+                }
+            }
             self.ensure_cursor()?.set_position(column, row);
             Ok(())
         }
     }
 
     /// Reset the draw area and move pointer to the top left corner
     fn reset_pos(&mut self) -> Result<(), TerminalModeError> {
-        self.properties.set_column(DSIZE::OFFSETX).terminal_err()?;
-        self.properties.set_row(DSIZE::OFFSETY).terminal_err()?;
         // Initialise the counter when we know it's valid
         self.cursor = Some(Cursor::new(DSIZE::WIDTH, DSIZE::HEIGHT));
 
+        // Reset cursor position
+        self.set_position(0, 0)?;
+
         Ok(())
     }
 
     /// Advance the cursor, automatically wrapping lines and/or screens if necessary
     /// Takes in an already-unwrapped cursor to avoid re-unwrapping
     fn advance_cursor(&mut self) -> Result<(), TerminalModeError> {
-        if let Some(CursorWrapEvent(new_row)) = self.ensure_cursor()?.advance() {
-            self.properties.set_row(new_row * 8).terminal_err()?;
-        }
+        let cursor = self.ensure_cursor()?;
+
+        cursor.advance();
+        let (c, r) = cursor.get_position();
+        self.set_position(c, r)?;
+
         Ok(())
     }
 
@@ -427,6 +457,23 @@ where
             _ => [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00],
         }
     }
+
+    fn rotate_bitmap(bitmap: [u8; 8]) -> [u8; 8] {
+        let mut rotated: [u8; 8] = [0; 8];
+
+        for col in 0..8 {
+            // source.msb is the top pixel
+            let source = bitmap[col];
+            for row in 0..8 {
+                let bit = source & 1 << row != 0;
+                if bit {
+                    rotated[row] |= 1 << col;
+                }
+            }
+        }
+
+        rotated
+    }
 }
 
 impl<DI, DSIZE> fmt::Write for TerminalMode<DI, DSIZE>