zaxis 0.0.5

An event-driven immediate mode GUI for desktop tools
Documentation
#[path = "split_pane/content.rs"]
mod content;
use zaxis::{
    vec2, App, Border, Button, Color, Context, CornerRadius, Frame, Id, Layout, Padding, Rect,
    Root, Shadow, SplitHandle, SplitHandleStyle, SplitOutput, SplitPane, SplitPanel, SplitSize,
    SplitStyle, SplitSurface, Ui,
};

#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
enum Panel {
    Files,
    Work,
    Inspector,
    Preview,
    Editor,
    Tasks,
    Log,
}
impl Panel {
    fn title(self) -> &'static str {
        match self {
            Self::Files => "Files",
            Self::Work => "Workspace",
            Self::Inspector => "Inspector",
            Self::Preview => "Preview",
            Self::Editor => "Editor",
            Self::Tasks => "Tasks",
            Self::Log => "Log",
        }
    }
    fn spec(self) -> SplitPanel {
        let size = match self {
            Self::Files => SplitSize::Pixels(180.0),
            Self::Inspector | Self::Preview => SplitSize::Weight(1.0),
            Self::Work | Self::Editor => SplitSize::Weight(3.0),
            Self::Tasks => SplitSize::Weight(2.0),
            Self::Log => SplitSize::Pixels(110.0),
        };
        SplitPanel::new(self).default_size(size).min_size(60.0)
    }
}
struct Workspace {
    text: String,
    file: usize,
    enabled: bool,
    vertical: bool,
    glass: bool,
    zoom: f32,
    order: Vec<Panel>,
    inner_order: Vec<Panel>,
    drag: Option<(Panel, zaxis::Vec2)>,
    bounds: Vec<(Id, Rect)>,
    logs: Vec<String>,
    runs: [u32; 12],
    smoke: bool,
    passes: usize,
}
impl Workspace {
    fn header(&mut self, ui: &mut Ui<'_>, panel: Panel) {
        let response = ui.add(
            Button::new(panel.title())
                .min_size(vec2(ui.available_width(), 28.0))
                .padding(Padding::symmetric(8.0, 3.0))
                .selected(self.drag.is_some_and(|(p, _)| p == panel)),
        );
        if response.pressed && self.drag.is_none() {
            if let Some(pointer) = ui.context().input().pointer {
                self.drag = Some((panel, pointer));
            }
        }
    }
    fn drop_panel<R>(&mut self, ui: &mut Ui<'_>, output: &SplitOutput<R>, order: &mut [Panel]) {
        self.bounds
            .extend(output.panels.iter().map(|p| (p.id, p.bounds)));
        let input = ui.context().input();
        if !input.primary_released {
            return;
        }
        let Some((source, start)) = self.drag else {
            return;
        };
        let Some(pointer) = input.pointer else { return };
        if (pointer - start).length_squared() < 36.0 {
            return;
        }
        let Some(from) = order.iter().position(|p| *p == source) else {
            return;
        };
        let Some(to) = output
            .panels
            .iter()
            .position(|p| p.bounds.contains(pointer))
        else {
            return;
        };
        if from != to {
            let panel = order[from];
            if from < to {
                order[from..=to].rotate_left(1);
            } else {
                order[to..=from].rotate_right(1);
            }
            self.logs.push(format!("Moved {}", panel.title()));
            ui.context().request_repaint();
        }
    }
    fn toggle(order: &mut Vec<Panel>, panel: Panel, present: bool) {
        if present && !order.contains(&panel) {
            order.push(panel);
        }
        if !present {
            order.retain(|p| *p != panel);
        }
    }
    fn card(&self, panel: Panel, pointer: Option<zaxis::Vec2>) -> SplitSurface {
        let target = self.drag.is_some()
            && self.bounds.iter().any(|(id, bounds)| {
                *id == Id::new(panel) && pointer.is_some_and(|p| bounds.contains(p))
            });
        SplitSurface::default()
            .fill(Color::gray(45))
            .corner_radius(CornerRadius::all(12.0))
            .padding(Padding::all(8.0))
            .border(Border::new(
                if target { 2.0 } else { 1.0 },
                if target {
                    Color::rgb(130, 173, 226)
                } else {
                    Color::gray(68)
                },
            ))
            .shadow(Shadow {
                blur_radius: 4.0,
                ..Shadow::default()
            })
            .blur(if self.glass { 6.0 } else { 0.0 })
    }
    fn workspace(&mut self, ui: &mut Ui<'_>, reset: bool) {
        let mut order = self.inner_order.clone();
        let handle = SplitHandleStyle::default()
            .kind(SplitHandle::Invisible)
            .thickness(3.0)
            .hit_width(10.0)
            .length(32.0);
        let panels: Vec<_> = order
            .iter()
            .map(|p| {
                let spec = p.spec();
                if *p == Panel::Editor {
                    spec.handle(handle.kind(SplitHandle::PanelEdge))
                } else {
                    spec
                }
            })
            .collect();
        let out = SplitPane::vertical("editor-and-log")
            .gap(10.0)
            .handle(handle)
            .resizable(self.enabled)
            .reset(reset)
            .double_click_reset(true)
            .panels(panels)
            .show(ui, |split| {
                for &panel in &order {
                    split.panel(panel, |ui| {
                        self.header(ui, panel);
                        self.content(ui, panel);
                    });
                }
            });
        self.drop_panel(ui, &out, &mut order);
        self.inner_order = order;
    }
}
impl App for Workspace {
    fn update(&mut self, c: &mut Context, frame: &mut Frame<'_>) {
        Root::new().padding(Padding::all(12.0)).show(c, |ui| {
            let mut reset = false;
            ui.horizontal(|ui| {
                reset = ui.button("Reset").clicked();
                if ui.button("Swap").clicked() && self.order.len() > 1 {
                    let last = self.order.len() - 1;
                    self.order.swap(0, last);
                }
                ui.checkbox(&mut self.enabled, "Resize");
                ui.checkbox(&mut self.vertical, "Vertical");
                for panel in [Panel::Files, Panel::Inspector, Panel::Preview] {
                    let mut visible = self.order.contains(&panel);
                    if ui.checkbox(&mut visible, panel.title()).changed() {
                        Self::toggle(&mut self.order, panel, visible);
                    }
                }
            });
            if reset {
                self.order = vec![Panel::Files, Panel::Work, Panel::Inspector];
                self.inner_order = vec![Panel::Editor, Panel::Tasks, Panel::Log];
                self.drag = None;
            }
            let pointer = ui.context().input().pointer;
            let mut order = self.order.clone();
            let panels: Vec<_> = order
                .iter()
                .map(|&panel| panel.spec().surface(self.card(panel, pointer)))
                .collect();
            self.bounds.clear();
            let handle = SplitHandleStyle::default()
                .kind(SplitHandle::Grip)
                .thickness(4.0)
                .length(36.0)
                .hit_width(14.0);
            let style = SplitStyle::default().gap(14.0).handle(handle);
            let axis = if self.vertical {
                Layout::Vertical
            } else {
                Layout::Horizontal
            };
            let out = SplitPane::new("workspace", axis)
                .style(style)
                .resizable(self.enabled)
                .reset(reset)
                .double_click_reset(true)
                .panels(panels)
                .show(ui, |split| {
                    for &panel in &order {
                        split.panel(panel, |ui| {
                            self.header(ui, panel);
                            if panel == Panel::Work {
                                self.workspace(ui, reset);
                            } else {
                                self.content(ui, panel);
                            }
                        });
                    }
                });
            self.drop_panel(ui, &out, &mut order);
            self.order = order;
            let input = ui.context().input();
            if input.primary_released || !input.focused || !input.primary_down {
                self.drag = None;
            }
        });
        if self.smoke {
            self.passes += 1;
            if self.passes >= 8 {
                frame.close();
            } else {
                c.request_repaint_after(std::time::Duration::from_millis(50));
            }
        }
    }
}
fn main() -> Result<(), zaxis::RunError> {
    zaxis::run_with_options(
        Workspace {
            text: "main.rs".into(),
            file: 0,
            enabled: true,
            vertical: false,
            glass: false,
            zoom: 1.0,
            order: vec![Panel::Files, Panel::Work, Panel::Inspector],
            inner_order: vec![Panel::Editor, Panel::Tasks, Panel::Log],
            drag: None,
            bounds: Vec::new(),
            logs: vec!["Ready".into()],
            runs: [0; 12],
            smoke: std::env::args().any(|a| a == "--smoke-test"),
            passes: 0,
        },
        zaxis::RunOptions {
            presentation_mode: zaxis::PresentationMode::Immediate,
            window_attributes: zaxis::winit::window::Window::default_attributes()
                .with_title("zaxis — SplitPane")
                .with_inner_size(zaxis::winit::dpi::LogicalSize::new(1150.0, 760.0)),
            ..Default::default()
        },
    )
}