`11dc068`

wire up keybindings and input parsing for new graph features

Authored by mfwolffe <wolffemf@dukes.jmu.edu> 2 months ago

SHA: 11dc06884a8b864a17597d8ea52d1373f33ea3d1
Parents: ace3ed3
Tree: 9d98c07

1 changed file

Status	File	+	-
M	`garcalc/src/app.rs`	624	5

garcalc/src/app.rsmodified

  use anyhow::Result;
  use garcalc_cas::{Evaluator, parser};
 -use garcalc_graph::{Graph2D, Graph3D};
 +use garcalc_graph::{CameraPreset, Graph2D, Graph3D, COLOR_PALETTE};
  use garcalc_ipc::Mode;
  use garcalc_math::input::SpecialKey;
  use garcalc_math::{
  };
  use gartk_core::{InputEvent, Key, Modifiers, MouseButton};
  use gartk_x11::{Connection, EventLoop, EventLoopConfig, Window, WindowConfig};
 +use std::process::Command;
  use std::time::{Duration, Instant};
  use crate::config::Config;
      has_focus: bool,
      /// Mouse drag state for graph panning
      drag_start: Option<(f64, f64)>,
 +    /// Whether to show the function list panel
 +    show_function_list: bool,
 +    /// Whether zeros markers are visible
 +    zeros_visible: bool,
 +    /// Cached zero points: (func_index, points)
 +    cached_zeros: Vec<(usize, Vec<(f64, f64)>)>,
 +    /// Cached intersection points: ((idx_i, idx_j), points)
 +    cached_intersections: Vec<((usize, usize), Vec<(f64, f64)>)>,
 +    /// Whether table view is visible
 +    table_visible: bool,
 +    /// Which function index to tabulate
 +    table_func_index: usize,
 +    /// Table scroll offset
 +    table_scroll_offset: usize,
 +    /// Table step size
 +    table_step: f64,
 +    /// Cached table data
 +    table_data: Vec<(f64, Option<f64>)>,
 +    /// Whether auto-rotate is enabled (3D mode)
 +    auto_rotate: bool,
 +    /// Auto-rotate speed (radians per tick)
 +    auto_rotate_speed: f64,
 +    /// Whether the viewport settings panel is open (2D graph)
 +    viewport_panel_open: bool,
 +    /// Which viewport field is being edited (0=xmin, 1=xmax, 2=ymin, 3=ymax)
 +    viewport_edit_field: usize,
 +    /// Buffer for editing viewport values
 +    viewport_edit_buffer: String,
 +    /// Whether the color picker popup is open
 +    color_picker_open: bool,
 +    /// Which function the color picker targets
 +    color_picker_func_index: usize,
 +    /// Whether the 3D settings panel is open
 +    settings3d_panel_open: bool,
      /// Configuration
      #[allow(dead_code)]
      config: Config,
              last_cursor_blink: Instant::now(),
              has_focus: false,
              drag_start: None,
 +            show_function_list: false,
 +            zeros_visible: false,
 +            cached_zeros: Vec::new(),
 +            cached_intersections: Vec::new(),
 +            table_visible: false,
 +            table_func_index: 0,
 +            table_scroll_offset: 0,
 +            table_step: 1.0,
 +            table_data: Vec::new(),
 +            auto_rotate: false,
 +            auto_rotate_speed: 0.02,
 +            viewport_panel_open: false,
 +            viewport_edit_field: 0,
 +            viewport_edit_buffer: String::new(),
 +            color_picker_open: false,
 +            color_picker_func_index: 0,
 +            settings3d_panel_open: false,
              config,
          })
