pb de check box

[tools/eficas.git] / Ihm / I_FORM_ETAPE.py

diff --git a/Ihm/I_FORM_ETAPE.py b/Ihm/I_FORM_ETAPE.py
index 37323c9a64bcb1c2181079573eede5af71337fbf..8318bee39843ac580d89f095b871e4ffcd93a1a0 100644 (file)
--- a/Ihm/I_FORM_ETAPE.py
+++ b/Ihm/I_FORM_ETAPE.py
@@ -19,16 +19,17 @@
 #
 """
 """
 #
 """
 """

+from __future__ import absolute_import

 import string,traceback,re
 identifier = re.compile(r"^[^\d\W]\w*\Z", re.UNICODE)
 
 
 from Extensions.i18n import tr
 import string,traceback,re
 identifier = re.compile(r"^[^\d\W]\w*\Z", re.UNICODE)
 
 
 from Extensions.i18n import tr

-from I_MACRO_ETAPE import MACRO_ETAPE
+from .I_MACRO_ETAPE import MACRO_ETAPE

 from Extensions import interpreteur_formule
 from Editeur import analyse_catalogue
 
 from Extensions import interpreteur_formule
 from Editeur import analyse_catalogue
 

-analyse_catalogue.l_noms_commandes.append('FORM') # déclare le nom FORM à l'analyseur de catalogue
+analyse_catalogue.l_noms_commandes.append('FORM') # declare le nom FORM a l'analyseur de catalogue

 
 
 class FORM_ETAPE(MACRO_ETAPE):
 
 
 class FORM_ETAPE(MACRO_ETAPE):


@@ -37,24 +38,24 @@ class FORM_ETAPE(MACRO_ETAPE):
 
     def McBuild(self):
         self.mc_liste=self.build_mc()
 
     def McBuild(self):
         self.mc_liste=self.build_mc()

-        # on crée la liste des types autorisés (liste des noms de mots-clés
+        # on cree la liste des types autorises (liste des noms de mots-cles

         # simples dans le catalogue de FORMULE)
         # simples dans le catalogue de FORMULE)

-        self.l_types_autorises = self.definition.entites.keys()
+        self.l_types_autorises = list(self.definition.entites.keys())

         # en plus de la construction traditionnelle des fils de self
         # en plus de la construction traditionnelle des fils de self

-        # il faut pour les FORMULE décortiquer l'expression ...
+        # il faut pour les FORMULE decortiquer l'expression ...

         self.type_retourne,self.arguments,self.corps = self.analyse_formule()
 
 
     def analyse_formule(self):
         """
         self.type_retourne,self.arguments,self.corps = self.analyse_formule()
 
 
     def analyse_formule(self):
         """

-        Cette méthode décortique l'expression de la FORMULE.
+        Cette methode decortique l'expression de la FORMULE.

         Elle retourne 3 valeurs:
         Elle retourne 3 valeurs:

-            - le type retourné par la FORMULE
+            - le type retourne par la FORMULE

             - les arguments de la FORMULE
             - le corps de la FORMULE, cad son expression
         """
         if len(self.mc_liste) == 0:
             - les arguments de la FORMULE
             - le corps de la FORMULE, cad son expression
         """
         if len(self.mc_liste) == 0:

-            # pas de fils pour self --> la FORMULE est incomplète
+            # pas de fils pour self --> la FORMULE est incomplete

             return None,None,None
         type_retourne="REEL"
         if len(self.mc_liste) > 0:
             return None,None,None
         type_retourne="REEL"
         if len(self.mc_liste) > 0:


@@ -81,7 +82,7 @@ class FORM_ETAPE(MACRO_ETAPE):
 
     def get_formule(self):
         """
 
     def get_formule(self):
         """

-        Retourne un tuple décrivant la formule :
+        Retourne un tuple decrivant la formule :

         (nom,type_retourne,arguments,corps)
         """
         t,a,c = self.analyse_formule()
         (nom,type_retourne,arguments,corps)
         """
         t,a,c = self.analyse_formule()


@@ -90,17 +91,17 @@ class FORM_ETAPE(MACRO_ETAPE):
 
     def verif_arguments(self,arguments = None):
         """
 
     def verif_arguments(self,arguments = None):
         """

-        Vérifie si les arguments passés en argument (si aucun prend les arguments courants)
+        Verifie si les arguments passes en argument (si aucun prend les arguments courants)

         sont des arguments valide pour une FORMULE.
         Retourne :
         sont des arguments valide pour une FORMULE.
         Retourne :

-            - un booléen, qui vaut 1 si arguments licites, 0 sinon
+            - un booleen, qui vaut 1 si arguments licites, 0 sinon

             - un message d'erreurs ('' si illicites)
         """
         if not arguments :
             arguments = self.arguments
         if not arguments :
             return 0,"Une formule doit avoir au minimum un argument"
             - un message d'erreurs ('' si illicites)
         """
         if not arguments :
             arguments = self.arguments
         if not arguments :
             return 0,"Une formule doit avoir au minimum un argument"

