Conteúdo
Índice 🔎︎

# Criar listeners de evento

Evento ativados por caixas de diálogo, documentos, formulários ou controles gráficos podem ser vinculados a macros, assim chamados de programação acionada por eventos. O método mais comum de relacionar eventos a macros está na aba Eventos no menu Ferramentas - Opções - Personalizar e nas propriedades de controle do painel Editor de caixas de diálogo do menu Ferramentas - Opções - Macros - Organizar caixas de diálogo.

Elementos gráficos, entradas de teclado, movimentos do mouse e outras interações homem-máquina podem ser controladas utilizando listeners UNO que observam o comportamento do usuário. Os listeners são códigos de programa alternativos dinâmicos às atribuições de macros. Pode-se criar tantos listeners UNO quanto os eventos a observar. Um listener simples pode também tratar vários controles da interface do usuário.

## Criar um listener de evento

Os listeners são anexados a controles contidos nas caixas de diálogo, bem como a eventos de documento ou de formulários. Listeners também podem ser utilizados ao criar caixas de diálogo em tempo de execução ou quando adicionar controles ao diálogo dinamicamente.

Este exemplo cria um listener para o controle Button1 da caixa de diálogo Dialog1 na biblioteca Standard.

### Com Python

             # -*- coding: utf-8 -*-
             from __future__ import unicode_literals

             import uno, unohelper
             from com.sun.star.awt import XActionListener
             from com.sun.star.awt import ActionEvent
             from com.sun.star.lang import EventObject
             from com.sun.star.ui.dialogs.ExecutableDialogResults \
                 import OK, CANCEL
             import msgbox as util

             _MY_BUTTON =  "Button1"
             _MY_LABEL = 'Python ouve..'
             _DLG_PROVIDER = "com.sun.star.awt.DialogProvider"

             def Main(*args):
                 ui = createUnoDialog("Standard.Dialog1", embedded=True)
                 ui.Title = "Python X[any]Listener"
                 ctl = ui.getControl(_MY_BUTTON)
                 ctl.Model.Label = _MY_LABEL
                 act = ActionListener()
                 ctl.addActionListener(act)
                 rc = ui.execute()
                 if rc == OK:
                     MsgBox("O usuário reconheceu o diálogo.")
                 elif rc == CANCEL:
                     MsgBox("O usuário cancelou o diálogo.")
                 ui.dispose()  # ui.endExecute
                 ctl.removeActionListener(act)

             def createUnoDialog(libr_dlg: str, embedded=False):
                 """ Cria um dialogo de sua localidade """
                 smgr = XSCRIPTCONTEXT.getComponentContext().ServiceManager
                 if embedded:
                     model = XSCRIPTCONTEXT.getDocument()
                     dp = smgr.createInstanceWithArguments(_DLG_PROVIDER, (model,))
                     location = "?location=document"
                 else:
                     dp = smgr.createInstanceWithContext(_DLG_PROVIDER, ctx)
                     location = "?location=application"
                 dlg = dp.createDialog("vnd.sun.star.script:"+libr_dlg+location)
                 return dlg

             class ActionListener(unohelper.Base, XActionListener):
                 """ Escuta e conta os cliques de botão """
                 def __init__(self):
                     self.count = 0

                 def actionPerformed(self, evt: ActionEvent):
                     self.count = self.count + 1
                     #mri(evt)
                     if evt.Source.Model.Name == _MY_BUTTON:
                         evt.Source.Model.Label = _MY_LABEL+ str( self.count )
                 return

                 def disposing(self, evt: EventObject):  # rotina obrigatória
                     pass

             def MsgBox(txt: str):
                 mb = util.MsgBox(uno.getComponentContext())
                 mb.addButton("Ok")
                 mb.show(txt, 0, "Python")

             g_exportedScripts = (Main,)

msgbox.py no diretório {instalação}/program/ tem alguns exemplos de listeners para botões.

### Com LibreOffice Basic

             Option Explicit

             Const MY_LIBRARY = "Standard", MY_DIALOG = "Dialog1", MY_BUTTON = "Button1"
             Const MY_LABEL = "Basic escuta.."
             Dim count As Integer

             Sub Main
                 Dim libr As Object ' com.sun.star.script.XLibraryContainer
                 Dim dlg As Object
                 Dim ui As Object  ' stardiv.Toolkit.UnoDialogControl
                 Dim ctl As Object ' stardiv.Toolkit.UnoButtonControl
                 Dim act As Object ' com.sun.star.awt.XActionListener
                 Dim rc As Object : rc = com.sun.star.ui.dialogs.ExecutableDialogResults

                 BasicLibraries.LoadLibrary(MY_LIBRARY)
                 libr = DialogLibraries.GetByName(MY_LIBRARY)
                 dlg = libr.GetByName(MY_DIALOG)
                 ui = CreateUnoDialog(dlg)
                 ui.Title = "Basic X[any]Listener example"
                 count = 0
                 ctl = ui.GetControl(MY_BUTTON)
                 ctl.Model.Label = MY_LABEL
                 act = CreateUnoListener("awt_", "com.sun.star.awt.XActionListener")
                 ctl.addActionListener(act)
                 Select Case ui.Execute
                     Case rc.OK : MsgBox "O usuário reconheceu o diálogo.",, "Basic"
                     Case rc.CANCEL : MsgBox "O usuário cancelou o diálogo.",, "Basic"
                 End Select
                 ui.dispose ' ui.endExecute()
                 ctl.removeActionListener(act)
             End Sub

             Private Sub awt_actionPerformed(evt As com.sun.star.awt.ActionEvent)
                 ''' Escuta e conta os cliques de botão '''
                 With evt.Source.Model
                     If .Name = MY_BUTTON Then
                         count = count + 1
                         .Label = MY_LABEL+Cstr(count)
                     End If
                 End With
             End Sub ' awt_actionPerformed

             Private Sub awt_disposing(evt As com.sun.star.lang.EventObject) ' mandatory Sub
                 ' seu código vai aqui
             End Sub ' awt_disposing

## Outros eventos de listeners

Os listeners são normalmente codificados junto com a abertura de caixas de diálogo. Há numerosas abordagens de listeners possíveis tais como tratadores de eventos para caixas de diálogo ou monitores de eventos para documentos e formulários.

Tópicos relacionados

Exemplos de programação para controles no editor de caixa de diálogo

Função CreateUnoListener

Eventos mapeando em objetos

Veja também Eventos de documento, Eventos de formulário.

Criar um manipulador de caixa de diálogo

Monitorar eventos de documentos

Exemplos de programação em Python