+     }
+                         }
                      } else if self.mode == Mode::Graph {
                          if mouse_ev.button == Some(MouseButton::Left) {
 -                            // Left click - start drag for pan
 -                            self.drag_start = Some((x, y));
 +                            // Check viewport panel preset clicks
 +                            if self.viewport_panel_open {
 +                                if let Some(preset) = self.ui.viewport_preset_hit(x, y) {
 +                                    self.graph.apply_viewport_preset(preset);
 +                                    self.viewport_panel_open = false;
 +                                    self.invalidate_caches();
 +                                    ev.request_redraw();
 +                                    // Don't start drag
 +                                } else {
 +                                    self.drag_start = Some((x, y));
 +                                }
 +                            } else if self.color_picker_open {
 +                                if let Some(palette_idx) = self.ui.color_picker_hit(x, y) {
 +                                    self.graph.set_function_color(self.color_picker_func_index, COLOR_PALETTE[palette_idx]);
 +                                    self.color_picker_open = false;
 +                                    ev.request_redraw();
 +                                } else {
 +                                    self.color_picker_open = false;
 +                                    self.drag_start = Some((x, y));
 +                                }
 +                            } else {
 +                                // Left click - start drag for pan
 +                                self.drag_start = Some((x, y));
 +                            }
                          } else if mouse_ev.button == Some(MouseButton::Right) {
                              // Right click - toggle trace mode
                              self.graph.trace_enabled = !self.graph.trace_enabled;
                      if self.tick_cursor_blink() {
                          ev.request_redraw();
+                     }
 +                    if self.auto_rotate && self.mode == Mode::Graph3D {
 +                        self.graph3d.camera.rotate(self.auto_rotate_speed, 0.0);
 +                        ev.request_redraw();
 +                    }
+                 }
                  _ => {}
+             }
                  self.mode = Mode::Graph3D;
                  return;
+             }
 +            Key::F4 if self.mode == Mode::Graph => {
 +                self.table_visible = !self.table_visible;
 +                if self.table_visible {
 +                    self.regenerate_table();
 +                }
 +                return;
 +            }
              _ => {}
+         }
          match key {
              Key::Char('r') if ctrl && self.mode == Mode::Graph => {
                  self.graph.reset_viewport();
 +                self.invalidate_caches();
                  return;
+             }
              Key::Char('c') if ctrl && self.mode == Mode::Graph => {
                  self.graph.clear_functions();
 +                self.invalidate_caches();
                  return;
+             }
              Key::Char('t') if ctrl && self.mode == Mode::Graph => {
                  self.graph.trace_enabled = !self.graph.trace_enabled;
                  return;
+             }
 +            Key::Char('l') if ctrl && self.mode == Mode::Graph => {
 +                self.show_function_list = !self.show_function_list;
 +                return;
 +            }
 +            Key::Char(c @ '1'..='9') if ctrl && self.mode == Mode::Graph => {
 +                let idx = (*c as usize) - ('1' as usize);
 +                self.graph.toggle_visibility(idx);
 +                self.invalidate_caches();
 +                return;
 +            }
 +            Key::Char('z') if ctrl && self.mode == Mode::Graph => {
 +                self.zeros_visible = !self.zeros_visible;
 +                if self.zeros_visible {
 +                    self.cached_zeros = self.graph.find_zeros();
 +                    self.cached_intersections = self.graph.find_intersections();
 +                }
 +                return;
 +            }
 +            // 2D graph: viewport panel
 +            Key::Char('w') if ctrl && self.mode == Mode::Graph => {
 +                self.viewport_panel_open = !self.viewport_panel_open;
 +                if self.viewport_panel_open {
 +                    self.viewport_edit_field = 0;
 +                    self.viewport_edit_buffer = format!("{:.4}", self.graph.viewport.x_min);
 +                }
 +                return;
 +            }
 +            // 2D graph: color picker
 +            Key::Char('k') if ctrl && self.mode == Mode::Graph => {
 +                if !self.graph.functions.is_empty() {
 +                    self.color_picker_open = !self.color_picker_open;
 +                    self.color_picker_func_index =
 +                        self.color_picker_func_index.min(self.graph.functions.len().saturating_sub(1));
 +                }
 +                return;
 +            }
 +            // 3D shortcuts
              Key::Char('r') if ctrl && self.mode == Mode::Graph3D => {
                  self.graph3d.reset_camera();
                  return;
                  self.graph3d.clear_surfaces();
                  return;
+             }
 +            Key::Char('m') if ctrl && self.mode == Mode::Graph3D => {
 +                self.graph3d.cycle_render_mode();
 +                return;
 +            }
 +            Key::Char('a') if ctrl && self.mode == Mode::Graph3D => {
 +                self.auto_rotate = !self.auto_rotate;
 +                return;
 +            }
 +            Key::Char('g') if ctrl && self.mode == Mode::Graph3D => {
 +                self.graph3d.config.show_coord_planes = !self.graph3d.config.show_coord_planes;
 +                return;
 +            }
 +            Key::Char('s') if ctrl && self.mode == Mode::Graph3D => {
 +                self.settings3d_panel_open = !self.settings3d_panel_open;
 +                return;
 +            }
 +            // 3D camera presets
 +            Key::Char('1') if ctrl && self.mode == Mode::Graph3D => {
 +                self.graph3d.camera.apply_preset(CameraPreset::Front);
 +                return;
 +            }
 +            Key::Char('3') if ctrl && self.mode == Mode::Graph3D => {
 +                self.graph3d.camera.apply_preset(CameraPreset::Side);
 +                return;
 +            }
 +            Key::Char('7') if ctrl && self.mode == Mode::Graph3D => {
 +                self.graph3d.camera.apply_preset(CameraPreset::Top);
 +                return;
 +            }
 +            Key::Char('5') if ctrl && self.mode == Mode::Graph3D => {
 +                self.graph3d.camera.apply_preset(CameraPreset::Isometric);
 +                return;
 +            }
              _ => {}
+         }
              return;
