Detektory Pythona: tworzenie detektorów zdarzeń

Spis treści
Indeks 🔎︎

# Tworzenie detektorów zdarzeń

Zdarzenia wywołane przez okna dialogowe, dokumenty, formularze lub kontrolki graficzne można powiązać z makrami, co jest określane jako programowanie sterowane zdarzeniami. Najpopularniejszą metodą powiązania zdarzeń z makrami jest zakładka Zdarzenia w menu Narzędzia - Dostosuj oraz Edytora okien dialogowych, który uruchamia się, wybierając Narzędzia - Makra - Menedżer okien dialogowych.

Artefakty graficzne, dane wprowadzane za pomocą klawiatury, ruchy myszy i inne interakcje człowiek-maszyna mogą być kontrolowane za pomocą detektorów UNO, które obserwują zachowanie użytkownika. Detektory to dynamiczne alternatywy kodu programu dla przypisań makr. Można utworzyć tyle detektorów UNO, ile wydarzeń należy obserwować. Pojedynczy detektor może również obsługiwać wiele kontrolek interfejsu użytkownika.

## Tworzenie detektora zdarzeń

Detekory przywiązują się do kontrolek znajdujących się w oknach dialogowych, a także do zdarzeń dokumentu lub formularza. Detekory są również używane podczas tworzenia okien dialogowych środowiska uruchomieniowego lub podczas dodawania kontrolek do okna dialogowego w locie.

Ten przykład tworzy detektor dla kontrolki Button1 w oknie Dialog1, które jest częścią biblioteki Standard.

### Za pomocą języka 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 = 'Detektory Pythona..'
             _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("Użytkownik potwierdził okno dialogowe.")
                 elif rc == CANCEL:
                     MsgBox("Użytkownik zamknął okno dialogowe.")
                 ui.dispose()  # ui.endExecute
                 ctl.removeActionListener(act)

             def createUnoDialog(libr_dlg: str, embedded=False):
                 """ Twórz okno dialogowe z podanej lokalizacji """
                 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):
                 """ Wykryj i policz kliknięcia przycisku """
                 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):  # metoda obowiązkowa
                     pass

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

             g_exportedScripts = (Main,)

Przykłady detektorów przycisków są dostarczane przez skrypt msgbox.py w katalogu {installation}/program/.

### Za pomocą języka LibreOffice Basic

             Option Explicit

             Const MY_LIBRARY = "Standard", MY_DIALOG = "Dialog1", MY_BUTTON = "Button1"
             Const MY_LABEL = "Detektory Basic.."
             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 "Użytkownik potwierdził okno dialogowe.",, "Basic"
                     Case rc.CANCEL : MsgBox "Użytkownik anulował okno dialogowe.",, "Basic"
                 End Select
                 ui.dispose ' ui.endExecute()
                 ctl.removeActionListener(act)
             End Sub

             Private Sub awt_actionPerformed(evt As com.sun.star.awt.ActionEvent)
                 ''' Słuchaj i zliczaj kliknięcia przycisków '''
                 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
                 ' miejsce na niestandardowy kod
             End Sub ' awt_disposing

## Inne detektory zdarzeń

Odbiorniki są zwykle kodowane wraz z otwieraniem okna dialogowego. Możliwe są liczne podejścia do odbiorników, takie jak programy obsługi zdarzeń dla okien dialogowych lub monitory zdarzeń dla dokumentów lub formularzy.

Tematy pokrewne

Przykłady programowania formantów w edytorze okien dialogowych

CreateUnoListener Function

D'oh! You found a bug (text/swriter/01/05060700.xhp# not found).

Mapowanie zdarzeń na obiekty

Zobacz też Zdarzenia dokumentu, Zdarzenia formularza.

Tworzenie okna dialogowego z modułem obsługi

Nałuchiwanie zdarzeń w dokumencie

Przykłady programowania w Pythonie