Nápověda LibreOffice 25.2
Služba Dialog přispívá ke správě dialogových oken vytvořených v editoru dialogových oken Basicu nebo dialogových oken vytvořených za běhu programu. Každá instance třídy představuje jedno dialogové okno zobrazené uživateli.
Dialogové okno může být zobrazeno v modálním nebo nemodálním režimu.
V modálním režimu se po zobrazení okna pozastaví vykonávání makra, dokud není stisknuto tlačítko OK nebo Zrušit. Mezitím může uživatel spouštět v okně specifické akce.
V nemodálním režimu je okno na pracovní ploše uživatele „plovoucí“ a vykonávání makra normálně pokračuje. Nemodální okno se zavře, pokud je ukončeno metodou Terminate() nebo pokud skončí relace LibreOffice. Tlačítko pro zavření okna je v těchto oknech neaktivní.
Při explicitním zavření je dialogové okno vymazáno z paměti.
Služba SFDialogs.Dialog úzce souvisí se službou SFDialogs.DialogControl.
Před používáním služby Dialog je nutné načíst či naimportovat knihovnu ScriptForge pomocí:
Služba Dialog je vytvořena metodou CreateScriptService. Ta vyžaduje tři dodatečné argumenty určující, jaké dialogové okno se má aktivovat:
Container: "GlobalScope" pro předinstalované knihovny nebo název okna, jak byl definován službou ScriptForge.UI. Výchozí hodnotou je prázdný řetězec "", který znamená aktuální dokument.
Library: Název knihovny obsažené v kontejneru, záleží u něj na velikosti písmen. Výchozí hodnotou je "Standard".
DialogName: Řetězec označující dialogové okno, záleží u něj na velikosti písmen.
V následujících příkladech pro Basic a Python se zobrazí dialogové okno dlgConsole, které je součástí sdílené knihovny ScriptForge:
      Dim oDlg As Object, lButton As Long
      Dim Container As String, Library As String, DialogName As String
      Set oDlg = CreateScriptService("SFDialogs.Dialog", "GlobalScope", "ScriptForge", "dlgConsole")
      ' ... místo pro inicializaci ovládacích prvků...
      lButton = oDlg.Execute()
      ' Výchozí režim je modální
      If lButton = oDlg.OKBUTTON Then
      ' ... Místo pro zpracování ovládacích prvků a provedení potřebných akcí
      End If
      oDlg.Terminate()
  Nebo pomocí Pythonu:
    dlg = CreateScriptService('SFDialogs.Dialog', 'GlobalScope', 'ScriptForge', 'dlgConsole')
    # ... místo pro inicializaci ovládacích prvků...
    rc = dlg.Execute()
    # Výchozí režim je modální
    if rc == dlg.OKBUTTON:
        # ... Místo pro zpracování ovládacích prvků a provedení potřebných akcí
    dlg.Terminate()
  Řetězec "GlobalScope" použije jako argument container v případě, že je dialogové okno uloženo v části nebo .
Služba pro dialogová okna nabízí metody, pomocí nichž lze do již existujících oken, vytvořených v editoru dialogových oken, dynamicky přidávat nové ovládací prvky. Okno je inicializováno s ovládacími prvky nastavenými v editoru a nové prvky lze doplňovat za běhu, a to před i po zavolání Execute().
Službu Dialog je také možné plnohodnotně volat - pomocí metody CreateScriptService - při vytváření dialogových oken za běhu. V tom případě jsou vyžadovány za názvem ad hoc služby "NewDialog" vyžadovány dva dodatečné argumenty:
DialogName: Řetězec označující dialogové okno, záleží u něj na velikosti písmen.
Place: umístění dialogového okna, kterým může být:
pole Array jazyka Basic nebo n-tice jazyka Python se 4 prvky: (X, Y, šířka, výška)
object com.sun.star.awt.Rectangle [X, Y, šířka, výška]
Všechny prvky jsou uvedeny v jednotkách Map AppFont.
    Sub newDialog()
        Dim oDlg As Object
       oDlg = CreateScriptService("NewDialog", "myDialog1", Array(100,200, 40, 110))
       ' ...
    End Sub
  Nebo pomocí Pythonu:
    def newDialog():
       dlg = CreateScriptService('NewDialog', 'myDialog1', (100,200, 40, 110))
       # ... Zpracování ovládacích prvků a provedení potřebných akcí
  Všechny vlastnosti a metody použitelné na předem určená dialogová okna jsou k dispozici také pro tato nová okna, včetně sady metod CreateXXX() přidávajících do okna nové ovládací prvky.
Instanci služby Dialog lze získat pomocí služby SFDialogs.DialogEvent, a to za předpokladu, že dialogové okno bylo službou Dialog vytvořeno. V následujícím příkladu je instanci služby Dialog, která spustila událost dialogového okna, obsažena v proměnné oDlg.
    Sub aDialogEventHander(ByRef poEvent As Object)
        Dim oDlg As Object
        Set oDlg = CreateScriptService("SFDialogs.DialogEvent", poEvent)
        ' ...
    End Sub
  Nebo pomocí Pythonu:
    def control_event_handler(event: uno):
        dlg = CreateScriptService("SFDialogs.DialogEvent", event)
        # ...
  Ve výše uvedených příkladech je možné předponu "SFDialogs." vynechat.
