X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=Ihm%2FI_MCSIMP.py;h=507cead75a6b56c7edebc6af905de397aa995797;hb=2446a0c7137fa3418368ec577194a6d00e54ed65;hp=4fa441de1212ea025be2cbe7e4e3021f784d4a53;hpb=58b5829ebf53f3e8fd09707bb5abcdb154107d47;p=tools%2Feficas.git

diff --git a/Ihm/I_MCSIMP.py b/Ihm/I_MCSIMP.py
index 4fa441de..507cead7 100644
--- a/Ihm/I_MCSIMP.py
+++ b/Ihm/I_MCSIMP.py
@@ -1,3 +1,4 @@
+# -*- coding: utf-8 -*-
 #            CONFIGURATION MANAGEMENT OF EDF VERSION
 # ======================================================================
 # COPYRIGHT (C) 1991 - 2002  EDF R&D                  WWW.CODE-ASTER.ORG
@@ -39,54 +40,90 @@ from Noyau.N_utils import repr_float
 from Noyau.N_ASSD import ASSD,assd
 from Noyau.N_GEOM import GEOM,geom
 from Noyau.N_CO import CO
+import Accas
 # fin attention
 
 from Extensions import parametre
+from Extensions import param2
 import I_OBJECT
+import CONNECTOR
+from I_VALIDATOR import ValError,listProto
 
 class MCSIMP(I_OBJECT.OBJECT):
+
+  def GetNomConcept(self):
+      p=self
+      while p.parent :
+         try :
+            nomconcept=p.get_sdname()
+            return nomconcept
+         except:
+            try :
+               nomconcept= p.object.get_sdname()
+               return nomconcept
+            except :
+               pass
+         p=p.parent
+      return ""
+
   def GetText(self):
     """
         Retourne le texte à afficher dans l'arbre représentant la valeur de l'objet
         pointé par self
     """
+
     if self.valeur == None : 
       return None
     elif type(self.valeur) == types.FloatType : 
-      txt = repr_float(self.valeur)
+      # Traitement d'un flottant isolé
+      txt = str(self.valeur)
+      clefobj=self.GetNomConcept()
+      if self.jdc.appli.dict_reels.has_key(clefobj):
+        if self.jdc.appli.dict_reels[clefobj].has_key(self.valeur):
+           txt=self.jdc.appli.dict_reels[clefobj][self.valeur]
     elif type(self.valeur) in (types.ListType,types.TupleType) :
+      # Traitement des listes
       txt='('
-      i=0
+      sep=''
       for val in self.valeur:
         if type(val) == types.FloatType : 
-           txt=txt + i*',' + repr_float(val)
-        elif type(val) == types.InstanceType and isinstance(val,ASSD): 
-           txt = txt + i*',' + val.get_name()
+           clefobj=self.GetNomConcept()
+           if self.jdc.appli.dict_reels.has_key(clefobj):
+              if self.jdc.appli.dict_reels[clefobj].has_key(val):
+                 txt=txt + sep +self.jdc.appli.dict_reels[clefobj][val]
+              else :
+                 txt=txt + sep + str(val)
+           else :
+              txt=txt + sep + str(val)
         else: 
-           txt = txt + i*','+ myrepr.repr(val)
-        i=1
+           txt = txt + sep+ str(val)
+        if len(txt) > 200:
+            #ligne trop longue, on tronque
+            txt=txt+" ..."
+            break
+        sep=','
       txt=txt+')'
     else:
-      txt = self.getval()
-    if type(txt) != types.StringType:
-      if type(txt) == types.InstanceType:
-        if isinstance(txt,parametre.PARAMETRE):
-          return str(txt)
-      return repr(txt)
-    # il faut tronquer txt au delà d'un certain nombre de caractères
-    # et avant tout retour chariot (txt peut être une chaîne de caractères
-    # sur plusieurs lignes (ex:shell)
-    txt = string.split(txt,'\n')[0]
-    if len(txt) < 30 :
-      return txt
-    else:
-      return txt[0:29]
+      # Traitement des autres cas
+      txt = str(self.valeur)
+
+    # txt peut etre une longue chaine sur plusieurs lignes.
+    # Il est possible de tronquer cette chaine au premier \n et 
+    # de limiter la longueur de la chaine a 30 caracteres. Cependant
+    # ceci provoque une perte d'information pour l'utilisateur
+    # Pour le moment on retourne la chaine telle que
+    return txt
 
   def getval(self):
     """ 
        Retourne une chaîne de caractère représentant la valeur de self 
     """
     val=self.valeur
+    if type(val) == types.FloatType : 
+      clefobj=self.GetNomConcept()
+      if self.jdc.appli.dict_reels.has_key(clefobj):
+        if self.jdc.appli.dict_reels[clefobj].has_key(val):
+           return self.jdc.appli.dict_reels[clefobj][val]
     if type(val) != types.TupleType :
       try:
         return val.get_name()
@@ -102,16 +139,13 @@ class MCSIMP(I_OBJECT.OBJECT):
       s=s+' )'
       return s
 
-  def get_min_max(self):
-    return self.definition.min,self.definition.max
-
   def wait_co(self):
     """
         Méthode booléenne qui retourne 1 si l'objet attend un objet ASSD 
         qui n'existe pas encore (type CO()), 0 sinon
     """
     for typ in self.definition.type:
-      if type(typ) == types.ClassType :
+      if type(typ) == types.ClassType or isinstance(typ,type):
         if issubclass(typ,CO) :
            return 1
     return 0
@@ -122,7 +156,7 @@ class MCSIMP(I_OBJECT.OBJECT):
         ou dérivé, 0 sinon
     """
     for typ in self.definition.type:
-      if type(typ) == types.ClassType :
+      if type(typ) == types.ClassType or isinstance(typ,type):
         if issubclass(typ,ASSD) and not issubclass(typ,GEOM):
           return 1
     return 0
@@ -130,11 +164,11 @@ class MCSIMP(I_OBJECT.OBJECT):
   def wait_assd_or_geom(self):
     """ 
          Retourne 1 si le mot-clé simple attend un objet de type
-          assd, ASSD, geom ou GEOM
+         assd, ASSD, geom ou GEOM
          Retourne 0 dans le cas contraire
     """
     for typ in self.definition.type:
-      if type(typ) == types.ClassType :
+      if type(typ) == types.ClassType or isinstance(typ,type):
         if typ.__name__ in ("GEOM","ASSD","geom","assd") or issubclass(typ,GEOM) :
           return 1
     return 0
@@ -145,7 +179,7 @@ class MCSIMP(I_OBJECT.OBJECT):
          Retourne 0 dans le cas contraire
     """
     for typ in self.definition.type:
-      if type(typ) == types.ClassType :
+      if type(typ) == types.ClassType or isinstance(typ,type):
         if issubclass(typ,GEOM) : return 1
     return 0
 
@@ -173,141 +207,224 @@ class MCSIMP(I_OBJECT.OBJECT):
   def isoblig(self):
     return self.definition.statut=='o'
 
-  def set_valeur(self,new_valeur,evaluation='oui'):
-    """
-        Remplace la valeur de self(si elle existe) par new_valeur
-            - si evaluation = 'oui' : 
-                        essaie d'évaluer new_valeur dans le contexte
-            - si evaluation = 'non' : 
-                        n'essaie pas d'évaluer (on stocke une string ou 
-                        une valeur de la liste into )
-    """
-    if evaluation == 'oui' and not self.wait_assd_or_geom():
-      valeur,test = self.eval_valeur(new_valeur)
-      if test :
-        self.val = new_valeur
-        self.valeur = valeur
-        self.init_modif()
-        return 1
+  def valid_val(self,valeur):
+      """
+        Verifie que la valeur passee en argument (valeur) est valide
+        sans modifier la valeur courante 
+      """
+      lval=listProto.adapt(valeur)
+      if lval is None:
+         valid=0
+         mess="None n'est pas une valeur autorisée"
       else:
-        # On n'a pas trouve de concept ni réussi à évaluer la valeur 
-        # dans le contexte
-        # Si le mot cle simple attend un type CO on crée un objet de ce 
-        # type de nom new_valeur
-        if self.wait_co():
-          try:
-            # Pour avoir la classe CO avec tous ses comportements
-            from Accas import CO
-            self.valeur=CO(new_valeur)
-          except:
-            traceback.print_exc()
-            return 0
-          self.val=self.valeur
-          self.init_modif()
-          return 1
-        elif type(new_valeur)==types.StringType and self.wait_TXM():
-          self.val = new_valeur
-          self.valeur = new_valeur
-          self.init_modif()
-          return 1
-        else:
-          return 0
-    else :
-      # on ne fait aucune vérification ...
+         try:
+            for val in lval:
+                self.typeProto.adapt(val)
+                self.intoProto.adapt(val)
+            self.cardProto.adapt(lval)
+            if self.definition.validators:
+                self.definition.validators.convert(lval)
+            valid,mess=1,""
+         except ValError,e:
+            mess=str(e)
+            valid=0
+      return valid,mess
+
+  def valid_valeur(self,new_valeur):
+      """
+        Verifie que la valeur passee en argument (new_valeur) est valide
+        sans modifier la valeur courante (evite d'utiliser set_valeur et est plus performant)
+      """
+      validite,mess=self.valid_val(new_valeur)
+      return validite
+
+  def valid_valeur_partielle(self,new_valeur):
+      """
+        Verifie que la valeur passee en argument (new_valeur) est une liste partiellement valide
+        sans modifier la valeur courante du mot cle
+      """
+      validite=1
       try:
-        self.valeur = eval(new_valeur)
-        self.val = eval(new_valeur)
+          for val in new_valeur:
+              self.typeProto.adapt(val)
+              self.intoProto.adapt(val)
+              #on ne verifie pas la cardinalité
+              if self.definition.validators:
+                  validite=self.definition.validators.valide_liste_partielle(new_valeur)
+      except ValError,e:
+          validite=0
+
+      return validite
+
+  def update_condition_bloc(self):
+      """ Met a jour les blocs conditionnels dependant du mot cle simple self
+      """
+      if self.definition.position == 'global' : 
+         self.etape.deep_update_condition_bloc()
+      elif self.definition.position == 'global_jdc' :
+         self.jdc.deep_update_condition_bloc()
+      else:
+         self.parent.update_condition_bloc()
+
+  def set_valeur(self,new_valeur,evaluation='oui'):
+        #print "set_valeur",new_valeur
         self.init_modif()
-        return 1
-      except:
         self.valeur = new_valeur
         self.val = new_valeur
-        self.init_modif()
+        self.update_condition_bloc()
+        self.fin_modif()
         return 1
 
   def eval_valeur(self,new_valeur):
     """
         Essaie d'évaluer new_valeur comme une SD, une déclaration Python 
-        ou un EVAL:
-           Retourne la valeur évaluée (ou None) et le test de réussite (1 ou 0)
+        ou un EVAL: Retourne la valeur évaluée (ou None) et le test de réussite (1 ou 0)
     """
-    #sd = self.jdc.get_sd_avant_etape(new_valeur,self.etape)
-    sd = self.jdc.get_contexte_avant(self.etape).get(new_valeur,None)
-    if sd :
+    sd = self.jdc.get_sd_avant_etape(new_valeur,self.etape)
+    #sd = self.jdc.get_contexte_avant(self.etape).get(new_valeur,None)
+    #print sd
+    if sd is not None:
       return sd,1
