Skip to main content

aylis_core/
forms.rs

1//! Forms abertos como janelas: `show`, `show_modal`, `close` e `ModalResult`, com
2//! a pergunta antes de fechar (`on_close_query`) e o aviso ao fechar (`on_close`).
3//!
4//! O core só mantém a lista de forms abertos (na ordem em que estão empilhados) e as
5//! regras; a plataforma abre e fecha as janelas de verdade para acompanhar essa lista
6//! ([`Ui::open_forms`]). No celular e no navegador, onde há uma tela só, a plataforma
7//! mostra o form do topo.
8//!
9//! O `ShowModal` do aylis **não bloqueia**: o resultado chega numa função quando o form
10//! fecha. Um loop modal dentro de um evento deixaria a interface sem se redesenhar.
11//!
12//! ```
13//! # use aylis_core::*;
14//! # #[derive(Default)] struct F { base: ControlBase }
15//! # impl Component for F {
16//! #   fn class_name(&self) -> &'static str { "Form" }
17//! #   fn control(&self) -> Option<&ControlBase> { Some(&self.base) }
18//! #   fn control_mut(&mut self) -> Option<&mut ControlBase> { Some(&mut self.base) }
19//! # }
20//! let mut ui = Ui::new();
21//! let principal = ui.add_root(F::default());
22//! let cliente = ui.add_root(F::default());
23//! ui.show(principal).unwrap();
24//! ui.show_modal(cliente, |_ui, result| {
25//!     if result == ModalResult::Ok { /* gravar */ }
26//! }).unwrap();
27//! ui.set_modal_result(cliente, ModalResult::Ok); // como um botão com modal_result = ok
28//! assert_eq!(ui.open_forms(), vec![principal]);
29//! ```
30
31use crate::component::ComponentId;
32use crate::error::{Error, Result};
33use crate::event::EventArgs;
34use crate::prop::{PropEnum, PropValue};
35use crate::ui::Ui;
36
37/// Onde a janela de um form fica na tela, em pixels físicos: posição do canto, tamanho da
38/// área interna e se está maximizada ou em tela cheia.
39/// A plataforma atualiza quando a janela é movida ou muda de
40/// tamanho; maximizada ou em tela cheia, guarda a posição e o tamanho de antes (para voltar a
41/// eles; em tela cheia, a posição fica no monitor dela). Para
42/// reabrir onde estava, o app guarda isto e devolve com [`Ui::set_window_placement`]
43/// antes do `show`.
44#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
45pub struct WindowPlacement {
46    pub x: i32,
47    pub y: i32,
48    /// 0 = ainda não se sabe (fica o tamanho do form).
49    pub width: u32,
50    pub height: u32,
51    pub maximized: bool,
52    /// Em tela cheia (no monitor da posição): reabre em tela cheia nele.
53    pub full_screen: bool,
54}
55
56impl Ui {
57    /// Onde está a janela do form (ou onde vai abrir), se a plataforma ou o app disseram.
58    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    /// A janela do form nasce escondida (o app que começa na bandeja); depois aparece com
67    /// [`WindowCommand::Show`](crate::WindowCommand::Show). Vale para a próxima vez que a
68    /// janela for criada.
69    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    /// A plataforma pergunta ao criar a janela (e o pedido se gasta).
78    pub fn take_start_hidden(&mut self, form: ComponentId) -> bool {
79        self.start_hidden.remove(&form)
80    }
81}
82
83/// Resultado de um form modal.
84#[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
124/// Chamada quando um form aberto com [`Ui::show_modal`] fecha.
125pub type ModalCallback = Box<dyn FnOnce(&mut Ui, ModalResult)>;
126
127pub(crate) struct OpenForm {
128    pub(crate) form: ComponentId,
129    pub(crate) modal: bool,
130    /// Form que estava ativo quando este abriu (dono da janela modal).
131    pub(crate) owner: Option<ComponentId>,
132    pub(crate) result: ModalResult,
133    pub(crate) on_close: Option<ModalCallback>,
134}
135
136impl Ui {
137    /// Cria o form `name` pela fábrica de forms do aplicativo.
138    /// Se já existe um form raiz com esse nome, devolve
139    /// ele. O form é criado fechado: abra com [`show`](Self::show) ou
140    /// [`show_modal`](Self::show_modal).
141    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    /// Cria mais uma instância do form `name`, mesmo que ele já exista (duas janelas de
156    /// cliente): cada uma com a sua instância e os
157    /// handlers falando com ela. O form é criado fechado.
158    ///
159    /// A segunda ganha um nome livre (`frmCliente2`, como o frame repetido): os caminhos
160    /// (`frmCliente2.edtNome`) e o protocolo distinguem as duas, e os handlers continuam os
161    /// do `frmCliente` ([`form_class`](Self::form_class)).
162    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    /// Outra raiz já tem o nome de `form`: ele ganha o primeiro livre (`nome2`, `nome3`...).
175    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    /// Os forms se empilham numa superfície só (o celular e o navegador; a plataforma
187    /// liga): abrir e fechar um form usam a propriedade `transition` dele.
188    pub fn set_stacked_forms(&mut self, stacked: bool) {
189        self.stacked_forms = stacked;
190    }
191
192    /// A `transition` do form (se ele tiver a propriedade), quando os forms se empilham.
193    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    /// Abre o form numa janela, sem bloquear os outros (como `Show`). O primeiro form
204    /// aberto é o principal: fechá-lo encerra o aplicativo. Se o form já está aberto,
205    /// vem para a frente. Se ele está embutido em outro (tem pai), só fica visível.
206    pub fn show(&mut self, form: ComponentId) -> Result<()> {
207        self.open(form, false, None)
208    }
209
210    /// Abre o form como modal (como `ShowModal`): os forms abertos antes dele não recebem
211    /// mouse nem teclado até ele fechar. Quando fechar, `on_close` recebe o
212    /// [`ModalResult`] (definido por [`set_modal_result`](Self::set_modal_result) ou por
213    /// um botão com `modal_result`).
214    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            // Já aberto: vem para a frente (um modal não pode ser reaberto por cima de si).
234            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        // O principal nunca tem dona: possuído por outro form (os abertos antes dele, um por
245        // monitor), ele ficava preso por cima dela e herdava o `topmost` dela (testado em 20/11:
246        // a paleta sempre por cima atrás da janela principal).
247        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        // Mostrar sem ativar (`activate_on_show` desligado; o relatório do Tabernáculo, J05).
253        if !matches!(self.get_prop(form, "activate_on_show"), Ok(PropValue::Bool(false))) {
254            self.activate = Some(form);
255        }
256        // Empilhado sobre outro: entra com a transição dele.
257        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        // O primeiro foco (o `active_control` do form), antes do on_show (que pode trocar).
263        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        // Os forms embutidos (o form de um Frame) aparecem junto: recebem o on_show deles depois
268        // do de fora (relatório do InsightDB, 11/11: o form dentro de um Frame não recebia).
269        for inner in self.embedded_forms(form) {
270            self.fire(inner, "on_show", &EventArgs::None);
271        }
272        self.invalidate();
273        Ok(())
274    }
275
276    /// Os forms embutidos em `form` (escopos de nomes da classe `Form`, como o de um Frame), de
277    /// cima para baixo.
278    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    /// O form aberto numa janela deixa de ter janela, sem fechar: sem o `on_close_query`, o
291    /// `on_close` nem o `close_action`, e continua com o estado dele (vai ser embutido em outro,
292    /// como a aba de uma faixa). O principal não larga a janela (`false`), nem um modal.
293    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    /// Fecha o form (como `Close`). Antes pergunta ao `on_close_query`: um handler que
309    /// chamar [`cancel_close`](Self::cancel_close) impede o fechamento (devolve `false`).
310    /// Depois dispara `on_close` (com o `ModalResult` como valor) e, se o form era
311    /// modal, chama a função passada ao [`show_modal`](Self::show_modal). Fechar o form
312    /// principal encerra o aplicativo. O form não é liberado (use [`free`](Self::free)).
313    pub fn close(&mut self, form: ComponentId) -> bool {
314        if !self.is_open(form) {
315            // Embutido ou nunca aberto: só esconde.
316            if let Some(cb) = self.control_mut(form) {
317                cb.set_visible(false);
318            }
319            return true;
320        }
321        // Já perguntou e o backend ainda não respondeu: o segundo pedido é a saída de
322        // emergência (o programa não responde).
323        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 // a resposta adiada já aceitou
329        } 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                // O backend responde depois: o form fica aberto até lá, e fecha com a resposta.
334                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        // O handler pode ter fechado o form (ou outros) enquanto respondia.
354        let Some(pos) = self.open_forms.iter().position(|f| f.form == form) else {
355            return true;
356        };
357        // Empilhado: sai com a transição (de volta) e fecha no fim dela.
358        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            // Liberar depois de fechar, fora do fechamento (o relatório do Tabernáculo, J21/J22).
384            self.free_later(form);
385        }
386        self.invalidate();
387        true
388    }
389
390    /// Libera o componente depois do evento em andamento (na próxima volta dos relógios): de
391    /// dentro de um handler do próprio componente, o `free` direto soltaria quem está rodando.
392    pub fn free_later(&mut self, id: ComponentId) {
393        self.set_timeout(0, move |ui| {
394            ui.free(id);
395        });
396    }
397
398    /// Mostra o form com a dona escolhida (`None`: sem dona, a janela independente), em vez da
399    /// do último form aberto (o relatório do Tabernáculo, J19).
400    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    /// Chamado de dentro de um `on_close_query`: o form continua
407    /// aberto.
408    pub fn cancel_close(&mut self) {
409        self.refuse("");
410    }
411
412    /// A resposta do `on_close_query`: recusado (com a mensagem na caixa de
413    /// erro) ou `can_close` falso mantém o form aberto.
414    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    /// O que fazer quando o usuário pede de novo para fechar um form cujo `on_close_query`
427    /// ainda espera o backend (o `aylis-controls` pergunta "O programa não está
428    /// respondendo. Encerrar o programa?"). Sem isso, o pedido é ignorado.
429    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    /// Encerra sem esperar o backend (a saída de emergência): avisa quem cuida do backend
440    /// ([`on_terminate`](Self::on_terminate): o `aylis-host` mata o processo, a ponte
441    /// abandona a sessão) e fecha o aplicativo sem perguntar de novo.
442    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    /// Quem cuida do backend na saída de emergência ([`terminate`](Self::terminate)).
452    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    /// Define o resultado do form. Num form modal, um valor
457    /// diferente de `None` fecha o form. De dentro de um evento (um botão com
458    /// `modal_result`, um handler), o form fecha quando o evento termina:
459    /// até lá um handler ainda pode voltar o resultado para `None` e cancelar.
460    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    /// Fecha os modais cujo resultado foi definido durante o evento que terminou.
476    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    /// Forms abertos, do fundo para o topo (o último é o ativo).
489    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    /// Form que estava ativo quando `form` abriu (a janela dona, para a plataforma).
502    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    /// Troca o dono do form aberto (`None`: janela independente, que não fica presa por cima
507    /// de outra nem minimiza junto, como as janelas do navegador). Vale para a janela criada
508    /// depois disto: chame logo após o `show`.
509    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    /// O form principal: o primeiro aberto (fechá-lo encerra o aplicativo).
516    pub fn main_form(&self) -> Option<ComponentId> {
517        self.main_form
518    }
519
520    /// Escolhe o form principal (como `Application.MainForm`).
521    pub fn set_main_form(&mut self, form: ComponentId) {
522        self.main_form = Some(form);
523        // Já aberto, deixa de ser possuído (veja o `open`).
524        self.set_form_owner(form, None);
525    }
526
527    /// Existe um form modal aberto depois deste: ele não recebe mouse nem teclado.
528    pub fn input_blocked(&self, form: ComponentId) -> bool {
529        self.blocking_modal(form).is_some()
530    }
531
532    /// O modal que bloqueia o form (o último aberto depois dele), se houver.
533    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    /// Form que a plataforma deve trazer para a frente (o pedido é consumido).
540    pub fn take_activation(&mut self) -> Option<ComponentId> {
541        self.activate.take()
542    }
543
544    /// Esquece forms liberados (chamado por `free`).
545    pub(crate) fn forget_forms(&mut self, freed: &[ComponentId]) {
546        self.open_forms.retain(|f| !freed.contains(&f.form));
547        // Os pedaços de um form em vários monitores (o print aberto e liberado a cada vez).
548        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}