Aide LibreOffice 25.2
Le service Session rassemble diverses méthodes à usage général concernant :
l'environnement d'installation ou d'exécution
introspection UNO
l'invocation de scripts ou de programmes externes
Avant d'utiliser le service Session, la bibliothèque ScriptForge doit être chargée ou importée :
    GlobalScope.BasicLibraries.LoadLibrary("ScriptForge")
    Dim session As Variant
    session = CreateScriptService("Session")
  
    from scriptforge import CreateScriptService
    session = CreateScriptService("Session")
  Vous trouverez ci-dessous une liste de constantes disponibles pour faciliter la désignation de la bibliothèque contenant un script Basic ou Python à invoquer. Utilisez-les comme session.CONSTANT.
| CONSTANT | Valeur | Où trouver la bibliothèque ? | Applicable | 
|---|---|---|---|
| SCRIPTISEMBEDDED | "document" | dans le document | Basic + Python | 
| SCRIPTISAPPLICATION | "application" | dans n'importe quelle bibliothèque partagée | Basic | 
| SCRIPTISPERSONAL | "user" | dans Mes macros | Python | 
| SCRIPTISPERSOXT | "user:uno_packages" | dans un extension installée pour l'utilisateur actif | Python | 
| SCRIPTISSHARED | "share" | dans Macros d'application | Python | 
| SCRIPTISSHAROXT | "share:uno_packages" | dans une extension installée pour tous les utilisateurs | Python | 
| SCRIPTISOXT | "uno_packages" | dans une extensions dont les paramètres d'installation sont inconnus | Python | 
| Liste des méthodes dans le service Session | ||
|---|---|---|
| 
             ExecuteBasicScript | 
             HasUnoProperty | |
Les méthodes Execute... du service Session se comportent comme suit : 
Les arguments sont passés par valeur. Les modifications apportées par la fonction appelée aux arguments ne mettent pas à jour leurs valeurs dans le script appelant. 
Une valeur unique ou un tableau de valeurs est renvoyé au script appelant.
Exécuter le script BASIC en fonction de son nom et de son emplacement, et récupérer son résultat, le cas échéant.
Si le script ne renvoie rien, ce qui est le cas des procédures définies avec Sub, la valeur retournée est Empty.
session.ExecuteBasicScript(scope: str, script: str, args: any[0..*]): any
scope : chaîne spécifiant où le script est stocké. Il peut s'agir de "document" (constante session.SCRIPTISEMBEDDED) ou "application" (constante session.SCRIPTISAPPLICATION).
script : chaîne spécifiant le script à appeler au format "library.module.method" en tant que chaîne sensible à la casse.
Une bibliothèque est chargée en mémoire si nécessaire.
Le module ne doit pas être un module de classe.
La méthode peut être un Sub ou une Function.
arts : les arguments à passer au script appelé.
Considérez la fonction de base suivante nommée DummyFunction qui est stockée dans "Mes macros" dans la bibliothèque "Standard" à l'intérieur d'un module nommé "Module1".
La fonction prend simplement deux valeurs entières v1 et v2 et renvoie la somme de toutes les valeurs commençant par v1 et se terminant par v2.
    Function DummyFunction(v1 as Integer, v2 as Integer) As Long
        Dim result as Long, i as Integer
        For i = v1 To v2
            result = result + i
        Next i
        DummyFunction = result
    End Function
  Les exemples ci-dessous montrent comment appeler DummyFunction à partir de scripts Basic et Python.
    Dim session : session = CreateScriptService("Session")
    Dim b_script as String, result as Long
    b_script = "Standard.Module1.DummyFunction"
    result = session.ExecuteBasicScript("application", b_script, 1, 10)
    MsgBox result ' 55
  
    session = CreateScriptService("Session")
    bas = CreateScriptService("Basic")
    b_script = 'Standard.Module1.DummyFunction'
    result = session.ExecuteBasicScript('application', b_script, 1, 10)
    bas.MsgBox(result) # 55
  Exécute une fonction Calc en utilisant son nom anglais et en se basant sur les arguments donnés. 
