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