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