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