Editeur/compoformule.py

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