Difference between revisions of "FR/Documentation/Python/Transfer from Basic to Python"

Latest revision as of 17:24, 16 December 2016

Translation Español

Si vous ressentez un certain mécontentement/manque avec OpenOffice Basic ou si vous souhaitez créer des composants UNO personnalisés, il est maintenant temps de transférer l'environnement de codage de Basic vers Python.

En Basic, le cadre d'exécution fournit des procédures/fonctions pour faire un certain nombre de choses. Mais en utilisant la passerelle Python-UNO , vous devrez faire cette tâche par des moyens API.

Commençons par le didacticiel Python et revenons à ce chapitre lorsque vous avez appris un peu sur le langage Python.

Emplacement des macros

Sur la version actuelle, l'organisateur de script pour Python ne fournit pas d'outil pour gérer les fichiers de script. Donc vous devez les gérer vous-même (où avec l'extension apso ). Les macros écrites en Python doivent être placées dans le répertoire spécifique sous le profil de votre utilisateur, le profil partagé ou le répertoire de script de votre document.

Le répertoire python (en minuscules) doit être créé dans le répertoire Scripts et vous pouvez y mettre vos scripts python contenant le code python.

chemin utilisateur /Scripts/python/votre_fichiere.py

Vous pouvez créer des sous-répertoires pour y mettre des fichiers de macro sous le répertoire Scripts / python

Vous devez ajouter l'extension de fichier "py" à votre nom de fichier.

Editeur Macro

Il n'existe pas d'éditeur intégré dédié au code en Python. Mais vous pouvez choisir votre éditeur de texte préféré pour modifier vos scripts Python.

Ceci est discuté dans une autre page.

Un court exemple

Voici un petit exemple écrit en Python.

def hello():
    XSCRIPTCONTEXT.getDocument().getText().setString("Bonjour !")

Chaque fonction appelable est une unité exécutable de la macro Python (vous pouvez choisir quelle fonction doit être listée dans l'interface graphique, voir autre document).

Vous pouvez accéder au document en cours via la méthode getDocument de la variable XSCRIPTCONTEXT du module. Cette macro change le contenu du document Writer à "Bonjour!" .

Utiliser des modules

 import uno
 
 import unohelper

Contexte de script

OoBasic est un runtime embarqué et il fonctionne toujours avec l'instance active du bureau. Donc le contexte est toujours couplé avec celui du bureau. Mais la passerelle Python-UNO fournit la façon de travailler en tant que client RPC (Remote Procedure Call). À ce moment, l'instance distante de Python a un contexte différent de l'instance de bureau. Par conséquent, vous devez utiliser le contexte de composant correct pour indiquer à la fabrique de composants multiples d'instancier un service.

Dans OoBasic, aucun objet correspondant n'a été fourni.

En macro Python,vous devez utiliser la variable de module XSCRIPTCONTEXT qui fournit l'interface com.sun.star.script.provider.XScriptContext.

• com.sun.star.frame.XModel getDocument()

Renvoie l'objet Document.

• com.sun.star.document.XScriptInvocationContext getInvocationContext()

Renvoie l'objet dépendant de l'invocation.

• com.sun.star.frame.XDesktop getDesktop()

Renvoie une instance du service com.sun.star.frame.Desktop.

• com.sun.star.uno.XComponentContext getComponentContext()

Retourne le contexte de composant courant qui est utilisé pour indiquer le contexte.

Garder en tête que la variable XSCRIPTCONTEXT est définie au niveau du module et n'est pas fournie aux modules importés depuis votre script.

Contexte de composant

En OoBasic, vous pouvez obtenir le contexte de composant comme suit:

 ctx = GetDefaultContext()

Mais vous n'avez pas besoin d'y accéder jusqu'à ce que vous ayez besoin d'obtenir des singletons.

En Python, vous pouvez accéder au contexte du composant à travers le contexte du script.

 ctx = XSCRIPTCONTEXT.getComponentContext()

Vous avez besoin de cette valeur pour instancier les services.

Gestionnaire de services

En OoBasic, vous pouvez obtenir le gestionnaire de services comme suit:

 smgr = GetProcessServiceManager()

Mais peu de gens y ont accès.

En Python, cette instance est la valeur la plus importante pour instancier les services et travailler avec les API du bureau.

 ctx = XSCRIPTCONTEXT.getComponentContext()
 smgr = ctx.getServiceManager()

Vous avez besoin à la fois du contexte des composants et du gestionnaire de services pour instancier les services.

Instance de service

En OoBasic, vous pouvez instancier les services par fonction intégrée comme suit:

 sfa = CreateUnoService("com.sun.star.ucb.SimpleFileAccess")

ou avec les arguments d'initialisation:

 arg = com.sun.star.ui.dialogs.TemplateDescription.FILESAVE_SIMPLE
 file_picker = CreateUnoServiceWithArguments("com.sun.star.ui.dialogs.FilePicker", Array(arg))

IEn Python, vous devez travailler avec l'interface com.sun.star.lang.XMultiComponentFactory comme suit:

 ctx = XSCRIPTCONTEXT.getComponentContext()
 smgr = ctx.getServiceManager()
 sfa = smgr.createInstanceWithContext("com.sun.star.ucb.SimpleFileAccess", ctx)

Si vous devez initialiser l'instance, utilisez la méthode createInstanceWithArgumentsAndContext:

 from com.sun.star.ui.dialogs.TemplateDescription import FILESAVE_SIMPLE
 file_picker = smgr.createInstanceWithArgumentsAndContext("com.sun.star.ui.dialogs.FilePicker", (FILESAVE_SIMPLE,) ctx)

Ou initialiser après l'instanciation:

 file_picker = smgr.createInstanceWithContext("com.sun.star.ui.dialogs.FilePicker", ctx)
 file_picker.initialize((FILESAVE_SIMPLE,))

Service avec Constructeur

En OoBasic, vous pouvez appeler la construction de service à partir de son module:

 shell_execute = com.sun.star.system.SystemShellExecute.create()

Dans Python, vous devez l'instancier avec la méthode XMultiComponentFactory::createInstanceWithArgumentsAndContext avec des arguments initiaux ou affecter après l'instanciation.

L'appel du constructeur effectue la vérification de type avant de passer les arguments à la méthode createInstanceWithArgumentsAndContext.

Document en cours

En OoBasic, la fonction d'exécution ThisComponent fournit l'accès au document courant:

 doc = ThisComponent

Sa valeur de retour est liée à l'emplacement de macro. Si la macro stockée dans un document, le résultat de ThisComponent est le document auquel le stockage de la macro appartient. Et si votre macro est stockée dans l'application (au sens large, la valeur renvoyée est le modèle de document de la trame actuellement active, c'est le même résultat issu de StarDesktop. GetCurrentComponent (). En Python, vous pouvez accéder au document actuel à travers le contexte du script:

 doc = XSCRIPTCONTEXT.getDocument()

Si votre macro est incorporée dans le document, le modèle de document correspond au document dans lequel la macro est stockée. Si votre macro est stockée dans l'espace utilisateur ou l'emplacement partagé, l'objet de document vient du cadre actif.

Bureau (Desktop)

En OoBasic, la fonction runtime StarDesktop est fournie:

 desktop = StarDesktop()

En Python, Vous pouvez accéder au bureau via le contexte du script:

 desktop = XSCRIPTCONTEXT.getDesktop()

Instance de Structure

En Basic, l'instance de struct peut être instanciée de deux façons:

 Dim a As New com.sun.star.awt.Point
 a = CreateUnoStruct("com.sun.star.awt.Point")

Avec l'instruction Dim et le nouveau mot-clé, vous pouvez instancier une structure ou un tableau de structures. Ou la méthode CreateUnoStruct fournit la manière d'instancier une structure au moment de l'exécution. Vous ne pouvez pas initialiser l'instance lors de la création, vous devez définir la valeur de ses membres.

En Python, vous pouvez utiliser les méthodes suivantes pour instancier une structure. Importer la classe struct et l'appeler.

 from com.sun.star.awt import Point
 
 a = Point()         # Instancie avec les valeurs par défaut, X=0, Y=0
 b = Point(100, 200) # Initialiser avec les valeurs initiales, X=100, Y=200

En appelant la classe pour créer une nouvelle instance de la structure, vous pouvez vider ses arguments, ou bien vous devez passer des valeurs pour tous les champs. En d'autres termes, vous ne pouvez pas passer un nombre insuffisant d'arguments à initialiser. Et son ordre doit correspondre à la définition de la structure dans son IDL. Par exemple, instance de struct b ayant X = 100 et Y = 200 dans le code ci-dessus.

Vous pouvez initialiser sans importer la classe de votre structure cible avec la fonction uno.createUnoStruct comme suit:

 import uno
 
 a = uno.createUnoStruct("com.sun.star.awt.Point")
 b = uno.createUnoStruct("com.sun.star.awt.Point", 100, 200)

Cela donne le même résultat avec l'exemple ci-dessus. Le premier paramètre de la méthode createUnoStruct est le nom de la structure à initialiser. Les arguments suivants sont des valeurs initiales pour la nouvelle instance.

Enumérations (Enum)

Dans Basic, vous pouvez accéder aux variables énumérées comme suit:

 ITALIC = com.sun.star.awt.FontSlant.ITALIC

En Python, Les moyens suivants peuvent être utilisés:

 import uno
 
 from com.sun.star.awt.FontSlant import ITALIC
 ITALIC = uno.getConstantByName("com.sun.star.awt.FontSlant.ITALIC")
 ITALIC = uno.Enum("com.sun.star.awt.FontSlant", "ITALIC")

Tout le chemin résulte de l'instance de la classe uno.Enum.

Constantes

En OoBasic, vous pouvez accéder aux constantes via leur module:

 BOLD = com.sun.star.awt.FontWeight.BOLD

En Python, les moyens suivants sont fournis:

 import uno
 
 from com.sun.star.awt.FontWeight import BOLD
 BOLD = uno.getConstantsByName("com.sun.star.awt.FontWeight.BOLD")

Sequence

La séquence est une suite de valeurs séquentielles du même type.

En OoBasic, array est utilisé.

En Python, le tuple est choisi pour représenter une séquence UNO. Note, la liste n'est pas autorisée à passer comme valeur de séquence.

Booléén (Boolean)

En Python, True or False (Vrai ou Faux).

Chaînes (String)

Une chaîne Python peut contenir au plus 64K octets.

Si vous devez écrire des caractères non Ascii 7 bits dans votre script, écrivez un commentaire magique à la tête de votre fichier. Ce sont des instructions Python standard.

 # -*- coding: utf_8 -*-

Veuillez lire la documentation Python pour plus de détails.

Vous devez utiliser des chaînes unicode pour écrire quelques caractères unicode dans Python 2.X. Et les chaînes provenant d'UNO sont encodées en unicode dans Python 2.X.

Caractères (Char)

Il n'y a pas de valeur dédiée pour le type de char dans OoBasic.

En Python, la classe uno.Char class est définie pour le type Char.

 import uno
 c = uno.Char("a")

Type

Le type "Type" est le type méta de UNO qui représente le type d'UNO. Depuis 3.4, si vous passez la valeur chaîne à la méthode comme un argument qui doit être type, la passerelle Basic le lira comme type.

oMap = com.sun.star.container.EnumerableMap.create("string", "string")

Dans Python, les méthodes suivantes peuvent être utilisées pour créer une nouvelle valeur de type.

 import uno
 t = uno.getTypeByName("string")
 t = uno.Type("string", uno.Enum("com.sun.star.uno.TypeClass", "STRING"))

Séquence d'octets (Byte sequence)

La séquence d'octets est une séquence de type octet.

Dans Basic, un tableau d'octet est utilisé pour la représenter

En Python, elle est représentée par str enenglobé par la classe uno.ByteSequence. Si vous prenez des séquences d'octets de UNO, elles sont l'instance de uno.ByteSequence. Si vous avez besoin d'en obtenir une valeur réelle, reportez-vous à sa variable d'instance value .

Exception

Dans StarBasic, vous obtenez une exception lancée comme une erreur. Et l'instruction On Error est utilisée pour la récupérer.

 Sub ErrorExample
 
   On Error GoTo Handler
 
   ' ... error
 
   Exit Sub
 
   Handler: 
 
 End Sub

Et vous ne pouvez pas envoyer d'exceptions à OoBasic.

En Python, l'exception lancée dans le monde UNO peut être traitée comme une exception de Python normale. Voici un exemple:

 from com.sun.star.container import IndexOutOfBoundsException
 
 try:
     obj.getByIndex(100) # soulève IndexOutOfBoundsException
 except IndexOutOfBoundsException as e:
     print(e)

Si la méthode getByIndex soulève IndexOutOfBoundsException, elle peut être prise dans l'instruction except, car toutes les exceptions héritent de la classe Exception de Python.

Et vous pouvez également lancer l'exception UNO à partir de votre code Python comme suit:

 from com.sun.star.uno import RuntimeException
 raise RuntimeException("Some message", None)

Valeur Vide (Empty)

En Basic, il existe certaines situations où l'on peut rencontrer des variables qui ne contiennent aucune valeur (ce qui n'est pas correct). Nul, vide, manquant, rien et ainsi de suite.

Dans Python, None est utilisé. Si une méthode définit comme valeur de retour "vide" dans sa définition, elle produit None si vous l'appelez. Si vous avez besoin de passer l'interface non valide comme un argument pour la méthode qui prend une certaine interface, envoyez lui None. Le résultat de ce comportement dépend entièrement de la mise en œuvre de la méthode.

Auditeur (Listener) et Interface

En OoBasic, vous pouvez créer un nouvel auditeur en utilisant la fonction d'exécution CreateUnoListener avec certaines sous-routines ou fonctions.

 Sub Add
 
   d = CreateUnoDialog(DialogLibraries.Standard.Dialog1)
   listener = CreateUnoListener("ActionListener", "com.sun.star.awt.XActionListener")
   d.getControl("CommandButton1").addActionListener(listener)
   d.execute()
   d.dispose()
 
 End Sub
 
 
 Sub ActionListener_actionPerformed(ev)
 
 End Sub
 
 Sub ActionListener_disposing(ev)
 
 End Sub

En Python, vous devez définir votre propre classe avec les interfaces souhaitées. Avec la classe helper, vous pouvez définir facilement comme suit:

 import unohelper
 
 from com.sun.star.awt import XActionListener
 
 class ActionListener(unohelper.Base, XActionListener):
     def __init__(self):
         pass
 
     def disposing(self, ev):
         pass
 
     def actionPerformed(self, ev):
         pass

La classe unohelper.Base fournit l'interface requise pour les composants UNO.

Conteneurs (Containers)

En OoBasic, l'objet conteneur fournit la façon d'accéder à son contenu de manière séquentielle.

En Python, aucun raccourci n'est fourni.

Si vous devez accéder aux éléments du conteneur indexé, utilisez la fonction de plage (range) pour générer des index séquentiels.

 for i in range(container.getCount()):
     obj = container.getByIndex(i)

URL et chemin Système

Si vous travaillez avec un fichier stocké dans votre système de fichiers local, vous devez obtenir son URL correspondante.

En OoBasic, la fonction d'exécution ConvertToURL est préparée pour cette tâche. Et il y a la fonction d'exécution ConvertFromURL pour la conversion inverse.

En Python, les fonctions suivantes sont définies dans un module pour cette tâche.

 import uno
 
 path = "/home/foo/Documents/file.odt"
 url = uno.systemPathToFileUrl(path)
 path = uno.fileUrlToSystemPath(url)

Arguments et valeur de retour

Dans StarBasic, le mode du premier argument de la méthode parseStrict est "inout" dans le code suivant:

 aURL = CreateUnoStruct("com.sun.star.util.URL")
 aURL.Complete = ".uno:Paste"
 CreateUnoService("com.sun.star.util.URLTransformer").parseStrict(aURL)

Le contenu de la variable aURL est mis à jour après avoir appelé la méthode.

En Python, le paramètre mode sortie est renvoyé en tant que partie de la valeur de retour.

 from com.sun.star.util import URL
 
 aURL = URL()
 aURL.Complete = ".uno:Paste"
 dummy, aURL = smgr.createInstanceWithContext("com.sun.star.util.URLTransformer", ctx).parseStrict(aURL)
 # Définition de com.sun.star.util.XURLTransformer::parseStrict method: 
 # void parseStrict([inout] com.sun.star.util.URL aURL);

Si une méthode a le mode out dans ses paramètres, son retour est toujours un tuple qui contient la valeur de retour d'origine et les valeurs pour les paramètres de sortie.

Voici un exemple possible:

 # boolean getSomeValue([in] string aName, [out] short aNum, [inout] long aNum2);
 result, num, num2 = obj.getSomeValue("foo", 100, 200)

Dans l'exemple ci-dessus, la variable result prend la valeur de retour d'origine, num prend la valeur de sortie pour le second paramètre et num2 prend la valeur de sortie pour le troisième paramètre. La méthode prend 100 comme deuxième paramètre mais elle n'est pas utilisée comme entrée de valeur. Aucune entrée dans le tuple retourné pour le paramètre mode in.

Fonctions à Executer

En Basic, vous ne pouvez pas choisir les routines à exécuter par les utilisateurs.

En Python, définissez la variable ' 'g_exportedScripts qui contient le tuple de fonctions 'appelables' dans votre fichier de macros.

 def func_a(): pass
 def func_b(): pass
 def func_hidden(): pass # pas visible dans l'interface utilisateur
 
 g_exportedScripts = func_a, func_b

Dans le code ci-dessus, func_hidden n'est pas affiché dans la boîte de dialogue d'exécution des macros.

Importer des Modules

En Basic, vous pouvez appeler des sous-programmes définis dans d'autres modules ou d'autres bibliothèques qui ont été chargées.

BasicLibraries.loadLibrary("Library1")
Library1.Foo()

 - Scripts/
   - python/
     - macro.py
     - pythonpath/  # Ce répertoire est ajouté automatiquement avant l'exécution de la macro
       - your_module.py  # ce module sera trouvé

Lorsque vous exécutez la macro à partir de votre fichier de script, l'exécuteur interne ajoute le répertoire pythonpath / à la liste sys.path pour être utilisé comme un emplacement de recherche.

S'il vous plaît gardez à l'esprit, le nom du module sera en conflit conflit si vous avez un module de même nom dans un autre endroit, c'est le mécanisme standard python de l'importation des modules, mettre vos modules dans une bibliothèque de nom différent pour éviter le conflit de nom.

Dialogues

En Basic, il existe la fonction d'exécution CreateUnoDialog pour instancier la boîte de dialogue.

 DialogLibraries.loadLibrary("Standard")
 dialog = CreateUnoDialog(DialogLibraries.Standard.Dialog1)
 dialog.execute()
 dialog.dispose()

 def dialog_example():
     ctx = XSCRIPTCONTEXT.getComponentContext()
     smgr = ctx.getServiceManager()
     dp = smgr.createInstanceWithContext("com.sun.star.awt.DialogProvider", ctx)
     dialog = dp.createDialog("vnd.sun.star.script:Standard.Dialog1?location=user")
     dialog.execute()
     dialog.dispose()

Message Box

En Basic, vous pouvez utiliser la fonction d'exécution MsgBox pour afficher un message aux utilisateurs.

  Msgbox "Hello."

n Python, aucune fonction n'est fournie, mais vous pouvez utiliser l'interface com.sun.star.awt.XMessageBoxFactory via le kit d'outils.

def messagebox(ctx, parent, message, title, message_type, buttons):
    """ Show message in message box. """
    toolkit = parent.getToolkit()
    older_imple = check_method_parameter(
        ctx, "com.sun.star.awt.XMessageBoxFactory", "createMessageBox", 
        1, "com.sun.star.awt.Rectangle")
    if older_imple:
        msgbox = toolkit.createMessageBox(
            parent, Rectangle(), message_type, buttons, title, message)
    else:
        message_type = uno.getConstantByName("com.sun.star.awt.MessageBoxType." + {
            "messbox": "MESSAGEBOX", "infobox": "INFOBOX", 
            "warningbox": "WARNINGBOX", "errorbox": "ERRORBOX", 
            "querybox": "QUERYBOX"}[message_type])
        msgbox = toolkit.createMessageBox(
            parent, message_type, buttons, title, message)
    n = msgbox.execute()
    msgbox.dispose()
    return n
 
 
def check_method_parameter(ctx, interface_name, method_name, param_index, param_type):
    """ Check the method has specific type parameter at the specific position. """
    cr = create_service(ctx, "com.sun.star.reflection.CoreReflection")
    try:
        idl = cr.forName(interface_name)
        m = idl.getMethod(method_name)
        if m:
            info = m.getParameterInfos()[param_index]
            return info.aType.getName() == param_type
    except:
        pass
    return False

Input Box

Aucune fonction n'est fournie pour Python, vous devez fabriquer votre propre fonction, ouù une boîte de dialogue. Voici un exemple:

def inputbox(message, title="", default="", x=None, y=None):
    """ Shows dialog with input box.
        @param message message to show on the dialog
        @param title window title
        @param default default value
        @param x dialog positio in twips, pass y also
        @param y dialog position in twips, pass y also
        @return string if OK button pushed, otherwise zero length string
    """
    WIDTH = 600
    HORI_MARGIN = VERT_MARGIN = 8
    BUTTON_WIDTH = 100
    BUTTON_HEIGHT = 26
    HORI_SEP = VERT_SEP = 8
    LABEL_HEIGHT = BUTTON_HEIGHT * 2 + 5
    EDIT_HEIGHT = 24
    HEIGHT = VERT_MARGIN * 2 + LABEL_HEIGHT + VERT_SEP + EDIT_HEIGHT
    import uno
    from com.sun.star.awt.PosSize import POS, SIZE, POSSIZE
    from com.sun.star.awt.PushButtonType import OK, CANCEL
    from com.sun.star.util.MeasureUnit import TWIP
    ctx = uno.getComponentContext()
    def create(name):
        return ctx.getServiceManager().createInstanceWithContext(name, ctx)
    dialog = create("com.sun.star.awt.UnoControlDialog")
    dialog_model = create("com.sun.star.awt.UnoControlDialogModel")
    dialog.setModel(dialog_model)
    dialog.setVisible(False)
    dialog.setTitle(title)
    dialog.setPosSize(0, 0, WIDTH, HEIGHT, SIZE)
    def add(name, type, x_, y_, width_, height_, props):
        model = dialog_model.createInstance("com.sun.star.awt.UnoControl" + type + "Model")
        dialog_model.insertByName(name, model)
        control = dialog.getControl(name)
        control.setPosSize(x_, y_, width_, height_, POSSIZE)
        for key, value in props.items():
            setattr(model, key, value)
    label_width = WIDTH - BUTTON_WIDTH - HORI_SEP - HORI_MARGIN * 2
    add("label", "FixedText", HORI_MARGIN, VERT_MARGIN, label_width, LABEL_HEIGHT, 
        {"Label": str(message), "NoLabel": True})
    add("btn_ok", "Button", HORI_MARGIN + label_width + HORI_SEP, VERT_MARGIN, 
            BUTTON_WIDTH, BUTTON_HEIGHT, {"PushButtonType": OK, "DefaultButton": True})
    add("btn_cancel", "Button", HORI_MARGIN + label_width + HORI_SEP, VERT_MARGIN + BUTTON_HEIGHT + 5, 
            BUTTON_WIDTH, BUTTON_HEIGHT, {"PushButtonType": CANCEL})
    add("edit", "Edit", HORI_MARGIN, LABEL_HEIGHT + VERT_MARGIN + VERT_SEP, 
            WIDTH - HORI_MARGIN * 2, EDIT_HEIGHT, {"Text": str(default)})
    frame = create("com.sun.star.frame.Desktop").getCurrentFrame()
    window = frame.getContainerWindow() if frame else None
    dialog.createPeer(create("com.sun.star.awt.Toolkit"), window)
    if not x is None and not y is None:
        ps = dialog.convertSizeToPixel(uno.createUnoStruct("com.sun.star.awt.Size", x, y), TWIP)
        _x, _y = ps.Width, ps.Height
    elif window:
        ps = window.getPosSize()
        _x = ps.Width / 2 - WIDTH / 2
        _y = ps.Height / 2 - HEIGHT / 2
    dialog.setPosSize(_x, _y, 0, 0, POS)
    edit = dialog.getControl("edit")
    edit.setSelection(uno.createUnoStruct("com.sun.star.awt.Selection", 0, len(str(default))))
    edit.setFocus()
    ret = edit.getModel().Text if dialog.execute() else ""
    dialog.dispose()
    return ret

inputbox("Please input some value", "Input", "Default value")

Exécuter une macro depuis un bouton de la barre d'outils

En Basic, vous pouvez appeler des sous-routines ou des fonctions via les boutons de la barre d'outils.

Sub WriteHello()
  ThisComponent.getText().getEnd().setString("Hello!")
End Sub

En Python, vous devez définir votre fonction Python avec un argument (ou un tuple d'arguments de longueur variable) pour prendre l'argument passé lorsque la fonction exécutée via le bouton de la barre d'outils assignée.

def writeHello(*args):
    # writeHello(arg): Est également ok mais si vous voulez appeler cette fonction
    # par certains moyens, définissez votre fonction avc des arguments variables.
    XSCRIPTCONTEXT.getDocument().getText().getEnd().setString("Hello!")