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
|
//! Build window-based GUI applications.
mod action;
pub mod screenshot;
pub use crate::core::window::Id;
pub use action::Action;
pub use screenshot::Screenshot;
use crate::command::{self, Command};
use crate::core::time::Instant;
use crate::core::window::{self, Event, Icon, Level, Mode, UserAttention};
use crate::core::Size;
use crate::futures::subscription::{self, Subscription};
/// Subscribes to the frames of the window of the running application.
///
/// The resulting [`Subscription`] will produce items at a rate equal to the
/// refresh rate of the first application window. Note that this rate may be variable, as it is
/// normally managed by the graphics driver and/or the OS.
///
/// In any case, this [`Subscription`] is useful to smoothly draw application-driven
/// animations without missing any frames.
pub fn frames() -> Subscription<Instant> {
subscription::raw_events(|event, _status| match event {
iced_core::Event::Window(_, Event::RedrawRequested(at)) => Some(at),
_ => None,
})
}
/// Spawns a new window with the given `id` and `settings`.
pub fn spawn<Message>(
id: window::Id,
settings: window::Settings,
) -> Command<Message> {
Command::single(command::Action::Window(id, Action::Spawn { settings }))
}
/// Closes the window with `id`.
pub fn close<Message>(id: window::Id) -> Command<Message> {
Command::single(command::Action::Window(id, Action::Close))
}
/// Begins dragging the window while the left mouse button is held.
pub fn drag<Message>(id: window::Id) -> Command<Message> {
Command::single(command::Action::Window(id, Action::Drag))
}
/// Resizes the window to the given logical dimensions.
pub fn resize<Message>(
id: window::Id,
new_size: Size<u32>,
) -> Command<Message> {
Command::single(command::Action::Window(id, Action::Resize(new_size)))
}
/// Fetches the window's size in logical dimensions.
pub fn fetch_size<Message>(
id: window::Id,
f: impl FnOnce(Size<u32>) -> Message + 'static,
) -> Command<Message> {
Command::single(command::Action::Window(id, Action::FetchSize(Box::new(f))))
}
/// Maximizes the window.
pub fn maximize<Message>(id: window::Id, maximized: bool) -> Command<Message> {
Command::single(command::Action::Window(id, Action::Maximize(maximized)))
}
/// Minimizes the window.
pub fn minimize<Message>(id: window::Id, minimized: bool) -> Command<Message> {
Command::single(command::Action::Window(id, Action::Minimize(minimized)))
}
/// Moves the window to the given logical coordinates.
pub fn move_to<Message>(id: window::Id, x: i32, y: i32) -> Command<Message> {
Command::single(command::Action::Window(id, Action::Move { x, y }))
}
/// Changes the [`Mode`] of the window.
pub fn change_mode<Message>(id: window::Id, mode: Mode) -> Command<Message> {
Command::single(command::Action::Window(id, Action::ChangeMode(mode)))
}
/// Fetches the current [`Mode`] of the window.
pub fn fetch_mode<Message>(
id: window::Id,
f: impl FnOnce(Mode) -> Message + 'static,
) -> Command<Message> {
Command::single(command::Action::Window(id, Action::FetchMode(Box::new(f))))
}
/// Toggles the window to maximized or back.
pub fn toggle_maximize<Message>(id: window::Id) -> Command<Message> {
Command::single(command::Action::Window(id, Action::ToggleMaximize))
}
/// Toggles the window decorations.
pub fn toggle_decorations<Message>(id: window::Id) -> Command<Message> {
Command::single(command::Action::Window(id, Action::ToggleDecorations))
}
/// Request user attention to the window. This has no effect if the application
/// is already focused. How requesting for user attention manifests is platform dependent,
/// see [`UserAttention`] for details.
///
/// Providing `None` will unset the request for user attention. Unsetting the request for
/// user attention might not be done automatically by the WM when the window receives input.
pub fn request_user_attention<Message>(
id: window::Id,
user_attention: Option<UserAttention>,
) -> Command<Message> {
Command::single(command::Action::Window(
id,
Action::RequestUserAttention(user_attention),
))
}
/// Brings the window to the front and sets input focus. Has no effect if the window is
/// already in focus, minimized, or not visible.
///
/// This [`Command`] steals input focus from other applications. Do not use this method unless
/// you are certain that's what the user wants. Focus stealing can cause an extremely disruptive
/// user experience.
pub fn gain_focus<Message>(id: window::Id) -> Command<Message> {
Command::single(command::Action::Window(id, Action::GainFocus))
}
/// Changes the window [`Level`].
pub fn change_level<Message>(id: window::Id, level: Level) -> Command<Message> {
Command::single(command::Action::Window(id, Action::ChangeLevel(level)))
}
/// Fetches an identifier unique to the window, provided by the underlying windowing system. This is
/// not to be confused with [`window::Id`].
pub fn fetch_id<Message>(
id: window::Id,
f: impl FnOnce(u64) -> Message + 'static,
) -> Command<Message> {
Command::single(command::Action::Window(id, Action::FetchId(Box::new(f))))
}
/// Changes the [`Icon`] of the window.
pub fn change_icon<Message>(id: window::Id, icon: Icon) -> Command<Message> {
Command::single(command::Action::Window(id, Action::ChangeIcon(icon)))
}
/// Captures a [`Screenshot`] from the window.
pub fn screenshot<Message>(
id: window::Id,
f: impl FnOnce(Screenshot) -> Message + Send + 'static,
) -> Command<Message> {
Command::single(command::Action::Window(
id,
Action::Screenshot(Box::new(f)),
))
}
|
