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
160
161
162
163
164
165
166
167
168
//! Os monitores (como o `Screen.Monitors` do Delphi): a plataforma informa a lista
//! ([`Ui::set_monitors`]) e em qual deles está a janela de cada form; o app lê com
//! [`Ui::monitors`] e [`Ui::form_monitor`] (nas outras linguagens, pelo componente `Screen`).
//! Coordenadas em pixels físicos da área de trabalho, como o sistema dá (o monitor à esquerda
//! do principal tem `x` negativo).
use crate::component::ComponentId;
use crate::forms::WindowPlacement;
use crate::ui::Ui;
/// Um modo de vídeo que o monitor aceita.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct VideoMode {
pub width: u32,
pub height: u32,
pub bit_depth: u16,
pub refresh_hz: f64,
}
/// Um monitor.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct Monitor {
/// O nome do aparelho ("XB273K V5"); sem ele, o do sistema.
pub name: String,
/// O nome do sistema (`\\.\DISPLAY1` no Windows): não muda enquanto o monitor fica ligado
/// na mesma saída, por isso é o que se guarda para reabrir nele.
pub device: String,
pub primary: bool,
pub x: i32,
pub y: i32,
pub width: u32,
pub height: u32,
/// A área útil (sem a barra de tarefas); igual à do monitor onde o sistema não diz.
pub work_x: i32,
pub work_y: i32,
pub work_width: u32,
pub work_height: u32,
/// A escala do sistema (1,5 = 150%).
pub scale: f64,
/// A taxa de atualização (0 = o sistema não diz, como no navegador).
pub refresh_hz: f64,
pub modes: Vec<VideoMode>,
}
impl Monitor {
/// A área útil, em pixels físicos: `(x, y, largura, altura)`.
pub fn work_area(&self) -> (i32, i32, u32, u32) {
(self.work_x, self.work_y, self.work_width, self.work_height)
}
/// Em JSON (o `Screen` das outras linguagens), com os nomes dos campos em inglês.
pub fn to_json(&self, index: usize) -> String {
let text = |s: &str| {
let mut out = String::from("\"");
for c in s.chars() {
match c {
'"' => out.push_str("\\\""),
'\\' => out.push_str("\\\\"),
c if (c as u32) < 0x20 => out.push_str(&format!("\\u{:04x}", c as u32)),
c => out.push(c),
}
}
out.push('"');
out
};
let modes: Vec<String> = self
.modes
.iter()
.map(|m| format!("{{\"width\":{},\"height\":{},\"bit_depth\":{},\"refresh_hz\":{}}}", m.width, m.height, m.bit_depth, m.refresh_hz))
.collect();
format!(
"{{\"index\":{index},\"name\":{},\"device\":{},\"primary\":{},\"x\":{},\"y\":{},\"width\":{},\"height\":{},\"work_x\":{},\"work_y\":{},\"work_width\":{},\"work_height\":{},\"scale\":{},\"refresh_hz\":{},\"modes\":[{}]}}",
text(&self.name),
text(&self.device),
self.primary,
self.x,
self.y,
self.width,
self.height,
self.work_x,
self.work_y,
self.work_width,
self.work_height,
self.scale,
self.refresh_hz,
modes.join(",")
)
}
}
/// Onde a janela de um form estava, para reabrir nela (o `remember_placement` do form).
#[derive(Clone, Debug, Default, PartialEq)]
pub struct SavedPlacement {
/// O `device` do monitor.
pub monitor: String,
pub placement: WindowPlacement,
}
/// A posição guardada, se ainda serve: o monitor dela continua ligado e a barra de título
/// fica à vista (pelo menos 120 x 40 pixels dentro da área útil de algum monitor). Senão,
/// `None` (o form abre como se não houvesse posição guardada, no monitor principal), como o
/// Windows faz com a janela de um monitor desligado.
pub fn restore_placement(saved: &SavedPlacement, monitors: &[Monitor]) -> Option<WindowPlacement> {
let p = saved.placement;
monitors.iter().find(|m| m.device == saved.monitor)?;
let visible = monitors.iter().any(|m| {
let (x, y, w, h) = m.work_area();
let left = p.x.max(x);
let right = (p.x + p.width.max(120) as i32).min(x + w as i32);
let top = p.y.max(y);
let bottom = (p.y + 40).min(y + h as i32);
right - left >= 120 && bottom - top >= 40
});
visible.then_some(p)
}
impl Ui {
/// Os monitores, na ordem do sistema (vazio antes de a plataforma informar).
pub fn monitors(&self) -> &[Monitor] {
&self.monitors
}
/// Conta as mudanças da lista (um monitor ligado, desligado ou com outra resolução): o
/// `Screen` compara para disparar o `on_change`.
pub fn monitors_version(&self) -> u64 {
self.monitors_version
}
/// A plataforma informa os monitores (só conta como mudança se a lista mudou).
pub fn set_monitors(&mut self, monitors: Vec<Monitor>) {
if monitors != self.monitors {
self.monitors = monitors;
self.monitors_version += 1;
}
}
/// O monitor (índice em [`Ui::monitors`]) em que está a janela do form.
pub fn form_monitor(&self, form: ComponentId) -> Option<usize> {
self.form_monitors.get(&self.root_of(form)).copied()
}
/// A janela do form está minimizada (a plataforma informa; o `on_minimize` e o `on_restore`
/// avisam a mudança).
pub fn is_minimized(&self, form: ComponentId) -> bool {
self.minimized_forms.contains(&self.root_of(form))
}
/// A plataforma informa que a janela do form minimizou ou voltou.
pub fn set_form_minimized(&mut self, form: ComponentId, minimized: bool) {
if minimized {
self.minimized_forms.insert(form);
} else {
self.minimized_forms.remove(&form);
}
}
/// A plataforma informa em que monitor está a janela do form.
pub fn set_form_monitor(&mut self, form: ComponentId, monitor: Option<usize>) {
match monitor {
Some(m) => {
self.form_monitors.insert(form, m);
}
None => {
self.form_monitors.remove(&form);
}
}
}
}