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         self.entry_arg.insert(END,args)
 167     corps = self.node.item.get_corps()
 168     if corps :
 169         self.entry_exp.insert(END,self.node.item.get_corps())
 170
 171   def verif_nom(self,event=None):
 172         """
 173         Lance la vérification du nom présent dans entry_nom
 174         """
 175         nom = self.entry_nom.get()
 176         if nom == '':
 177             test,erreur = 0,"Aucun nom fourni !"
 178         else:
 179             test,erreur = self.node.item.verif_nom(nom)
 180         if not test:
 181             widgets.showerror("Nom invalide",erreur)
 182             self.entry_nom.focus()
 183             self.entry_nom.selection_range(0,END)
 184             self.parent.appli.affiche_infos("%s n'est pas un nom valide pour une FORMULE" %nom)
 185         else:
 186             self.parent.appli.affiche_infos("%s est un nom valide pour une FORMULE" %nom)
 187             self.entry_arg.focus()
 188
 189   def verif_arguments(self,event=None):
 190         """
 191         Lance la vérification des arguments présents dans entry_arg
 192         """
 193         arguments = self.entry_arg.get()
 194         if arguments == '' :
 195             test,erreur = 0,"Aucun argument fourni"
 196         else:
 197             test,erreur = self.node.item.verif_arguments(arguments)
 198         if not test:
 199             widgets.showerror("Argument(s) invalide(s)",erreur)
 200             self.entry_arg.focus()
 201             self.entry_arg.selection_range(0,END)
 202             self.parent.appli.affiche_infos("Argument(s) invalide(s) pour une FORMULE")
 203         else:
 204             self.parent.appli.affiche_infos("Argument(s) valide(s) pour une FORMULE")
 205             self.entry_exp.focus()
 206
 207   def verif_corps(self,event=None):
 208         """
 209         Lance la vérification du corps de formule présent dans entry_exp
 210         """
 211         new_nom = self.entry_nom.get()
 212         new_typ="REEL"
 213         new_arg = self.entry_arg.get()
 214         new_exp = self.entry_exp.get()
 215         if new_exp == '':
 216             test,erreur = 0,"Aucune expression fournie !"
 217         else:
 218             test,erreur = self.node.item.verif_formule_python((new_nom,new_typ,new_arg,new_exp))
 219
 220         if not test:
 221             widgets.showerror("Corps de FORMULE invalide",erreur)
 222             self.entry_exp.focus()
 223             self.entry_exp.selection_range(0,END)
 224             self.parent.appli.affiche_infos("Corps de FORMULE invalide")
 225         else:
 226             self.parent.appli.affiche_infos("Corps de FORMULE valide")
 227
 228 class FORMULETreeItem(compooper.EtapeTreeItem):
 229     """
 230     Classe servant à définir l'item porté par le noeud de l'arbre d'EFICAS
 231     qui représente la FORMULE
 232     """
 233     panel = FORMULEPanel
 234
 235     def init(self):
 236       self.setfunction = self.set_valeur
 237
 238 # ---------------------------------------------------------------------------
 239 #                   API de FORMULE pour l'arbre
 240 # ---------------------------------------------------------------------------
 241     def GetSubList(self):
 242       """
 243       Retourne la liste des fils de self
 244       On considère que FORMULE n'a pas de fils
 245       --> modification par rapport à MACRO classique
 246       """
 247       # dans EFICAS on ne souhaite pas afficher les mots-clés fils de FORMULE
 248       # de façon traditionnelle
 249       return []
 250
 251     def GetIconName(self):
 252       """
 253       Retourne le nom de l'icône à afficher dans l'arbre
 254       Ce nom dépend de la validité de l'objet
 255       """
 256       if self.object.isactif():
 257         self.object.state="modified"
 258         if self.object.isvalid():
 259           return "ast-green-square"
 260         else:
 261           return "ast-red-square"
 262       else:
 263         return "ast-white-text"
 264
 265     def GetLabelText(self):
 266       """ Retourne 3 valeurs :
 267       - le texte à afficher dans le noeud représentant l'item
 268       - la fonte dans laquelle afficher ce texte
 269       - la couleur du texte
 270       """
 271       if self.object.isactif():
 272         # None --> fonte et couleur par défaut
 273         return self.labeltext,None,None
 274       else:
 275         return self.labeltext,fontes.standard_italique,None
 276
 277 # ---------------------------------------------------------------------------
 278 #       Méthodes permettant la modification et la lecture des attributs
 279 #       du paramètre = API graphique de la FORMULE pour Panel et EFICAS
 280 # ---------------------------------------------------------------------------
 281
 282     def get_nom(self):
 283       """
 284       Retourne le nom de la FORMULE
 285       """
 286       return self.object.get_nom()
 287
 288     def get_type(self):
 289       """
 290       Retourne le type de la valeur retournée par la FORMULE
 291       """
 292       return self.object.type_retourne
 293
 294     def get_args(self):
 295       """
 296       Retourne les arguments de la FORMULE
 297       """
 298       args=""
 299       for mot in self.object.mc_liste:
 300           if mot.nom == 'NOM_PARA':
 301              args=mot.valeur
 302              break
 303       if args :
 304           if args[0] == "(" and args[-1] ==")":
 305              args=args[1:-1]
 306       return args
 307
 308     def get_corps(self):
 309       """
 310       Retourne le corps de la FORMULE
 311       """
 312       corps=""
 313       for mot in self.object.mc_liste:
 314           if mot.nom == 'VALE':
 315              corps=mot.valeur
 316              break
 317       return corps
 318
 319
 320     def get_liste_types_autorises(self):
 321       """
 322          Retourne la liste des types autorises pour les valeurs de sortie
 323          d'une FORMULE
 324       """
 325       return self.object.l_types_autorises
 326
 327     def save_formule(self,new_nom,new_typ,new_arg,new_exp):
 328       """
 329       Vérifie si (new_nom,new_typ,new_arg,new_exp) définit bien une FORMULE
 330       licite :
 331           - si oui, stocke ces paramètres comme nouveaux paramètres de la
 332             FORMULE courante et retourne 1
 333           - si non, laisse les paramètres anciens de la FORMULE inchangés et
 334             retourne 0
 335       """
 336       test,erreur = self.object.verif_formule_python(formule=(new_nom,new_typ,new_arg,
 337                                                        new_exp))
 338       if test :
 339           # la formule est bien correcte : on sauve les nouveaux paramètres
 340           test=self.object.update_formule_python(formule=(new_nom,new_typ,new_exp,new_arg))
 341       return test,erreur
 342
 343 # ---------------------------------------------------------------------------
 344 #          Accès aux méthodes de vérification de l'objet FORM_ETAPE
 345 # ---------------------------------------------------------------------------
 346
 347     def verif_nom(self,nom):
 348         """
 349         Lance la vérification du nom passé en argument
 350         """
 351         return self.object.verif_nom(nom)
 352
 353     def verif_arguments(self,arguments):
 354         """
 355         Lance la vérification des arguments passés en argument
 356         """
 357         return self.object.verif_arguments('('+arguments+')')
 358
 359     def verif_formule(self,formule):
 360         """
 361         Lance la vérification de FORMULE passée en argument
 362         """
 363         return self.object.verif_formule(formule=formule)
 364
 365
 366     def verif_formule_python(self,formule):
 367         """
 368         Lance la vérification de FORMULE passée en argument
 369         """
 370         return self.object.verif_formule_python(formule=formule)
 371
 372 import Accas
 373 treeitem =FORMULETreeItem
 374 objet = Accas.FORM_ETAPE