cursive_split_panel/

view.rs

use super::{actions::*, after::*, split_panel::*, which::*};

use {
    cursive::{direction::*, event::*, theme::*, view::*, *},
    std::cmp::*,
};

const TYPE_NAME: &str = "SplitPanel";

const TOP_LEFT: &str = "┌";
const BOTTOM_LEFT: &str = "└";
const TOP_RIGHT: &str = "┐";
const BOTTOM_RIGHT: &str = "┘";
const VERTICAL: &str = "│";
const VERTICAL_THICK: &str = "┃";
const HORIZONTAL: &str = "─";
const HORIZONTAL_THICK: &str = "━";
const TOP_HINGE: &str = "┰";
const BOTTOM_HINGE: &str = "┸";
const LEFT_HINGE: &str = "┝";
const RIGHT_HINGE: &str = "┥";

impl View for SplitPanel {
    fn type_name(&self) -> &'static str {
        TYPE_NAME
    }

    fn focus_view(&mut self, selector: &Selector) -> Result<EventResult, ViewNotFound> {
        // TODO: we are losing the focus_view callback
        if self.front.view.focus_view(selector).is_ok() {
            Ok(self.set_focus(Some(WhichPane::Front)))
        } else if self.back.view.focus_view(selector).is_ok() {
            Ok(self.set_focus(Some(WhichPane::Back)))
        } else {
            Err(ViewNotFound)
        }
    }

    fn take_focus(&mut self, source: Direction) -> Result<EventResult, CannotFocus> {
        match source.relative(self.orientation).unwrap_or(Relative::Front) {
            Relative::Front => match self.front.view.take_focus(source) {
                Ok(event_result) => Ok(event_result),
                Err(_) => self.back.view.take_focus(source),
            },

            Relative::Back => match self.back.view.take_focus(source) {
                Ok(event_result) => Ok(event_result),
                Err(_) => self.front.view.take_focus(source),
            },
        }
    }

    fn needs_relayout(&self) -> bool {
        self.needs_relayout || self.front.view.needs_relayout() || self.back.view.needs_relayout()
    }

    fn layout(&mut self, mut size: Vec2) {
        self.size = Some(size);

        // Extent (not including border)
        if self.border {
            size = size - (2, 2);
        }
        let extent = *size.get(self.orientation);

        // Divider
        let divider = self.layout_divider(extent);

        // Front
        self.front.start = 0;
        self.front.extent = divider;

        // Back
        self.back.start = divider + 1;
        if self.back.start >= extent {
            // No room for back, so we will effectively disable it
            self.back.start = 0;
            self.back.extent = 0;
        } else {
            self.back.extent = extent - self.back.start;
        }

        self.front.layout(size, self.orientation);
        self.back.layout(size, self.orientation);

        self.needs_relayout = false;
    }

    fn required_size(&mut self, constraint: Vec2) -> Vec2 {
        let front = self.front.view.required_size(constraint);
        let back = self.back.view.required_size(constraint);

        let size = Vec2::from(match self.orientation {
            Orientation::Horizontal => (front.x + back.x, max(front.y, back.y)),
            Orientation::Vertical => (max(front.x, back.x), front.y + back.y),
        });

        if self.border {
            // Add border and divider
            size + match self.orientation {
                Orientation::Horizontal => (3, 2),
                Orientation::Vertical => (2, 3),
            }
        } else {
            // Add divider
            size + match self.orientation {
                Orientation::Horizontal => (1, 0),
                Orientation::Vertical => (0, 1),
            }
        }
    }

    fn important_area(&self, size: Vec2) -> Rect {
        match self.focus {
            Some(WhichPane::Front) => self.front.important_area(size, self.orientation, self.border),
            Some(WhichPane::Back) => self.back.important_area(size, self.orientation, self.border),
            None => Rect::from_size((0, 0), size),
        }
    }

    fn on_event(&mut self, event: Event) -> EventResult {
        match if self.movable_divider { self.actions.get(&event) } else { None } {
            Some(action) => match action {
                Action::MoveDividerToFront => self.move_divider(-1),
                Action::MoveDividerToBack => self.move_divider(1),
            },

            None => match event {
                Event::Mouse { offset, position, event } => {
                    if self.moving_divider {
                        // Moving divider

                        if matches!(event, MouseEvent::Release(_)) {
                            // End moving divider
                            self.moving_divider = false;
                        } else if let Some(position) = position.checked_sub(offset) {
                            let mut divider = *position.get(self.orientation);

                            if self.border && divider != 0 {
                                divider -= 1;
                            }

                            self.set_divider(divider);
                        }

                        EventResult::consumed()
                    } else if self.is_start_moving_divider(offset, position, event) {
                        // Start moving divider

                        self.moving_divider = true;
                        EventResult::consumed()
                    } else if let Some((offset, position)) =
                        self.front.mouse_event(offset, position, self.orientation, self.border, self.size)
                    {
                        // In front pane

                        let prior = if event.grabs_focus() {
                            self.set_focus(Some(WhichPane::Front))
                        } else {
                            EventResult::Ignored
                        };

                        self.front.view.on_event(Event::Mouse { offset, position, event }).after(prior)
                    } else if let Some((offset, position)) =
                        self.back.mouse_event(offset, position, self.orientation, self.border, self.size)
                    {
                        // In back pane

                        let prior = if event.grabs_focus() {
                            self.set_focus(Some(WhichPane::Back))
                        } else {
                            EventResult::Ignored
                        };

                        self.back.view.on_event(Event::Mouse { offset, position, event }).after(prior)
                    } else {
                        EventResult::Ignored
                    }
                }

                event => match self.focus {
                    Some(WhichPane::Front) => self.front.view.on_event(event),
                    Some(WhichPane::Back) => self.back.view.on_event(event),
                    None => {
                        // We'll default to focusing on the front pane
                        let prior = self.set_focus(Some(WhichPane::Front));
                        self.front.view.on_event(event).after(prior)
                    }
                },
            },
        }
    }

    fn call_on_any(&mut self, selector: &Selector, callback: AnyCb) {
        self.front.view.call_on_any(selector, callback);
        self.back.view.call_on_any(selector, callback);
    }

    fn draw(&self, printer: &Printer) {
        let mut _shrinked = None;
        let printer = if self.draw_lines(printer) {
            _shrinked = Some(printer.shrinked_centered((2, 2)));
            &_shrinked.expect("shrinked")
        } else {
            printer
        };

        self.front.draw(printer, self.orientation, self.is_focused(WhichPane::Front));
        self.back.draw(printer, self.orientation, self.is_focused(WhichPane::Back));
    }
}