+         }
 +        // Viewport panel keys (graph mode only)
 +        if self.viewport_panel_open && self.mode == Mode::Graph {
 +            match key {
 +                Key::Tab => {
 +                    self.commit_viewport_edit();
 +                    self.viewport_edit_field = (self.viewport_edit_field + 1) % 4;
 +                    self.load_viewport_edit_buffer();
 +                    return;
 +                }
 +                Key::Return => {
 +                    self.commit_viewport_edit();
 +                    self.viewport_panel_open = false;
 +                    self.invalidate_caches();
 +                    return;
 +                }
 +                Key::Escape => {
 +                    self.viewport_panel_open = false;
 +                    return;
 +                }
 +                Key::Backspace => {
 +                    self.viewport_edit_buffer.pop();
 +                    return;
 +                }
 +                Key::Char(c @ ('0'..='9' | '.' | '-')) => {
 +                    self.viewport_edit_buffer.push(*c);
 +                    return;
 +                }
 +                _ => {}
 +            }
 +        }
++
 +        // Color picker keys (graph mode only)
 +        if self.color_picker_open && self.mode == Mode::Graph {
 +            if matches!(key, Key::Escape) {
 +                self.color_picker_open = false;
 +                return;
 +            }
 +        }
++
 +        // 3D settings panel keys
 +        if self.settings3d_panel_open && self.mode == Mode::Graph3D {
 +            match key {
 +                Key::Escape => {
 +                    self.settings3d_panel_open = false;
 +                    return;
 +                }
 +                Key::Char(']') => {
 +                    self.graph3d.config.grid_lines = (self.graph3d.config.grid_lines + 5).min(100);
 +                    return;
 +                }
 +                Key::Char('[') => {
 +                    self.graph3d.config.grid_lines = self.graph3d.config.grid_lines.saturating_sub(5).max(10);
 +                    return;
 +                }
 +                Key::Char('>') => {
 +                    self.graph3d.config.surface_alpha = (self.graph3d.config.surface_alpha + 0.05).min(1.0);
 +                    return;
 +                }
 +                Key::Char('<') => {
 +                    self.graph3d.config.surface_alpha = (self.graph3d.config.surface_alpha - 0.05).max(0.1);
 +                    return;
 +                }
 +                Key::Char('c') => {
 +                    self.graph3d.config.colormap = self.graph3d.config.colormap.next();
 +                    return;
 +                }
 +                Key::Char('m') => {
 +                    self.graph3d.cycle_render_mode();
 +                    return;
 +                }
 +                _ => {}
 +            }
 +        }
