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