Si les arguments sont des matrices, la fonction est exécutée comme une formule de matrice.
session.ExecuteCalcFunction(calcfunction: str, args: any[0..*]): any
calcfunction : le nom de la fonction Calc à appeler, en anglais.
args : les arguments à passer à la fonction Calc appelée. Chaque argument doit être une chaîne, une valeur numérique ou un tableau de tableaux combinant ces types.
    session.ExecuteCalcFunction("AVERAGE", 1, 5, 3, 7) ' 4
    session.ExecuteCalcFunction("ABS", Array(Array(-1, 2, 3), Array(4, -5, 6), Array(7, 8, -9)))(2)(2) ' 9
    session.ExecuteCalcFunction("LN", -3)
    ' Génère une erreur.
  
    session.ExecuteCalcFunction("AVERAGE", 1, 5, 3, 7) # 4
    session.ExecuteCalcFunction("ABS", ((-1, 2, 3), (4, -5, 6), (7, 8, -9)))[2][2] # 9
    session.ExecuteCalcFunction("LN", -3)
  Exécuter le script Python en fonction de son emplacement et de son nom, récupérer son résultat le cas échéant. Le résultat peut être une valeur unique ou une matrice de valeurs.
Si le script est introuvable, ou s'il ne renvoie rien, la valeur renvoyée est Empty.
session.ExecutePythonScript(scope: str, script: str, args: any[0..*]): any
scope : l'une des constantes applicables répertoriées ci-dessus. La valeur par défaut est session.SCRIPTISSHARED.
script : Soit "library/module.py$method" ou "module.py$method" ou "myExtension.oxt|myScript|module.py$method" comme chaîne sensible à la casse.
library : le chemin de dossier du module Python.
myScript : le dossier contenant le module Python.
module.py : le module Python.
method : la fonction Python.
arts : les arguments à passer au script appelé.
Considérez la fonction Python odd_integers définie ci-dessous qui crée une liste avec des valeurs entières impaires entre v1 et v2. Supposons que cette fonction soit stockée dans un fichier nommé my_macros.py dans le dossier de scripts utilisateur.
    def odd_integers(v1, v2):
        odd_list = [v for v in range(v1, v2 + 1) if v % 2 != 0]
        return odd_list
  Lisez la page d'aide Organisation et emplacement des scripts Python pour en savoir plus sur l'emplacement de stockage des scripts Python.
Les exemples suivants montrent comment appeler la fonction odd_integers à partir de scripts Basic et Python.
    Dim script as String, session as Object
    script = "my_macros.py$odd_integers"
    session = CreateScriptService("Session")
    Dim result as Variant
    result = session.ExecutePythonScript(session.SCRIPTISPERSONAL, script, 1, 9)
    MsgBox SF_String.Represent(result)
  
    session = CreateScriptService("Session")
    script = "my_macros.py$odd_integers"
    result = session.ExecutePythonScript(session.SCRIPTISPERSONAL, script, 1, 9)
    bas.MsgBox(repr(result))
  Renvoie les paramètres d'export PDF actuels définis dans la boîte de dialogue , accessible en choisissant .
Les options d'export définies avec la boîte de dialogue sont conservées pour une utilisation future. Par conséquent, GetPDFExportOptions renvoie les paramètres actuellement définis. En outre, utilisez SetPDFExportOptions pour modifier les options d'export PDF actuelles.
Cette méthode renvoie un objet Dictionary dans lequel chaque clé représente les options d'export et les valeurs correspondantes sont les paramètres d'export PDF actuels.
Lisez la page wiki d'exportation PDF pour en savoir plus sur toutes les options disponibles.
session.GetPDFExportOptions(): obj
    Dim expSettings As Object, msg As String, key As String, optLabels As Variant
    expSettings = session.GetPDFExportOptions()
    optLabels = expSettings.Keys
    For Each key in optLabels
        msg = msg + key & ": " & expSettings.Item(key) & Chr(10)
    Next key
    MsgBox msg
    ' Zoom: 100
    ' Changes: 4
    ' Quality: 90
    ' ...
  Renvoie True si un objet UNO contient la méthode donnée. Renvoie False lorsque la méthode est introuvable ou lorsqu'un argument est invalide.