++
 +        // Table view keys (graph mode only)
 +        if self.table_visible && self.mode == Mode::Graph {
 +            match key {
 +                Key::Up => {
 +                    if self.table_scroll_offset > 0 {
 +                        self.table_scroll_offset -= 1;
 +                    }
 +                    return;
 +                }
 +                Key::Down => {
 +                    if self.table_scroll_offset + 20 < self.table_data.len() {
 +                        self.table_scroll_offset += 1;
 +                    }
 +                    return;
 +                }
 +                Key::Char('e') if ctrl => {
 +                    self.export_table_to_clipboard();
 +                    return;
 +                }
 +                Key::Char('[') => {
 +                    self.table_step = (self.table_step / 2.0).max(0.001);
 +                    self.regenerate_table();
 +                    return;
 +                }
 +                Key::Char(']') => {
 +                    self.table_step = (self.table_step * 2.0).min(100.0);
 +                    self.regenerate_table();
 +                    return;
 +                }
 +                _ => {}
 +            }
 +        }
++
          // Plain text editor for graph/3D modes
          match key {
              Key::Backspace => {
                  let lhs = input[..eq_pos].trim();
                  let rhs = input[eq_pos + 1..].trim();
 -                // Check if this is "y = f(x)" (explicit) or implicit
 -                if lhs == "y" {
 +                // Check if this is "r = f(theta)" (polar), "y = f(x)" (explicit), or implicit
 +                if lhs == "r" {
 +                    match parser::parse(rhs) {
 +                        Ok(expr) => {
 +                            self.graph.add_polar(expr, (0.0, std::f64::consts::TAU));
 +                            self.history.push(HistoryEntry {
 +                                input: input.clone(),
 +                                result: format!(
 +                                    "Added polar curve {}",
 +                                    self.graph.functions.len()
 +                                ),
 +                                error: None,
 +                            });
 +                            self.invalidate_caches();
 +                        }
 +                        Err(e) => {
 +                            self.history.push(HistoryEntry {
 +                                input: input.clone(),
 +                                result: String::new(),
 +                                error: Some(e.to_string()),
 +                            });
 +                        }
 +                    }
 +                } else if lhs == "y" {
                      // Explicit function y = f(x)
                      match parser::parse(rhs) {
                          Ok(expr) => {
                                  result: format!("Added function {}", self.graph.functions.len()),
                                  error: None,
                              });
 +                            self.invalidate_caches();
+                         }
                          Err(e) => {
                              self.history.push(HistoryEntry {
                                  ),
                                  error: None,
                              });
 +                            self.invalidate_caches();
+                         }
                          Err(e) => {
                              self.history.push(HistoryEntry {
+                         }
+                     }
+                 }
 +            } else if input.starts_with("piecewise(") || input.starts_with("pw(") {
 +                self.parse_piecewise(&input);
              } else if input.contains(',') && (input.contains('t') || input.starts_with('(')) {
                  // Parametric curve: (x(t), y(t)) or x(t), y(t)
                  self.parse_parametric(&input);
                              result: format!("Added function {}", self.graph.functions.len()),
                              error: None,
                          });
 +                        self.invalidate_caches();
