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