Při vytváření handleru události pro událost dialogového okna je vhodné zpracovávat chyby v samotném podprogramu. Například následující handler je volán tehdy, když je v dialogovém okně stisknuto tlačítko myši.
    Sub OnMouseButtonPressed(ByRef oEvent As Object)
    On Local Error GoTo Catch
        Dim oDialog As Object
        oDialog = CreateScriptService("DialogEvent", oEvent)
        ' Zpracování události
        Exit Sub
    Catch:
        MsgBox SF_Exception.Description
        SF_Exception.Clear
    End Sub
  Volání SF_Exception.Clear použijte, pokud si nepřejete, aby se chyba propagovala.
V Pythonu použijte pro zpracování výjimek nativní bloky try/except, jak ukazuje následující příklad:
    def on_mouse_button_pressed(event=None):
        try:
            dlg = CreateScriptService("DialogEvent", event)
            # Zpracování události
        except Exception as e:
            # Objekt "bas" je instancí služby Basic
            bas.MsgBox(str(e))
  | Název | Pouze pro čtení | Typ | Popis | 
|---|---|---|---|
| OKBUTTON | ano | Integer | Hodnota = 1. Bylo stisknuto tlačítko OK. | 
| CANCELBUTTON | ano | Integer | Hodnota = 0. Bylo stisknuto tlačítko Zrušit. | 
| Caption | ne | String | Určuje popisek dialogového okna. | 
| Height | ne | Long | Určuje výšku dialogového okna. | 
| Modal | ano | Boolean | Určuje, zda je dialogové okno aktuálně v modálním režimu. | 
| Name | ano | String | Název dialogového okna. | 
| Page | ne | Integer | Dialogové okno může mít několik stránek, které uživatel krok za krokem prochází. Vlastnost Page objektu Dialog určuje, která stránka okna je aktivní. | 
| Visible | ne | Boolean | Určuje, zda je dialogové okno na pracovní ploše viditelné. Ve výchozím nastavení je viditelné až po spuštění metody Execute(). | 
| XDialogModel | ano | objekt | Objekt UNO představující model dialogového okna. Podrobné informace naleznete v dokumentaci API na stránkách XControlModel a UnoControlDialogModel. | 
| XDialogView | ano | objekt | Objekt UNO představující pohled (view) dialogového okna. Podrobné informace naleznete v dokumentaci API na stránkách XControl a UnoControlDialog. | 
| Width | ne | Long | Určuje šířku dialogového okna. | 
Vlastnosti On... vracejí řetězec URI s odkazem na skript spuštěný událostí. Je možné tyto vlastnosti nastavit programově.
Jejich specifikaci na wiki stránce v části Scripting framework URI specification.
| Název | Čtení/zápis | Popis v IDE jazyka BASIC | 
|---|---|---|
| OnFocusGained | ano | Při zaměření | 
| OnFocusLost | ano | Při ztrátě zaměření | 
| OnKeyPressed | ano | Klávesa stisknuta | 
| OnKeyReleased | ano | Klávesa uvolněna | 
| OnMouseDragged | ano | Myš se pohnula spolu se stisknutou klávesou | 
| OnMouseEntered | ano | Myš uvnitř | 
| OnMouseExited | ano | Myš vně | 
| OnMouseMoved | ano | Posuv myši | 
| OnMousePressed | ano | Stisknuto tlačítko myši | 
| OnMouseReleased | ano | Uvolněno tlačítko myši | 
Přiřazování událostí pomocí IDE Basicu a pomocí maker se vzájemně vylučuje.
Rozměry dialogových oken jsou nastavovány v jednotkách Map AppFont. Stejné jednotky využívají i modely pro dialogová okna a ovládací prvky, zatímco při jejich zobrazení se používají pixely.
Nastaví aktuální instanci služby Dialog zaměření. V případě úspěšného nastavení vrátí True.
Metoda je volána z události dialogového okna či ovládacího prvku, případně při zobrazení okna v nemodálním režimu.
svc.Activate(): bool
      Dim oDlg As Object
      Set oDlg = CreateScriptService(,, "myDialog")
      oDlg.Execute()
      ' ...
      oDlg.Activate()
   V příkladech v Pythonu i jazyce LibreOffice Basic se předpokládá, že je okno uloženo v aktuálním dokumentu v knihovně Standard.
     dlg = CreateScriptService(,,'myDialog')
     dlg.Execute()
     # ...
     dlg.Activate()
   Zarovná aktuální instanci dialogového okna na střed rodičovského okna. Bez argumentů metoda dialogové okno zarovná na střed aktuálního okna.