+    lsd = self.jdc.cherche_list_avant(self.etape,new_valeur) 
+    if lsd :
+      return lsd,1
     else:
       d={}
       # On veut EVAL avec tous ses comportements. On utilise Accas. Perfs ??
-      from Accas import EVAL
-      d['EVAL']=EVAL
+      d['EVAL']=Accas.EVAL
       try :
         objet = eval(new_valeur,d)
         return objet,1
       except Exception:
+        itparam=self.cherche_item_parametre(new_valeur)
+        if itparam:
+             return itparam,1
+        try :
+             object=eval(new_valeur.valeur,d)
+        except :
+             pass
         if CONTEXT.debug : traceback.print_exc()
         return None,0
 
+  def eval_val(self,new_valeur):
+    """
+       Tente d'evaluer new_valeur comme un objet du jdc (par appel a eval_val_item)
+       ou comme une liste de ces memes objets
+       Si new_valeur contient au moins un separateur (,), tente l'evaluation sur
+       la chaine splittee
+    """
+    if type(new_valeur) in (types.ListType,types.TupleType):
+       valeurretour=[]
+       for item in new_valeur :
+          valeurretour.append(self.eval_val_item(item))
+       return valeurretour
+    else:
+       valeur=self.eval_val_item(new_valeur)
+       return valeur
+
+  def eval_val_item(self,new_valeur):
+    """
+       Tente d'evaluer new_valeur comme un concept, un parametre, un objet Python
+       Si c'est impossible retourne new_valeur inchange
+       argument new_valeur : string (nom de concept, de parametre, expression ou simple chaine)
+    """
+    if self.etape and self.etape.parent:
+       valeur=self.etape.parent.eval_in_context(new_valeur,self.etape)
+       return valeur
+    else:
+       try :
+           valeur = eval(val)
+           return valeur
+       except:
+           #traceback.print_exc()
+           return new_valeur
+           pass
+
+  def cherche_item_parametre (self,new_valeur):
+        try:
+          nomparam=new_valeur[0:new_valeur.find("[")]
+          indice=new_valeur[new_valeur.find("[")+1:new_valeur.find("]")]
+          for p in self.jdc.params:
+             if p.nom == nomparam :
+                if int(indice) < len(p.get_valeurs()):
+                   itparam=parametre.ITEM_PARAMETRE(p,int(indice))
+                   return itparam
+          return None
+        except:
+          return None
+
+  def update_concept(self,sd):
+    if type(self.valeur) in (types.ListType,types.TupleType) :
+       if sd in self.valeur:self.fin_modif()
+    else:
+       if sd == self.valeur:self.fin_modif()
+
   def delete_concept(self,sd):
     """ 
         Inputs :
-           sd=concept detruit
+           - sd=concept detruit
         Fonction :
-           Met a jour la valeur du mot cle simple suite à la disparition 
-           du concept sd
+        Met a jour la valeur du mot cle simple suite à la disparition 
+        du concept sd
     """
+    #print "delete_concept",sd
     if type(self.valeur) == types.TupleType :
       if sd in self.valeur:
+        self.init_modif()
         self.valeur=list(self.valeur)
         self.valeur.remove(sd)
-        self.init_modif()
+        self.fin_modif()
     elif type(self.valeur) == types.ListType:
       if sd in self.valeur:
-        self.valeur.remove(sd)
         self.init_modif()
+        self.valeur.remove(sd)
+        self.fin_modif()
     else:
       if self.valeur == sd:
+        self.init_modif()
         self.valeur=None
         self.val=None
-        self.init_modif()
+        self.fin_modif()
 
