perilus

RISC-V processor built with Chisel
git clone https://git.bradleygannon.com/perilus.git
Log | Files | Refs | Submodules | README

registers.rs (4257B)

      1 use eframe::egui;
      2 use egui::{Align2, FontId, Rect, Sense, Ui, pos2, vec2};
      3 
      4 use crate::app::{
      5     FONT_SIZE, NUM_CELLS, PC_COLOR, REG_COL_GAP, REG_COLS, REG_LABEL_W, REG_ROWS, ROW_H, SimApp,
      6     char_width,
      7 };
      8 use crate::state::{Focus, hex_char, register_alias};
      9 
     10 impl SimApp {
     11     pub(crate) fn registers_ui(&mut self, ui: &mut Ui) {
     12         ui.horizontal_wrapped(|ui| {
     13             ui.label(format!("state: {}", self.run_state));
     14             ui.separator();
     15             ui.label(format!("cu: {}", self.perilus.get_control_unit_state()));
     16             ui.separator();
     17             ui.label(self.status.as_str());
     18         });
     19         ui.add_space(4.0);
     20 
     21         let font = FontId::monospace(FONT_SIZE);
     22         let nib_w = char_width(ui, &font);
     23         let cell_w = REG_LABEL_W + 8.0 * nib_w + REG_COL_GAP;
     24         let grid_size = vec2(cell_w * REG_COLS as f32, ROW_H * REG_ROWS as f32);
     25         let (grid_rect, response) = ui.allocate_exact_size(grid_size, Sense::click());
     26 
     27         let text_color = ui.visuals().text_color();
     28         let background = ui.visuals().panel_fill;
     29         let painter = ui.painter();
     30         let registers = self.perilus.get_registers();
     31         let focus_registers = self.focus == Focus::Registers;
     32         for col in 0..REG_COLS {
     33             for row in 0..REG_ROWS {
     34                 let cell_index = col * REG_ROWS + row;
     35                 let origin = pos2(
     36                     grid_rect.left() + col as f32 * cell_w,
     37                     grid_rect.top() + row as f32 * ROW_H,
     38                 );
     39                 let (label, value, color) = if cell_index == 0 {
     40                     ("pc".to_string(), self.current_pc, PC_COLOR)
     41                 } else {
     42                     let label = if self.show_aliases {
     43                         register_alias(cell_index).to_string()
     44                     } else {
     45                         format!("x{cell_index}")
     46                     };
     47                     (label, registers[cell_index], text_color)
     48                 };
     49                 painter.text(
     50                     pos2(origin.x, origin.y + ROW_H * 0.5),
     51                     Align2::LEFT_CENTER,
     52                     label,
     53                     font.clone(),
     54                     text_color,
     55                 );
     56                 for nib in 0..8u8 {
     57                     let digit = ((value >> ((7 - nib as u32) * 4)) & 0xf) as u8;
     58                     let cell = Rect::from_min_size(
     59                         pos2(origin.x + REG_LABEL_W + nib as f32 * nib_w, origin.y),
     60                         vec2(nib_w, ROW_H),
     61                     );
     62                     let selected = focus_registers
     63                         && cell_index as u8 == self.reg_index
     64                         && nib == self.reg_nib;
     65                     if selected {
     66                         painter.rect_filled(cell, 0.0, text_color);
     67                         painter.text(
     68                             cell.center(),
     69                             Align2::CENTER_CENTER,
     70                             hex_char(digit),
     71                             font.clone(),
     72                             background,
     73                         );
     74                     } else {
     75                         painter.text(
     76                             cell.center(),
     77                             Align2::CENTER_CENTER,
     78                             hex_char(digit),
     79                             font.clone(),
     80                             color,
     81                         );
     82                     }
     83                 }
     84             }
     85         }
     86 
     87         if response.clicked()
     88             && let Some(pos) = response.interact_pointer_pos()
     89         {
     90             let x = pos.x - grid_rect.left();
     91             let y = pos.y - grid_rect.top();
     92             if x >= 0.0 && y >= 0.0 {
     93                 let col = (x / cell_w) as usize;
     94                 let row = (y / ROW_H) as usize;
     95                 let x_in_cell = x - col as f32 * cell_w;
     96                 if col < REG_COLS && row < REG_ROWS && x_in_cell >= REG_LABEL_W {
     97                     let nib = (((x_in_cell - REG_LABEL_W) / nib_w) as usize).min(7);
     98                     self.reg_index = (col * REG_ROWS + row).min(NUM_CELLS - 1) as u8;
     99                     self.reg_nib = nib as u8;
    100                     self.focus = Focus::Registers;
    101                 }
    102             }
    103         }
    104     }
    105 }