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
  11 # Attention : les classes ASSD,.... peuvent etre surchargées
  12 # dans le package Accas. Il faut donc prendre des précautions si
  13 # on utilise les classes du Noyau pour faire des tests (isxxxx, ...)
  14 # Si on veut créer des objets comme des CO avec les classes du noyau
  15 # ils n'auront pas les conportements des autres packages (pb!!!)
  16 # Il vaut mieux les importer d'Accas mais problème d'import circulaire,
  17 # on ne peut pas les importer au début.
  18 # On fait donc un import local quand c'est nécessaire (peut occasionner
  19 # des pbs de prformance).
  20 from Noyau.N_ASSD import ASSD,assd
  21 from Noyau.N_GEOM import GEOM,geom
  22 from Noyau.N_CO import CO
  23 # fin attention
  24
  25 from Extensions import parametre
  26 import I_OBJECT
  27
  28 class MCSIMP(I_OBJECT.OBJECT):
  29   def GetText(self):
  30     """
  31         Retourne le texte à afficher dans l'arbre représentant la valeur de l'objet
  32         pointé par self
  33     """
  34     if self.valeur == None :
  35       return None
  36     elif type(self.valeur) == types.FloatType :
  37       txt = repr_float(self.valeur)
  38     elif type(self.valeur) in (types.ListType,types.TupleType) :
  39       txt='('
  40       i=0
  41       for val in self.valeur:
  42         if type(val) == types.FloatType :
  43            txt=txt + i*',' + repr_float(val)
  44         elif type(val) == types.InstanceType and isinstance(val,ASSD):
  45            txt = txt + i*',' + val.get_name()
  46         else:
  47            txt = txt + i*','+ myrepr.repr(val)
  48         i=1
  49       txt=txt+')'
  50     else:
  51       txt = self.getval()
  52     if type(txt) != types.StringType:
  53       if type(txt) == types.InstanceType:
  54         if isinstance(txt,parametre.PARAMETRE):
  55           return str(txt)
  56       return repr(txt)
  57     # il faut tronquer txt au delà d'un certain nombre de caractères
  58     # et avant tout retour chariot (txt peut être une chaîne de caractères
  59     # sur plusieurs lignes (ex:shell)
  60     txt = string.split(txt,'\n')[0]
  61     if len(txt) < 30 :
  62       return txt
  63     else:
  64       return txt[0:29]
  65
  66   def getval(self):
  67     """
  68        Retourne une chaîne de caractère représentant la valeur de self
  69     """
  70     val=self.valeur
  71     if type(val) != types.TupleType :
  72       try:
  73         return val.get_name()
  74       except:
  75         return val
  76     else :
  77       s='( '
  78       for item in val :
  79         try :
  80           s=s+item.get_name()+','
  81         except:
  82           s=s+`item`+','
  83       s=s+' )'
  84       return s
  85
  86   def get_min_max(self):
  87     return self.definition.min,self.definition.max
  88
  89   def wait_co(self):
  90     """
  91         Méthode booléenne qui retourne 1 si l'objet attend un objet ASSD
  92         qui n'existe pas encore (type CO()), 0 sinon
  93     """
  94     for typ in self.definition.type:
  95       if type(typ) == types.ClassType :
  96         if issubclass(typ,CO) :
  97            return 1
  98     return 0
  99
 100   def wait_assd(self):
 101     """
 102         Méthode booléenne qui retourne 1 si le MCS attend un objet de type ASSD
 103         ou dérivé, 0 sinon
 104     """
 105     for typ in self.definition.type:
 106       if type(typ) == types.ClassType :
 107         if issubclass(typ,ASSD) and not issubclass(typ,GEOM):
 108           return 1
 109     return 0
 110
 111   def wait_assd_or_geom(self):
 112     """
 113          Retourne 1 si le mot-clé simple attend un objet de type
 114           assd, ASSD, geom ou GEOM
 115          Retourne 0 dans le cas contraire
 116     """
 117     for typ in self.definition.type:
 118       if type(typ) == types.ClassType :
 119         if typ.__name__ in ("GEOM","ASSD","geom","assd") or issubclass(typ,GEOM) :
 120           return 1
 121     return 0
 122
 123   def wait_geom(self):
 124     """
 125          Retourne 1 si le mot-clé simple attend un objet de type GEOM
 126          Retourne 0 dans le cas contraire
 127     """
 128     for typ in self.definition.type:
 129       if type(typ) == types.ClassType :
 130         if issubclass(typ,GEOM) : return 1
 131     return 0
 132
 133   def wait_TXM(self):
 134     """
 135          Retourne 1 si le mot-clé simple attend un objet de type TXM
 136          Retourne 0 dans le cas contraire
 137     """
 138     for typ in self.definition.type:
 139       if typ == 'TXM' :return 1
 140     return 0
 141
 142   def get_liste_valeurs(self):
 143     """
 144     """
 145     if self.valeur == None:
 146       return []
 147     elif type(self.valeur) == types.TupleType:
 148       return list(self.valeur)
 149     elif type(self.valeur) == types.ListType:
 150       return self.valeur
 151     else:
 152       return [self.valeur]
 153
 154   def isoblig(self):
 155     return self.definition.statut=='o'
 156
 157   def set_valeur(self,new_valeur,evaluation='oui'):
 158     """
 159         Remplace la valeur de self(si elle existe) par new_valeur
 160             - si evaluation = 'oui' :
 161                         essaie d'évaluer new_valeur dans le contexte
 162             - si evaluation = 'non' :
 163                         n'essaie pas d'évaluer (on stocke une string ou
 164                         une valeur de la liste into )
 165     """
 166     if evaluation == 'oui' and not self.wait_assd_or_geom():
 167       valeur,test = self.eval_valeur(new_valeur)
 168       if test :
 169         self.val = new_valeur
 170         self.valeur = valeur
 171         self.init_modif()
 172         return 1
 173       else:
 174         # On n'a pas trouve de concept ni réussi à évaluer la valeur
 175         # dans le contexte
 176         # Si le mot cle simple attend un type CO on crée un objet de ce
 177         # type de nom new_valeur
 178         if self.wait_co():
 179           try:
 180             # Pour avoir la classe CO avec tous ses comportements
 181             from Accas import CO
 182             self.valeur=CO(new_valeur)
 183           except:
 184             traceback.print_exc()
 185             return 0
 186           self.val=self.valeur
 187           self.init_modif()
 188           return 1
 189         elif type(new_valeur)==types.StringType and self.wait_TXM():
 190           self.val = new_valeur
 191           self.valeur = new_valeur
 192           self.init_modif()
 193           return 1
 194         else:
 195           return 0
 196     else :
 197       # on ne fait aucune vérification ...
 198       try:
 199         self.valeur = eval(new_valeur)
 200         self.val = eval(new_valeur)
 201         self.init_modif()
 202         return 1
 203       except:
 204         self.valeur = new_valeur
 205         self.val = new_valeur
 206         self.init_modif()
 207         return 1
 208
 209   def eval_valeur(self,new_valeur):
 210     """
 211         Essaie d'évaluer new_valeur comme une SD, une déclaration Python
 212         ou un EVAL:
 213            Retourne la valeur évaluée (ou None) et le test de réussite (1 ou 0)
 214     """
 215     #sd = self.jdc.get_sd_avant_etape(new_valeur,self.etape)
 216     sd = self.jdc.get_contexte_avant(self.etape).get(new_valeur,None)
 217     if sd :
 218       return sd,1
 219     else:
 220       d={}
 221       # On veut EVAL avec tous ses comportements. On utilise Accas. Perfs ??
 222       from Accas import EVAL
 223       d['EVAL']=EVAL
 224       try :
 225         objet = eval(new_valeur,d)
 226         return objet,1
 227       except Exception:
 228         if CONTEXT.debug : traceback.print_exc()
 229         return None,0
 230
 231   def delete_concept(self,sd):
 232     """
 233         Inputs :
 234            sd=concept detruit
 235         Fonction :
 236            Met a jour la valeur du mot cle simple suite à la disparition
 237            du concept sd
 238     """
 239     if type(self.valeur) == types.TupleType :
 240       if sd in self.valeur:
 241         self.valeur=list(self.valeur)
 242         self.valeur.remove(sd)
 243         self.init_modif()
 244     elif type(self.valeur) == types.ListType:
 245       if sd in self.valeur:
 246         self.valeur.remove(sd)
 247         self.init_modif()
 248     else:
 249       if self.valeur == sd:
 250         self.valeur=None
 251         self.val=None
 252         self.init_modif()
 253
 254   def copy(self):
 255     """ Retourne une copie de self """
 256     objet = self.makeobjet()
 257     # il faut copier les listes et les tuples mais pas les autres valeurs
 258     # possibles (réel,SD,...)
 259     if type(self.valeur) in (types.ListType,types.TupleType):
 260        objet.valeur = copy(self.valeur)
 261     else:
 262        objet.valeur = self.valeur
 263     objet.val = objet.valeur
 264     return objet
 265
 266   def makeobjet(self):
 267     return self.definition(val = None, nom = self.nom,parent = self.parent)
 268
 269   def get_sd_utilisees(self):
 270     """
 271         Retourne une liste qui contient la SD utilisée par self si c'est le cas
 272         ou alors une liste vide
 273     """
 274     l=[]
 275     if type(self.valeur) == types.InstanceType:
 276       #XXX Est ce différent de isinstance(self.valeur,ASSD) ??
 277       if issubclass(self.valeur.__class__,ASSD) : l.append(self.valeur)
 278     return l
 279
 280
 281   def set_valeur_co(self,nom_co):
 282       """
 283           Affecte à self l'objet de type CO et de nom nom_co
 284       """
 285       step=self.etape.parent
 286       if nom_co == None or nom_co == '':
 287          new_objet=None
 288       else:
 289          # Pour le moment on importe en local le CO de Accas.
 290          # Si problème de perfs, il faudra faire autrement
 291          from Accas import CO
 292          # Avant de créer un concept il faut s'assurer du contexte : step
 293          # courant
 294          sd= step.get_sd_autour_etape(nom_co,self.etape,avec='oui')
 295          if sd:
 296             # Si un concept du meme nom existe deja dans la portée de l'étape
 297             # on ne crée pas le concept
 298             return 0,"un concept de meme nom existe deja"
 299          # Il n'existe pas de concept de meme nom. On peut donc le créer
 300          # Il faut néanmoins que la méthode NommerSdProd de step gère les
 301          # contextes en mode editeur
 302          # Normalement la méthode  du Noyau doit etre surchargée
 303          # On déclare l'étape du mot clé comme etape courante pour NommerSdprod
 304          cs= CONTEXT.get_current_step()
 305          CONTEXT.unset_current_step()
 306          CONTEXT.set_current_step(step)
 307          step.set_etape_context(self.etape)
 308          new_objet = CO(nom_co)
 309          CONTEXT.unset_current_step()
 310          CONTEXT.set_current_step(cs)
 311       self.valeur = new_objet
 312       self.val = new_objet
 313       self.init_modif()
 314       step.reset_context()
 315       # On force l'enregistrement de new_objet en tant que concept produit
 316       # de la macro en appelant get_type_produit avec force=1
 317       self.etape.get_type_produit(force=1)
 318       return 1,"Concept créé"
 319
 320   def reparent(self,parent):
 321      """
 322          Cette methode sert a reinitialiser la parente de l'objet
 323      """
 324      self.parent=parent
 325      self.jdc=parent.jdc
 326      self.etape=parent.etape
 327
 328   def verif_existence_sd(self):
 329      """
 330         Vérifie que les structures de données utilisées dans self existent bien dans le contexte
 331         avant étape, sinon enlève la référence à ces concepts
 332      """
 333      l_sd_avant_etape = self.jdc.get_contexte_avant(self.etape).values()
 334      if type(self.valeur) in (types.TupleType,types.ListType) :
 335        l=[]
 336        for sd in self.valeur:
 337          if isinstance(sd,ASSD) :
 338             if sd in l_sd_avant_etape :
 339                l.append(sd)
 340          else:
 341             l.append(sd)
 342        self.valeur=l
 343        self.init_modif()
 344      else:
 345        if isinstance(self.valeur,ASSD) :
 346           if self.valeur not in l_sd_avant_etape :
 347              self.valeur = None
 348              self.init_modif()
 349
 350
 351   def get_min_max(self):
 352      """
 353      Retourne les valeurs min et max admissibles pour la valeur de self
 354      """
 355      return self.definition.min,self.definition.max
 356
 357
 358   def get_type(self):
 359      """
 360      Retourne le type attendu par le mot-clé simple
 361      """
 362      return self.definition.type
 363
 364
 365
 366
 367
 368
 369
 370
 371
 372
 373
 374
 375
 376