-  def copy(self):
-    """ Retourne une copie de self """
-    objet = self.makeobjet()
-    # il faut copier les listes et les tuples mais pas les autres valeurs
-    # possibles (réel,SD,...)
-    if type(self.valeur) in (types.ListType,types.TupleType):
-       objet.valeur = copy(self.valeur)
-    else:
-       objet.valeur = self.valeur
-    objet.val = objet.valeur
-    return objet
-
-  def makeobjet(self):
-    return self.definition(val = None, nom = self.nom,parent = self.parent)
-
-  def get_sd_utilisees(self):
-    """ 
-        Retourne une liste qui contient la SD utilisée par self si c'est le cas
-        ou alors une liste vide
+  def replace_concept(self,old_sd,sd):
     """
-    l=[]
-    if type(self.valeur) == types.InstanceType:
-      #XXX Est ce différent de isinstance(self.valeur,ASSD) ??
-      if issubclass(self.valeur.__class__,ASSD) : l.append(self.valeur)
-    return l
-
+        Inputs :
+           - old_sd=concept remplacé
+           - sd=nouveau concept
+        Fonction :
+        Met a jour la valeur du mot cle simple suite au remplacement 
+        du concept old_sd
+    """
+    #print "replace_concept",old_sd,sd
+    if type(self.valeur) == types.TupleType :
+      if old_sd in self.valeur:
+        self.init_modif()
+        self.valeur=list(self.valeur)
+        i=self.valeur.index(old_sd)
+        self.valeur[i]=sd
+        self.fin_modif()
+    elif type(self.valeur) == types.ListType:
+      if old_sd in self.valeur:
+        self.init_modif()
+        i=self.valeur.index(old_sd)
+        self.valeur[i]=sd
+        self.fin_modif()
+    else:
+      if self.valeur == old_sd:
+        self.init_modif()
+        self.valeur=sd
+        self.val=sd
+        self.fin_modif()
 
   def set_valeur_co(self,nom_co):
       """
           Affecte à self l'objet de type CO et de nom nom_co
       """
+      #print "set_valeur_co",nom_co
       step=self.etape.parent
       if nom_co == None or nom_co == '':
          new_objet=None
       else:
-         # Pour le moment on importe en local le CO de Accas.
-         # Si problème de perfs, il faudra faire autrement
-         from Accas import CO
          # Avant de créer un concept il faut s'assurer du contexte : step 
          # courant
          sd= step.get_sd_autour_etape(nom_co,self.etape,avec='oui')
@@ -324,48 +441,48 @@ class MCSIMP(I_OBJECT.OBJECT):
          CONTEXT.unset_current_step()
          CONTEXT.set_current_step(step)
          step.set_etape_context(self.etape)
-         new_objet = CO(nom_co)
+         new_objet = Accas.CO(nom_co)
          CONTEXT.unset_current_step()
          CONTEXT.set_current_step(cs)
+      self.init_modif()
       self.valeur = new_objet
       self.val = new_objet
-      self.init_modif()
-      step.reset_context()
       # On force l'enregistrement de new_objet en tant que concept produit 
       # de la macro en appelant get_type_produit avec force=1
       self.etape.get_type_produit(force=1)
+      self.fin_modif()
+      step.reset_context()
+      #print "set_valeur_co",new_objet
       return 1,"Concept créé"
-	
-  def reparent(self,parent):
-     """
-         Cette methode sert a reinitialiser la parente de l'objet
-     """
-     self.parent=parent
-     self.jdc=parent.jdc
-     self.etape=parent.etape
-
+        
   def verif_existence_sd(self):
      """
         Vérifie que les structures de données utilisées dans self existent bien dans le contexte