session.HasUnoMethod(unoobject: uno, methodname: str): bool
unoobject: l'objet à examiner.
methodname : la méthode sous forme de chaîne sensible à la casse
    Dim a As Variant
    a = CreateUnoService("com.sun.star.sheet.FunctionAccess")
    MsgBox session.HasUnoMethod(a, "callFunction") ' True
  
    bas = CreateScriptService("Basic")
    a = bas.CreateUnoService("com.sun.star.sheet.FunctionAccess")
    result = session.HasUnoMethod(a, "callFunction")
    bas.MsgBox(result) # True
  Renvoie True si un objet UNO a la propriété donnée. Renvoie False lorsque la propriété est introuvable ou lorsqu'un argument n'est pas valide.
session.HasUnoProperty(unoobject: uno, propertyname: str): bool
unoobject: l'objet à examiner.
propertyname : la propriété sous forme de chaîne sensible à la casse
    Dim svc As Variant
    svc = CreateUnoService("com.sun.star.sheet.FunctionAccess")
    MsgBox session.HasUnoProperty(svc, "Wildcards")
  
    bas = CreateScriptService("Basic")
    a = bas.CreateUnoService("com.sun.star.sheet.FunctionAccess")
    result = session.HasUnoProperty(a, "Wildcards")
    bas.MsgBox(result) # True
  Ouvrir un Localisateur de ressource universelle (URL) dans le navigateur par défaut.
session.OpenURLInBrowser(url: str)
url: l'URL à ouvrir.
    ' Basic
    session.OpenURLInBrowser("help.libreoffice.org/")
  
    # Python
    session.OpenURLInBrowser("help.libreoffice.org/")
  Exécute une commande système arbitraire et renvoie True si elle a été lancée avec succès.
session.RunApplication(command: str, parameters: str): bool
commande : la commande à exécuter. Il peut s'agir d'un fichier exécutable ou d'un document enregistré auprès d'une application afin que le système sache quelle application lancer pour ce document. Cette méthode démarre indifféremment des scripts .bat ou shell. La commande doit être exprimée dans la notation SF_FileSystem.FileNaming actuelle.
parameters : une liste de paramètres séparés par des espaces sous la forme d'une chaîne unique. La méthode ne valide pas les paramètres donnés, mais les transmet uniquement à la commande spécifiée.
    session.RunApplication("Notepad.exe")
    session.RunApplication("C:\\myFolder\\myDocument.odt")
    session.RunApplication("kate", "/home/user/install.txt") ' GNU/Linux
  
    session.RunApplication("Notepad.exe")
    session.RunApplication(r"C:\\myFolder\\myDocument.odt")
    session.RunApplication("kate", "/home/user/install.txt") # GNU/Linux
  Envoyer un message - avec des pièces jointes facultatives - aux destinataires à partir du client de messagerie de l'utilisateur. Le message peut être modifié par l'utilisateur avant l'envoi ou, alternativement, être envoyé immédiatement.
session.SendMail(recipient: str, cc: str = '', bcc: str = '', subject: str = '', body: str = '', filenames: str = '', editmessage: bool = True)
recipient : une adresse e-mail (le destinataire "À").
cc : une liste d'adresses e-mail séparées par des virgules (les destinataires en "copie carbone").
bcc : une liste d'adresses e-mail séparées par des virgules (les destinataires de la "copie carbone invisible").
subject: l'entête du message.
body : le contenu du message sous forme de texte non formaté.
filenames : une liste de noms de fichiers séparés par des virgules. Chaque nom de fichier doit respecter la notation SF_FileSystem.FileNaming.
editmessage : lorsque True (par défaut), le message est modifié avant d'être envoyé.
    session.SendMail("someone@example.com" _
        , Cc := "b@other.fr, c@other.be" _
        , FileNames := "C:\myFile1.txt, C:\myFile2.txt")
  
    session.SendMail("someone@example.com",
                     cc="john@other.fr, mary@other.be"
                     filenames=r"C:\myFile1.txt, C:\myFile2.txt")
  Modifie les paramètres d'export PDF définis dans la boîte de dialogue , accessible en choisissant .
