Inhalte

# Erstellen von Ereignislistenern

Ereignisse, die durch Dialoge, Dokumente, Formulare oder grafische Steuerelemente ausgelöst werden, können mit Makros verknüpft werden, die als Ereignis-gesteuerte Programmierung bezeichnet werden. Die gebräuchlichsten Methoden, Ereignisse mit Makros in Beziehung zu setzen, sind Ereignisse (wählen Sie Extras – Anpassen… – Register: Ereignisse) und der Dialog-Editor (wählen Sie Extras – Makros – Dialoge verwalten…).

Grafische Werkzeuge, Tastatureingaben, Mausbewegungen und andere Mensch-Maschine-Interaktionen können mithilfe von UNO-Listener gesteuert werden, die auf das Verhalten des Benutzers achten. Listener sind dynamische Programmcodealternativen zu Makrozuweisungen. Man kann so viele UNO-Listener erstellen wie Ereignisse, auf die man achten kann. Ein einzelner Listener kann auch mehrere Benutzeroberflächensteuerelemente verarbeiten.

## Erstellen eines Ereignis-Listeners

Listener werden an Steuerelemente angehängt, die in Dialogen enthalten sind, sowie um Ereignisse zu dokumentieren oder zu bilden. Listener werden auch beim Erstellen von Laufzeitdialogen oder beim Hinzufügen von Steuerelementen zu einem Dialog im laufenden Betrieb verwendet.

In diesem Beispiel wird ein Listener für die Steuerung von Button1 des Dialogs Dialog1 in der Bibliothek Standard erstellt.

### Mit 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 hört zu.'
             _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("Der Benutzer hat den Dialog bestätigt.")
                 elif rc == CANCEL:
                     MsgBox("Der Benutzer hat den Dialog abgebrochen.")
                 ui.dispose()  # ui.endExecute
                 ctl.removeActionListener(act)

             def createUnoDialog(libr_dlg: str, embedded=False):
                 """ Erstellt einen Dialog von seinem Speicherort aus """
                 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):
                 """ Lauscht nach & zählt die Tastenanschläge """
                 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):  # obligatorische Routine
                     pass

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

             g_exportedScripts = (Main,)

msgbox.py im Verzeichnis {Installation}/program/ enthält einige Beispiele für Schaltflächen-Listener.

### Mit LibreOffice Basic

             Option Explicit

             Const MY_LIBRARY = "Standard", MY_DIALOG = "Dialog1", MY_BUTTON = "Button1"
             Const MY_LABEL = "Basic belauscht.."
             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 "Der Benutzer hat den Dialog bestätigt.",, "Basic"
                     Case rc.CANCEL : MsgBox "Der Benutzer hat den Dialog abgebrochen.",, "Basic"
                 End Select
                 ui.dispose ' ui.endExecute()
                 ctl.removeActionListener(act)
             End Sub

             Private Sub awt_actionPerformed(evt As com.sun.star.awt.ActionEvent)
                 """ Lauscht nach & zählt die Tastenklicks """
                 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
                 ' Ihr Code gehört hier her
             End Sub ' awt_disposing

## Weitere Event-Listener

Listener werden normalerweise zusammen mit der Dialogöffnung codiert. Zahlreiche Listener-Ansätze sind möglich, beispielsweise Event-Handler für Dialoge oder Event-Monitore für Dokumente oder Formulare.

Verwandte Themen

Programmbeispiele für Steuerelemente im Dialog-Editor

Funktion CreateUnoListener

Ereigniszuordnung zu Objekten

Siehe auch Dokumentereignisse, Formularereignisse.

Einen Dialog-Handler erstellen

Dokumentereignisse überwachen

Python-Programmierbeispiele