Python Listeners : Aanmaken

Inhoud

# Listeners aanmaken

Een gebeurtenis die door een dialoog, document, formulier of een afbeelding optreedt kan aan een macro worden gekoppeld, dit wordt event-driven programmeren genoemd. Men maakt dan meestal een relatie tussen een gebeurtenis en een macro aan via het tabblad Gebeurtenissen in het menu Extra – Aanpassen en het paneel Dialoog-editor in Extra - Macro's – Dialoogvensters beheren... menu.

Met UNO-listeners kan men invoer via toetsenbord, muisbewegingen en andere vormen van invoer door de gebruiker controleren. Een listener is een dynamische programma en een alternatief voor een koppeling aan een macro. U kunt zoveel UNO-listeners aanmaken als u gebeurtenissen hebt die u wilt afvangen. Een enkele listener kan ook meerdere invoeracties van gebruikers afvangen.

## Een listener voor het afhandelen van gebeurtenissen aanmaken

Listeners worden gekoppeld aan controles in dialogen, documenten of formuliergebeurtenissen. Listeners worden ook gebruikt voor het aanmaken van runtime dialogen en bij het dynamisch toevoegen van controles aan een dialoog.

In dit voorbeeld wordt een listener aangemaakt voor het controleren van een knop Button in een dialoog Dialog1 in de Standaard bibliotheek.

### Met 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 luistert..'
             _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("De gebruiker heeft de dialoog bevestigd.")
                 elif rc == CANCEL:
                     MsgBox("De gebruiker heeft de dialoog geannuleerd.")
                 ui.dispose()  # ui.endExecute
                 ctl.removeActionListener(act)

             def createUnoDialog(libr_dlg: str, embedded=False):
                 """ Een dialoog aanmaken vanaf de locatie """
                 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):
                 """ Afvangen en tellen aantal klikken op een knop """
                 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):  # verplichte routine
                     pass

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

             g_exportedScripts = (Main,)

msgbox.py in map {installation}/program/ bevat voorbeelden van listeners naar knoppen.

### Met LibreOfficeDev BASIC

             Option Explicit

             Const MY_LIBRARY = "Standard", MY_DIALOG = "Dialog1", MY_BUTTON = "Button1"
             Const MY_LABEL = "BASIC luistert.."
             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 "De gebruiker heeft de dialoog bevestigd.",, "Basic"
                     Case rc.CANCEL : MsgBox "De gebruiker heeft de dialoog geannuleerd.",, "Basic"
                 End Select
                 ui.dispose ' ui.endExecute()
                 ctl.removeActionListener(act)
             End Sub

             Private Sub awt_actionPerformed(evt As com.sun.star.awt.ActionEvent)
                 ''' Afvangen en tellen aantal klikken op een knop '''
                 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
                 ' hier komt uw code
             End Sub ' awt_disposing

## Andere Listeners

Listeners worden meestal gecodeerd bij het openen van een dialoog. De aanpak kan verschillen, er zijn handlers voor gebeurtenissen in een dialoog mogelijk maar het monitoren van gebeurtenissen in een document of formulier.

Verwante onderwerpen

Programmeervoorbeelden voor besturingselementen in de dialoogeditor

CreateUnoListener

Gebeurtenissen toewijzen aan objecten

Zie ook Documentgebeurtenissen, Formuliergebeurtenissen.

Een dialog-handler aanmaken

Documentgebeurtenissen monitoren

Python programmeringsvoorbeelden

Help ons, alstublieft!