orbital-datatable 0.1.1

Interactive DataTable product for the Orbital component library
Documentation 
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
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

/// Default number of extra rows rendered above/below the visible window.
pub const DEFAULT_ROW_OVERSCAN: usize = 5;
/// Default number of extra columns rendered left/right of the visible window.
pub const DEFAULT_COL_OVERSCAN: usize = 2;

/// Virtual row window with spacer padding heights.
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct RowViewport {
    pub start: usize,
    pub end: usize,
    pub padding_top_px: f64,
    pub padding_bottom_px: f64,
}

/// Virtual column window with spacer padding widths.
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct ColumnViewport {
    pub start: usize,
    pub end: usize,
    pub padding_left_px: f64,
    pub padding_right_px: f64,
}

/// Compute which row indices to render for a scroll position.
pub fn compute_row_viewport(
    scroll_top: f64,
    viewport_height: f64,
    row_count: usize,
    row_height: f64,
    overscan: usize,
) -> RowViewport {
    if row_count == 0 || row_height <= 0.0 {
        return RowViewport {
            start: 0,
            end: 0,
            padding_top_px: 0.0,
            padding_bottom_px: 0.0,
        };
    }

    let first_visible = (scroll_top / row_height).floor() as usize;
    let visible_count = ((viewport_height / row_height).ceil() as usize).max(1);
    let start = first_visible.saturating_sub(overscan);
    let end = (first_visible + visible_count + overscan).min(row_count);

    RowViewport {
        start,
        end,
        padding_top_px: start as f64 * row_height,
        padding_bottom_px: (row_count.saturating_sub(end)) as f64 * row_height,
    }
}

/// Compute which column indices to render for a horizontal scroll position.
pub fn compute_column_viewport(
    scroll_left: f64,
    viewport_width: f64,
    column_widths: &[f64],
    overscan: usize,
) -> ColumnViewport {
    let col_count = column_widths.len();
    if col_count == 0 {
        return ColumnViewport {
            start: 0,
            end: 0,
            padding_left_px: 0.0,
            padding_right_px: 0.0,
        };
    }

    let offsets = super::scroll::column_left_offsets(column_widths);
    let total_width: f64 = column_widths.iter().sum();

    let mut start = 0usize;
    for (i, &off) in offsets.iter().enumerate() {
        let w = column_widths[i];
        if off + w > scroll_left {
            start = i;
            break;
        }
        if i == col_count - 1 {
            start = col_count;
        }
    }

    let right_edge = scroll_left + viewport_width;
    let mut end = col_count;
    for (i, &off) in offsets.iter().enumerate() {
        if off >= right_edge {
            end = i;
            break;
        }
    }

    let start = start.saturating_sub(overscan);
    let end = (end + overscan).min(col_count);

    let padding_left = offsets.get(start).copied().unwrap_or(0.0);
    let padding_right = total_width - offsets.get(end).unwrap_or(&total_width);

    ColumnViewport {
        start,
        end,
        padding_left_px: padding_left,
        padding_right_px: padding_right.max(0.0),
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn row_viewport_covers_visible_range() {
        let vp = compute_row_viewport(200.0, 400.0, 100, 40.0, 2);
        assert!(vp.start <= 5);
        assert!(vp.end >= 15);
        assert_eq!(vp.padding_top_px, vp.start as f64 * 40.0);
    }

    #[test]
    fn column_viewport_empty() {
        let vp = compute_column_viewport(0.0, 500.0, &[], 2);
        assert_eq!(vp.start, 0);
        assert_eq!(vp.end, 0);
    }
}