-	avant étape, sinon enlève la référence à ces concepts
+        avant étape, sinon enlève la référence à ces concepts
      """
+     #print "verif_existence_sd"
+     # Attention : possible probleme avec include
+     # A priori il n'y a pas de raison de retirer les concepts non existants
+     # avant etape. En fait il s'agit uniquement eventuellement de ceux crees par une macro
      l_sd_avant_etape = self.jdc.get_contexte_avant(self.etape).values()  
      if type(self.valeur) in (types.TupleType,types.ListType) :
        l=[]
        for sd in self.valeur:
          if isinstance(sd,ASSD) :
-	    if sd in l_sd_avant_etape :
-	       l.append(sd)
-	 else:
-	    l.append(sd)
-       self.valeur=l
-       self.init_modif()
+            if sd in l_sd_avant_etape or self.etape.get_sdprods(sd.nom) is sd:
+               l.append(sd)
+         else:
+            l.append(sd)
+       if len(l) < len(self.valeur):
+          self.init_modif()
+          self.valeur=tuple(l)
+          self.fin_modif()
      else:
        if isinstance(self.valeur,ASSD) :
-	  if self.valeur not in l_sd_avant_etape :
-	     self.valeur = None
+          if self.valeur not in l_sd_avant_etape and self.etape.get_sdprods(self.valeur.nom) is None:
              self.init_modif()
- 
+             self.valeur = None
+             self.fin_modif()
  
   def get_min_max(self):
      """
@@ -379,17 +496,89 @@ class MCSIMP(I_OBJECT.OBJECT):
      Retourne le type attendu par le mot-clé simple
      """
      return self.definition.type
+
+  def delete_mc_global(self):
+      """ Retire self des declarations globales
+      """
+      if self.definition.position == 'global' : 
+         etape = self.get_etape()
+         if etape :
+            del etape.mc_globaux[self.nom]
+      elif self.definition.position == 'global_jdc' :
+         del self.jdc.mc_globaux[self.nom]
+
+  def update_mc_global(self):
+     """
+        Met a jour les mots cles globaux enregistrés dans l'étape parente
+        et dans le jdc parent.
+        Un mot cle simple peut etre global. 
+     """
+     if self.definition.position == 'global' :
+        etape = self.get_etape()
+        if etape :
+           etape.mc_globaux[self.nom]=self
+     elif self.definition.position == 'global_jdc' :
+        if self.jdc:
+           self.jdc.mc_globaux[self.nom]=self
+
+  def nbrColonnes(self):
+     genea = self.get_genealogie()
+     if "VALE_C" in genea and "DEFI_FONCTION" in genea : return 3
+     if "VALE" in genea and "DEFI_FONCTION" in genea : return 2
+     return 0
+
+  def valide_item(self,item):
+      """Valide un item isolé. Cet item est candidat à l'ajout à la liste existante"""
+      valid=1
+      try:
+          #on verifie le type
+          self.typeProto.adapt(item)
+          #on verifie les choix possibles
+          self.intoProto.adapt(item)
+          #on ne verifie pas la cardinalité
+          if self.definition.validators:
+              valid=self.definition.validators.verif_item(item)
+      except ValError,e:
+          #traceback.print_exc()
+          valid=0
+      return valid
+
+  def verif_type(self,item):
+      """Verifie le type d'un item de liste"""
+      try:
+          #on verifie le type
+          self.typeProto.adapt(item)
+          #on verifie les choix possibles
+          self.intoProto.adapt(item)
+          #on ne verifie pas la cardinalité mais on verifie les validateurs
+          if self.definition.validators:
+              valid=self.definition.validators.verif_item(item)
+          comment=""
+          valid=1
+      except ValError,e:
+          #traceback.print_exc()
+          comment=str(e)
+          valid=0
+      return valid,comment
+
+#--------------------------------------------------------------------------------
  
- 
- 
- 
- 
- 
- 
- 
- 
- 
- 
- 
- 
- 
+#ATTENTION SURCHARGE : toutes les methodes ci apres sont des surcharges du Noyau et de Validation
+# Elles doivent etre reintegrees des que possible
+
+
+  def verif_typeihm(self,val,cr='non'):
+      try :
+         val.eval()
+         return 1
+      except :
+         traceback.print_exc()
+         pass
+      return self.verif_type(val,cr)
+
+  def verif_typeliste(self,val,cr='non') :
+      verif=0
+      for v in val :
+        verif=verif+self.verif_typeihm(v,cr)
+      return verif
+