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