qtrs 0.4.0

qtrs - A type-safe, builder-pattern-driven Qt6 GUI library for Rust
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
128
129
130
131
132
133
134

//! Status bar widget.
//!
//! Wraps [`QStatusBar`](https://doc.qt.io/qt-6/qstatusbar.html).

use crate::ffi;
use crate::signal::SignalHandle;
use crate::widget::AsWidget;
use cxx::let_cxx_string;

/// A status bar for displaying status information at the bottom of a window.
///
/// `StatusBar` uses a **builder pattern**: call [`StatusBar::new`] to obtain
/// a [`Builder`], chain configuration, then call `.build()`.
///
/// # Example
///
/// ```no_run
/// use qtrs::StatusBar;
///
/// let bar = StatusBar::new().build();
/// bar.show_message("Ready", 3000);
/// ```
pub struct StatusBar {
    pub(crate) ptr: *mut ffi::QStatusBar,
    pub(crate) has_parent: bool,
    pub(crate) signal_handles: Vec<SignalHandle>,
}

impl StatusBar {
    /// Start building a new status bar.
    pub fn new() -> Builder { Builder::new() }

    /// Show a temporary message for the given number of milliseconds.
    pub fn show_message(&self, text: &str, timeout_ms: i32) {
        debug_assert!(!self.ptr.is_null());
        let_cxx_string!(c_text = text);
        unsafe { ffi::QStatusBar_showMessage(self.ptr, &c_text, timeout_ms); }
    }

    /// Clear the current message.
    pub fn clear_message(&self) {
        debug_assert!(!self.ptr.is_null());
        unsafe { ffi::QStatusBar_clearMessage(self.ptr); }
    }

    /// Add a widget to the status bar (left side).
    pub fn add_widget(&self, w: &dyn AsWidget) {
        debug_assert!(!self.ptr.is_null());
        unsafe { ffi::QStatusBar_addWidget(self.ptr, w.widget_ptr()); }
    }

    /// Add a permanent widget to the status bar (right side).
    pub fn add_permanent_widget(&self, w: &dyn AsWidget) {
        debug_assert!(!self.ptr.is_null());
        unsafe { ffi::QStatusBar_addPermanentWidget(self.ptr, w.widget_ptr()); }
    }

    /// Remove a widget from the status bar.
    pub fn remove_widget(&self, w: &dyn AsWidget) {
        debug_assert!(!self.ptr.is_null());
        unsafe { ffi::QStatusBar_removeWidget(self.ptr, w.widget_ptr()); }
    }

    /// Set whether the size grip is enabled.
    pub fn set_size_grip_enabled(&self, enabled: bool) {
        debug_assert!(!self.ptr.is_null());
        unsafe { ffi::QStatusBar_setSizeGripEnabled(self.ptr, enabled); }
    }

    /// Get the raw status bar pointer for use with [`MainWindow::set_status_bar`](crate::MainWindow).
    pub(crate) fn statusbar_ptr(&self) -> *mut ffi::QStatusBar {
        self.ptr
    }

    /// Wrap an existing `QStatusBar*` obtained via `findChild`.
    #[doc(hidden)]
    #[allow(dead_code)]
    pub(crate) fn from_raw(ptr: *mut ffi::QStatusBar) -> Self {
        debug_assert!(!ptr.is_null());
        Self { ptr, has_parent: true, signal_handles: Vec::new() }
    }
}

impl AsWidget for StatusBar {
    fn widget_ptr(&self) -> *mut ffi::QWidget {
        debug_assert!(!self.ptr.is_null());
        unsafe { ffi::toQWidget_QStatusBar(self.ptr) }
    }
    fn set_has_parent(&mut self) { self.has_parent = true; }
}

impl Drop for StatusBar {
    fn drop(&mut self) {
        if self.ptr.is_null() { return; }
        if self.has_parent {
            unsafe { ffi::QWidget_disconnectAll(self.ptr as *mut _); }
            for h in self.signal_handles.drain(..) { unsafe { h.reclaim(); } }
        } else {
            for h in self.signal_handles.drain(..) { unsafe { h.reclaim(); } }
            unsafe { ffi::QStatusBar_delete(self.ptr) };
        }
        self.ptr = std::ptr::null_mut();
    }
}

/// Builder for [`StatusBar`].
pub struct Builder {
    parent: Option<*mut ffi::QWidget>,
}

impl Builder {
    fn new() -> Self {
        Self { parent: None }
    }

    /// Set the parent widget.
    pub fn parent(mut self, parent: &dyn AsWidget) -> Self {
        self.parent = Some(parent.widget_ptr());
        self
    }

    /// Create the C++ `QStatusBar` and return the Rust wrapper.
    pub fn build(self) -> StatusBar {
        let ptr = unsafe {
            ffi::QStatusBar_new(self.parent.unwrap_or(std::ptr::null_mut()))
        };
        debug_assert!(!ptr.is_null());
        StatusBar {
            ptr,
            has_parent: self.parent.is_some(),
            signal_handles: Vec::new(),
        }
    }
}