-        # il faut au préalable enlever les parenthèses ouvrantes et fermantes
+        # il faut au prealable enlever les parentheses ouvrantes et fermantes

         # encadrant les arguments
         arguments = string.strip(arguments)
         if arguments[0] != '(':
         # encadrant les arguments
         arguments = string.strip(arguments)
         if arguments[0] != '(':


@@ -110,7 +111,7 @@ class FORM_ETAPE(MACRO_ETAPE):
         # on peut tester la syntaxe de chaque argument maintenant
         erreur=''
         test = 1
         # on peut tester la syntaxe de chaque argument maintenant
         erreur=''
         test = 1

-        arguments = arguments[1:-1] # on enlève les parenthèses ouvrante et fermante
+        arguments = arguments[1:-1] # on enleve les parentheses ouvrante et fermante

         l_arguments = string.split(arguments,',')
         for a in l_arguments :
             if not re.match(identifier,str(a)) : return 0, str(a)+" n est pas un identifiant"
         l_arguments = string.split(arguments,',')
         for a in l_arguments :
             if not re.match(identifier,str(a)) : return 0, str(a)+" n est pas un identifiant"


@@ -118,10 +119,10 @@ class FORM_ETAPE(MACRO_ETAPE):
 
     def verif_corps(self,corps=None,arguments=None):
         """
 
     def verif_corps(self,corps=None,arguments=None):
         """

-        Cette méthode a pour but de vérifier si le corps de la FORMULE
+        Cette methode a pour but de verifier si le corps de la FORMULE

         est syntaxiquement correct.
         Retourne :
         est syntaxiquement correct.
         Retourne :

-            - un booléen, qui vaut 1 si corps de FORMULE licite, 0 sinon
+            - un booleen, qui vaut 1 si corps de FORMULE licite, 0 sinon

             - un message d'erreurs ('' si illicite)
         """
         if not corps :
             - un message d'erreurs ('' si illicite)
         """
         if not corps :


@@ -129,10 +130,10 @@ class FORM_ETAPE(MACRO_ETAPE):
         if not arguments :
             arguments = self.arguments
         formule=(self.get_nom(),self.type_retourne,arguments,corps)
         if not arguments :
             arguments = self.arguments
         formule=(self.get_nom(),self.type_retourne,arguments,corps)

-        # on récupère la liste des constantes et des autres fonctions prédéfinies
-        # et qui peuvent être utilisées dans le corps de la formule courante
+        # on recupere la liste des constantes et des autres fonctions predefinies
+        # et qui peuvent etre utilisees dans le corps de la formule courante

         l_ctes,l_form = self.jdc.get_parametres_fonctions_avant_etape(self)
         l_ctes,l_form = self.jdc.get_parametres_fonctions_avant_etape(self)