V případě úspěšného zarovnání vrátí True.
svc.Center(opt Parent: obj): bool
Parent: Nepovinný objekt, kterým může být:
objekt dialogového okna knihovny ScriptForge
objekt dokumentu (Calc, Base, ...) knihovny ScriptForge
     Sub TriggerEvent(oEvent As Object)
         Dim oDialog1 As Object, oDialog2 As Object, lExec As Long
         Set oDialog1 = CreateScriptService("DialogEvent", oEvent) ' Dialogové okno, které způsobilo událost
         Set oDialog2 = CreateScriptService("Dialog", ...) ' Otevře druhé dialogové okno
         oDialog2.Center(oDialog1)
         lExec = oDialog2.Execute()
         Select Case lExec
             ...
     End Sub
  
     def triggerEvent(event: uno):
       dlg1 = CreateScriptService('DialogEvent.Dialog', event)  # Dialogové okno, které způsobilo událost
       dlg2 = CreateScriptService('Dialog', ...)  # Otevře druhé dialogové okno
       dlg2.Center(dlg1)
       rc = dlg2.Execute()
       if rc is False:
         # ...
   Zduplikuje v dialogovém okně již existující ovládací prvek jakéhokoliv typu. Duplicitní prvek je ponechán beze změny a je možné jej přesunout.
svc.CloneControl(SourceName: str, ControlName: str, Left: num, Top: num): svc
SourceName: Název ovládacího prvku, který se má zduplikovat.
ControlName: Platný název ovládacího prvku jako řetězec, u něhož se rozlišuje velikost písmen. Tento název nesmí být ještě použit.
Left, Top: Souřadnice nového ovládacího prvku vyjádřené v jednotkách Map AppFont.
      Set myButton2 = oDlg.CloneControl("Button1", "Button2", 30, 30)
   
     dlg = dlg.CloneControl('Button1', 'Button2', 30, 30)
   Vrátí:
seznam ovládacích prvků, které dialogové okno obsahuje
nebo instanci třídy DialogControl podle zadaného názvu
svc.Controls(): str[0..*]
svc.Controls(controlname: str): svc
ControlName : Platný název jako řetězec, u něhož záleží na velikost písmen. Není-li zadán, vrátí se seznam názvů ovládacích prvků jako pole začínající od 0.
      Dim myDialog As Object, myList As Variant, myControl As Object
      Set myDialog = CreateScriptService("SFDialogs.Dialog", , "Standard", "Dialog1")
      myList = myDialog.Controls()
      Set myControl = myDialog.Controls("myTextBox")
   
     dlg = CreateScriptService('SFDialogs.Dialog','', 'Standard', 'Dialog1')
     ctrls = dlg.Controls()
     ctrl = dlg.Controls('myTextBox')
   Vytvoří v aktuálním dialogovém okně nový ovládací prvek typu Button.
svc.CreateButton(ControlName: str, Place: any, Toggle: bool = False, Push: str = ""): svc
ControlName: název nového ovládacího prvku. Tento název nesmí být ještě použit.
Place: jedna z možností:
pole Array jazyka Basic nebo n-tice jazyka Python se 4 prvky: (X, Y, šířka, výška)
object com.sun.star.awt.Rectangle [X, Y, šířka, výška]
Všechny prvky jsou uvedeny v jednotkách Map AppFont.
Toggle: je-li True, vytvoří se přepínací tlačítko. Výchozí = False
Push: "OK", "CANCEL" nebo "" (výchozí)
Instance služby SFDialogs.DialogControl nebo Nothing.
     Set myButton = oDlg.CreateButton("Button1", Array(20, 20, 60, 15))
   
     myButton = dlg.CreateButton('Button1', (20, 20, 60, 15))
   Vytvoří v aktuálním dialogovém okně nový ovládací prvek typu CheckBox.
svc.CreateCheckBox(ControlName: str, Place: any, Multiline: bool = False): svc
MultiLine: Je-li True (výchozí = False), popisek se bude moci zobrazit na více než jednom řádku.
     Set myCheckBox = oDlg.CreateCheckBox("CheckBox1", Array(20, 20, 60, 15), MultiLine := True)
   
     myCheckBox = dlg.CreateCheckBox('CheckBox1', (20, 20, 60, 15), MultiLine = True)
   Vytvoří v aktuálním dialogovém okně nový ovládací prvek typu ComboBox.
svc.CreateComboBox(ControlName: str, Place: any, Border: str = "3D", DropDown: bool = True, LineCount: num = 5): svc
Border: "3D" (výchozí), "FLAT" nebo "NONE"
DropDown: Je-li True (výchozí), zobrazí se rozbalovací tlačítko.
LineCount: Určuje maximální počet řádků v rozbalovacím poli (výchozí = 5).
     Set myComboBox = oDlg.CreateComboBox("ComboBox1", Array(20, 20, 60, 15), Dropdown := True)
   
     myComboBox = dlg.CreateComboBox('ComboBox1', (20, 20, 60, 15), Dropdown = True)
   Vytvoří v aktuálním dialogovém okně nový ovládací prvek typu CurrencyField.
