1use crate::component::ComponentId;
32use crate::error::{Error, Result};
33use crate::event::EventArgs;
34use crate::prop::{PropEnum, PropValue};
35use crate::ui::Ui;
36
37#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
45pub struct WindowPlacement {
46 pub x: i32,
47 pub y: i32,
48 pub width: u32,
50 pub height: u32,
51 pub maximized: bool,
52 pub full_screen: bool,
54}
55
56impl Ui {
57 pub fn window_placement(&self, form: ComponentId) -> Option<WindowPlacement> {
59 self.placements.get(&form).copied()
60 }
61
62 pub fn set_window_placement(&mut self, form: ComponentId, placement: WindowPlacement) {
63 self.placements.insert(form, placement);
64 }
65
66 pub fn set_start_hidden(&mut self, form: ComponentId, hidden: bool) {
70 if hidden {
71 self.start_hidden.insert(form);
72 } else {
73 self.start_hidden.remove(&form);
74 }
75 }
76
77 pub fn take_start_hidden(&mut self, form: ComponentId) -> bool {
79 self.start_hidden.remove(&form)
80 }
81}
82
83#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
85pub enum ModalResult {
86 #[default]
87 None,
88 Ok,
89 Cancel,
90 Abort,
91 Retry,
92 Ignore,
93 Yes,
94 No,
95 Close,
96}
97
98impl ModalResult {
99 pub const ALL: [ModalResult; 9] = [
100 ModalResult::None,
101 ModalResult::Ok,
102 ModalResult::Cancel,
103 ModalResult::Abort,
104 ModalResult::Retry,
105 ModalResult::Ignore,
106 ModalResult::Yes,
107 ModalResult::No,
108 ModalResult::Close,
109 ];
110}
111
112impl PropEnum for ModalResult {
113 const NAMES: &'static [&'static str] = &["none", "ok", "cancel", "abort", "retry", "ignore", "yes", "no", "close"];
114
115 fn from_index(index: usize) -> Option<Self> {
116 Self::ALL.get(index).copied()
117 }
118
119 fn index(self) -> usize {
120 Self::ALL.iter().position(|&r| r == self).expect("todos os valores estão em ALL")
121 }
122}
123
124pub type ModalCallback = Box<dyn FnOnce(&mut Ui, ModalResult)>;
126
127pub(crate) struct OpenForm {
128 pub(crate) form: ComponentId,
129 pub(crate) modal: bool,
130 pub(crate) owner: Option<ComponentId>,
132 pub(crate) result: ModalResult,
133 pub(crate) on_close: Option<ModalCallback>,
134}
135
136impl Ui {
137 pub fn create_form(&mut self, name: &str) -> Result<ComponentId> {
142 let existing = self.roots().iter().copied().find(|&r| self.name(r).is_some_and(|n| n.eq_ignore_ascii_case(name)));
143 if let Some(form) = existing {
144 return Ok(form);
145 }
146 let fail = |message: String| Error::FormNotCreated { name: name.to_string(), message };
147 let mut factory = self.services_mut().forms.take().ok_or_else(|| fail("nenhuma fábrica de forms (abra um projeto)".into()))?;
148 let result = factory.create_form(self, name);
149 if self.services().forms.is_none() {
150 self.services_mut().forms = Some(factory);
151 }
152 result.map_err(fail)
153 }
154
155 pub fn create_form_instance(&mut self, name: &str) -> Result<ComponentId> {
163 let fail = |message: String| Error::FormNotCreated { name: name.to_string(), message };
164 let mut factory = self.services_mut().forms.take().ok_or_else(|| fail("nenhuma fábrica de forms (abra um projeto)".into()))?;
165 let result = factory.create_form(self, name);
166 if self.services().forms.is_none() {
167 self.services_mut().forms = Some(factory);
168 }
169 let form = result.map_err(fail)?;
170 self.free_root_name(form);
171 Ok(form)
172 }
173
174 fn free_root_name(&mut self, form: ComponentId) {
176 let Some(name) = self.name(form).filter(|n| !n.is_empty()).map(str::to_string) else { return };
177 let taken = |ui: &Ui, candidate: &str| ui.roots().iter().any(|&r| r != form && ui.name(r).is_some_and(|n| n.eq_ignore_ascii_case(candidate)));
178 if !taken(self, &name) {
179 return;
180 }
181 let free = (2..).map(|n| format!("{name}{n}")).find(|c| !taken(self, c)).expect("sempre há um número livre");
182 self.remember_form_class(form, &name);
183 let _ = self.set_name(form, &free);
184 }
185
186 pub fn set_stacked_forms(&mut self, stacked: bool) {
189 self.stacked_forms = stacked;
190 }
191
192 fn form_transition(&self, form: ComponentId) -> crate::transition::Transition {
194 if !self.stacked_forms {
195 return crate::transition::Transition::None;
196 }
197 match self.get_prop(form, "transition") {
198 Ok(PropValue::Enum(name)) => <crate::transition::Transition as PropEnum>::from_name(&name).unwrap_or_default(),
199 _ => crate::transition::Transition::None,
200 }
201 }
202
203 pub fn show(&mut self, form: ComponentId) -> Result<()> {
207 self.open(form, false, None)
208 }
209
210 pub fn show_modal(
215 &mut self,
216 form: ComponentId,
217 on_close: impl FnOnce(&mut Ui, ModalResult) + 'static,
218 ) -> Result<()> {
219 self.open(form, true, Some(Box::new(on_close)))
220 }
221
222 fn open(&mut self, form: ComponentId, modal: bool, on_close: Option<ModalCallback>) -> Result<()> {
223 if !self.contains(form) {
224 return Err(Error::InvalidId);
225 }
226 if self.parent(form).is_some() {
227 if let Some(cb) = self.control_mut(form) {
228 cb.set_visible(true);
229 }
230 return Ok(());
231 }
232 if let Some(pos) = self.open_forms.iter().position(|f| f.form == form) {
233 if !modal && !self.input_blocked(form) {
235 let entry = self.open_forms.remove(pos);
236 self.open_forms.push(entry);
237 self.activate = Some(form);
238 }
239 return Ok(());
240 }
241 if self.main_form.is_none() {
242 self.main_form = Some(form);
243 }
244 let owner = if self.main_form == Some(form) { None } else { self.open_forms.last().map(|f| f.form) };
248 self.open_forms.push(OpenForm { form, modal, owner, result: ModalResult::None, on_close });
249 if let Some(cb) = self.control_mut(form) {
250 cb.set_visible(true);
251 }
252 if !matches!(self.get_prop(form, "activate_on_show"), Ok(PropValue::Bool(false))) {
254 self.activate = Some(form);
255 }
256 let kind = self.form_transition(form);
258 if kind != crate::transition::Transition::None && self.main_form != Some(form) {
259 self.start_transition(None, Some(form), kind, crate::transition::TRANSITION_MS, false);
260 }
261 self.report(&crate::activity::Activity::FormShown { form, modal });
262 if let Ok(crate::prop::PropValue::Component(Some(first))) = self.get_prop(form, "active_control") {
264 self.set_focus(first);
265 }
266 self.fire(form, "on_show", &EventArgs::None);
267 for inner in self.embedded_forms(form) {
270 self.fire(inner, "on_show", &EventArgs::None);
271 }
272 self.invalidate();
273 Ok(())
274 }
275
276 fn embedded_forms(&self, form: ComponentId) -> Vec<ComponentId> {
279 let mut out = Vec::new();
280 let mut stack: Vec<ComponentId> = self.children(form).iter().rev().copied().collect();
281 while let Some(id) = stack.pop() {
282 if self.is_name_scope(id) && self.class_name(id) == Some("Form") {
283 out.push(id);
284 }
285 stack.extend(self.children(id).iter().rev().copied());
286 }
287 out
288 }
289
290 pub fn release_window(&mut self, form: ComponentId) -> bool {
294 let Some(pos) = self.open_forms.iter().position(|f| f.form == form) else { return true };
295 if self.main_form == Some(form) || self.open_forms[pos].modal {
296 return false;
297 }
298 let entry = self.open_forms.remove(pos);
299 self.frame_requests.borrow_mut().remove(&form);
300 if let Some(state) = self.input.get_mut(&form) {
301 *state = Default::default();
302 }
303 self.activate = entry.owner.filter(|o| self.is_open(*o)).or_else(|| self.open_forms.last().map(|f| f.form));
304 self.invalidate();
305 true
306 }
307
308 pub fn close(&mut self, form: ComponentId) -> bool {
314 if !self.is_open(form) {
315 if let Some(cb) = self.control_mut(form) {
317 cb.set_visible(false);
318 }
319 return true;
320 }
321 if self.questions.closes.contains(&form) {
324 self.unresponsive_close(form);
325 return false;
326 }
327 let can_close = if self.questions.closing_now.contains(&form) {
328 true } else {
330 match self.ask(form, "on_close_query", &EventArgs::None) {
331 crate::question::Asked::Answered(answer) => self.close_answer(form, &answer),
332 crate::question::Asked::Deferred(token) => {
333 self.questions.closes.push(form);
335 self.on_answer(token, move |ui, answer| {
336 ui.questions.closes.retain(|&f| f != form);
337 if ui.close_answer(form, &answer) && ui.contains(form) {
338 ui.questions.closing_now.push(form);
339 ui.close(form);
340 ui.questions.closing_now.retain(|&f| f != form);
341 }
342 });
343 false
344 }
345 }
346 };
347 if !can_close {
348 if let Some(f) = self.open_forms.iter_mut().find(|f| f.form == form) {
349 f.result = ModalResult::None;
350 }
351 return false;
352 }
353 let Some(pos) = self.open_forms.iter().position(|f| f.form == form) else {
355 return true;
356 };
357 let kind = self.form_transition(form);
359 if kind != crate::transition::Transition::None && self.closing_now != Some(form) && self.main_form != Some(form) {
360 if !self.in_transition(form) || self.transitions_entering(form) {
361 self.start_transition(Some(form), None, kind.reversed(), crate::transition::TRANSITION_MS, true);
362 }
363 return true;
364 }
365 let entry = self.open_forms.remove(pos);
366 self.report(&crate::activity::Activity::FormClosed { form });
367 self.frame_requests.borrow_mut().remove(&form);
368 if let Some(cb) = self.control_mut(form) {
369 cb.set_visible(false);
370 }
371 if let Some(state) = self.input.get_mut(&form) {
372 *state = Default::default();
373 }
374 self.activate = entry.owner.filter(|o| self.is_open(*o)).or_else(|| self.open_forms.last().map(|f| f.form));
375 let result = entry.result;
376 self.fire(form, "on_close", &EventArgs::Value(PropValue::Enum(result.name().to_string())));
377 if let Some(callback) = entry.on_close {
378 callback(self, result);
379 }
380 if self.main_form == Some(form) {
381 self.request_close();
382 } else if matches!(self.get_prop(form, "close_action"), Ok(PropValue::Enum(ref a)) if a == "free") {
383 self.free_later(form);
385 }
386 self.invalidate();
387 true
388 }
389
390 pub fn free_later(&mut self, id: ComponentId) {
393 self.set_timeout(0, move |ui| {
394 ui.free(id);
395 });
396 }
397
398 pub fn show_owned(&mut self, form: ComponentId, owner: Option<ComponentId>) -> Result<()> {
401 self.show(form)?;
402 self.set_form_owner(form, owner);
403 Ok(())
404 }
405
406 pub fn cancel_close(&mut self) {
409 self.refuse("");
410 }
411
412 fn close_answer(&mut self, form: ComponentId, answer: &crate::question::Answer) -> bool {
415 match answer {
416 crate::question::Answer::Refused(message) => {
417 if !message.is_empty() {
418 self.raise_exception(crate::Exception { message: message.clone(), path: self.path_of(form), event: "on_close_query".into() });
419 }
420 false
421 }
422 accepted => accepted.flag("can_close", true),
423 }
424 }
425
426 pub fn set_unresponsive_handler(&mut self, f: impl Fn(&mut Ui, ComponentId) + 'static) {
430 self.questions.unresponsive = Some(std::rc::Rc::new(f));
431 }
432
433 fn unresponsive_close(&mut self, form: ComponentId) {
434 if let Some(f) = self.questions.unresponsive.clone() {
435 f(self, form);
436 }
437 }
438
439 pub fn terminate(&mut self) {
443 if let Some(f) = self.questions.terminate.clone() {
444 f(self);
445 }
446 let forms: Vec<ComponentId> = self.questions.closes.drain(..).collect();
447 self.questions.closing_now.extend(forms);
448 self.request_close();
449 }
450
451 pub fn on_terminate(&mut self, f: impl Fn(&mut Ui) + 'static) {
453 self.questions.terminate = Some(std::rc::Rc::new(f));
454 }
455
456 pub fn set_modal_result(&mut self, form: ComponentId, result: ModalResult) {
461 let Some(open) = self.open_forms.iter_mut().find(|f| f.form == form) else { return };
462 open.result = result;
463 if !open.modal || result == ModalResult::None {
464 return;
465 }
466 if self.call_depth > 0 {
467 if !self.pending_closes.contains(&form) {
468 self.pending_closes.push(form);
469 }
470 } else {
471 self.close(form);
472 }
473 }
474
475 pub(crate) fn flush_closes(&mut self) {
477 for form in std::mem::take(&mut self.pending_closes) {
478 if self.modal_result(form) != ModalResult::None {
479 self.close(form);
480 }
481 }
482 }
483
484 pub fn modal_result(&self, form: ComponentId) -> ModalResult {
485 self.open_forms.iter().find(|f| f.form == form).map_or(ModalResult::None, |f| f.result)
486 }
487
488 pub fn open_forms(&self) -> Vec<ComponentId> {
490 self.open_forms.iter().map(|f| f.form).collect()
491 }
492
493 pub fn is_open(&self, form: ComponentId) -> bool {
494 self.open_forms.iter().any(|f| f.form == form)
495 }
496
497 pub fn is_modal(&self, form: ComponentId) -> bool {
498 self.open_forms.iter().any(|f| f.form == form && f.modal)
499 }
500
501 pub fn form_owner(&self, form: ComponentId) -> Option<ComponentId> {
503 self.open_forms.iter().find(|f| f.form == form).and_then(|f| f.owner)
504 }
505
506 pub fn set_form_owner(&mut self, form: ComponentId, owner: Option<ComponentId>) {
510 if let Some(f) = self.open_forms.iter_mut().find(|f| f.form == form) {
511 f.owner = owner;
512 }
513 }
514
515 pub fn main_form(&self) -> Option<ComponentId> {
517 self.main_form
518 }
519
520 pub fn set_main_form(&mut self, form: ComponentId) {
522 self.main_form = Some(form);
523 self.set_form_owner(form, None);
525 }
526
527 pub fn input_blocked(&self, form: ComponentId) -> bool {
529 self.blocking_modal(form).is_some()
530 }
531
532 pub fn blocking_modal(&self, form: ComponentId) -> Option<ComponentId> {
534 let top_modal = self.open_forms.iter().rposition(|f| f.modal)?;
535 let pos = self.open_forms.iter().position(|f| f.form == form)?;
536 (pos < top_modal).then(|| self.open_forms[top_modal].form)
537 }
538
539 pub fn take_activation(&mut self) -> Option<ComponentId> {
541 self.activate.take()
542 }
543
544 pub(crate) fn forget_forms(&mut self, freed: &[ComponentId]) {
546 self.open_forms.retain(|f| !freed.contains(&f.form));
547 self.form_pieces.retain(|f, _| !freed.contains(f));
549 if self.main_form.is_some_and(|m| freed.contains(&m)) {
550 self.main_form = None;
551 }
552 }
553}