impl SplitPanel {
    // Whether a pane is focused.
    fn is_focused(&self, which: WhichPane) -> bool {
        self.focus.map(|focus| focus == which).unwrap_or_default()
    }

    // Set the focused pane (and un-focus the old one).
    fn set_focus(&mut self, focus: Option<WhichPane>) -> EventResult {
        let old_focus = self.focus;
        self.focus = focus;
        if self.focus != old_focus
            && let Some(old_focus) = old_focus
        {
            return match old_focus {
                WhichPane::Front => self.front.view.on_event(Event::FocusLost),
                WhichPane::Back => self.back.view.on_event(Event::FocusLost),
            };
        }

        EventResult::consumed()
    }

    // Whether we click on the divider to start moving it.
    fn is_start_moving_divider(&self, offset: Vec2, position: Vec2, event: MouseEvent) -> bool {
        if event.button().is_none() || self.moving_divider || !self.movable_divider {
            return false;
        }

        if let Some(mut divider) = self.divider
            && let Some(size) = self.size
            && size.x != 0
            && size.y != 0
            && let Some(position) = position.checked_sub(offset)
        {
            if self.border {
                divider += 1;
                let corner = size - (1, 1);
                match self.orientation {
                    Orientation::Horizontal => position.y > 0 && position.y < corner.y && position.x == divider,
                    Orientation::Vertical => position.x > 0 && position.x < corner.x && position.y == divider,
                }
            } else {
                match self.orientation {
                    Orientation::Horizontal => position.x == divider,
                    Orientation::Vertical => position.y == divider,
                }
            }
        } else {
            false
        }
    }