svc.CreateCurrencyField(ControlName: str, Place: any, Border ="3D", SpinButton: bool = False, MinValue: num = -1000000, MaxValue: num = +1000000, Increment: num = 1, Accuracy: num = 2): svc
Border: "3D" (výchozí), "FLAT" nebo "NONE"
SpinButton: je-li True (výchozí = False), zobrazí se číselník.
MinValue: nejmenší hodnota, kterou lze do ovládacího prvku zadat. Výchozí = -1000000
MaxValue: největší hodnota, kterou lze do ovládacího prvku zadat. Výchozí = +1000000
Increment: krok při stisknutí číselníku. Výchozí = 1
Accuracy: určuje desetinnou přesnost. Výchozí = 2 desetinná místa
     Set myCurrencyField = oDlg.CreateCurrencyField("CurrencyField1", Array(20, 20, 60, 15), SpinButton := True)
   
     myCurrencyField = dlg.CreateCurrencyField('CurrencyField1', (20, 20, 60, 15), SpinButton = True)
   Vytvoří v aktuálním dialogovém okně nový ovládací prvek typu DateField.
svc.CreateDateField(ControlName: str, Place: any, Border: str = "3D", DropDown: bool = False, opt MinDate: datetime, opt MaxDate: datetime): svc
Border: "3D" (výchozí), "FLAT" nebo "NONE"
DropDown: je-li True (výchozí = False), zobrazí se rozbalovací tlačítko.
MinDate: nejčasnější datum, které lze do ovládacího prvku zadat. Výchozí = 1900-01-01
MaxDate: nejpozdnější datum, které lze do ovládacího prvku zadat. Výchozí = 2200-12-31
     Set myDateField = oDlg.CreateDateField("DateField1", Array(20, 20, 60, 15), Dropdown := True)
   
     myDateField = dlg.CreateDateField('DateField1', (20, 20, 60, 15), Dropdown = True)
   Vytvoří v aktuálním dialogovém okně nový ovládací prvek typu FileControl.
svc.CreateFileControl(ControlName: str, Place: any, Border: str = "3D"): svc
Border: "3D" (výchozí), "FLAT" nebo "NONE"
     Set myFileControl = oDlg.CreateFileControl("FileControl1", Array(20, 20, 60, 15))
   
     myFileControl = dlg.CreateFileControl('FileControl1', (20, 20, 60, 15))
   Vytvoří v aktuálním dialogovém okně nový ovládací prvek typu FixedLine.
svc.CreateFixedLine(ControlName: str, Place: any, Orientation: str): svc
Orientation: použijte "H" pro vodorovnou a "V" pro svislou orientaci.
     Set myFixedLine = oDlg.CreateFixedLine("FixedLine1", Array(20, 20, 60, 15), Orientation := "vertical")
   
     myFixedLine = dlg.CreateFixedLine('FixedLine1', (20, 20, 60, 15), Orientation = 'vertical')
   Vytvoří v aktuálním dialogovém okně nový ovládací prvek typu FixedText.
svc.CreateFixedText(ControlName: str, Place: any, Border: str = "3D", MultiLine: bool = False, Align: str = "LEFT", VerticalAlign: str = "TOP"): svc
Border: "NONE" (výchozí), "FLAT" nebo "3D"
Multiline: Je-li True (výchozí = False), popisek se bude moci zobrazit na více než jednom řádku.
Align: vodorovné zarovnání, "LEFT" (výchozí), "CENTER" nebo "RIGHT"
VerticalAlign: svislé zarovnání, "TOP" (výchozí), "MIDDLE" nebo "BOTTOM"
     Set myFixedText = oDlg.CreateFixedText("FixedText1", Array(20, 20, 60, 15), MultiLine := True)
   
     myFixedText = dlg.CreateFixedText('FixedText1', (20, 20, 60, 15), MultiLine = True)
   Vytvoří v aktuálním dialogovém okně nový ovládací prvek typu FormattedField.
svc.CreateFormattedField(ControlName: str, Place: any, Border: str = "3D", SpinButton: bool = False, MinValue: num = -1000000, MaxValue: num = +1000000): svc
Border: "3D" (výchozí), "FLAT" nebo "NONE"
SpinButton: je-li True (výchozí = False), zobrazí se číselník.
MinValue: nejmenší hodnota, kterou lze do ovládacího prvku zadat. Výchozí = -1000000
MaxValue: největší hodnota, kterou lze do ovládacího prvku zadat. Výchozí = +1000000
     Set myFormattedField = oDlg.CreateFormattedField("FormattedField1", Array(20, 20, 60, 15), SpinButton := True)
   
     myFormattedField = dlg.CreateFormattedField('FormattedField1', (20, 20, 60, 15), SpinButton = True)
   Vytvoří v aktuálním dialogovém okně nový ovládací prvek typu GroupBox.
