TDF LibreOffice Document Liberation Project Blogs communautaires Weblate Nextcloud Redmine Ask LibreOffice Donner

EN
AN
AR
AST
BE
BG
BN
BRX
CA
CS
DA
DE
EL
EO
ES
FA
FI
FR
GD
GL
GUG
HE
HI
HR
HU
ID
IS
IT
JA
JV
KO
KU
LO-LA
LT
MN
MR
NE
NL
NO
OC
OM
PA
PL
PT
PT-BR
RO
RU
SAH
SK
SL
SQ
SV
TA
TE
ไทย (TH)
TR
UK
UZ
VI
正體 (ZH-TW)
简体 (ZH-CN)
Article Title: Macros/Python Guide/fr/Guide/interface

⇐ Boites de dialogue |Table des matières| Traitement de texte ⇒

Gestion de l'interface

La fenêtre d'affichage

Afficher une fenêtre vide

Nous abordons ici le code de base pour créer une simple fenêtre d'affichage pour une interface graphique.

Exécution de la macro fenêtre_vide.py

Le code complet de la macro fenetre_vide.py :

#!
#coding: utf8
#Macro: fenetre_vide.py
#Objectif: Affiche une fenêtre vide active avec comme titre la suite bureautique
#Auteur: Franc SERRES
#Licence: https://www.gnu.org/licenses/gpl-3.0.fr.html

import os, sys, traceback
import uno
from com.sun.star.beans import PropertyValue

def affiche():
    #Définition des paramètres pour la récupération de la configuration de la suite bureautique
    prop = PropertyValue()
    prop.Name = 'nodepath'
    prop.Value = '/org.openoffice.Setup/Product'
    paramètres = (prop,)
    #Récupération du contexte de la suite bureautique
    ctx = uno.getComponentContext()
    #Création d'une instance de gestion de la configuration
    configuration = ctx.ServiceManager.createInstanceWithContext(
        'com.sun.star.configuration.ConfigurationProvider', ctx)
    #Création d'une instance de gestion des informations de configuration
    informations = configuration.createInstanceWithArguments( 
        'com.sun.star.configuration.ConfigurationAccess', paramètres)
    #Récupération du nom de la suite bureautique
    bureautique = informations.getByName('ooName')
    #Récupération de la version de la suite
    révision = informations.getByName('ooSetupVersionAboutBox')
    
    #Création d'une instance de modèle de fenêtre
    modèlefenêtre = ctx.ServiceManager.createInstance('com.sun.star.awt.UnoControlDialogModel')
    #Définition de ses dimentions
    #Largeur
    modèlefenêtre.Width = 300
    #Hauteur
    modèlefenêtre.Height = 175
    # Titre de la fenêtre
    modèlefenêtre.Title = bureautique + ' ' + révision
    #
    #Création d'une instance de fenêtre
    fenêtredialogue = ctx.ServiceManager.createInstance('com.sun.star.awt.UnoControlDialog')
    #Affectation du modèle de fenêtre
    fenêtredialogue.setModel(modèlefenêtre)
    #
    #Création de l'instance des éléments de base de gestion d'une fenêtre
    interface = ctx.ServiceManager.createInstance('com.sun.star.awt.Toolkit')
    #Affectation des éléments de base à la fenêtre
    fenêtredialogue.createPeer(interface,None)
    # Création de la fenêtre
    fenêtredialogue.execute()

g_exportedScripts = affiche,

Afficher une fenêtre modale

Une fenêtre modale est, dans une interface graphique, une fenêtre qui prend le contrôle total du clavier et de l'écran.

À quoi cela sert-il ?

Dans une macro nous voulons qu'une interface graphique (une fenêtre ou une boite de dialogue) prenne le contrôle du clavier et de la souris. Le programme parent intérompt son exécution et attend la fin de la fenêtre modale ou le retour d'un résultat de fin de son exécution.

C'est à dire, par exemple comme dans une boite d'information où le programme attent une réponse impérative (oui/non).

Il est alors impossible d'avoir le focus sur la fenêtre ou la boite de dialogue du père.

Dans notre code python ceci est possible au moment de la création de notre fenêtre lorsque nous créons l'object avec la méthode .execute() Celle-ci exécute l'objet comme un enfant qui prend le contrôle du clavier et de la souris.

