uzor 1.0.20

Core UI engine — geometry, interaction, input state
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

//! Scrollable container geometry and configuration
//!
//! High-level abstraction for scrollable content areas.
//! Handles offset calculation and geometry computation for headless architecture.

use crate::types::{Rect, ScrollState};
use serde::{Deserialize, Serialize};

/// Response from scrollable container geometry calculation
#[derive(Clone, Debug, Default, Serialize, Deserialize)]
pub struct ScrollableResponse {
    /// Total content size (as measured)
    pub content_size: f64,
    /// Viewport size
    pub viewport_size: f64,
    /// Whether scrollbar is visible
    pub has_scrollbar: bool,
    /// Viewport rectangle
    pub viewport: Rect,
    /// Content area rectangle (excluding scrollbar)
    pub content_area: Rect,
}

/// Configuration for scrollable container
#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct ScrollableConfig {
    /// Width of scrollbar
    pub scrollbar_size: f64,
    /// Whether to always show scrollbar
    pub always_show_scrollbar: bool,
}

impl Default for ScrollableConfig {
    fn default() -> Self {
        Self {
            scrollbar_size: 8.0,
            always_show_scrollbar: false,
        }
    }
}

/// Scrollable container for managing scrollable content rendering
pub struct ScrollableContainer {
    viewport: Rect,
    scroll_offset: f64,
    #[allow(dead_code)]
    is_dragging: bool,
    config: ScrollableConfig,
}

impl ScrollableContainer {
    pub fn new(viewport: Rect, scroll_state: &ScrollState, config: Option<ScrollableConfig>) -> Self {
        Self {
            viewport,
            scroll_offset: scroll_state.offset,
            is_dragging: scroll_state.is_dragging,
            config: config.unwrap_or_default(),
        }
    }

    /// Get content area rectangle (excludes scrollbar space)
    pub fn content_area(&self) -> Rect {
        Rect::new(
            self.viewport.x,
            self.viewport.y,
            self.viewport.width - self.config.scrollbar_size,
            self.viewport.height,
        )
    }

    /// Calculate scrollable area geometry
    pub fn calculate(self, content_height: f64) -> ScrollableResponse {
        let needs_scrollbar = content_height > self.viewport.height || self.config.always_show_scrollbar;

        let content_area = Rect::new(
            self.viewport.x,
            self.viewport.y,
            self.viewport.width - self.config.scrollbar_size,
            self.viewport.height,
        );

        ScrollableResponse {
            content_size: content_height,
            viewport_size: self.viewport.height,
            has_scrollbar: needs_scrollbar,
            viewport: self.viewport,
            content_area,
        }
    }

    pub fn content_y(&self) -> f64 {
        self.viewport.y - self.scroll_offset
    }

    pub fn content_width(&self) -> f64 {
        self.viewport.width - self.config.scrollbar_size
    }
}