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