+                     }
                      Err(e) => {
                          self.history.push(HistoryEntry {
+                 }
+             }
          } else if self.mode == Mode::Graph3D {
 +            // Check for spherical surface: "sphere: expr" or "sph: expr"
 +            let sph_prefix = input.strip_prefix("sphere:")
 +                .or_else(|| input.strip_prefix("sph:"));
 +            if let Some(sph_expr) = sph_prefix {
 +                match parser::parse(sph_expr.trim()) {
 +                    Ok(expr) => {
 +                        self.graph3d.add_spherical(expr);
 +                        self.history.push(HistoryEntry {
 +                            input: input.clone(),
 +                            result: format!("Added spherical surface {}", self.graph3d.surfaces.len()),
 +                            error: None,
 +                        });
 +                    }
 +                    Err(e) => {
 +                        self.history.push(HistoryEntry {
 +                            input: input.clone(),
 +                            result: String::new(),
 +                            error: Some(e.to_string()),
 +                        });
 +                    }
 +                }
 +                self.input.clear();
 +                self.cursor = 0;
 +                self.history_index = None;
 +                return;
 +            }
++
 +            // Check for cylindrical surface: "cyl: expr" or "cylinder: expr"
 +            let cyl_prefix = input.strip_prefix("cyl:")
 +                .or_else(|| input.strip_prefix("cylinder:"));
 +            if let Some(cyl_expr) = cyl_prefix {
 +                match parser::parse(cyl_expr.trim()) {
 +                    Ok(expr) => {
 +                        self.graph3d.add_cylindrical(expr);
 +                        self.history.push(HistoryEntry {
 +                            input: input.clone(),
 +                            result: format!("Added cylindrical surface {}", self.graph3d.surfaces.len()),
 +                            error: None,
 +                        });
 +                    }
 +                    Err(e) => {
 +                        self.history.push(HistoryEntry {
 +                            input: input.clone(),
 +                            result: String::new(),
 +                            error: Some(e.to_string()),
 +                        });
 +                    }
 +                }
 +                self.input.clear();
 +                self.cursor = 0;
 +                self.history_index = None;
 +                return;
 +            }
++
 +            // Check for level surface: "level: expr = c"
 +            if let Some(level_str) = input.strip_prefix("level:") {
 +                let level_str = level_str.trim();
 +                if let Some(eq_pos) = level_str.find('=') {
 +                    let expr_str = level_str[..eq_pos].trim();
 +                    let level_val_str = level_str[eq_pos + 1..].trim();
 +                    let level_val = level_val_str.parse::<f64>().unwrap_or(0.0);
 +                    match parser::parse(expr_str) {
 +                        Ok(expr) => {
 +                            self.graph3d.add_level_surface(expr, level_val);
 +                            self.history.push(HistoryEntry {
 +                                input: input.clone(),
 +                                result: format!("Added level surface {}", self.graph3d.surfaces.len()),
 +                                error: None,
 +                            });
 +                        }
 +                        Err(e) => {
 +                            self.history.push(HistoryEntry {
 +                                input: input.clone(),
 +                                result: String::new(),
 +                                error: Some(e.to_string()),
 +                            });
 +                        }
 +                    }
 +                } else {
 +                    self.history.push(HistoryEntry {
 +                        input: input.clone(),
 +                        result: String::new(),
 +                        error: Some("Level surface format: level: f(x,y,z) = c".to_string()),
 +                    });
 +                }
 +                self.input.clear();
 +                self.cursor = 0;
 +                self.history_index = None;
 +                return;
 +            }
++
              // Check for parametric surface: (x(u,v), y(u,v), z(u,v))
              if input.contains(',') && (input.contains('u') || input.starts_with('(')) {
                  self.parse_parametric_surface(&input);
                      result: format!("Added parametric curve {}", self.graph.functions.len()),
                      error: None,
                  });
 +                self.invalidate_caches();