-        # on crée un objet vérificateur
+        # on cree un objet verificateur

         try:
             verificateur = self.interpreteur(formule=formule,
                                              constantes = l_ctes,
         try:
             verificateur = self.interpreteur(formule=formule,
                                              constantes = l_ctes,


@@ -144,10 +145,10 @@ class FORM_ETAPE(MACRO_ETAPE):
 
     def verif_nom(self,nom=None):
         """
 
     def verif_nom(self,nom=None):
         """

-        Vérifie si le nom passé en argument (si aucun prend le nom courant)
+        Verifie si le nom passe en argument (si aucun prend le nom courant)

         est un nom valide pour une FORMULE.
         Retourne :
         est un nom valide pour une FORMULE.
         Retourne :

-            - un booléen, qui vaut 1 si nom licite, 0 sinon
+            - un booleen, qui vaut 1 si nom licite, 0 sinon

             - un message d'erreurs ('' si illicite)
         """
         if not nom :
             - un message d'erreurs ('' si illicite)
         """
         if not nom :


@@ -165,10 +166,10 @@ class FORM_ETAPE(MACRO_ETAPE):
 
     def verif_type(self,type=None):
         """
 
     def verif_type(self,type=None):
         """

-        Vérifie si le type passé en argument (si aucun prend le type courant)
+        Verifie si le type passe en argument (si aucun prend le type courant)

         est un type valide pour une FORMULE.
         Retourne :
         est un type valide pour une FORMULE.
         Retourne :

-            - un booléen, qui vaut 1 si type licite, 0 sinon
+            - un booleen, qui vaut 1 si type licite, 0 sinon

             - un message d'erreurs ('' si illicite)
         """
         if not type:
             - un message d'erreurs ('' si illicite)
         """
         if not type:


@@ -181,11 +182,11 @@ class FORM_ETAPE(MACRO_ETAPE):
 
     def verif_formule(self,formule=None):
         """
 
     def verif_formule(self,formule=None):
         """

-        Vérifie la validité de la formule passée en argument.
-        Cette nouvelle formule est passée sous la forme d'un tuple : (nom,type_retourne,arguments,corps)
-        Si aucune formule passée, prend les valeurs courantes de la formule
+        Verifie la validite de la formule passee en argument.
+        Cette nouvelle formule est passee sous la forme d'un tuple : (nom,type_retourne,arguments,corps)
+        Si aucune formule passee, prend les valeurs courantes de la formule

         Retourne :
         Retourne :

-            - un booléen, qui vaut 1 si formule licite, 0 sinon
+            - un booleen, qui vaut 1 si formule licite, 0 sinon

             - un message d'erreurs ('' si illicite)
         """
         if not formule :
             - un message d'erreurs ('' si illicite)
         """
         if not formule :


@@ -200,7 +201,7 @@ class FORM_ETAPE(MACRO_ETAPE):
         test_corps,erreur_corps = self.verif_corps(corps = formule[3], arguments = args)
         # test global = produit des tests partiels
         test = test_nom*test_type*test_arguments*test_corps
         test_corps,erreur_corps = self.verif_corps(corps = formule[3], arguments = args)
         # test global = produit des tests partiels
         test = test_nom*test_type*test_arguments*test_corps

-        # message d'erreurs global = concaténation des messages partiels
+        # message d'erreurs global = concatenation des messages partiels

         erreur = ''
         if not test :
             for mess in (erreur_nom,erreur_type,erreur_arguments,erreur_corps):
         erreur = ''
         if not test :
             for mess in (erreur_nom,erreur_type,erreur_arguments,erreur_corps):


@@ -239,17 +240,17 @@ class FORM_ETAPE(MACRO_ETAPE):
 
     def update(self,formule):
         """
 
     def update(self,formule):
         """

-        Méthode externe.
-        Met à jour les champs nom, type_retourne,arguments et corps de la FORMULE
-        par les nouvelles valeurs passées dans le tuple formule.
-        On stocke les valeurs SANS vérifications.
+        Methode externe.
+        Met a jour les champs nom, type_retourne,arguments et corps de la FORMULE
+        par les nouvelles valeurs passees dans le tuple formule.
+        On stocke les valeurs SANS verifications.

         """
         self.type_retourne = formule[1]
         self.arguments = '('+formule[2]+')'
         self.corps = formule[3]
         """
         self.type_retourne = formule[1]
         self.arguments = '('+formule[2]+')'
         self.corps = formule[3]

-        # il faut ajouter le mot-clé simple correspondant dans mc_liste
-        # pour cela on utilise la méthode générale build_mc
-        # du coup on est obligé de modifier le dictionnaire valeur de self ...
+        # il faut ajouter le mot-cle simple correspondant dans mc_liste
+        # pour cela on utilise la methode generale build_mc
+        # du coup on est oblige de modifier le dictionnaire valeur de self ...

         self.valeur = {}
         self.valeur[self.type_retourne] = self.arguments+' = ' + self.corps
         self.McBuild()
         self.valeur = {}
         self.valeur[self.type_retourne] = self.arguments+' = ' + self.corps
         self.McBuild()


@@ -283,7 +284,7 @@ class FORM_ETAPE(MACRO_ETAPE):
           mocles["VALE_C"]=formule[2]
 
         for k,v in self.definition.entites.items():
           mocles["VALE_C"]=formule[2]
 
         for k,v in self.definition.entites.items():

-            if not mocles.has_key(k):continue
+            if not k in  mocles : continue

             child=self.definition.entites[k](None,nom=k,parent=self)
             child.valeur=mocles[k]
             child.state = 'modified'
             child=self.definition.entites[k](None,nom=k,parent=self)
             child.valeur=mocles[k]
             child.state = 'modified'


@@ -330,10 +331,10 @@ class FORM_ETAPE(MACRO_ETAPE):
            - sd=concept detruit
          Fonction :
          Mettre a jour les mots cles de l etape et eventuellement le concept produit si reuse
            - sd=concept detruit
          Fonction :
          Mettre a jour les mots cles de l etape et eventuellement le concept produit si reuse

-         suite à la disparition du concept sd
+         suite a la disparition du concept sd

          Seuls les mots cles simples MCSIMP font un traitement autre que de transmettre aux fils,
          Seuls les mots cles simples MCSIMP font un traitement autre que de transmettre aux fils,

-         sauf les objets FORM_ETAPE qui doivent vérifier que le concept détruit n'est pas 
-         utilisé dans le corps de la fonction
+         sauf les objets FORM_ETAPE qui doivent verifier que le concept detruit n'est pas 
+         utilise dans le corps de la fonction

         """
         self.init_modif()
          
         """
         self.init_modif()
          


@@ -343,8 +344,8 @@ class FORM_ETAPE(MACRO_ETAPE):
            - old_sd=concept remplace
            - sd = nouveau concept
          Fonction :
            - old_sd=concept remplace
            - sd = nouveau concept
          Fonction :

-         Les objets FORM_ETAPE devraient vérifier que le concept remplacé n'est pas
-         utilisé dans le corps de la fonction
+         Les objets FORM_ETAPE devraient verifier que le concept remplace n'est pas
+         utilise dans le corps de la fonction

         """
         self.init_modif()
 
         """
         self.init_modif()