Issues with column stretching when using egui_extras::TableBuilder

[nczyw]

I have a table with 4 columns:

Column 1 and Column 2 have fixed widths
Column 3 and Column 4 should automatically share the remaining available space equally

However, I encountered a layout issue when using egui_extras::TableBuilder.

Problem 1

If I set:

egui::TextEdit::singleline(&mut text)
    .desired_width(ui.available_width())

then after resizing the window smaller, Column 3 and Column 4 stop shrinking. It looks like the .desired_width(ui.available_width()) affects Column::remainder(), causing the remaining columns to no longer recalculate their widths properly.

Problem 2

If I do not set .desired_width(ui.available_width()), then the TextEdit inside Column 3 does not expand or adapt properly to the column width changes.

Expected behavior

I want a layout where:

Column 1 and Column 2 are fixed width
Column 3 and Column 4 always evenly split the remaining space
The layout correctly adapts when resizing the window (both growing and shrinking)
Question

What is the correct way to achieve this behavior in egui_extras::TableBuilder?

Here is the problematic code:

use eframe::egui;
use tokio::sync::watch;
use egui_extras::{TableBuilder, Column};

use crate::modbus::share_data::ShareDataRef;
pub struct AppUi {
    scale_factor: f32,
    share_data: ShareDataRef,
    error_rx: watch::Receiver<Option<String>>,
    max_len: usize,
}

impl AppUi {
    pub fn new(
        share_data: ShareDataRef,
    ) -> Self {
        let error_rx = share_data.read().expect("'share_data': RwLock poisoned").error_msg.subscribe();
        let share_data_clone = share_data.clone();
        let data = share_data_clone.read().unwrap();
        let max_len = data.coils.len()
            .max(data.input_registers.len())
            .max(data.input_registers.len())
            .max(data.holding_registers.len());
        Self {
            scale_factor: 1.0,
            share_data: share_data,
            error_rx: error_rx,
            max_len: max_len,
        }
    }
}

impl eframe::App for AppUi {
    fn ui(
        &mut self, 
        ui: &mut eframe::egui::Ui, 
        _frame: &mut eframe::Frame
    ) {
        
        egui::Panel::bottom("status_bar")
            .resizable(false)
            .show_separator_line(true)
            .max_size(24.0)
            .show_inside(ui, |ui| {
                let is_running = self.share_data.read().unwrap().is_running;
                let status_text = if is_running { "✔ Running" } else { "❌ Stopped" };
                ui.horizontal(|ui| {
                    ui.label(status_text);
                    ui.add(egui::Separator::default().vertical());
                    if self.error_rx.has_changed().unwrap_or(false) {
                        if let Some(err) = self.error_rx.borrow().clone() {
                            ui.colored_label(egui::Color32::RED, err);
                        }
                    }
                    ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
                        let fps = ui.ctx().input(|i| i.unstable_dt) * 1000.0;
                        ui.label(format!("{:.1}ms", fps));
                    });
                });
        });
        egui::CentralPanel::default().show_inside(ui, |ui| {
                ui.vertical_centered(|ui| {
                    ui.heading("Modbus TCP Server");
                });
                
                TableBuilder::new(ui)
                    .vscroll(true)
                    .column(Column::exact(50.0))
                    .column(Column::exact(120.0))
                    .column(Column::remainder())
                    .column(Column::remainder())
                    .header(20.0, |mut row| {
                        row.col(|ui| { 
                            ui.with_layout(egui::Layout::right_to_left(egui::Align::Min), |ui| {
                                ui.label("Coils"); 
                            });
                        });
                        row.col(|ui| { 
                            ui.with_layout(egui::Layout::left_to_right(egui::Align::Min), |ui| {
                                ui.label("Discrete Inputs"); 
                            });
                        });
                        row.col(|ui| { 
                            ui.with_layout(egui::Layout::left_to_right(egui::Align::Min), |ui| {
                                ui.label("Input Registers"); 
                            });
                        });
                        row.col(|ui| { 
                            ui.with_layout(egui::Layout::left_to_right(egui::Align::Min), |ui| {
                                ui.label("Holding Registers"); 
                            });
                        });
                    })
                    .body(|mut body| {
                        let mut data = self.share_data.write().unwrap();
                        for i in 0..self.max_len {
                            body.row(20.0, |mut row| {
                                row.col(|ui| {
                                    if let Some(val) = data.coils.get_mut(i) {
                                        ui.horizontal(|ui| {
                                            ui.label(egui::RichText::new(format!("{:3}", i)).monospace());
                                            ui.checkbox(val, "");
                                        });
                                    }
                                });

                                row.col(|ui| {
                                    if let Some(val) = data.discrete_inputs.get_mut(i) {
                                        ui.horizontal(|ui| {
                                            ui.label(egui::RichText::new(format!("{:3}", i)).monospace());
                                            ui.checkbox(val, "");
                                        });
                                    }
                                });
                                
                                row.col(|ui| {
                                    if let Some(val) = data.input_registers.get_mut(i) {
                                        let mut text = val.to_string();
                                        if ui.add(
                                            egui::TextEdit::singleline(&mut text).desired_width(ui.available_width())
                                        ).changed() {
                                            if let Ok(new_val) = text.parse::<u16>() {
                                                *val = new_val;
                                            }
                                        }
                                    }
                                });
                                
                                row.col(|ui| {
                                    if let Some(val) = data.holding_registers.get_mut(i) {
                                        let mut text = val.to_string();
                                        if ui.add(
                                            egui::TextEdit::singleline(&mut text)
                                        ).changed() {
                                            if let Ok(new_val) = text.parse::<u16>() {
                                                *val = new_val;
                                            }
                                        }
                                    }
                                });
                                
                            });
                        }
                    });

            
            /* 
            ui.heading("Modbus TCP Server");
            let is_running = {
                let data = self.share_data.read().expect("'share_data': RwLock poisoned");
                data.is_running
            };
            let button_text = if is_running { "⏹ Disconnect" } else { "▶ Connect"};
            let button_color = if is_running {
                egui::Color32::RED
            } else {
                egui::Color32::GREEN
            };
            if ui.add(
                egui::Button::new(button_text)
                    .fill(button_color)
                    .min_size(egui::vec2(120.0, 40.0))
            ).clicked() {
                let data = self.share_data.read().expect("'share_data': RwLock poisoned");
                data.change_conection_state.notify_one();
                //println!("Server {}.", if new_state { "started" } else { "stopped" });
            }
            */
        });
        
    }
    fn logic(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
        if (ctx.pixels_per_point() - self.scale_factor).abs() > 0.01 {
            ctx.set_pixels_per_point(self.scale_factor);
        }
    }
}