pub trait Component: Any {
Show 67 methods
// Required method
fn class_name(&self) -> &'static str;
// Provided methods
fn inner(&self) -> Option<&dyn Component> { ... }
fn inner_mut(&mut self) -> Option<&mut dyn Component> { ... }
fn class_chain(&self, out: &mut Vec<&'static str>) { ... }
fn control(&self) -> Option<&ControlBase> { ... }
fn control_mut(&mut self) -> Option<&mut ControlBase> { ... }
fn props(&self) -> &'static [PropInfo] { ... }
fn default_event(&self) -> Option<&'static str> { ... }
fn get_prop(&self, _name: &str) -> Option<PropValue> { ... }
fn set_prop(&mut self, name: &str, _value: PropValue) -> Result<()> { ... }
fn notification(&mut self, freed: ComponentId) { ... }
fn paint(&self, canvas: &mut dyn Canvas, ctx: &PaintCtx<'_>) { ... }
fn transparent_background(&self) -> bool { ... }
fn opaque(&self, style: &ResolvedStyle) -> bool { ... }
fn clip_shape(&self) -> Option<ClipShape> { ... }
fn paint_after(&self, canvas: &mut dyn Canvas, ctx: &PaintCtx<'_>) { ... }
fn paint_is_pure(&self) -> bool { ... }
fn provided(&self) -> Option<Provided<'_>> { ... }
fn resized(&mut self, ctx: &mut EventCtx<'_>) { ... }
fn click(&mut self, ctx: &mut EventCtx<'_>) { ... }
fn pointer_down(&mut self, ctx: &mut EventCtx<'_>, event: &PointerEvent) { ... }
fn pointer_up(&mut self, ctx: &mut EventCtx<'_>, event: &PointerEvent) { ... }
fn pointer_move(&mut self, ctx: &mut EventCtx<'_>, event: &PointerEvent) { ... }
fn pointer_enter(&mut self, ctx: &mut EventCtx<'_>) { ... }
fn pointer_leave(&mut self, ctx: &mut EventCtx<'_>) { ... }
fn wheel(&mut self, ctx: &mut EventCtx<'_>, event: &WheelEvent) { ... }
fn gesture(&mut self, ctx: &mut EventCtx<'_>, event: &GestureEvent) { ... }
fn swipe(&mut self, ctx: &mut EventCtx<'_>, event: &SwipeEvent) { ... }
fn touch_end(&mut self, ctx: &mut EventCtx<'_>) { ... }
fn edge_swipe(&mut self, ctx: &mut EventCtx<'_>, event: &SwipeEvent) -> bool { ... }
fn context_menu(
&mut self,
ctx: &mut EventCtx<'_>,
at: PointF,
touch: bool,
) -> bool { ... }
fn key_down(&mut self, ctx: &mut EventCtx<'_>, event: &KeyEvent) { ... }
fn key_up(&mut self, ctx: &mut EventCtx<'_>, event: &KeyEvent) { ... }
fn shortcut(&mut self, ctx: &mut EventCtx<'_>, event: &KeyEvent) { ... }
fn platform_hooks(&self) -> Option<&dyn PlatformHooks> { ... }
fn platform_hooks_mut(&mut self) -> Option<&mut dyn PlatformHooks> { ... }
fn design_hooks(&self) -> Option<&dyn DesignHooks> { ... }
fn design_hooks_mut(&mut self) -> Option<&mut dyn DesignHooks> { ... }
fn contains_point(&self, local: PointF, size: SizeF) -> bool { ... }
fn hit_slop(&self) -> f32 { ... }
fn scroll_axes(&self) -> (bool, bool) { ... }
fn drag_drop(&self) -> Option<&dyn DragDrop> { ... }
fn drag_drop_mut(&mut self) -> Option<&mut dyn DragDrop> { ... }
fn accepts_text(&self) -> bool { ... }
fn captures_key(&self, event: &KeyEvent) -> bool { ... }
fn mnemonic_text(&self) -> Option<&str> { ... }
fn mnemonic_focuses_child(&self) -> bool { ... }
fn text_input(&mut self, ctx: &mut EventCtx<'_>, text: &str) { ... }
fn focus_enter(&mut self, ctx: &mut EventCtx<'_>) { ... }
fn focus_exit(&mut self, ctx: &mut EventCtx<'_>) { ... }
fn property_changed(&mut self, ctx: &mut EventCtx<'_>, name: &str) { ... }
fn checked_state(&self) -> Option<bool> { ... }
fn change_args(&self, name: &str, value: &PropValue) -> Option<EventArgs> { ... }
fn paint_only_property(&self, name: &str) -> bool { ... }
fn timed(&self) -> Option<&dyn Timed> { ... }
fn timed_mut(&mut self) -> Option<&mut dyn Timed> { ... }
fn layout_hooks(&self) -> Option<&dyn LayoutHooks> { ... }
fn child_pointer_mut(&mut self) -> Option<&mut dyn ChildPointer> { ... }
fn popup(&self) -> Option<&dyn Popup> { ... }
fn popup_mut(&mut self) -> Option<&mut dyn Popup> { ... }
fn accessible_items(&self) -> Option<&dyn AccessibleItems> { ... }
fn accessible_items_mut(&mut self) -> Option<&mut dyn AccessibleItems> { ... }
fn attach(&self) -> Option<(ComponentId, f32, f32)> { ... }
fn event_info(&self, event: &str) -> Vec<(&'static str, String)> { ... }
fn message(&mut self, ctx: &mut EventCtx<'_>, message: &dyn Any) { ... }
fn methods(&self) -> &'static [MethodInfo] { ... }
fn invoke(
&mut self,
ctx: &mut EventCtx<'_>,
method: &str,
args: &[PropValue],
) -> Result<PropValue, String> { ... }
}Expand description
Componente: a base de tudo que vive no Ui, visual ou não.
Todos os métodos, exceto class_name, têm implementação
padrão — sobrescreva só o que precisar.
§Controle visual
Um componente é um controle quando devolve um ControlBase em
control / control_mut.
§“Herança” por composição
Para criar um componente a partir de outro, guarde o componente base num campo e
devolva-o em inner / inner_mut.
Tudo que você não sobrescrever (pintura, eventos, propriedades, ControlBase) é
repassado automaticamente para ele. Para chamar o comportamento original dentro de
um método sobrescrito (o inherited), chame o método no campo:
struct GlowButton { base: Button }
impl Component for GlowButton {
fn class_name(&self) -> &'static str { "GlowButton" }
fn inner(&self) -> Option<&dyn Component> { Some(&self.base) }
fn inner_mut(&mut self) -> Option<&mut dyn Component> { Some(&mut self.base) }
fn paint(&self, canvas: &mut dyn Canvas, ctx: &PaintCtx) {
self.base.paint(canvas, ctx); // inherited Paint
// ...desenho extra
}
}Required Methods§
Sourcefn class_name(&self) -> &'static str
fn class_name(&self) -> &'static str
Nome da classe (“Button”, “ClientDataSet”…). É o nome usado no registro de classes, nos arquivos de layout e nos estilos do tema.
Provided Methods§
Sourcefn inner(&self) -> Option<&dyn Component>
fn inner(&self) -> Option<&dyn Component>
O componente “pai” na composição, se houver (o equivalente ao ancestral).
fn inner_mut(&mut self) -> Option<&mut dyn Component>
Sourcefn class_chain(&self, out: &mut Vec<&'static str>)
fn class_chain(&self, out: &mut Vec<&'static str>)
Cadeia de classes, da mais derivada para a base. Usada pelo tema: um
GlowButton sem estilo próprio usa o estilo de Button.
Sourcefn control(&self) -> Option<&ControlBase>
fn control(&self) -> Option<&ControlBase>
Dados de controle visual. Componentes não visuais devolvem None.
fn control_mut(&mut self) -> Option<&mut ControlBase>
Sourcefn props(&self) -> &'static [PropInfo]
fn props(&self) -> &'static [PropInfo]
Propriedades publicadas desta camada. As do componente base (inner) e as do
ControlBase são incluídas automaticamente pelo Ui.
Sourcefn default_event(&self) -> Option<&'static str>
fn default_event(&self) -> Option<&'static str>
O evento padrão: o duplo clique no designer cria o handler dele e abre o código.
None: a IDE escolhe pelo nome (o on_change da classe, o
on_timer… ou o on_click).
Sourcefn get_prop(&self, _name: &str) -> Option<PropValue>
fn get_prop(&self, _name: &str) -> Option<PropValue>
Lê uma propriedade desta camada; None se não for dela.
Sourcefn set_prop(&mut self, name: &str, _value: PropValue) -> Result<()>
fn set_prop(&mut self, name: &str, _value: PropValue) -> Result<()>
Grava uma propriedade desta camada. Devolva Error::UnknownProperty se não for
dela (o Ui então tenta a camada base).
Sourcefn notification(&mut self, freed: ComponentId)
fn notification(&mut self, freed: ComponentId)
Avisa que um componente foi liberado (como Notification(AComponent, opRemove)).
Quem guarda referências para outros componentes deve limpá-las aqui.
Sourcefn paint(&self, canvas: &mut dyn Canvas, ctx: &PaintCtx<'_>)
fn paint(&self, canvas: &mut dyn Canvas, ctx: &PaintCtx<'_>)
Pinta o controle. O canvas já está na origem do controle; ctx.rect é a área dele.
Sourcefn transparent_background(&self) -> bool
fn transparent_background(&self) -> bool
O controle não tem fundo (um texto, uma caixa de seleção, um medidor): com o fill
próprio, o Ui pinta o fundo dele inteiro. Os que têm
fundo usam o fill no desenho deles.
Sourcefn opaque(&self, style: &ResolvedStyle) -> bool
fn opaque(&self, style: &ResolvedStyle) -> bool
O paint deste estilo cobre o retângulo inteiro do controle com cor opaca (um painel
de fundo sólido sem cantos arredondados, um form). Com true, o que fica inteiro atrás
dele (um irmão pintado antes) não é pintado: um medidor animando embaixo de uma tela que
o cobre não pede quadros. Na dúvida, false (o padrão): só se perde a economia.
Sourcefn clip_shape(&self) -> Option<ClipShape>
fn clip_shape(&self) -> Option<ClipShape>
A forma do controle, quando não é o retângulo (o form redondo): o fundo, o vidro e os
filhos ficam dentro dela, com a borda suavizada. None (o padrão): o retângulo, com o
raio do estilo no fundo.
Sourcefn paint_after(&self, canvas: &mut dyn Canvas, ctx: &PaintCtx<'_>)
fn paint_after(&self, canvas: &mut dyn Canvas, ctx: &PaintCtx<'_>)
Pinta por cima dos filhos (bordas, anel de foco…).
Sourcefn paint_is_pure(&self) -> bool
fn paint_is_pure(&self) -> bool
A pintura (paint e paint_after) só lê: sem efeito colateral (nada de evento, de
cache que avança, de quadro de vídeo consumido) e o mesmo desenho para o mesmo estado,
estilo e propriedades. Com true, o Ui pode ensaiar o desenho fora do quadro e não
repintar o controle quando ele não mudou (o fundo de um contêiner quando o mouse entra
nele). Os contêineres simples dizem true; o padrão é false, mesmo com inner
(quem herda de um contêiner e pinta por cima precisa dizer de novo).
Sourcefn provided(&self) -> Option<Provided<'_>>
fn provided(&self) -> Option<Provided<'_>>
Um componente provedor (item 25): o que ele oferece aos componentes que o apontam pela
propriedade provider (veja crate::providers). O padrão: nada.
Sourcefn resized(&mut self, ctx: &mut EventCtx<'_>)
fn resized(&mut self, ctx: &mut EventCtx<'_>)
O tamanho real (bounds) mudou depois de um layout (como o Resize).
Sourcefn click(&mut self, ctx: &mut EventCtx<'_>)
fn click(&mut self, ctx: &mut EventCtx<'_>)
Clique (como Click). O padrão dispara o evento on_click.
fn pointer_down(&mut self, ctx: &mut EventCtx<'_>, event: &PointerEvent)
fn pointer_up(&mut self, ctx: &mut EventCtx<'_>, event: &PointerEvent)
fn pointer_move(&mut self, ctx: &mut EventCtx<'_>, event: &PointerEvent)
fn pointer_enter(&mut self, ctx: &mut EventCtx<'_>)
fn pointer_leave(&mut self, ctx: &mut EventCtx<'_>)
fn wheel(&mut self, ctx: &mut EventCtx<'_>, event: &WheelEvent)
Sourcefn gesture(&mut self, ctx: &mut EventCtx<'_>, event: &GestureEvent)
fn gesture(&mut self, ctx: &mut EventCtx<'_>, event: &GestureEvent)
Pinça/giro de dois dedos. Marque como tratado (ctx.set_handled()) para não subir
para os pais.
Sourcefn swipe(&mut self, ctx: &mut EventCtx<'_>, event: &SwipeEvent)
fn swipe(&mut self, ctx: &mut EventCtx<'_>, event: &SwipeEvent)
Um deslizar do dedo (o Carousel troca de item, o TabControl de página). Marque
como tratado (ctx.set_handled()) para não subir para os pais.
Sourcefn touch_end(&mut self, ctx: &mut EventCtx<'_>)
fn touch_end(&mut self, ctx: &mut EventCtx<'_>)
O dedo que arrastava (rolando) saiu da tela: quem segue o arrasto por dentro (a linha da lista deslizada para mostrar as ações) fecha ou fica aberto. Vai ao controle tocado e a todos os pais.
Sourcefn edge_swipe(&mut self, ctx: &mut EventCtx<'_>, event: &SwipeEvent) -> bool
fn edge_swipe(&mut self, ctx: &mut EventCtx<'_>, event: &SwipeEvent) -> bool
Um deslizar que começou na borda do form (event.start nas coordenadas do form) e que
ninguém tratou: a NavigationDrawer abre. true se tratou.
O menu de contexto próprio do controle (o de texto do Edit e do Memo: Recortar,
Copiar, Colar, Selecionar tudo). O Ui chama no botão direito e no toque longo
(touch), subindo do controle tocado pelos pais, só quando nem ele nem um pai tem
popup_menu (o menu do app vence). at é o ponto local. true se abriu um menu.
fn key_down(&mut self, ctx: &mut EventCtx<'_>, event: &KeyEvent)
fn key_up(&mut self, ctx: &mut EventCtx<'_>, event: &KeyEvent)
Sourcefn shortcut(&mut self, ctx: &mut EventCtx<'_>, event: &KeyEvent)
fn shortcut(&mut self, ctx: &mut EventCtx<'_>, event: &KeyEvent)
Tecla de atalho que ninguém tratou (como o atalho de um item de menu): o Ui
oferece a todos os componentes do form. Marque como tratado
(EventCtx::set_handled) se for sua.
Sourcefn platform_hooks(&self) -> Option<&dyn PlatformHooks>
fn platform_hooks(&self) -> Option<&dyn PlatformHooks>
Os ganchos raros (barra de tarefas, bandeja, vista nativa, conector, arquivos soltos),
se este componente usa: devolva Some(self) e implemente PlatformHooks.
fn platform_hooks_mut(&mut self) -> Option<&mut dyn PlatformHooks>
Sourcefn design_hooks(&self) -> Option<&dyn DesignHooks>
fn design_hooks(&self) -> Option<&dyn DesignHooks>
Os ganchos do designer (pontos que se arrastam dentro do controle), se este
componente usa: devolva Some(self) e implemente DesignHooks.
fn design_hooks_mut(&mut self) -> Option<&mut dyn DesignHooks>
Sourcefn contains_point(&self, local: PointF, size: SizeF) -> bool
fn contains_point(&self, local: PointF, size: SizeF) -> bool
O ponto (coordenadas do controle, já sem a rotação) acerta o controle? Padrão: o retângulo inteiro. As formas (círculo, estrela, linha…) respondem só na figura.
Sourcefn hit_slop(&self) -> f32
fn hit_slop(&self) -> f32
Quanto o controle recebe o mouse além do próprio retângulo (as alças de uma moldura
desenhadas do lado de fora). Fora do retângulo, quem decide é o
contains_point (que recebe o ponto fora dele). Padrão: 0.
Sourcefn scroll_axes(&self) -> (bool, bool)
fn scroll_axes(&self) -> (bool, bool)
Em que eixos o conteúdo rola (horizontal, vertical): o Ui::reveal
rola estes contêineres para mostrar um controle de dentro (o campo sob o teclado).
Sourcefn drag_drop(&self) -> Option<&dyn DragDrop>
fn drag_drop(&self) -> Option<&dyn DragDrop>
O arrasto e a soltura feitos pelo próprio componente (veja DragDrop). None (o padrão):
o componente não usa.
fn drag_drop_mut(&mut self) -> Option<&mut dyn DragDrop>
fn accepts_text(&self) -> bool
Sourcefn captures_key(&self, event: &KeyEvent) -> bool
fn captures_key(&self, event: &KeyEvent) -> bool
O controle usa a tecla (o Enter de um Memo, as setas de uma lista): ela não vira o
Tab do form (tab_keys).
Sourcefn mnemonic_text(&self) -> Option<&str>
fn mnemonic_text(&self) -> Option<&str>
A legenda com o & da letra do atalho ("&Salvar": Alt+S), para os controles que
aceitam (botões, caixas de marcar, rótulos, grupos).
Sourcefn mnemonic_focuses_child(&self) -> bool
fn mnemonic_focuses_child(&self) -> bool
No Alt+letra, o foco vai para o primeiro filho (um grupo) em vez de clicar.
Sourcefn text_input(&mut self, ctx: &mut EventCtx<'_>, text: &str)
fn text_input(&mut self, ctx: &mut EventCtx<'_>, text: &str)
Texto digitado (já com acentos e IME resolvidos pela plataforma).
fn focus_enter(&mut self, ctx: &mut EventCtx<'_>)
fn focus_exit(&mut self, ctx: &mut EventCtx<'_>)
Sourcefn property_changed(&mut self, ctx: &mut EventCtx<'_>, name: &str)
fn property_changed(&mut self, ctx: &mut EventCtx<'_>, name: &str)
Uma propriedade publicada mudou por nome (Ui::set_prop: JSON,
Object Inspector, protocolo). É o lugar dos efeitos colaterais da mudança: aqui
o componente tem o Ui (por exemplo, o TabControl mostra a aba nova).
Sourcefn checked_state(&self) -> Option<bool>
fn checked_state(&self) -> Option<bool>
A marca do controle agora (checked), lida pelo núcleo na pintura: o tema reflete a
marca mesmo quando o campo muda direto, sem o set_prop (C02 do Tabernáculo).
Sourcefn change_args(&self, name: &str, value: &PropValue) -> Option<EventArgs>
fn change_args(&self, name: &str, value: &PropValue) -> Option<EventArgs>
Os argumentos do on_change quando a propriedade de valor name muda pelo código
(Ui::set_prop: o acesso tipado, o protocolo);
value é o valor novo. O padrão é EventArgs::Value(value): o controle que dispara
outro argumento quando o usuário muda (o texto do item, numa ComboBox) devolve o mesmo
aqui, e None não dispara. Quais propriedades contam: is_value_property.
Sourcefn paint_only_property(&self, name: &str) -> bool
fn paint_only_property(&self, name: &str) -> bool
A propriedade name só muda a pintura (o valor de um medidor, o giro de um 3D): o
set_prop dela repinta sem refazer o layout da tela. As do controle (cores, opacidade,
giro, deslocamento, cursor, dica) o Ui já conhece; aqui vão as do componente. Na
dúvida, false (refazer o layout nunca está errado, só custa).
Sourcefn timed(&self) -> Option<&dyn Timed>
fn timed(&self) -> Option<&dyn Timed>
O relógio do próprio componente (veja Timed). O padrão: o do componente de dentro.
fn timed_mut(&mut self) -> Option<&mut dyn Timed>
Sourcefn layout_hooks(&self) -> Option<&dyn LayoutHooks>
fn layout_hooks(&self) -> Option<&dyn LayoutHooks>
O layout feito pelo próprio componente (veja LayoutHooks). O padrão: o do componente de
dentro.
Sourcefn child_pointer_mut(&mut self) -> Option<&mut dyn ChildPointer>
fn child_pointer_mut(&mut self) -> Option<&mut dyn ChildPointer>
O mouse nos componentes de dentro (veja ChildPointer). O padrão: o do componente de
dentro.
Sourcefn popup(&self) -> Option<&dyn Popup>
fn popup(&self) -> Option<&dyn Popup>
O comportamento de popup do próprio componente (veja Popup). O padrão: o do componente
de dentro.
fn popup_mut(&mut self) -> Option<&mut dyn Popup>
Sourcefn accessible_items(&self) -> Option<&dyn AccessibleItems>
fn accessible_items(&self) -> Option<&dyn AccessibleItems>
Os itens de acessibilidade do próprio componente (veja AccessibleItems). O padrão: o do
componente de dentro.
fn accessible_items_mut(&mut self) -> Option<&mut dyn AccessibleItems>
Sourcefn attach(&self) -> Option<(ComponentId, f32, f32)>
fn attach(&self) -> Option<(ComponentId, f32, f32)>
Prende o controle a um irmão (mesmo pai): devolve o alvo e o ponto dele onde o
centro deste controle fica (0..1 na largura e na altura: (1, 0) é o canto de
cima à direita). É o que deixa um Badge no canto de um botão.
Sourcefn event_info(&self, event: &str) -> Vec<(&'static str, String)>
fn event_info(&self, event: &str) -> Vec<(&'static str, String)>
Dados extras de um evento que está sendo entregue (chave e texto), para quem recebe
os eventos fora do Rust: o protocolo os manda no info do evento (o on_message do
WebView manda a URL de quem mandou).
Sourcefn message(&mut self, ctx: &mut EventCtx<'_>, message: &dyn Any)
fn message(&mut self, ctx: &mut EventCtx<'_>, message: &dyn Any)
Mensagem enviada por outro componente com Ui::send_message.
O tipo da mensagem é livre: cada camada
(por exemplo a de dados) define as suas e o componente faz downcast_ref.
Sourcefn methods(&self) -> &'static [MethodInfo]
fn methods(&self) -> &'static [MethodInfo]
Os métodos que invoke atende, com os tipos (o catálogo do
acesso tipado nas linguagens: frmPaint.pcDesenho.Undo).
Sourcefn invoke(
&mut self,
ctx: &mut EventCtx<'_>,
method: &str,
args: &[PropValue],
) -> Result<PropValue, String>
fn invoke( &mut self, ctx: &mut EventCtx<'_>, method: &str, args: &[PropValue], ) -> Result<PropValue, String>
Um método pelo nome (Ui::invoke, o comando invoke do
protocolo): o que não é propriedade, como undo, clear ou save. Funciona igual
em Rust e nas outras linguagens (pelo protocolo). Devolve o resultado ou o erro.
Dyn Compatibility§
This trait is dyn compatible.
In older versions of Rust, dyn compatibility was called "object safety".