gpuikit 0.7.0

A UI toolkit for GPUI applications
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

//! Cursor blink state management for text input components.

use gpui::Context;
use smol::Timer;
use std::time::Duration;

/// Manages the blinking state of a text cursor.
///
/// The cursor blinks at a configurable interval when enabled. Blinking can be
/// temporarily paused (e.g., during typing) to provide immediate visual feedback.
pub struct CursorBlink {
    interval: Duration,
    generation: usize,
    visible: bool,
    active: bool,
    paused: bool,
}

impl CursorBlink {
    /// Creates a new cursor blink manager with the given interval.
    ///
    /// The cursor starts in a disabled state with visibility set to true.
    pub fn new(interval: Duration, _cx: &mut Context<Self>) -> Self {
        Self {
            interval,
            generation: 0,
            visible: true,
            active: false,
            paused: false,
        }
    }

    /// Returns whether the cursor should currently be rendered.
    pub fn visible(&self) -> bool {
        self.visible
    }

    /// Returns whether blinking is currently active.
    pub fn is_active(&self) -> bool {
        self.active
    }

    /// Activates cursor blinking.
    ///
    /// When activated, the cursor will alternate between visible and hidden
    /// states at the configured interval. Has no effect if already active.
    pub fn enable(&mut self, cx: &mut Context<Self>) {
        if self.active {
            return;
        }

        self.active = true;
        self.visible = false;
        self.paused = false;
        self.tick(cx);
    }

    /// Deactivates cursor blinking.
    ///
    /// The cursor visibility is set to false when disabled. Call
    /// `pause_blinking` instead if you want to temporarily stop blinking
    /// while keeping the cursor visible.
    pub fn disable(&mut self, cx: &mut Context<Self>) {
        self.active = false;
        self.visible = false;
        self.paused = false;
        cx.notify();
    }

    /// Temporarily pauses blinking and shows the cursor.
    ///
    /// This is useful during user input to provide immediate feedback.
    /// Blinking resumes automatically after the blink interval elapses.
    pub fn pause_blinking(&mut self, cx: &mut Context<Self>) {
        if !self.visible {
            self.visible = true;
            cx.notify();
        }

        self.paused = true;
        self.generation = self.generation.wrapping_add(1);

        let generation = self.generation;
        let interval = self.interval;

        cx.spawn(async move |this, cx| {
            Timer::after(interval).await;
            this.update(cx, |this, cx| {
                if this.generation == generation {
                    this.paused = false;
                    this.tick(cx);
                }
            })
        })
        .detach();
    }

    fn tick(&mut self, cx: &mut Context<Self>) {
        if !self.active || self.paused {
            return;
        }

        self.visible = !self.visible;
        cx.notify();

        self.generation = self.generation.wrapping_add(1);
        let generation = self.generation;
        let interval = self.interval;

        cx.spawn(async move |this, cx| {
            Timer::after(interval).await;
            if let Some(this) = this.upgrade() {
                this.update(cx, |this, cx| {
                    if this.generation == generation {
                        this.tick(cx);
                    }
                });
            }
        })
        .detach();
    }
}