svc.CreateGroupBox(ControlName: str, Place: any): svc
     Set myGroupBox = oDlg.CreateGroupBox("GroupBox1", Array(20, 20, 60, 15))
   
     myGroupBox = dlg.CreateGroupBox('GroupBox1', (20, 20, 60, 15))
   Vytvoří v aktuálním dialogovém okně nový ovládací prvek typu Hyperlink.
svc.CreateHyperlink(ControlName: str, Place: any, Border: str = "NONE", MultiLine: bool = False, Align: str = "LEFT", VerticalAlign: str = "TOP"): svc
Border: "NONE" (výchozí), "FLAT" nebo "3D"
MultiLine: Je-li True (výchozí = False), popisek se bude moci zobrazit na více než jednom řádku.
Align: vodorovné zarovnání, "LEFT" (výchozí), "CENTER" nebo "RIGHT"
VerticalAlign: svislé zarovnání, "TOP" (výchozí), "MIDDLE" nebo "BOTTOM"
     Set myHyperlink = oDlg.CreateHyperlink("Hyperlink1", Array(20, 20, 60, 15), MultiLine := True)
   
     myHyperlink = dlg.CreateHyperlink('Hyperlink1', (20, 20, 60, 15), MultiLine = True)
   Vytvoří v aktuálním dialogovém okně nový ovládací prvek typu ImageControl.
