Conteúdo

# Criar ouvintes de evento

Os eventos gerados por caixas de diálogo, documentos, formulários ou controlos gráficos podem ser associados a macros, o que se designa por programação orientada por eventos. O método mais comum para relacionar eventos com macros é o separador Eventos no menu Ferramentas – Personalizar e o painel de propriedades do controlo Editor de Caixas de Diálogo no menu Ferramentas – Macros – Organizar Caixas de Diálogo....

Os artefactos gráficos, as entradas do teclado, os movimentos do rato e outras interações homem-máquina podem ser controlados através de ouvintes UNO que monitorizam o comportamento do utilizador. Os ouvintes são alternativas dinâmicas de código de programa às atribuições de macros. É possível criar tantos ouvintes UNO quantos forem os eventos a monitorizar. Um único ouvinte também pode gerir vários controlos da interface do utilizador.

## Criar um ouvinte de evento

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

Este exemplo cria um ouvinte para o controlo 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 utilizador reconheceu o diálogo.")
                 elif rc == CANCEL:
                     MsgBox("O utilizador cancelou o diálogo.")
                 ui.dispose()  # ui.endExecute
                 ctl.removeActionListener(act)

             def createUnoDialog(libr_dlg: str, embedded=False):
                 """ Criar um diálogo da sua localização """
                 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):
                 """ Escutar e contar 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 ouvintes de 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 utilizador reconheceu o diálogo.",, "Basic"
                     Case rc.CANCEL : MsgBox "O utilizador 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
                 ' o seu código vai aqui
             End Sub ' awt_disposing

## Outros eventos de ouvintes

Os ouvintes são normalmente codificados juntamente com a abertura da caixa de diálogo. Existem várias abordagens possíveis para os ouvintes, tais como manipuladores de eventos para caixas de diálogo ou monitores de eventos para documentos ou formulários.

Tópicos relacionados

Exemplos de programação de controlos no editor de caixas de diálogo

CreateUnoListener Function

Eventos que mapeiam em objetos

Veja também Eventos que mapeiam em objetos, Eventos de formulário.

Criar uma manipulador de caixas de diálogo

A escutar eventos do documento

Exemplos de programação em Python

Necessitamos da sua ajuda!