fenêtredialogue.execute()

Exécution de la macro fenêtre_modale.py

Fermeture de la fenêtre

Fermeture de la boite de dialogue

Le code complet de la macro fenetre_modale.py :

#!
#coding: utf8
#Macro: fenetre_modale.py
#Objectif: Affiche une fenêtre vide avec comme titre la suite bureautique et une boite de dialogue avec le titre «Terminer»
#Auteur: Franc SERRES
#Licence: https://www.gnu.org/licenses/gpl-3.0.fr.html

import os, sys, traceback
import uno
from com.sun.star.awt.MessageBoxType import \
    MESSAGEBOX as BOÎTEDIALOGUE, \
    INFOBOX as BOÎTEINFORMATION, \
    ERRORBOX as BOÎTEERREUR, \
    WARNINGBOX as BOÎTEAVERTISSEMENT, \
    QUERYBOX as BOÎTEQUESTION
from com.sun.star.awt.MessageBoxButtons import \
    BUTTONS_OK as BOUTON_OK, \
    BUTTONS_OK_CANCEL as BOUTONS_OK_ANNULER, \
    BUTTONS_YES_NO as BOUTONS_OUI_NON, \
    BUTTONS_YES_NO_CANCEL as BOUTONS_OUI_NON_ANNULER, \
    BUTTONS_RETRY_CANCEL as BOUTONS_RÉESSAYER_ANNULER, \
    BUTTONS_ABORT_IGNORE_RETRY as BOUTONS_INTERROMPRE_REESSAYER_IGNORER, \
    DEFAULT_BUTTON_OK as OK_PAR_DEFAUT, \
    DEFAULT_BUTTON_CANCEL as ANNULER_PAR_DEFAUT, \
    DEFAULT_BUTTON_RETRY as RÉESSAYER_PAR_DEFAUT, \
    DEFAULT_BUTTON_YES as OUI_PAR_DEFAUT, \
    DEFAULT_BUTTON_NO as NON_PAR_DEFAUT, \
    DEFAULT_BUTTON_IGNORE as IGNORER_PAR_DEFAUT
from com.sun.star.awt.MessageBoxResults import CANCEL, OK, YES, NO, RETRY, IGNORE
from com.sun.star.beans import PropertyValue

def afficheFenêtre(messageboîte, titreboîteàmessage, typedebouton=BOUTON_OK, typedeboite=BOÎTEDIALOGUE):
    #typedeboite :
    #  Boite de message     : BOÎTEDIALOGUE
    #  Boite d'information  : BOÎTEINFORMATION
    #  Boite d'erreur       : BOÎTEERREUR
    #  Boite d'alerte       : BOÎTEAVERTISSEMENT
    #  Boite d'intérogation : BOÎTEQUESTION
    #
    #typedebouton :
    #  OK                        : BOUTON_OK
    #  OK/ANNULER                : BOUTONS_OK_ANNULER
    #  OUI/NON                   : BOUTONS_OUI_NON
    #  OUI/NON/ANNULER           : BOUTONS_OUI_NON_ANNULER
    #  RÉESSAYER/ANNULER         : BOUTONS_RÉESSAYER_ANNULER
    #  ANNULER/RÉESSAYER/IGNORER : BOUTONS_INTERROMPRE_REESSAYER_IGNORER
    bureau = XSCRIPTCONTEXT.getDesktop()
    cadre = bureau.getCurrentFrame()
    fenêtre = cadre.getContainerWindow()
    boîteàoutils = fenêtre.getToolkit()
    fenêtremessage = boîteàoutils.createMessageBox(fenêtre, typedeboite, typedebouton, titreboîteàmessage, messageboîte)
    return fenêtremessage.execute()

