napali 0.1.1

TUI interface for Integrated Reasoning's accelerated solver API
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

use ratatui::prelude::*;
use std::rc::Rc;

/// Represents the layers within a graphical user interface.
///
/// This struct organizes different layers of UI components, each represented by a `Rect`.
/// The use of `Rc<[Rect]>` implies that these layers are reference-counted and can be shared
/// across multiple parts of the UI without full ownership, promoting efficient memory usage.
///
/// Fields:
/// - `zero`: The bottom layer, typically used for background or base elements.
/// - `one`: A layer above `zero`, often used for primary UI elements.
/// - `details`: A specific `Rect` for detailed or focused content.
/// - `details_inner`: Layers within the `details` area, allowing for nested or complex UI structures.
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct Layers {
  pub zero: Rc<[Rect]>,
  pub one: Rc<[Rect]>,
  pub details: Rect,
  pub details_inner: Rc<[Rect]>,
}

impl Layers {
  /// Creates a new `Layers` instance based on the provided `Rect`.
  ///
  /// This method initializes the different layers of the UI, positioning them according to
  /// the given area and specific layout constraints. It demonstrates how various UI elements
  /// are organized in a hierarchical and structured manner.
  ///
  /// Parameters:
  /// - `area`: The `Rect` defining the overall area available for the layers.
  ///
  /// Returns:
  /// A new instance of `Layers` with initialized fields.
  pub fn new(area: Rect) -> Self {
    let zero = Layout::default()
      .direction(Direction::Vertical)
      .constraints(vec![
        Constraint::Max(2),
        Constraint::Min(1),
        Constraint::Max(3),
      ])
      .split(area.inner(&Margin {
        horizontal: 1,
        vertical: 1,
      }));

    let one = Layout::default()
      .direction(Direction::Horizontal)
      .constraints(vec![Constraint::Min(40), Constraint::Min(40)])
      .split(zero[1]);
    let details = one[1];
    let details_inner = Layout::default()
      .direction(Direction::Vertical)
      .constraints(vec![
        Constraint::Min(8),
        Constraint::Min(8),
        Constraint::Min(20),
      ])
      .split(details);

    Layers {
      zero,
      one,
      details,
      details_inner,
    }
  }
}