widgetkit_runtime/
context.rs

1use crate::{internal::RuntimeServices, scheduler::Scheduler, tasks::Tasks, widget::Widget};
2use std::{marker::PhantomData, ptr::NonNull};
3use widgetkit_core::{InstanceId, Size, WidgetId};
4
5pub struct MountCtx<W>
6where
7    W: Widget,
8{
9    widget_id: WidgetId,
10    instance_id: InstanceId,
11    _marker: PhantomData<fn() -> W>,
12}
13
14impl<W> MountCtx<W>
15where
16    W: Widget,
17{
18    pub(crate) fn new(widget_id: WidgetId, instance_id: InstanceId) -> Self {
19        Self {
20            widget_id,
21            instance_id,
22            _marker: PhantomData,
23        }
24    }
25
26    pub fn widget_id(&self) -> WidgetId {
27        self.widget_id
28    }
29
30    pub fn instance_id(&self) -> InstanceId {
31        self.instance_id
32    }
33}
34
35pub struct StartCtx<W>
36where
37    W: Widget,
38{
39    widget_id: WidgetId,
40    instance_id: InstanceId,
41    services: NonNull<RuntimeServices<W::Message>>,
42    _marker: PhantomData<fn() -> W>,
43}
44
45impl<W> StartCtx<W>
46where
47    W: Widget,
48{
49    pub(crate) fn new(
50        widget_id: WidgetId,
51        instance_id: InstanceId,
52        services: NonNull<RuntimeServices<W::Message>>,
53    ) -> Self {
54        Self {
55            widget_id,
56            instance_id,
57            services,
58            _marker: PhantomData,
59        }
60    }
61
62    pub fn widget_id(&self) -> WidgetId {
63        self.widget_id
64    }
65
66    pub fn instance_id(&self) -> InstanceId {
67        self.instance_id
68    }
69
70    pub fn post(&mut self, message: W::Message) {
71        let services = self.services_mut();
72        let _ = services.dispatcher.post_message(message);
73    }
74
75    pub fn request_render(&mut self) {
76        let services = self.services_mut();
77        if services.request_render() {
78            services.dispatcher.wake.wake();
79        }
80    }
81
82    /// Returns the scheduler owned by the current widget instance.
83    /// All timers created here are cleared when the instance stops or is disposed.
84    pub fn scheduler(&mut self) -> Scheduler<'_, W::Message> {
85        let services = self.services_mut();
86        Scheduler::new(&mut services.scheduler, services.dispatcher.clone())
87    }
88
89    /// Returns the task backend owned by the current widget instance.
90    /// All tasks created here are canceled when the instance stops or is disposed.
91    pub fn tasks(&mut self) -> Tasks<'_, W::Message> {
92        let services = self.services_mut();
93        Tasks::new(services.tasks.as_mut())
94    }
95
96    fn services_mut(&mut self) -> &mut RuntimeServices<W::Message> {
97        unsafe { self.services.as_mut() }
98    }
99}
100
101pub struct UpdateCtx<W>
102where
103    W: Widget,
104{
105    widget_id: WidgetId,
106    instance_id: InstanceId,
107    services: NonNull<RuntimeServices<W::Message>>,
108    _marker: PhantomData<fn() -> W>,
109}
110
111impl<W> UpdateCtx<W>
112where
113    W: Widget,
114{
115    pub(crate) fn new(
116        widget_id: WidgetId,
117        instance_id: InstanceId,
118        services: NonNull<RuntimeServices<W::Message>>,
119    ) -> Self {
120        Self {
121            widget_id,
122            instance_id,
123            services,
124            _marker: PhantomData,
125        }
126    }
127
128    pub fn widget_id(&self) -> WidgetId {
129        self.widget_id
130    }
131
132    pub fn instance_id(&self) -> InstanceId {
133        self.instance_id
134    }
135
136    pub fn post(&mut self, message: W::Message) {
137        let services = self.services_mut();
138        let _ = services.dispatcher.post_message(message);
139    }
140
141    pub fn request_render(&mut self) {
142        let services = self.services_mut();
143        if services.request_render() {
144            services.dispatcher.wake.wake();
145        }
146    }
147
148    /// Returns the scheduler owned by the current widget instance.
149    /// All timers created here are cleared when the instance stops or is disposed.
150    pub fn scheduler(&mut self) -> Scheduler<'_, W::Message> {
151        let services = self.services_mut();
152        Scheduler::new(&mut services.scheduler, services.dispatcher.clone())
153    }
154
155    /// Returns the task backend owned by the current widget instance.
156    /// All tasks created here are canceled when the instance stops or is disposed.
157    pub fn tasks(&mut self) -> Tasks<'_, W::Message> {
158        let services = self.services_mut();
159        Tasks::new(services.tasks.as_mut())
160    }
161
162    fn services_mut(&mut self) -> &mut RuntimeServices<W::Message> {
163        unsafe { self.services.as_mut() }
164    }
165}
166
167pub struct RenderCtx<W>
168where
169    W: Widget,
170{
171    widget_id: WidgetId,
172    instance_id: InstanceId,
173    surface_size: Size,
174    _marker: PhantomData<fn() -> W>,
175}
176
177impl<W> RenderCtx<W>
178where
179    W: Widget,
180{
181    pub(crate) fn new(widget_id: WidgetId, instance_id: InstanceId, surface_size: Size) -> Self {
182        Self {
183            widget_id,
184            instance_id,
185            surface_size,
186            _marker: PhantomData,
187        }
188    }
189
190    pub fn widget_id(&self) -> WidgetId {
191        self.widget_id
192    }
193
194    pub fn instance_id(&self) -> InstanceId {
195        self.instance_id
196    }
197
198    pub fn surface_size(&self) -> Size {
199        self.surface_size
200    }
201}
202
203pub struct StopCtx<W>
204where
205    W: Widget,
206{
207    widget_id: WidgetId,
208    instance_id: InstanceId,
209    services: NonNull<RuntimeServices<W::Message>>,
210    _marker: PhantomData<fn() -> W>,
211}
212
213impl<W> StopCtx<W>
214where
215    W: Widget,
216{
217    pub(crate) fn new(
218        widget_id: WidgetId,
219        instance_id: InstanceId,
220        services: NonNull<RuntimeServices<W::Message>>,
221    ) -> Self {
222        Self {
223            widget_id,
224            instance_id,
225            services,
226            _marker: PhantomData,
227        }
228    }
229
230    pub fn widget_id(&self) -> WidgetId {
231        self.widget_id
232    }
233
234    pub fn instance_id(&self) -> InstanceId {
235        self.instance_id
236    }
237
238    /// Returns the scheduler owned by the current widget instance.
239    /// All timers created here are cleared when the instance stops or is disposed.
240    pub fn scheduler(&mut self) -> Scheduler<'_, W::Message> {
241        let services = self.services_mut();
242        Scheduler::new(&mut services.scheduler, services.dispatcher.clone())
243    }
244
245    /// Returns the task backend owned by the current widget instance.
246    /// All tasks created here are canceled when the instance stops or is disposed.
247    pub fn tasks(&mut self) -> Tasks<'_, W::Message> {
248        let services = self.services_mut();
249        Tasks::new(services.tasks.as_mut())
250    }
251
252    fn services_mut(&mut self) -> &mut RuntimeServices<W::Message> {
253        unsafe { self.services.as_mut() }
254    }
255}
256
257pub struct DisposeCtx<W>
258where
259    W: Widget,
260{
261    widget_id: WidgetId,
262    instance_id: InstanceId,
263    _marker: PhantomData<fn() -> W>,
264}
265
266impl<W> DisposeCtx<W>
267where
268    W: Widget,
269{
270    pub(crate) fn new(widget_id: WidgetId, instance_id: InstanceId) -> Self {
271        Self {
272            widget_id,
273            instance_id,
274            _marker: PhantomData,
275        }
276    }
277
278    pub fn widget_id(&self) -> WidgetId {
279        self.widget_id
280    }
281
282    pub fn instance_id(&self) -> InstanceId {
283        self.instance_id
284    }
285}
widgetkit_runtime/context.rs

widgetkit_runtime/
context.rs