    // Move the divider (if allowed).
    fn move_divider(&mut self, delta: isize) -> EventResult {
        if !self.movable_divider {
            return EventResult::Ignored;
        }

        match self.divider {
            Some(divider) => {
                if delta > 0 {
                    self.set_divider(divider + delta as usize);
                } else if let Some(divider) = divider.checked_add_signed(delta) {
                    self.set_divider(divider);
                }
            }

            None => self.set_divider(0),
        }

        EventResult::consumed()
    }

    // Layout the divider.
    fn layout_divider(&mut self, extent: usize) -> usize {
        match self.divider {
            Some(divider) => {
                if divider >= extent {
                    if extent == 0 {
                        // There won't immediately be room for front and back
                        self.set_divider(0);
                    } else {
                        // There won't immediately be room for back
                        self.set_divider(extent - 1);
                    }
                }
            }

            // Default to middle
            None => self.set_divider(extent / 2),
        }

        self.divider.expect("divider")
    }

    // Draw border and divider.
    //
    // Returns true if a border was drawn.
    fn draw_lines(&self, printer: &Printer) -> bool {
        let Some(mut divider) = self.divider else {
            // This would only happen if we try to draw before layout
            return false;
        };

        if printer.size.x == 0 || printer.size.y == 0 {
            return false;
        }

        let corner = printer.size - (1, 1);

        if self.border {
            divider += 1;

            // Border corners
            printer.print((0, 0), TOP_LEFT);
            printer.print((corner.x, 0), TOP_RIGHT);
            printer.print((0, corner.y), BOTTOM_LEFT);
            printer.print(corner, BOTTOM_RIGHT);

            let mut _divider_printer = None;
            let divider_printer = if self.moving_divider {
                let mut divider_printer = printer.clone();
                divider_printer.set_effect(Effect::Reverse);
                _divider_printer = Some(divider_printer);
                &_divider_printer.expect("divider_printer")
            } else {
                printer
            };

            match self.orientation {
                Orientation::Horizontal => {
                    // Hinges
                    printer.print((divider, 0), TOP_HINGE);
                    printer.print((divider, corner.y), BOTTOM_HINGE);

                    if let Some(length) = divider.checked_sub(1) {
                        // Top border
                        printer.print_hline((1, 0), length, HORIZONTAL);
                        // Bottom border
                        printer.print_hline((1, corner.y), length, HORIZONTAL);
                    }

                    if let Some(length) = corner.x.checked_sub(divider + 1) {
                        // Top border
                        printer.print_hline((divider + 1, 0), length, HORIZONTAL);
                        // Bottom border
                        printer.print_hline((divider + 1, corner.y), length, HORIZONTAL);
                    }

                    if let Some(length) = corner.y.checked_sub(1) {
                        // Left border
                        printer.print_vline((0, 1), length, VERTICAL);
                        // Divider
                        divider_printer.print_vline((divider, 1), length, VERTICAL_THICK);
                        // Right border
                        printer.print_vline((corner.x, 1), length, VERTICAL);
                    }
                }

                Orientation::Vertical => {
                    // Hinges
                    printer.print((0, divider), LEFT_HINGE);
                    printer.print((corner.x, divider), RIGHT_HINGE);

                    if let Some(length) = divider.checked_sub(1) {
                        // Left border
                        printer.print_vline((0, 1), length, VERTICAL);
                        // Right border
                        printer.print_vline((corner.x, 1), length, VERTICAL);
                    }

                    if let Some(length) = corner.y.checked_sub(divider + 1) {
                        // Left border
                        printer.print_vline((0, divider + 1), length, VERTICAL);
                        // Right border
                        printer.print_vline((corner.x, divider + 1), length, VERTICAL);
                    }

                    if let Some(length) = corner.x.checked_sub(1) {
                        // Top border
                        printer.print_hline((1, 0), length, HORIZONTAL);
                        // Divider
                        divider_printer.print_hline((1, divider), length, HORIZONTAL_THICK);
                        // Bottom border
                        printer.print_hline((1, corner.y), length, HORIZONTAL);
                    }
                }
            }

            true
        } else {
            match self.orientation {
                Orientation::Horizontal => printer.print_vline((divider, 0), corner.y, VERTICAL),
                Orientation::Vertical => printer.print_vline((divider, 0), corner.y, VERTICAL),
            }

            false
        }
    }
}