winrt-xaml 1.0.0

A Rust library for creating modern Windows UIs using WinRT and XAML with reactive data binding
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
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159

//! Slider control implementation - stub for Win32 TRACKBAR.

use crate::controls::UIElement;
use crate::error::Result;
use crate::events::{EventHandler, ValueChangedEventArgs};
use parking_lot::RwLock;
use std::sync::Arc;
use windows::Win32::Foundation::*;

/// Slider orientation.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum SliderOrientation {
    /// Horizontal slider.
    Horizontal,
    /// Vertical slider.
    Vertical,
}

/// A slider control.
#[derive(Clone)]
pub struct Slider {
    element: UIElement,
    inner: Arc<SliderInner>,
}

struct SliderInner {
    value: RwLock<f64>,
    minimum: RwLock<f64>,
    maximum: RwLock<f64>,
    step_frequency: RwLock<f64>,
    orientation: RwLock<SliderOrientation>,
    value_changed: EventHandler<ValueChangedEventArgs<f64>>,
}

impl Slider {
    /// Create a new slider.
    pub fn new() -> Result<Self> {
        let inner = Arc::new(SliderInner {
            value: RwLock::new(0.0),
            minimum: RwLock::new(0.0),
            maximum: RwLock::new(100.0),
            step_frequency: RwLock::new(1.0),
            orientation: RwLock::new(SliderOrientation::Horizontal),
            value_changed: EventHandler::new(),
        });

        Ok(Slider {
            element: UIElement::empty(),
            inner,
        })
    }

    /// Get the current value.
    pub fn value(&self) -> f64 {
        *self.inner.value.read()
    }

    /// Set the value.
    pub fn set_value(&self, value: f64) {
        *self.inner.value.write() = value;
    }

    /// Set the value (fluent API).
    pub fn with_value(self, value: f64) -> Self {
        self.set_value(value);
        self
    }

    /// Get the minimum value.
    pub fn minimum(&self) -> f64 {
        *self.inner.minimum.read()
    }

    /// Set the minimum value.
    pub fn set_minimum(&self, minimum: f64) {
        *self.inner.minimum.write() = minimum;
    }

    /// Set the minimum value (fluent API).
    pub fn with_minimum(self, minimum: f64) -> Self {
        self.set_minimum(minimum);
        self
    }

    /// Get the maximum value.
    pub fn maximum(&self) -> f64 {
        *self.inner.maximum.read()
    }

    /// Set the maximum value.
    pub fn set_maximum(&self, maximum: f64) {
        *self.inner.maximum.write() = maximum;
    }

    /// Set the maximum value (fluent API).
    pub fn with_maximum(self, maximum: f64) -> Self {
        self.set_maximum(maximum);
        self
    }

    /// Get the step frequency.
    pub fn step_frequency(&self) -> f64 {
        *self.inner.step_frequency.read()
    }

    /// Set the step frequency.
    pub fn set_step_frequency(&self, step: f64) {
        *self.inner.step_frequency.write() = step;
    }

    /// Set the step frequency (fluent API).
    pub fn with_step_frequency(self, step: f64) -> Self {
        self.set_step_frequency(step);
        self
    }

    /// Get the orientation.
    pub fn orientation(&self) -> SliderOrientation {
        *self.inner.orientation.read()
    }

    /// Set the orientation.
    pub fn set_orientation(&self, orientation: SliderOrientation) {
        *self.inner.orientation.write() = orientation;
    }

    /// Set the orientation (fluent API).
    pub fn with_orientation(self, orientation: SliderOrientation) -> Self {
        self.set_orientation(orientation);
        self
    }

    /// Subscribe to the value changed event.
    pub fn value_changed(&self) -> &EventHandler<ValueChangedEventArgs<f64>> {
        &self.inner.value_changed
    }

    /// Get the underlying UI element.
    pub fn element(&self) -> &UIElement {
        &self.element
    }

    /// Get the HWND of this slider.
    pub fn hwnd(&self) -> HWND {
        self.element.hwnd()
    }
}

impl Default for Slider {
    fn default() -> Self {
        Self::new().expect("Failed to create slider")
    }
}

impl From<Slider> for UIElement {
    fn from(slider: Slider) -> Self {
        slider.element.clone()
    }
}