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     nb.setnaturalsize()
  61
  62   def makeFormulePage(self,page):
  63     """
  64     Crée la page qui permet d'afficher et d'éditer le texte de la FORMULE
  65     """
  66     self.frame_valeur = Frame(page)
  67     self.frame_valeur.place(relwidth=0.9,relheight=0.9,relx=0.05,rely=0.05,anchor='nw')
  68     # affichage du titre du panneau
  69     self.titre = StringVar()
  70     self.titre.set("FORMULE "+self.node.item.get_nom())
  71
  72     self.entry_nom = Entry(self.frame_valeur)
  73     Label(self.frame_valeur,textvariable=self.titre,font=Fonte_TITRE).place(relx=0.5,rely=0.,anchor='n')
  74     # création des labels et entries associés aux nom, type retourné, arguments et corps de la FORMULE
  75
  76     Label(self.frame_valeur,text= 'Nom de la formule : ').place(relx=0.,rely=0.1)
  77     Label(self.frame_valeur,text= 'Arguments : ').place(relx=0.,rely=0.40)
  78     self.entry_arg = Entry(self.frame_valeur)
  79     Label(self.frame_valeur,text= 'Expression : ').place(relx=0.,rely=0.65)
  80     self.entry_exp = Entry(self.frame_valeur)
  81
  82     # binding sur les entries
  83     self.entry_nom.bind("<Return>",self.verif_nom)
  84     self.entry_arg.bind("<Return>",self.verif_arguments)
  85     self.entry_exp.bind("<Return>",self.verif_corps)
  86     # affichage des entries
  87     self.entry_nom.place(relx=0.35,rely=0.10,relwidth=0.2)
  88     self.entry_arg.place(relx=0.35,rely=0.40,relwidth=0.4)
  89
  90     # affichage d'une phrase d'aide pour les arguments
  91     aide = """Entrer les arguments sous la forme
  92 de VARIABLES séparées par des virgules (,)
  93 Exemple X,Y,Z """
  94     Label(self.frame_valeur,text=aide, justify="l").place(relx=0.5,rely=0.47,anchor='n')
  95
  96     self.entry_exp.place(relx=0.35,rely=0.65,relwidth=0.60)
  97     # affichage d'une phrase d'aide pour l'expression
  98     aide = """Un retour de chariot dans une zone de saisie vous permet de vérifier si
  99 la valeur que vous avez entrée est valide.
 100 Ce n'est qu'après avoir appuyé sur le bouton Valider que les nouvelles
 101 valeurs seront effectivement prises en compte."""
 102     Label(self.frame_valeur,text=aide).place(relx=0.5,rely=0.75,anchor='n')
 103
 104     # affichage des nom, type retourné, arguments et corps de la FORMULE
 105     self.display_valeur()
 106     # affichage des boutons
 107     self.make_buttons()
 108     # entry_nom prend le focus
 109     self.entry_nom.focus()
 110
 111   def make_buttons(self):
 112     """
 113     Crée les boutons du panneau
 114     """
 115     self.bouton_sup.place_forget()
 116     self.bouton_doc.place_forget()
 117     self.bouton_val = Button(self.fr_but,text='Valider',command=self.change_valeur,width=14)
 118     self.bouton_ann = Button(self.fr_but,text='Annuler',command=self.display_valeur,width=14)
 119
 120     self.bouton_val.place(relx=0.15,rely=0.5,relheight=0.8,anchor='center')
 121     self.bouton_ann.place(relx=0.40,rely=0.5,relheight=0.8,anchor='center')
 122     self.bouton_sup.place(relx=0.65,rely=0.5,relheight=0.8,anchor='center')
 123     self.bouton_doc.place(relx=0.90,rely=0.5,relheight=0.8,anchor='center')
 124
 125   def change_valeur(self):
 126     """
 127     Stocke la nouvelle FORMULE décrite par l'utilisateur
 128     """
 129     if self.parent.modified == 'n' : self.parent.init_modif()
 130     # on récupère les nouveaux nom, type retourné, arguments et corps de la FORMULE
 131     new_nom = self.entry_nom.get()
 132     new_typ="REEL"
 133     new_arg = self.entry_arg.get()
 134     new_exp = self.entry_exp.get()
 135     self.verif_arguments()
 136     self.verif_corps()
 137     # on essaie de les stocker
 138     test,erreur = self.node.item.save_formule(new_nom,new_typ,new_arg,new_exp)
 139     if test :
 140         # on a pu stocker les nouveaux paramètres : il faut rafraîchir l'affichage
 141         self.node.update()
 142         self.display_valeur()
 143         self.parent.appli.affiche_infos("FORMULE %s modifiée" %self.node.item.get_nom())
 144     else:
 145         # la formule est incorrecte : on affiche les erreurs
 146         widgets.showerror("Formule incorrecte",erreur)
 147         self.parent.appli.affiche_infos("FORMULE %s non modifiée" %self.node.item.get_nom())
 148
 149   def display_valeur(self):
 150     """
 151     Affiche dans self.widget_text de la valeur de l'objet FORMULE
 152     (annule d'éventuelles modifications faite par l'utilisateur)
 153     """
 154     # on efface tout texte affiché dans les entries
 155     self.entry_nom.delete(0,END)
 156     self.entry_arg.delete(0,END)
 157     self.entry_exp.delete(0,END)
 158     # on rafraîchit le titre du panneau
 159     self.titre.set('FORMULE '+self.node.item.get_nom())
 160     # on insére les nouveaux nom, type retourné, arguments et corps de la FORMULE
 161     nom = self.node.item.get_nom()
 162     if nom != '':
 163         self.entry_nom.insert(END,nom)
 164     args = self.node.item.get_args()
 165     if args:
 166         texte_args=""
 167         for i in args :
 168             if texte_args != "" :
 169                texte_args = texte_args +","
 170             texte_args=texte_args + i
 171         self.entry_arg.insert(END,texte_args)
 172     corps = self.node.item.get_corps()
 173     if corps :
 174         self.entry_exp.insert(END,self.node.item.get_corps())
 175
 176   def verif_nom(self,event=None):
 177         """
 178         Lance la vérification du nom présent dans entry_nom
 179         """
 180         nom = self.entry_nom.get()
 181         if nom == '':
 182             test,erreur = 0,"Aucun nom fourni !"
 183         else:
 184             test,erreur = self.node.item.verif_nom(nom)
 185         if not test:
 186             widgets.showerror("Nom invalide",erreur)
 187             self.entry_nom.focus()
 188             self.entry_nom.selection_range(0,END)
 189             self.parent.appli.affiche_infos("%s n'est pas un nom valide pour une FORMULE" %nom)
 190         else:
 191             self.parent.appli.affiche_infos("%s est un nom valide pour une FORMULE" %nom)
 192             self.entry_arg.focus()
 193
 194   def verif_arguments(self,event=None):
 195         """
 196         Lance la vérification des arguments présents dans entry_arg
 197         """
 198         arguments = self.entry_arg.get()
 199         if arguments == '' :
 200             test,erreur = 0,"Aucun argument fourni"
 201         else:
 202             test,erreur = self.node.item.verif_arguments(arguments)
 203         if not test:
 204             widgets.showerror("Argument(s) invalide(s)",erreur)
 205             self.entry_arg.focus()
 206             self.entry_arg.selection_range(0,END)
 207             self.parent.appli.affiche_infos("Argument(s) invalide(s) pour une FORMULE")
 208         else:
 209             self.parent.appli.affiche_infos("Argument(s) valide(s) pour une FORMULE")
 210             self.entry_exp.focus()
 211
 212   def verif_corps(self,event=None):
 213         """
 214         Lance la vérification du corps de formule présent dans entry_exp
 215         """
 216         new_nom = self.entry_nom.get()
 217         new_typ="REEL"
 218         new_arg = self.entry_arg.get()
 219         new_exp = self.entry_exp.get()
 220         if new_exp == '':
 221             test,erreur = 0,"Aucune expression fournie !"
 222         else:
 223             test,erreur = self.node.item.verif_formule_python((new_nom,new_typ,new_arg,new_exp))
 224
 225         if not test:
 226             widgets.showerror("Corps de FORMULE invalide",erreur)
 227             self.entry_exp.focus()
 228             self.entry_exp.selection_range(0,END)
 229             self.parent.appli.affiche_infos("Corps de FORMULE invalide")
 230         else:
 231             self.parent.appli.affiche_infos("Corps de FORMULE valide")
 232
 233 class FORMULETreeItem(compooper.EtapeTreeItem):
 234     """
 235     Classe servant à définir l'item porté par le noeud de l'arbre d'EFICAS
 236     qui représente la FORMULE
 237     """
 238     panel = FORMULEPanel
 239
 240     def init(self):
 241       self.setfunction = self.set_valeur
 242
 243 # ---------------------------------------------------------------------------
 244 #                   API de FORMULE pour l'arbre
 245 # ---------------------------------------------------------------------------
 246     def GetSubList(self):
 247       """
 248       Retourne la liste des fils de self
 249       On considère que FORMULE n'a pas de fils
 250       --> modification par rapport à MACRO classique
 251       """
 252       # dans EFICAS on ne souhaite pas afficher les mots-clés fils de FORMULE
 253       # de façon traditionnelle
 254       return []
 255
 256     def GetIconName(self):
 257       """
 258       Retourne le nom de l'icône à afficher dans l'arbre
 259       Ce nom dépend de la validité de l'objet
 260       """
 261       if self.object.isactif():
 262         self.object.state="modified"
 263         if self.object.isvalid():
 264           return "ast-green-square"
 265         else:
 266           return "ast-red-square"
 267       else:
 268         return "ast-white-text"
 269
 270     def GetLabelText(self):
 271       """ Retourne 3 valeurs :
 272       - le texte à afficher dans le noeud représentant l'item
 273       - la fonte dans laquelle afficher ce texte
 274       - la couleur du texte
 275       """
 276       if self.object.isactif():
 277         # None --> fonte et couleur par défaut
 278         return self.labeltext,None,None
 279       else:
 280         return self.labeltext,fontes.standard_italique,None
 281
 282 # ---------------------------------------------------------------------------
 283 #       Méthodes permettant la modification et la lecture des attributs
 284 #       du paramètre = API graphique de la FORMULE pour Panel et EFICAS
 285 # ---------------------------------------------------------------------------
 286
 287     def get_nom(self):
 288       """
 289       Retourne le nom de la FORMULE
 290       """
 291       return self.object.get_nom()
 292
 293     def get_type(self):
 294       """
 295       Retourne le type de la valeur retournée par la FORMULE
 296       """
 297       return self.object.type_retourne
 298
 299     def get_args(self):
 300       """
 301       Retourne les arguments de la FORMULE
 302       """
 303       args=""
 304       for mot in self.object.mc_liste:
 305           if mot.nom == 'NOM_PARA':
 306              args=mot.valeur
 307              break
 308       if args :
 309           if args[0] == "(" and args[-1] ==")":
 310              args=args[1:-1]
 311           # transforme en tuple si ce n est pas déjà le casa
 312           try :
 313              args=string.split(args,',')
 314           except :
 315              pass
 316       return args
 317
 318     def get_corps(self):
 319       """
 320       Retourne le corps de la FORMULE
 321       """
 322       corps=""
 323       for mot in self.object.mc_liste:
 324           if mot.nom == 'VALE':
 325              corps=mot.valeur
 326              break
 327       return corps
 328
 329
 330     def get_liste_types_autorises(self):
 331       """
 332          Retourne la liste des types autorises pour les valeurs de sortie
 333          d'une FORMULE
 334       """
 335       return self.object.l_types_autorises
 336
 337     def save_formule(self,new_nom,new_typ,new_arg,new_exp):
 338       """
 339       Vérifie si (new_nom,new_typ,new_arg,new_exp) définit bien une FORMULE
 340       licite :
 341           - si oui, stocke ces paramètres comme nouveaux paramètres de la
 342             FORMULE courante et retourne 1
 343           - si non, laisse les paramètres anciens de la FORMULE inchangés et
 344             retourne 0
 345       """
 346       test,erreur = self.object.verif_formule_python(formule=(new_nom,new_typ,new_arg,
 347                                                        new_exp))
 348       if test :
 349           # la formule est bien correcte : on sauve les nouveaux paramètres
 350           test=self.object.update_formule_python(formule=(new_nom,new_typ,new_exp,new_arg))
 351       return test,erreur
 352
 353 # ---------------------------------------------------------------------------
 354 #          Accès aux méthodes de vérification de l'objet FORM_ETAPE
 355 # ---------------------------------------------------------------------------
 356
 357     def verif_nom(self,nom):
 358         """
 359         Lance la vérification du nom passé en argument
 360         """
 361         return self.object.verif_nom(nom)
 362
 363     def verif_arguments(self,arguments):
 364         """
 365         Lance la vérification des arguments passés en argument
 366         """
 367         return self.object.verif_arguments('('+arguments+')')
 368
 369     def verif_formule(self,formule):
 370         """
 371         Lance la vérification de FORMULE passée en argument
 372         """
 373         return self.object.verif_formule(formule=formule)
 374
 375
 376     def verif_formule_python(self,formule):
 377         """
 378         Lance la vérification de FORMULE passée en argument
 379         """
 380         return self.object.verif_formule_python(formule=formule)
 381
 382 import Accas
 383 treeitem =FORMULETreeItem
 384 objet = Accas.FORM_ETAPE