Editeur/compoformule.py

   1 # -*- coding: utf-8 -*-
   2 #            CONFIGURATION MANAGEMENT OF EDF VERSION
   3 # ======================================================================
   4 # COPYRIGHT (C) 1991 - 2002  EDF R&D                  WWW.CODE-ASTER.ORG
   5 # THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY
   6 # IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY
   7 # THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR
   8 # (AT YOUR OPTION) ANY LATER VERSION.
   9 #
  10 # THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT
  11 # WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF
  12 # MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU
  13 # GENERAL PUBLIC LICENSE FOR MORE DETAILS.
  14 #
  15 # YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE
  16 # ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER,
  17 #    1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE.
  18 #
  19 #
  20 # ======================================================================
  21 """
  22 Ce module contient les classes permettant de définir les objets graphiques
  23 représentant un objet de type FORMULE, cad le panneau et l'item de l'arbre
  24 d'EFICAS
  25 """
  26
  27 # import modules Python
  28 from Tkinter import *
  29 import Pmw
  30 import string
  31
  32 # import modules EFICAS
  33 import widgets
  34 import panels
  35 import fontes
  36 import compooper
  37
  38 Fonte_TITRE = fontes.standard_gras_souligne
  39
  40
  41 class FORMULEPanel(panels.OngletPanel):
  42   """
  43   Classe servant à construire le panneau associé à un paramètre.
  44   C'est au moyen de ce panneau que l'utilisateur peut accéder
  45   aux nom et valeur du paramètre en vue éventuellement de les
  46   modifier.
  47   """
  48
  49   def init(self):
  50     nb = Pmw.NoteBook(self,raisecommand=self.raisecmd)
  51     nb.pack(fill = 'both', expand = 1)
  52     self.nb=nb
  53     nb.add('Formule', tab_text='Définition Formule')
  54     nb.add('Commande', tab_text='Nouvelle Commande')
  55     nb.add('Commentaire',tab_text='Paramètre/Commentaire')
  56     self.makeFormulePage(nb.page("Formule"))
  57     self.makeCommandePage(nb.page("Commande"))
  58     self.makeParamCommentPage_for_etape(nb.page("Commentaire"))
  59     nb.tab('Formule').focus_set()
  60     self.enlevebind()
  61     self.creebind()
  62     nb.setnaturalsize()
  63
  64   def makeFormulePage(self,page):
  65     """
  66     Crée la page qui permet d'afficher et d'éditer le texte de la FORMULE
  67     """
  68     self.frame_valeur = Frame(page)
  69     self.frame_valeur.place(relwidth=0.95,relheight=0.95,relx=0.05,rely=0.05,anchor='nw')
  70     #self.frame_valeur.place(relwidth=0.9,relheight=0.9,relx=0.05,rely=0.05,anchor='nw')
  71     # affichage du titre du panneau
  72     self.titre = StringVar()
  73     self.titre.set("FORMULE "+self.node.item.get_nom())
  74
  75     self.entry_nom = Entry(self.frame_valeur)
  76     Label(self.frame_valeur,textvariable=self.titre,font=Fonte_TITRE).place(relx=0.5,rely=0.,anchor='n')
  77     # création des labels et entries associés aux nom, type retourné, arguments et corps de la FORMULE
  78
  79     Label(self.frame_valeur,text= 'Nom de la formule : ').place(relx=0.,rely=0.1)
  80     Label(self.frame_valeur,text= 'Arguments : ').place(relx=0.,rely=0.40)
  81     self.entry_arg = Entry(self.frame_valeur)
  82     Label(self.frame_valeur,text= 'Expression : ').place(relx=0.,rely=0.65)
  83     self.entry_exp = Entry(self.frame_valeur)
  84
  85     # binding sur les entries
  86     self.entry_nom.bind("<Return>",self.verif_nom)
  87     self.entry_nom.bind("<KP_Enter>",self.verif_nom)
  88     self.entry_arg.bind("<Return>",self.verif_arguments)
  89     self.entry_arg.bind("<KP_Enter>",self.verif_arguments)
  90     self.entry_exp.bind("<Return>",self.verif_corps)
  91     self.entry_exp.bind("<KP_Enter>",self.verif_corps)
  92     # affichage des entries
  93     self.entry_nom.place(relx=0.35,rely=0.10,relwidth=0.2)
  94     self.entry_arg.place(relx=0.35,rely=0.40,relwidth=0.4)
  95
  96     # affichage d'une phrase d'aide pour les arguments
  97     aide = """Entrer les arguments sous la forme
  98 de VARIABLES séparées par des virgules (,)
  99 Exemple X,Y,Z """
 100     Label(self.frame_valeur,text=aide, justify="l").place(relx=0.5,rely=0.47,anchor='n')
 101
 102     self.entry_exp.place(relx=0.35,rely=0.65,relwidth=0.60)
 103     # affichage d'une phrase d'aide pour l'expression
 104     aide = """Un retour de chariot dans une zone de saisie vous permet de vérifier si
 105 la valeur que vous avez entrée est valide.
 106 Ce n'est qu'après avoir appuyé sur le bouton Valider que les nouvelles
 107 valeurs seront effectivement prises en compte."""
 108     Label(self.frame_valeur,text=aide).place(relx=0.5,rely=0.75,anchor='n')
 109
 110     # affichage des nom, type retourné, arguments et corps de la FORMULE
 111     self.display_valeur()
 112     # affichage des boutons
 113     self.make_buttons()
 114     # entry_nom prend le focus
 115     self.entry_nom.focus()
 116
 117   def make_buttons(self):
 118     """
 119     Crée les boutons du panneau
 120     """
 121     self.bouton_sup.place_forget()
 122     self.bouton_doc.place_forget()
 123     self.bouton_val = Button(self.fr_but,text='Valider',command=self.change_valeur,width=14)
 124     self.bouton_ann = Button(self.fr_but,text='Annuler',command=self.display_valeur,width=14)
 125
 126     self.bouton_val.place(relx=0.15,rely=0.5,relheight=0.8,anchor='center')
 127     self.bouton_ann.place(relx=0.40,rely=0.5,relheight=0.8,anchor='center')
 128     self.bouton_sup.place(relx=0.65,rely=0.5,relheight=0.8,anchor='center')
 129     self.bouton_doc.place(relx=0.90,rely=0.5,relheight=0.8,anchor='center')
 130
 131   def change_valeur(self):
 132     """
 133     Stocke la nouvelle FORMULE décrite par l'utilisateur
 134     """
 135     if self.parent.modified == 'n' : self.parent.init_modif()
 136     # on récupère les nouveaux nom, type retourné, arguments et corps de la FORMULE
 137     new_nom = self.entry_nom.get()
 138     new_typ="REEL"
 139     new_arg = self.entry_arg.get()
 140     new_exp = self.entry_exp.get()
 141     self.verif_arguments()
 142     self.verif_corps()
 143     # on essaie de les stocker
 144     test,erreur = self.node.item.save_formule(new_nom,new_typ,new_arg,new_exp)
 145     if test :
 146         # on a pu stocker les nouveaux paramètres : il faut rafraîchir l'affichage
 147         self.node.update()
 148         self.display_valeur()
 149         self.parent.appli.affiche_infos("FORMULE %s modifiée" %self.node.item.get_nom())
 150     else:
 151         # la formule est incorrecte : on affiche les erreurs
 152         widgets.showerror("Formule incorrecte",erreur)
 153         self.parent.appli.affiche_infos("FORMULE %s non modifiée" %self.node.item.get_nom())
 154
 155   def display_valeur(self):
 156     """
 157     Affiche dans self.widget_text de la valeur de l'objet FORMULE
 158     (annule d'éventuelles modifications faite par l'utilisateur)
 159     """
 160     # on efface tout texte affiché dans les entries
 161     self.entry_nom.delete(0,END)
 162     self.entry_arg.delete(0,END)
 163     self.entry_exp.delete(0,END)
 164     # on rafraîchit le titre du panneau
 165     self.titre.set('FORMULE '+self.node.item.get_nom())
 166     # on insére les nouveaux nom, type retourné, arguments et corps de la FORMULE
 167     nom = self.node.item.get_nom()
 168     if nom != '':
 169         self.entry_nom.insert(END,nom)
 170     args = self.node.item.get_args()
 171     if args:
 172         texte_args=""
 173         for i in args :
 174             if texte_args != "" :
 175                texte_args = texte_args +","
 176             texte_args=texte_args + i
 177         self.entry_arg.insert(END,texte_args)
 178     corps = self.node.item.get_corps()
 179     if corps :
 180         self.entry_exp.insert(END,self.node.item.get_corps())
 181
 182   def verif_nom(self,event=None):
 183         """
 184         Lance la vérification du nom présent dans entry_nom
 185         """
 186         nom = self.entry_nom.get()
 187         if nom == '':
 188             test,erreur = 0,"Aucun nom fourni !"
 189         else:
 190             test,erreur = self.node.item.verif_nom(nom)
 191         if not test:
 192             widgets.showerror("Nom invalide",erreur)
 193             self.entry_nom.focus()
 194             self.entry_nom.selection_range(0,END)
 195             self.parent.appli.affiche_infos("%s n'est pas un nom valide pour une FORMULE" %nom)
 196         else:
 197             self.parent.appli.affiche_infos("%s est un nom valide pour une FORMULE" %nom)
 198             self.entry_arg.focus()
 199
 200   def verif_arguments(self,event=None):
 201         """
 202         Lance la vérification des arguments présents dans entry_arg
 203         """
 204         arguments = self.entry_arg.get()
 205         if arguments == '' :
 206             test,erreur = 0,"Aucun argument fourni"
 207         else:
 208             test,erreur = self.node.item.verif_arguments(arguments)
 209         if not test:
 210             widgets.showerror("Argument(s) invalide(s)",erreur)
 211             self.entry_arg.focus()
 212             self.entry_arg.selection_range(0,END)
 213             self.parent.appli.affiche_infos("Argument(s) invalide(s) pour une FORMULE")
 214         else:
 215             self.parent.appli.affiche_infos("Argument(s) valide(s) pour une FORMULE")
 216             self.entry_exp.focus()
 217
 218   def verif_corps(self,event=None):
 219         """
 220         Lance la vérification du corps de formule présent dans entry_exp
 221         """
 222         new_nom = self.entry_nom.get()
 223         new_typ="REEL"
 224         new_arg = self.entry_arg.get()
 225         new_exp = self.entry_exp.get()
 226         if new_exp == '':
 227             test,erreur = 0,"Aucune expression fournie !"
 228         else:
 229             test,erreur = self.node.item.verif_formule_python((new_nom,new_typ,new_arg,new_exp))
 230
 231         if not test:
 232             widgets.showerror("Corps de FORMULE invalide",erreur)
 233             self.entry_exp.focus()
 234             self.entry_exp.selection_range(0,END)
 235             self.parent.appli.affiche_infos("Corps de FORMULE invalide")
 236         else:
 237             self.parent.appli.affiche_infos("Corps de FORMULE valide")
 238
 239 class FORMULETreeItem(compooper.EtapeTreeItem):
 240     """
 241     Classe servant à définir l'item porté par le noeud de l'arbre d'EFICAS
 242     qui représente la FORMULE
 243     """
 244     panel = FORMULEPanel
 245
 246     def init(self):
 247       self.setfunction = self.set_valeur
 248
 249 # ---------------------------------------------------------------------------
 250 #                   API de FORMULE pour l'arbre
 251 # ---------------------------------------------------------------------------
 252     def GetSubList(self):
 253       """
 254       Retourne la liste des fils de self
 255       On considère que FORMULE n'a pas de fils
 256       --> modification par rapport à MACRO classique
 257       """
 258       # dans EFICAS on ne souhaite pas afficher les mots-clés fils de FORMULE
 259       # de façon traditionnelle
 260       return []
 261
 262     def GetIconName(self):
 263       """
 264       Retourne le nom de l'icône à afficher dans l'arbre
 265       Ce nom dépend de la validité de l'objet
 266       """
 267       if self.object.isactif():
 268         self.object.state="modified"
 269         if self.object.isvalid():
 270           return "ast-green-square"
 271         else:
 272           return "ast-red-square"
 273       else:
 274         return "ast-white-text"
 275
 276     def GetLabelText(self):
 277       """ Retourne 3 valeurs :
 278       - le texte à afficher dans le noeud représentant l'item
 279       - la fonte dans laquelle afficher ce texte
 280       - la couleur du texte
 281       """
 282       if self.object.isactif():
 283         # None --> fonte et couleur par défaut
 284         return self.labeltext,None,None
 285       else:
 286         return self.labeltext,fontes.standard_italique,None
 287
 288 # ---------------------------------------------------------------------------
 289 #       Méthodes permettant la modification et la lecture des attributs
 290 #       du paramètre = API graphique de la FORMULE pour Panel et EFICAS
 291 # ---------------------------------------------------------------------------
 292
 293     def get_nom(self):
 294       """
 295       Retourne le nom de la FORMULE
 296       """
 297       return self.object.get_nom()
 298
 299     def get_type(self):
 300       """
 301       Retourne le type de la valeur retournée par la FORMULE
 302       """
 303       return self.object.type_retourne
 304
 305     def get_args(self):
 306       """
 307       Retourne les arguments de la FORMULE
 308       """
 309       args=""
 310       for mot in self.object.mc_liste:
 311           if mot.nom == 'NOM_PARA':
 312              args=mot.valeur
 313              break
 314       if args :
 315           if args[0] == "(" and args[-1] ==")":
 316              args=args[1:-1]
 317           # transforme en tuple si ce n est pas déjà le casa
 318           try :
 319              args=string.split(args,',')
 320           except :
 321              pass
 322       return args
 323
 324     def get_corps(self):
 325       """
 326       Retourne le corps de la FORMULE
 327       """
 328       corps=""
 329       for mot in self.object.mc_liste:
 330           if mot.nom == 'VALE':
 331              corps=mot.valeur
 332              break
 333       return corps
 334
 335
 336     def get_liste_types_autorises(self):
 337       """
 338          Retourne la liste des types autorises pour les valeurs de sortie
 339          d'une FORMULE
 340       """
 341       return self.object.l_types_autorises
 342
 343     def save_formule(self,new_nom,new_typ,new_arg,new_exp):
 344       """
 345       Vérifie si (new_nom,new_typ,new_arg,new_exp) définit bien une FORMULE
 346       licite :
 347           - si oui, stocke ces paramètres comme nouveaux paramètres de la
 348             FORMULE courante et retourne 1
 349           - si non, laisse les paramètres anciens de la FORMULE inchangés et
 350             retourne 0
 351       """
 352       test,erreur = self.object.verif_formule_python(formule=(new_nom,new_typ,new_arg,
 353                                                        new_exp))
 354       if test :
 355           # la formule est bien correcte : on sauve les nouveaux paramètres
 356           test=self.object.update_formule_python(formule=(new_nom,new_typ,new_exp,new_arg))
 357       return test,erreur
 358
 359 # ---------------------------------------------------------------------------
 360 #          Accès aux méthodes de vérification de l'objet FORM_ETAPE
 361 # ---------------------------------------------------------------------------
 362
 363     def verif_nom(self,nom):
 364         """
 365         Lance la vérification du nom passé en argument
 366         """
 367         return self.object.verif_nom(nom)
 368
 369     def verif_arguments(self,arguments):
 370         """
 371         Lance la vérification des arguments passés en argument
 372         """
 373         return self.object.verif_arguments('('+arguments+')')
 374
 375     def verif_formule(self,formule):
 376         """
 377         Lance la vérification de FORMULE passée en argument
 378         """
 379         return self.object.verif_formule(formule=formule)
 380
 381
 382     def verif_formule_python(self,formule):
 383         """
 384         Lance la vérification de FORMULE passée en argument
 385         """
 386         return self.object.verif_formule_python(formule=formule)
 387
 388 import Accas
 389 treeitem =FORMULETreeItem
 390 objet = Accas.FORM_ETAPE