def affiche():
    try:
        prop = PropertyValue()
        prop.Name = 'nodepath'
        prop.Value = '/org.openoffice.Setup/Product'
        properties = (prop,)
        ctx = uno.getComponentContext()
        configuration = ctx.ServiceManager.createInstanceWithContext(
            'com.sun.star.configuration.ConfigurationProvider', ctx)
        informations = configuration.createInstanceWithArguments( 
            'com.sun.star.configuration.ConfigurationAccess', properties)
        bureautique = informations.getByName('ooName')
        révision = informations.getByName('ooSetupVersionAboutBox')
        modèlefenêtre = ctx.ServiceManager.createInstance('com.sun.star.awt.UnoControlDialogModel')
        # Size of Dialog
        modèlefenêtre.Width = 300
        modèlefenêtre.Height = 175
        # Title of Dialog
        modèlefenêtre.Title = bureautique + ' ' + révision
        #
        # Create the dialog and set the model
        fenêtredialogue = ctx.ServiceManager.createInstance('com.sun.star.awt.UnoControlDialog')
        fenêtredialogue.setModel(modèlefenêtre)
        #
        # Create a fenêtre and then tell the dialog to use the created fenêtre.
        affichage = ctx.ServiceManager.createInstance('com.sun.star.awt.Toolkit')
        fenêtredialogue.createPeer(affichage,None)		# None : OK / none : NG
        # Dialog
        fenêtredialogue.execute()
        texte = 'Vous venez de créer la fenêtre vide modale'

    except Exception as er:
        texte = str(traceback.format_exc()) + '\n' + str(er)
    finally:
        afficheFenêtre(texte,'Résultat')
    afficheFenêtre('Pour afficher cette boite de dialogue vous avez été obligé de fermer la fenêtre vide\n Cliquez sur OK pour terminer l\'exécution du programme','Terminer')
    
g_exportedScripts = affiche,

Afficher une fenêtre non-modale

Nous voulons parfois dans une macro que plusieurs fenêtres s'exécutent en même temps. Par exemple comme une fenêtre principale et des boîtes d'outils flottants.

Pour y arriver la fenêtre principale se crée avec la méthode .execute(). Mais les autres fenêtres sont créées en amont de son appel et activées avec la méthode .setVisible(). L'utilisateur peux alors passer d'une fenêtre à l'autre grâce au focus qui va basculer la capture du clavier et de la souris.

…
fenêtreoutils.setVisible(True)
…
fenêtreprincipale.execute().

Exécution de la macro fenêtre_non_modale.py

Fermeture de la boite de dialogue

Le code complet de la macro fenetre_non_modale.py :

#!
#coding: utf8
#Macro: fenetre_non_modale.py
#Objectif: Affiche une fenêtre vide active avec comme titre la suite bureautique et une boite de dialogue avec le titre «Attente»
#Auteur: Franc SERRES
#Licence: https://www.gnu.org/licenses/gpl-3.0.fr.html

import os, sys, traceback
import uno
from com.sun.star.awt.MessageBoxType import \
    MESSAGEBOX as BOÎTEDIALOGUE, \
    INFOBOX as BOÎTEINFORMATION, \
    ERRORBOX as BOÎTEERREUR, \
    WARNINGBOX as BOÎTEAVERTISSEMENT, \
    QUERYBOX as BOÎTEQUESTION
from com.sun.star.awt.MessageBoxButtons import \
    BUTTONS_OK as BOUTON_OK, \
    BUTTONS_OK_CANCEL as BOUTONS_OK_ANNULER, \
    BUTTONS_YES_NO as BOUTONS_OUI_NON, \
    BUTTONS_YES_NO_CANCEL as BOUTONS_OUI_NON_ANNULER, \
    BUTTONS_RETRY_CANCEL as BOUTONS_RÉESSAYER_ANNULER, \
    BUTTONS_ABORT_IGNORE_RETRY as BOUTONS_INTERROMPRE_REESSAYER_IGNORER, \
    DEFAULT_BUTTON_OK as OK_PAR_DEFAUT, \
    DEFAULT_BUTTON_CANCEL as ANNULER_PAR_DEFAUT, \
    DEFAULT_BUTTON_RETRY as RÉESSAYER_PAR_DEFAUT, \
    DEFAULT_BUTTON_YES as OUI_PAR_DEFAUT, \
    DEFAULT_BUTTON_NO as NON_PAR_DEFAUT, \
    DEFAULT_BUTTON_IGNORE as IGNORER_PAR_DEFAUT
from com.sun.star.awt.MessageBoxResults import CANCEL, OK, YES, NO, RETRY, IGNORE
from com.sun.star.beans import PropertyValue