+             }
              (Err(e), _) | (_, Err(e)) => {
                  self.history.push(HistoryEntry {
+         }
+     }
 +    /// Parse and add a piecewise function
 +    fn parse_piecewise(&mut self, input: &str) {
 +        let inner = input
 +            .trim()
 +            .strip_prefix("piecewise(")
 +            .or_else(|| input.trim().strip_prefix("pw("))
 +            .and_then(|s| s.strip_suffix(')'));
++
 +        let inner = match inner {
 +            Some(s) => s,
 +            None => {
 +                self.history.push(HistoryEntry {
 +                    input: input.to_string(),
 +                    result: String::new(),
 +                    error: Some(
 +                        "Invalid piecewise syntax. Use: piecewise(expr1, cond1, expr2, cond2, ...)"
 +                            .to_string(),
 +                    ),
 +                });
 +                return;
 +            }
 +        };
++
 +        let parts: Vec<&str> = inner.split(',').collect();
 +        if parts.len() < 2 || parts.len() % 2 != 0 {
 +            self.history.push(HistoryEntry {
 +                input: input.to_string(),
 +                result: String::new(),
 +                error: Some(
 +                    "Piecewise needs pairs: expr1, cond1, expr2, cond2, ...".to_string(),
 +                ),
 +            });
 +            return;
 +        }
++
 +        let mut pieces = Vec::new();
 +        for chunk in parts.chunks(2) {
 +            let expr_str = chunk[0].trim();
 +            let cond_str = chunk[1].trim();
++
 +            let expr = match parser::parse(expr_str) {
 +                Ok(e) => e,
 +                Err(e) => {
 +                    self.history.push(HistoryEntry {
 +                        input: input.to_string(),
 +                        result: String::new(),
 +                        error: Some(format!("Parse error in '{}': {}", expr_str, e)),
 +                    });
 +                    return;
 +                }
 +            };
++
 +            let condition = match Self::parse_condition(cond_str) {
 +                Some(c) => c,
 +                None => {
 +                    self.history.push(HistoryEntry {
 +                        input: input.to_string(),
 +                        result: String::new(),
 +                        error: Some(format!(
 +                            "Invalid condition: '{}'. Use: x<0, x>=2, else",
 +                            cond_str
 +                        )),
 +                    });
 +                    return;
 +                }
 +            };
++
 +            pieces.push(garcalc_graph::PiecewisePiece { expr, condition });
 +        }
++
 +        self.graph.add_piecewise(pieces);
 +        self.history.push(HistoryEntry {
 +            input: input.to_string(),
 +            result: format!("Added piecewise function {}", self.graph.functions.len()),
 +            error: None,
 +        });
 +        self.invalidate_caches();
 +    }
++
 +    fn parse_condition(s: &str) -> Option<garcalc_graph::PiecewiseCondition> {
 +        use garcalc_graph::PiecewiseCondition;
 +        let s = s.trim();
++
 +        if s == "else" || s == "otherwise" {
 +            return Some(PiecewiseCondition::Always);
 +        }
++
 +        // Try range conditions like "0 <= x < 3"
 +        if let Some(cond) = Self::parse_range_condition(s) {
 +            return Some(cond);
 +        }
++
 +        // Try "x >= val", "x > val", "x <= val", "x < val"
 +        for (op, ctor) in [
 +            (
 +                ">=",
 +                PiecewiseCondition::GreaterEqual as fn(f64) -> PiecewiseCondition,
 +            ),
 +            (
 +                "<=",
 +                PiecewiseCondition::LessEqual as fn(f64) -> PiecewiseCondition,
 +            ),
 +            (
 +                ">",
 +                PiecewiseCondition::GreaterThan as fn(f64) -> PiecewiseCondition,
 +            ),
 +            (
 +                "<",
 +                PiecewiseCondition::LessThan as fn(f64) -> PiecewiseCondition,
 +            ),
 +        ] {
 +            if let Some(rest) = s
 +                .strip_prefix("x")
 +                .and_then(|r| r.trim_start().strip_prefix(op))
 +            {
 +                if let Ok(val) = rest.trim().parse::<f64>() {
 +                    return Some(ctor(val));
 +                }
 +            }
 +        }
++
 +        None
 +    }
++
 +    fn parse_range_condition(s: &str) -> Option<garcalc_graph::PiecewiseCondition> {
 +        use garcalc_graph::PiecewiseCondition;
 +        let s = s.trim();
++
 +        let x_pos = s.find('x')?;
 +        let left = s[..x_pos].trim();
 +        let right = s[x_pos + 1..].trim();
++
 +        if left.is_empty() || right.is_empty() {
 +            return None;
 +        }
++
 +        let (left_val, left_inclusive) = if let Some(rest) = left.strip_suffix("<=") {
 +            (rest.trim().parse::<f64>().ok()?, true)
 +        } else if let Some(rest) = left.strip_suffix("<") {
 +            (rest.trim().parse::<f64>().ok()?, false)
 +        } else {
 +            return None;
 +        };
++
 +        let (right_val, right_inclusive) = if let Some(rest) = right.strip_prefix("<=") {
 +            (rest.trim().parse::<f64>().ok()?, true)
 +        } else if let Some(rest) = right.strip_prefix("<") {
 +            (rest.trim().parse::<f64>().ok()?, false)
 +        } else {
 +            return None;
 +        };
++
 +        if left_inclusive && right_inclusive {
 +            Some(PiecewiseCondition::BetweenInclusive(left_val, right_val))
 +        } else {
 +            Some(PiecewiseCondition::Between(left_val, right_val))
 +        }
 +    }
++
 +    fn commit_viewport_edit(&mut self) {
 +        if let Ok(val) = self.viewport_edit_buffer.parse::<f64>() {
 +            match self.viewport_edit_field {
 +                0 => self.graph.viewport.x_min = val,
 +                1 => self.graph.viewport.x_max = val,
 +                2 => self.graph.viewport.y_min = val,
 +                3 => self.graph.viewport.y_max = val,
 +                _ => {}
 +            }
 +        }
 +    }
++
 +    fn load_viewport_edit_buffer(&mut self) {
 +        self.viewport_edit_buffer = match self.viewport_edit_field {
 +            0 => format!("{:.4}", self.graph.viewport.x_min),
 +            1 => format!("{:.4}", self.graph.viewport.x_max),
 +            2 => format!("{:.4}", self.graph.viewport.y_min),
 +            3 => format!("{:.4}", self.graph.viewport.y_max),
 +            _ => String::new(),
 +        };
 +    }
++
 +    fn invalidate_caches(&mut self) {
 +        if self.zeros_visible {
 +            self.cached_zeros = self.graph.find_zeros();
 +            self.cached_intersections = self.graph.find_intersections();
 +        }
 +        if self.table_visible {
 +            self.regenerate_table();
 +        }
 +    }
++
 +    fn regenerate_table(&mut self) {
 +        let x_min = self.graph.viewport.x_min;
 +        let x_max = self.graph.viewport.x_max;
 +        self.table_data =
 +            self.graph
 +                .generate_table(self.table_func_index, x_min, x_max, self.table_step);
 +        self.table_scroll_offset = 0;
 +    }
++
 +    fn export_table_to_clipboard(&self) {
 +        let mut csv = String::from("x\tf(x)\n");
 +        for (x, y) in &self.table_data {
 +            match y {
 +                Some(yv) => csv.push_str(&format!("{:.6}\t{:.6}\n", x, yv)),
 +                None => csv.push_str(&format!("{:.6}\tundefined\n", x)),
 +            }
 +        }
 +        let _ = Command::new("xclip")
 +            .args(["-selection", "clipboard"])
 +            .stdin(std::process::Stdio::piped())
 +            .spawn()
 +            .and_then(|mut child| {
 +                use std::io::Write;
 +                if let Some(ref mut stdin) = child.stdin {
 +                    let _ = stdin.write_all(csv.as_bytes());
 +                }
 +                child.wait()
 +            });
 +    }
++
      fn render(&mut self) -> Result<()> {
          let math_input = if self.mode == Mode::Calculator {
              Some(&self.math_input)
              &self.graph3d,
              self.help_modal_open,
              self.calc_buttons_extended,
 +            self.show_function_list,
 +            self.zeros_visible,
 +            &self.cached_zeros,
 +            &self.cached_intersections,
 +            self.table_visible,
 +            self.table_scroll_offset,
 +            self.table_step,
 +            &self.table_data,
 +            self.viewport_panel_open,
 +            self.viewport_edit_field,
 +            &self.viewport_edit_buffer,
 +            self.color_picker_open,
 +            self.color_picker_func_index,
 +            self.settings3d_panel_open,
 +            self.auto_rotate,
          )?;
          Ok(())
+     }