Listener Python: creazione di listener di eventi

Contenuto

# Creazione di listener di eventi

Gli eventi generati da finestre di dialogo, documenti, formulari o controlli grafici si possono collegare a macro, a cui ci si può riferire come programmazione controllata da eventi. Il metodo più comune per collegare eventi alle macro è utilizzare la scheda Eventi nel menu Strumenti – Personalizza e il pannello delle proprietà dei controlli dell'Editor delle finestre di dialogo dal menu Strumenti - Macro – Organizza finestre di dialogo....

Gli artefatti grafici, gli input di tastiera, i movimenti del mouse e altre interazioni uomo/macchina possono essere controllati mediante listener UNO che "ascoltano" il comportamento dell'utente. I listener sono alternative di codice di programmazione dinamica alle assegnazioni macro. Si possono creare tanti listener UNO quanti sono gli eventi da ascoltare. Un listener singolo può anche gestire più controlli di interfaccia utente.

## Creazione di un listener di eventi

Listener vengono allegati ai controlli contenuti negli eventi contenuti nelle finestre di dialogo, nel documento o nei formulari. I listener vengono utilizzati anche quando si creano finestre di dialogo al tempo di esecuzione o quando si aggiungono al volo controlli a una finestra di dialogo.

Questo esempio crea un listener per il controllo Button1 della finestra di dialogo Dialog1 nella libreria Standard.

### Con 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 è in ascolto..'
             _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("L'utente ha dato l'ok alla finestra di dialogo.")
                 elif rc == CANCEL:
                     MsgBox("L'utente ha annullato la finestra di dialogo.")
                 ui.dispose()  # ui.endExecute
                 ctl.removeActionListener(act)

             def createUnoDialog(libr_dlg: str, embedded=False):
                 """ Creare una finestra di dialogo dalla sua posizione """
                 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):
                 """ Ascoltare e conteggiare i clic dei pulsanti """
                 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):  # routine obbligatoria
                     pass

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

             g_exportedScripts = (Main,)

il file msgbox.py nella cartella {installation}/program/ contiene alcuni esempi di listener dei pulsanti.

### Con LibreOffice Basic

             Option Explicit

             Const MY_LIBRARY = "Standard", MY_DIALOG = "Dialog1", MY_BUTTON = "Button1"
             Const MY_LABEL = "Basic è in ascolto.."
             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 "L'utente ha dato l'ok alla finestra di dialogo.",, "Basic"
                     Case rc.CANCEL : MsgBox "L'utente ha annullato la finestra di dialogo.",, "Basic"
                 End Select
                 ui.dispose ' ui.endExecute()
                 ctl.removeActionListener(act)
             End Sub

             Private Sub awt_actionPerformed(evt As com.sun.star.awt.ActionEvent)
                 ''' Ascoltare e conteggiare i clic dei pulsanti '''
                 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
                 ' il vostro codice va qui
             End Sub ' awt_disposing

## Altri listener di eventi

I listener sono in genere codificati insieme con l'apertura della finestra di dialogo. Sono possibili numerosi approcci di listener, come i gestori degli eventi per le finestre di dialogo o il monitor degli eventi per i documenti o i formulari.

Argomenti correlati

Esempi di programmazione per i campi di controllo nell'editor delle finestre di dialogo

Funzione CreateUnoListener

Mappatura di eventi agli oggetti

Vedere anche Eventi del documento, Eventi del formulario.

D'oh! You found a bug (text/sbasic/python/python_handler.xhp#pythonhandler_h1 not found).

Ascolto degli eventi del documento

Esempi di programmazione in Python