L'appel de cette méthode modifie les valeurs réelles définies dans la boîte de dialogue , qui sont utilisées par la méthode ExportAsPDF du service Document.
Cette méthode renvoie True en cas de succès.
Lisez la page wiki d'exportation PDF pour en savoir plus sur toutes les options disponibles.
session.SetPDFExportOptions(pdfoptions: obj): bool
pdfoptions : objet Dictionary qui définit les paramètres d'export PDF à modifier. Chaque paire clé-valeur représente une option d'export et la valeur qui sera définie dans la boîte de dialogue.
L'exemple suivant modifie la résolution d'image maximale à 150 ppp et exporte le document actuel sous forme de fichier PDF.
    Dim newSettings As Object, oDoc As Object
    Set oDoc = CreateScriptService("Document")
    Set newSettings = CreateScriptService("Dictionary")
    newSettings.Add("ReduceImageResolution", True)
    newSettings.Add("MaxImageResolution", 150)
    session.SetPDFExportOptions(newSettings)
    oDoc.ExportAsPDF("C:\Documents\myFile.pdf", Overwrite := True)
  Renvoie une liste des méthodes appelables depuis un objet UNO. La liste est une matrice de chaînes de base zéro et peut être vide.
session.UnoMethods(unoobject: uno): str[0..*]
unoobject: l'objet à examiner.
    Dim svc : svc = CreateUnoService("com.sun.star.sheet.FunctionAccess")
    Dim methods : methods = session.UnoMethods(svc)
    Dim msg as String
    For Each m in methods
        msg = msg & m & Chr(13)
    Next m
    MsgBox msg
  
    bas = CreateScriptService("Basic")
    a = bas.CreateUnoService("com.sun.star.sheet.FunctionAccess")
    methods = session.UnoMethods(a)
    msg = "\n".join(methods)
    bas.MsgBox(msg)
  Renvoie une liste des propriétés d'un objet UNO. La liste est une matrice de chaînes de base zéro et peut être vide.
session.UnoProperties(unoobject: uno): str[0..*]
unoobject: l'objet à examiner.
    Dim svc As Variant
    svc = CreateUnoService("com.sun.star.sheet.FunctionAccess")
    MsgBox SF_Array.Contains(session.UnoProperties(svc), "Wildcards") ' True
  
    bas = CreateScriptService("Basic")
    svc = bas.CreateUnoService("com.sun.star.sheet.FunctionAccess")
    properties = session.UnoProperties(a)
    b = "Wildcards" in properties
    bas.MsgBox(str(b)) # True
  Identifiez le type d'un objet UNO sous forme de chaîne.
session.UnoObjectType(unoobject: uno): str
unoobject: l'objet à examiner.
    Dim svc As Variant, txt As String
    svc = CreateUnoService("com.sun.star.system.SystemShellExecute")
    txt = session.UnoObjectType(svc) ' "com.sun.star.comp.system.SystemShellExecute"
    svc = CreateUnoStruct("com.sun.star.beans.Property")
    txt = session.UnoObjectType(svc) ' "com.sun.star.beans.Property"
  
    bas = CreateScriptService("Basic")
    svc = bas.CreateUnoService("com.sun.star.system.SystemShellExecute")
    txt = session.UnoObjectType(svc) # "com.sun.star.comp.system.SystemShellExecute"
    svc = bas.CreateUnoService("com.sun.star.beans.Property")
    txt = session.UnoObjectType(svc) # "com.sun.star.beans.Property"
  Récupérez du contenu web à partir d'une URI.
session.WebService(uri: str): str
uri : le texte URI d'un service web.
    session.WebService("wiki.documentfoundation.org/api.php?" _
        & "hidebots=1&days=7&limit=50&action=feedrecentchanges&feedformat=rss")
  
    session.WebService(("wiki.documentfoundation.org/api.php?" 
                       "hidebots=1&days=7&limit=50&action=feedrecentchanges&feedformat=rss"))