Ihm/I_MCSIMP.py

   1 import types,string
   2 import traceback
   3 from copy import copy
   4 from repr import Repr
   5 myrepr = Repr()
   6 myrepr.maxstring = 100
   7 myrepr.maxother = 100
   8
   9 from Noyau.N_utils import repr_float
  10 from Noyau.N_ASSD import ASSD,assd
  11 from Noyau.N_GEOM import GEOM,geom
  12 from Noyau.N_CO import CO
  13 from Noyau.N_EVAL import EVAL
  14 from Extensions import parametre
  15 import I_OBJECT
  16
  17 class MCSIMP(I_OBJECT.OBJECT):
  18   def GetText(self):
  19     """
  20         Retourne le texte à afficher dans l'arbre représentant la valeur de l'objet
  21         pointé par self
  22     """
  23     if self.valeur == None :
  24       return None
  25     elif type(self.valeur) == types.FloatType :
  26       txt = repr_float(self.valeur)
  27     elif type(self.valeur) in (types.ListType,types.TupleType) :
  28       txt='('
  29       i=0
  30       for val in self.valeur:
  31         if type(val) == types.FloatType :
  32            txt=txt + i*',' + repr_float(val)
  33         elif type(val) == types.InstanceType and isinstance(val,ASSD):
  34            txt = txt + i*',' + val.get_name()
  35         else:
  36            txt = txt + i*','+ myrepr.repr(val)
  37         i=1
  38       txt=txt+')'
  39     else:
  40       txt = self.getval()
  41     if type(txt) != types.StringType:
  42       if type(txt) == types.InstanceType:
  43         if isinstance(txt,parametre.PARAMETRE):
  44           return str(txt)
  45       return repr(txt)
  46     # il faut tronquer txt au delà d'un certain nombre de caractères
  47     # et avant tout retour chariot (txt peut être une chaîne de caractères
  48     # sur plusieurs lignes (ex:shell)
  49     txt = string.split(txt,'\n')[0]
  50     if len(txt) < 30 :
  51       return txt
  52     else:
  53       return txt[0:29]
  54
  55   def getval(self):
  56     """
  57        Retourne une chaîne de caractère représentant la valeur de self
  58     """
  59     val=self.valeur
  60     if type(val) != types.TupleType :
  61       try:
  62         return val.get_name()
  63       except:
  64         return val
  65     else :
  66       s='( '
  67       for item in val :
  68         try :
  69           s=s+item.get_name()+','
  70         except:
  71           s=s+`item`+','
  72       s=s+' )'
  73       return s
  74
  75   def get_min_max(self):
  76     return self.definition.min,self.definition.max
  77
  78   def wait_co(self):
  79     """
  80         Méthode booléenne qui retourne 1 si l'objet attend un objet ASSD
  81         qui n'existe pas encore (type CO()), 0 sinon
  82     """
  83     for typ in self.definition.type:
  84       if type(typ) == types.ClassType :
  85         if typ is CO : return 1
  86     return 0
  87
  88   def wait_assd(self):
  89     """
  90         Méthode booléenne qui retourne 1 si le MCS attend un objet de type ASSD
  91         ou dérivé, 0 sinon
  92     """
  93     for typ in self.definition.type:
  94       if type(typ) == types.ClassType :
  95         if issubclass(typ,ASSD) and not issubclass(typ,GEOM):
  96           return 1
  97     return 0
  98
  99   def wait_assd_or_geom(self):
 100     """
 101          Retourne 1 si le mot-clé simple attend un objet de type
 102           assd, ASSD, geom ou GEOM
 103          Retourne 0 dans le cas contraire
 104     """
 105     for typ in self.definition.type:
 106       if type(typ) == types.ClassType :
 107         if typ in (GEOM,ASSD,geom,assd) or issubclass(typ,GEOM) :
 108           return 1
 109     return 0
 110
 111   def wait_geom(self):
 112     """
 113          Retourne 1 si le mot-clé simple attend un objet de type GEOM
 114          Retourne 0 dans le cas contraire
 115     """
 116     for typ in self.definition.type:
 117       if type(typ) == types.ClassType :
 118         if issubclass(typ,GEOM) : return 1
 119     return 0
 120
 121   def wait_TXM(self):
 122     """
 123          Retourne 1 si le mot-clé simple attend un objet de type TXM
 124          Retourne 0 dans le cas contraire
 125     """
 126     for typ in self.definition.type:
 127       if typ == 'TXM' :return 1
 128     return 0
 129
 130   def get_liste_valeurs(self):
 131     """
 132     """
 133     if self.valeur == None:
 134       return []
 135     elif type(self.valeur) == types.TupleType:
 136       return list(self.valeur)
 137     elif type(self.valeur) == types.ListType:
 138       return self.valeur
 139     else:
 140       return [self.valeur]
 141
 142   def isoblig(self):
 143     return self.definition.statut=='o'
 144
 145   def set_valeur(self,new_valeur,evaluation='oui'):
 146     """
 147         Remplace la valeur de self(si elle existe) par new_valeur
 148             - si evaluation = 'oui' :
 149                         essaie d'évaluer new_valeur dans le contexte
 150             - si evaluation = 'non' :
 151                         n'essaie pas d'évaluer (on stocke une string ou
 152                         une valeur de la liste into )
 153     """
 154     if evaluation == 'oui' and not self.wait_assd_or_geom():
 155       valeur,test = self.eval_valeur(new_valeur)
 156       if test :
 157         self.val = new_valeur
 158         self.valeur = valeur
 159         self.init_modif()
 160         return 1
 161       else:
 162         # On n'a pas trouve de concept ni réussi à évaluer la valeur
 163         # dans le contexte
 164         # Si le mot cle simple attend un type CO on crée un objet de ce
 165         # type de nom new_valeur
 166         if self.wait_co():
 167           try:
 168             self.valeur=CO(new_valeur)
 169           except:
 170             traceback.print_exc()
 171             return 0
 172           self.val=self.valeur
 173           self.init_modif()
 174           return 1
 175         elif type(new_valeur)==types.StringType and self.wait_TXM():
 176           self.val = new_valeur
 177           self.valeur = new_valeur
 178           self.init_modif()
 179           return 1
 180         else:
 181           return 0
 182     else :
 183       # on ne fait aucune vérification ...
 184       try:
 185         self.valeur = eval(new_valeur)
 186         self.val = eval(new_valeur)
 187         self.init_modif()
 188         return 1
 189       except:
 190         self.valeur = new_valeur
 191         self.val = new_valeur
 192         self.init_modif()
 193         return 1
 194
 195   def eval_valeur(self,new_valeur):
 196     """
 197         Essaie d'évaluer new_valeur comme une SD, une déclaration Python
 198         ou un EVAL:
 199            Retourne la valeur évaluée (ou None) et le test de réussite (1 ou 0)
 200     """
 201     #sd = self.jdc.get_sd_avant_etape(new_valeur,self.etape)
 202     sd = self.jdc.get_contexte_avant(self.etape).get(new_valeur,None)
 203     if sd :
 204       return sd,1
 205     else:
 206       d={}
 207       d['EVAL']=EVAL
 208       try :
 209         objet = eval(new_valeur,d)
 210         return objet,1
 211       except Exception:
 212         if CONTEXT.debug : traceback.print_exc()
 213         return None,0
 214
 215   def delete_concept(self,sd):
 216     """
 217         Inputs :
 218            sd=concept detruit
 219         Fonction :
 220            Met a jour la valeur du mot cle simple suite à la disparition
 221            du concept sd
 222     """
 223     if type(self.valeur) == types.TupleType :
 224       if sd in self.valeur:
 225         self.valeur=list(self.valeur)
 226         self.valeur.remove(sd)
 227         self.init_modif()
 228     elif type(self.valeur) == types.ListType:
 229       if sd in self.valeur:
 230         self.valeur.remove(sd)
 231         self.init_modif()
 232     else:
 233       if self.valeur == sd:
 234         self.valeur=None
 235         self.val=None
 236         self.init_modif()
 237
 238   def copy(self):
 239     """ Retourne une copie de self """
 240     objet = self.makeobjet()
 241     #XXX est ce utile ??
 242     objet.valeur = copy(self.valeur)
 243     objet.val = copy(self.val)
 244     return objet
 245
 246   def makeobjet(self):
 247     return self.definition(val = None, nom = self.nom,parent = self.parent)
 248
 249   def get_sd_utilisees(self):
 250     """
 251         Retourne une liste qui contient la SD utilisée par self si c'est le cas
 252         ou alors une liste vide
 253     """
 254     l=[]
 255     if type(self.valeur) == types.InstanceType:
 256       #XXX Est ce différent de isinstance(self.valeur,ASSD) ??
 257       if issubclass(self.valeur.__class__,ASSD) : l.append(self.valeur)
 258     return l
 259
 260
 261   def set_valeur_co(self,nom_co):
 262       """
 263       Affecte à self l'objet de type CO et de nom nom_co
 264       """
 265       new_objet = CO(nom_co)
 266       self.valeur = new_objet
 267       self.val = new_objet
 268       self.init_modif()
 269