def afficheFenêtre(messageboîte, titreboîteàmessage, typedebouton=BOUTON_OK, typedeboite=BOÎTEDIALOGUE):
    #typedeboite :
    #  Boite de message     : BOÎTEDIALOGUE
    #  Boite d'information  : BOÎTEINFORMATION
    #  Boite d'erreur       : BOÎTEERREUR
    #  Boite d'alerte       : BOÎTEAVERTISSEMENT
    #  Boite d'intérogation : BOÎTEQUESTION
    #
    #typedebouton :
    #  OK                        : BOUTON_OK
    #  OK/ANNULER                : BOUTONS_OK_ANNULER
    #  OUI/NON                   : BOUTONS_OUI_NON
    #  OUI/NON/ANNULER           : BOUTONS_OUI_NON_ANNULER
    #  RÉESSAYER/ANNULER         : BOUTONS_RÉESSAYER_ANNULER
    #  ANNULER/RÉESSAYER/IGNORER : BOUTONS_INTERROMPRE_REESSAYER_IGNORER
    bureau = XSCRIPTCONTEXT.getDesktop()
    cadre = bureau.getCurrentFrame()
    fenêtre = cadre.getContainerWindow()
    boîteàoutils = fenêtre.getToolkit()
    fenêtremessage = boîteàoutils.createMessageBox(fenêtre, typedeboite, typedebouton, titreboîteàmessage, messageboîte)
    return fenêtremessage.execute()

def affiche():
    try:
        prop = PropertyValue()
        prop.Name = 'nodepath'
        prop.Value = '/org.openoffice.Setup/Product'
        properties = (prop,)
        ctx = uno.getComponentContext()
        configuration = ctx.ServiceManager.createInstanceWithContext(
            'com.sun.star.configuration.ConfigurationProvider', ctx)
        informations = configuration.createInstanceWithArguments( 
            'com.sun.star.configuration.ConfigurationAccess', properties)
        bureautique = informations.getByName('ooName')
        révision = informations.getByName('ooSetupVersionAboutBox')
        modèlefenêtre = ctx.ServiceManager.createInstance('com.sun.star.awt.UnoControlDialogModel')
        # Size of Dialog
        modèlefenêtre.Width = 300
        modèlefenêtre.Height = 175
        # Title of Dialog
        modèlefenêtre.Title = bureautique + ' ' + révision
        #
        # Create the dialog and set the model
        fenêtredialogue = ctx.ServiceManager.createInstance('com.sun.star.awt.UnoControlDialog')
        fenêtredialogue.setModel(modèlefenêtre)
        #
        # Create a fenêtre and then tell the dialog to use the created fenêtre.
        affichage = ctx.ServiceManager.createInstance('com.sun.star.awt.Toolkit')
        fenêtredialogue.createPeer(affichage,None)		# None : OK / none : NG
        # Dialog
        fenêtredialogue.setVisible(True)
        texte = 'Vous venez de créer la fenêtre vide non modale'

    except Exception as er:
        texte = str(traceback.format_exc()) + '\n' + str(er)
    finally:
        afficheFenêtre(texte,'Résultat')
    afficheFenêtre('La fenêtre et la boîte de dialogue ont un focus distinct\nCliquez sur OK pour terminer l\'exécution du programme','Attente')
g_exportedScripts = affiche,

Afficher un menu

Macro Fenêtre avec menu

#!
#coding: utf8
#Macro: fenetre_vide.py
#Objectif: Affiche une fenêtre vide active avec comme titre la suite bureautique
#Auteur: Franc SERRES
#Licence: https://www.gnu.org/licenses/gpl-3.0.fr.html

import uno

#Librairies pour avoir des informations système
#import os, sys, traceback
from com.sun.star.beans import PropertyValue, NamedValue

#Librairies de gestion des fenêtres
from com.sun.star.awt import Rectangle, WindowDescriptor
#from com.sun.star.frame import XController
#from com.sun.star.awt.WindowClass import TOP, MODALTOP, CONTAINER, SIMPLE
#from com.sun.star.awt.WindowAttribute import SHOW, FULLSIZE, OPTIMUMSIZE, MINSIZE, BORDER, SIZEABLE, MOVEABLE, CLOSEABLE, SYSTEMDEPENDENT, NODECORATION
#from com.sun.star.awt.PosSize import PS_POSSIZE