svc.CreateImageControl(ControlName: str, Place: any, Border: str = "3D", Scale: str = "FITTOSIZE"): svc
Border: "3D" (výchozí), "FLAT" nebo "NONE"
Scale: Jedna z následujících hodnot: "FITTOSIZE" (výchozí), "KEEPRATIO" nebo "NO"
     Set myImageControl = oDlg.CreateImageControl("ImageControl1", Array(20, 20, 60, 15))
   
       myImageControl = dlg.CreateImageControl('ImageControl1", (20, 20, 60, 15))
   Vytvoří v aktuálním dialogovém okně nový ovládací prvek typu ListBox.
svc.CreateListBox(ControlName: str, Place: any, Border: str = "3D", DropDown: bool = True, LineCount: num = 5, MultiSelect: bool = False): svc
Border: "3D" (výchozí), "FLAT" nebo "NONE"
DropDown: Je-li True (výchozí), zobrazí se rozbalovací tlačítko.
LineCount: Určuje maximální počet řádků v rozbalovacím poli (výchozí = 5).
MultiSelect: Je-li True, bude možné vybrat více než 1 položku. Výchozí = False
     Set myListBox = oDlg.CreateListBox("ListBox1", Array(20, 20, 60, 15), Dropdown := True, MultiSelect := True)
   
     myListBox = dlg.CreateListBox('ListBox1', (20, 20, 60, 15), Dropdown = True, MultiSelect = True)
   Vytvoří v aktuálním dialogovém okně nový ovládací prvek typu NumericField.
svc.CreateNumericField(ControlName: str, Place: any, Border: str = "3D", SpinButton: bool = False, MinValue: num = -1000000, MaxValue: num = 1000000, Increment: num = 1, Accuracy: num = 2): svc
Border: "3D" (výchozí), "FLAT" nebo "NONE"
SpinButton: je-li True (výchozí = False), zobrazí se číselník.
MinValue: nejmenší hodnota, kterou lze do ovládacího prvku zadat. Výchozí = -1000000
MaxValue: největší hodnota, kterou lze do ovládacího prvku zadat. Výchozí = +1000000
Increment: krok při stisknutí číselníku. Výchozí = 1
Accuracy: určuje desetinnou přesnost. Výchozí = 2 desetinná místa
     Set myNumericField = oDlg.CreateNumericField("NumericField1", Array(20, 20, 60, 15), SpinButton := True)
   
     myNumericField = dlg.CreateNumericField('NumericField1', (20, 20, 60, 15), SpinButton = True)
   Vytvoří v aktuálním dialogovém okně nový ovládací prvek typu PatternField.
svc.CreatePatternField(ControlName: str, Place: any, Border: str = "3D", EditMask: str, opt LiteralMax: str): svc
Border: "3D" (výchozí), "FLAT" nebo "NONE"
EditMask: znak určující, co může uživatel zadat.
Další informace naleznete na wiki v části Pattern_Field.
LiteralMask: obsahuje výchozí hodnoty, které se v poli zobrazí.
     Set myPatternField = oDlg.CreatePatternField("PatternField1", Array(20, 20, 60, 15), EditMask := "NNLNNLLLLL", LiteralMask := "__.__.2002")
   
     myPatternField = dlg.CreatePatternField('PatternField1', (20, 20, 60, 15), EditMask = 'NNLNNLLLLL', LiteralMask = '__.__.2002')
   Vytvoří v aktuálním dialogovém okně nový ovládací prvek typu ProgressBar.
svc.CreateProgressBar(ControlName: str, opt Place: any, Border: str = "3D", MinValue: num = 0, MaxValue: num = 100): svc
Border: "3D" (výchozí), "FLAT" nebo "NONE"
MinValue: nejmenší hodnota, kterou lze do ovládacího prvku zadat. Výchozí = 0
MaxValue: největší hodnota, kterou lze do ovládacího prvku zadat. Výchozí = 100
     Set myProgressBar = oDlg.CreateProgressBar("ProgressBar1", Array(20, 20, 60, 15), MaxValue := 1000)
   
     myProgressBar = dlg.CreateProgressBar('ProgressBar1', (20, 20, 60, 15), MaxValue = 1000)
   Vytvoří v aktuálním dialogovém okně nový ovládací prvek typu RadioButton.
svc.CreateRadioButton(ControlName: str, Place: any, MultiLine: bool = False): svc
MultiLine: Je-li True (výchozí = False), popisek se bude moci zobrazit na více než jednom řádku.
     Set myRadioButton = oDlg.CreateRadioButton("RadioButton1", Array(20, 20, 60, 15), MultiLine := True)
   
     myRadioButton = dlg.CreateRadioButton('RadioButton1', (20, 20, 60, 15), MultiLine = True)
   Vytvoří v aktuálním dialogovém okně nový ovládací prvek typu ScrollBar.
svc.CreateScrollBar(ControlName: str, Place, Orientation: str, Border: str = "3D", MinValue: num = 0, MaxValue: num = 100): svc
Orientation: použijte "H" pro vodorovnou a "V" pro svislou orientaci.
Border: "3D" (výchozí), "FLAT" nebo "NONE"
MinValue: nejmenší hodnota, kterou lze do ovládacího prvku zadat. Výchozí = 0
MaxValue: největší hodnota, kterou lze do ovládacího prvku zadat. Výchozí = 100
     Set myScrollBar = oDlg.CreateScrollBar("ScrollBar1", Array(20, 20, 60, 15), MaxValue := 1000)
   
     myScrollBar = dialog.CreateScrollBar('ScrollBar1', (20, 20, 60, 15), MaxValue = 1000)
   Vytvoří v aktuálním dialogovém okně nový ovládací prvek typu TableControl.
svc.CreateTableControl(ControlName: str, Place: any, Border: str = "3D", RowHeaders: bool = True, ColumnHeaders: bool = True, ScrollBars: str = "N", GridLines: bool = False): svc
Border: "3D" (výchozí), "FLAT" nebo "NONE"
RowHeaders: je-li True (výchozí), zobrazí se záhlaví řádků.
ColumnHeaders: je-li True (výchozí), zobrazí se záhlaví sloupců.
ScrollBars: možnými hodnotami jsou: "H" nebo "Horizontal" (vodorovný posuvník); "V" nebo "Vertical" (svislý posuvník); "B" nebo "Both" (oba posuvníky); "N" nebo "None" (bez posuvníků; výchozí). Posuvníky se zobrazují dynamicky podle potřeby.
GridLines: je-li True (výchozí = False), mezi buňkami se vykreslí vodorovné a svislé čáry.
     Set myTableControl = oDlg.CreateTableControl("TableControl1", Array(20, 20, 60, 15), ScrollBars := "B")
   
     myTableControl = dlg.CreateTableControl('TableControl1', (20, 20, 60, 15), ScrollBars = 'B')
   Vytvoří v aktuálním dialogovém okně nový ovládací prvek typu TextField.
svc.CreateTextField(ControlName: str, Place: any, Border: str = "3D", MultiLine: bool = False, MaximumLength: num = 0, PasswordCharacter: str = ""): svc
Border: "3D" (výchozí), "FLAT" nebo "NONE"
MultiLine: Je-li True (výchozí = False), popisek se bude moci zobrazit na více než jednom řádku.
MaximumLength: maximální počet znaků (výchozí = 0 znamená neomezený)
PasswordCharacter: jediný znak určující zástupný znak pro textové pole s heslem (výchozí = "")
Set myTextField = oDlg.CreateTextField("TextField1", Array(20, 20, 120, 50), MultiLine := True)
   
     myTextField = dlg.CreateTextField('TextField1', (20, 20, 120, 50), MultiLine = True)
   Vytvoří v aktuálním dialogovém okně nový ovládací prvek typu TimeField.
svc.CreateTimeField(ControlName: str, Place: any, Border: str = "3D", MinTime: num = 0, MaxTime: num = 24): svc
Border: "3D" (výchozí), "FLAT" nebo "NONE"
MinTime: nejmenší hodnota, kterou lze do ovládacího prvku zadat. Výchozí = 0
MaxTime: největší hodnota, kterou lze do ovládacího prvku zadat. Výchozí = 24h
     Set myTimeField = oDlg.CreateTimeField("TimeField1", Array(20, 20, 60, 15))
   
     myTimeField = dlog.CreateTimeField('TimeField1', (20, 20, 60, 15))
   Vytvoří v aktuálním dialogovém okně nový ovládací prvek typu TreeControl.
svc.CreateTreeControl(ControlName: str, Place: any, Border = "3D"): svc
Border: "3D" (výchozí), "FLAT" nebo "NONE"
     Set myTreeControl = oDlg.CreateTreeControl("TreeControl1", Array(20, 20, 60, 15))
   
     myTreeControl = dlg.CreateTreeControl('TreeControl1', (20, 20, 60, 15))
   Ukončí zobrazení modálního dialogového okna a předá zadaný argument do návratové hodnoty aktuálně spuštěné akce Excecute().
Metodu EndExecute() obvykle obsahuje zpracování makra spuštěného událostí dialogového okna či ovládacího prvku.
svc.EndExecute(returnvalue: int)
returnvalue: Hodnota předaná spuštěné metodě Execute().
      Sub OnEvent(poEvent As com.sun.star.lang.EventObject)
          Dim oDlg As Object
          Set oDlg = CreateScriptService("SFDialogs.DialogEvent", poEvent)
          oDlg.EndExecute(ReturnValue := 25)
      End Sub
   
     from com.sun.star.lang import EventObject
     def on_event(event: EventObject):
         dlg = CreateScriptService("SFDialogs.DialogEvent", event)
         dlg.EndExecute(25)
   Výše zmíněný zápis com.sun.star.lang.EventObject je nepovinný. Podobná označení napomáhají identifikovat rozhraní pro programování aplikací (API) pro LibreOffice.
Zobrazí dialogové okno, a pokud je okno modální, počká na jeho zavření uživatelem. Vrácená hodnota je:
0 : stisknuto tlačítko Zrušit
nebo 1 : stisknuto tlačítko OK
Okno je možné zastavit také příkazem EndExecute() spuštěným událostí dialogového okna či ovládacího prvku.
U nemodálních oken vrátí tato metoda vždy hodnotu 0 a bude pokračovat provádění makra.
svc.Execute(modal: bool = True): int
modal: False v případě nemodálního dialogového okna. Výchozí = True.
V tomto příkladu Basicu je okno myDialog uloženo v knihovně Standard v aktuálním dokumentu.
      Dim oDlg As Object, lReturn As Long
      Set oDlg = CreateScriptService("SFDialogs.Dialog", , , "myDialog")
      lReturn = oDlg.Execute(Modal := False)
      Select Case lReturn
          ' ...
      End Select
   Tento kód v Pythonu zobrazí modální dialogového okno DlgConvert se sdílené knihovny Basicu Euro.
     dlg = CreateScriptService("SFDialogs.Dialog", 'GlobalScope', 'Euro', "DlgConvert")
     rc = dlg.Execute()
     if rc == dlg.CANCELBUTTON:
         # ...
   Nahradí všechny textové řetězce dialogového okna jejich přeloženými verzemi z instance služby L10N. Metoda přeloží následující řetězce:
V případě úspěšného nahrazení vrátí metoda True.
Seznam řetězců okna určených k překladu vytvoříte metodou AddTextsFromDialog ze služby L10N.
svc.GetTextsFromL10N(l10n: svc): bool
l10n: Instance služby L10N, ze které se přeložené řetězce získají.
V následujícím příkladu se načtou přeložené řetězce a použijí se na dialogové okno "MyDialog".
     oDlg = CreateScriptService("Dialog", "GlobalScope", "Standard", "MyDialog")
     myPO = CreateScriptService("L10N", "/home/user/po_files/")
     oDlg.GetTextsFromL10N(myPO)
     oDlg.Execute()
   
     dlg = CreateScriptService("Dialog", "GlobalScope", "Standard", "MyDialog")
     myPO = CreateScriptService("L10N", "/home/user/po_files/")
     dlg.GetTextsFromL10N(myPO)
     dlg.Execute()
   Další informace o nakládání se soubory PO a POT naleznete na stránce služby L10N.
Nastaví indexy pro aktivaci ovládacích prvků. Jejich posloupnost je zadána jako pole názvů prvků od prvního po poslední.
Ovládací prvky s indexem >= 1 nejsou přístupné pomocí klávesy TAB v případě, že:
- nejsou uvedeny v zadaném seznamu
 - jsou typu FixedLine, GroupBox nebo ProgressBar
- jsou zakázané
svc.TabsList(TabsList: num, Start: num = 1, Increment: num = 1): bool
TabsList: pole s platnými názvy ovládacích prvků v pořadí aktivace.
Start: index aktivace, který se má přiřadit prvnímu ovládacímu prvku v seznamu. Výchozí = 1
Increment: rozdíl mezi dvěma následujícími indexy pořadí. Výchozí = 1
V případě úspěšného nastavení vrátí True.
     oDlg.OrderTabs(Array("myListBox", "myTextField", "myNumericField"), Start := 10)
   
     dlg.OrderTabs(('myListBox', 'myTextField', 'myNumericField'), Start = 10)
   Přesune levý horní roh dialogového okna na nové souřadnice a/nebo změní rozměry okna. Všechny vzdálenosti jsou udávány v jednotkách AppFont. Bez argumentů tato metoda nastaví výchozí rozměry. V případě úspěšné změny vrátí True.
svc.Resize(opt Left: num, opt Top: num, opt Width: num, opt Height: num): bool
Left: vodorovná vzdálenost od levého horního rohu
Top: svislá vzdálenost od levého horního rohu
Width: šířka obdélníku představujícího dialogové okno
Height: výška obdélníku představujícího dialogové okno
Vynechané argumenty zůstanou nezměněny.
     oDlg.Resize(1000, 2000, Height := 6000) ' Šířka se nezmění
   
     dlg.Resize(1000, 2000, Height = 6000)  # Šířka se nezmění
   Určuje, které ovládací prvky dialogového okna slouží k přepínání stránek. Tím usnadní správu vlastnosti Page dialogového okna a souvisejících ovládacích prvků.
Dialogová okna mohou mít více stránek. Aktuálně zobrazenou stránku určuje vlastnost Page dialogového okna. Pokud tato vlastnost není změněna, výchozí zobrazená stránka bude rovna 0 (nule), což znamená, že nebude stránka nebude určena a zobrazí se všechny viditelné ovládací prvky bez ohledu na to, jako hodnotu mají nastavenu ve svých vlastnostech Page.
Změní-li se vlastnost Page dialogového okna, například na hodnotu 1, 2, 3 atd., zobrazí se pouze ty ovládací prvky, jejichž vlastnost Page aktuální stránce dialogového okna odpovídá.
Metodou SetPageManager je možné určit čtyři typu prvků spravujících stránky:
Seznam nebo pole se seznamem: v tomto případě odpovídá stránce každá položka seznamu či pole se seznamu. První položka odkazuje na stránku 1, druhá na stránku 2 atd.
Skupina přepínačů: to, která stránka je zobrazena, bude určovat skupina přepínačů.
Posloupnost tlačítek: určuje sadu tlačítek, z nichž každé odpovídá stránce dialogového okna. Umístíte-li tlačítka v okně vedle sebe, můžete tím napodobit rozhraní s kartami.
Tlačítka Předchozí/Další: určuje, která tlačítka dialogového okna budou použita pro přechod na předchozí/další stránku.
Je možné použít více způsobů správy stránek zároveň.
Předpokládá se, že se tato metoda bude volat pouze jednou, před voláním metody Execute. Následující volání jsou ignorována.
V případě úspěšného provedení vrátí metoda True.
svc.SetPageManager(pilotcontrols: str = "", tabcontrols: str = "", wizardcontrols: str = "", opt lastpage: int): bool
pilotcontrols: čárkami oddělený seznam názvů ovládacích prvků typu ListBox, ComboBox nebo RadioButton, které se použijí pro správu stránek. U ovládacích prvků typu RadioButton zadejte název prvního prvku skupiny, která se má použít.
tabcontrols: čárkami oddělený seznam názvů tlačítek, která se použijí pro správu stránky. Pořadí, v jakém jsou zadány, odpovídá číslům stránek, ke kterým jsou přiřazeny.
wizardcontrols: čárkou oddělený seznam názvů dvou tlačítek, které se použijí jako tlačítka Předchozí/Další.
lastpage: číslo poslední dostupné stránky. Tuto hodnotu je vhodné zadat při použití správy stránek s tlačítky Předchozí/Další.
Dialogové okno obsahuje tři stránky a ovládací prvek typu ListBox pojmenovaný "aPageList", který se použije k nastavení zobrazené stránky. Kromě toho má dvě tlačítka pojmenovaná "btnPrevious" a "btnNext", která se použijí jako tlačítka Předchozí/Další.
    oDlg.SetPageManager(PilotControls := "aPageList", _
                           WizardControls := "btnPrevious,btnNext", _
                           LastPage := 3)
    oDlg.Execute()
  
    dlg.SetPageManager(pilotcontrols="aPageList",
                       wizardcontrols="btnPrevious,btnNext",
                       lastpage=3)
    dlg.Execute()
  Ukončí službu Dialog pro aktuální instanci. V případě úspěšného ukončení vrátí True.
svc.Terminate(): bool
V níže uvedených příkladech v Basicu a v Pythonu je otevřena dialogová okna DlgConsole a dlgTrace, která jsou uložena ve sdílených knihovnách ScriptForge a Access2Base. Tlačítka pro zavření okna jsou zakázána, a na konci spuštěného procesu je proto okno ukončeno explicitně.
V tomto příkladu je potlačené zavírání okna nahrazeno tlačítkem v DlgConsole:
     oDlg = CreateScriptService("SFDialogs.Dialog","GlobalScope","ScriptForge","DlgConsole")
     oDlg.Execute(modal:=False)
     Wait 5000
     oDlg.Terminate()
   
     from time import sleep
     dlg = CreateScriptService('SFDialogs.Dialog',"GlobalScope",'Access2Base',"dlgTrace")
     dlg.Execute(modal=False)
     sleep 5
     dlg.Terminate()