#Librairies de Gestion des menus
#from com.sun.star.awt.MenuItemStyle import AUTOCHECK, CHECKABLE, RADIOCHECK
#from com.sun.star.awt import XMenuListener
#from com.sun.star.lang import XEventListener

#global event

#Fonctions de débuggage
# MRI - API Explorer
def mri (ctx, xCible):
    try:
        xMri = ctx.ServiceManager.createInstanceWithContext("mytools.Mri", ctx)
        xMri.inspect(xCible)
    except:
        raise _rtex("\L'extension Python MRI n'est pas installée", uno.getComponentContext())

def getConfigSetting (sNodeConfig, bUpdate):
    "get a configuration node"
    # example: xNode = getConfigSetting( "/org.openoffice.Office.Common/Path/Current", False)
    xSvMgr = uno.getComponentContext().ServiceManager
    xConfigProvider = xSvMgr.createInstanceWithContext("com.sun.star.configuration.ConfigurationProvider", uno.getComponentContext())
    xPropertyValue = uno.createUnoStruct("com.sun.star.beans.PropertyValue")
    xPropertyValue.Name = "nodepath"
    xPropertyValue.Value = sNodeConfig
    if bUpdate:
        sService = "com.sun.star.configuration.ConfigurationUpdateAccess"
    else:
        sService = "com.sun.star.configuration.ConfigurationAccess"
    xNode = xConfigProvider.createInstanceWithArguments(sService, (xPropertyValue,))
    return xNode

def info():
    pass

def affiche():
    #Définition des paramètres pour la récupération de la configuration de la suite bureautique
    prop = PropertyValue()
    prop.Name = 'nodepath'
    prop.Value = '/org.openoffice.Setup/Product'
    paramètres = (prop,)
    #Récupération du contexte de la suite bureautique
    ctx = XSCRIPTCONTEXT.getComponentContext()
    #récupération du gestionaire de services
    smgr =ctx.getServiceManager()
    #Création d'une instace bureautique dans le contexte
    desktop = smgr.createInstanceWithContext('com.sun.star.frame.Desktop', ctx)
    #Création d'un cadre MonCadre dans le contexte
    frame = smgr.createInstanceWithContext('com.sun.star.frame.TaskCreator', ctx).createInstanceWithArguments((NamedValue('FrameName', 'MonCadre'), NamedValue('PosSize', Rectangle(100, 100, 400, 500))))
    #Récupération de sa fenêtre
    window = frame.getContainerWindow()
    #Affichage de la fenêtre
    window.setVisible(True)
    #Modification de son titre
    frame.setTitle('Mon titre')
    #Affecte le contener parent de la frame
    frame.setCreator(desktop)
    #Ajout de la frame à la liste des frames du contener parent
    desktop.getFrames().append(frame)
    #Récupération des outils de gestion de la fenêtre
    toolkit = window.getToolkit()
    #Création d'une instance de bare de menu dans le contexte
    menubar = smgr.createInstanceWithContext('com.sun.star.awt.MenuBar',ctx)
    #Suppression de ses valeurs par défaut
    menubar.removeItem(0,menubar.getItemCount())
    #Ajout des entrées de menus
    menubar_insert = menubar.insertItem
    file_menu = menubar_insert(0,'~Fichier',0,0)
    edit_menu = menubar_insert(1,'~Editer',0,1)
    about_menu = menubar_insert(2,'~Apropos',0,2)
    menubar.setCommand(2,'info')
    #Listener du menu
    #Affectation du menu
    window.setMenuBar(menubar)
    mri(ctx, menubar)
    if cmd_arguments == '--close-window':
        window.setVisible(False)
    #elif cmd_arguments == '--close-office':
    #    mri(ctx, menubar)

g_exportedScripts = affiche,

Python

La fenêtre d'affichage

Afficher une fenêtre vide

Afficher une fenêtre modale

À quoi cela sert-il ?

Afficher une fenêtre non-modale

Afficher un menu

Afficher une barre d'outils

Afficher des widgets

Afficher un label

Afficher des boutons

Afficher une barre de progression

Afficher une zone d'édition

Afficher des boutons de sélection

Afficher des boutons radio

Afficher une liste de sélection

Afficher une boite liste

Afficher un champ date

Afficher un champ heures

Afficher un champ sélection de fichier