Ihm/I_MCSIMP.py

   1 # -*- coding: utf-8 -*-
   2 # Copyright (C) 2007-2021   EDF R&D
   3 #
   4 # This library is free software; you can redistribute it and/or
   5 # modify it under the terms of the GNU Lesser General Public
   6 # License as published by the Free Software Foundation; either
   7 # version 2.1 of the License.
   8 #
   9 # This library is distributed in the hope that it will be useful,
  10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12 # Lesser General Public License for more details.
  13 #
  14 # You should have received a copy of the GNU Lesser General Public
  15 # License along with this library; if not, write to the Free Software
  16 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  17 #
  18 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  19 #
  20 from __future__ import absolute_import
  21 import types
  22 import traceback
  23 from copy import copy
  24 from Extensions.i18n import tr
  25 from Extensions.eficas_exception import EficasException
  26
  27 from Noyau.N_utils import repr_float
  28 import Validation
  29 from . import CONNECTOR
  30
  31 # Attention : les classes ASSD,.... peuvent etre surchargees
  32 # dans le package Accas. Il faut donc prendre des precautions si
  33 # on utilise les classes du Noyau pour faire des tests (isxxxx, ...)
  34 # Si on veut creer des objets comme des CO avec les classes du noyau
  35 # ils n'auront pas les conportements des autres packages (pb!!!)
  36 # Il vaut mieux les importer d'Accas mais probleme d'import circulaire,
  37 # on ne peut pas les importer au debut.
  38 # On fait donc un import local quand c'est necessaire (peut occasionner
  39 # des pbs de prformance).
  40 from Noyau.N_ASSD import ASSD,assd
  41 from Noyau.N_GEOM import GEOM,geom
  42 from Noyau.N_CO import CO
  43 from Accas.A_ASSD import UserASSD
  44 import Accas
  45 # fin attention
  46
  47 from Extensions import parametre
  48 from Extensions import param2
  49 from . import I_OBJECT
  50 from . import CONNECTOR
  51 from .I_VALIDATOR import ValError,listProto
  52
  53 class MCSIMP(I_OBJECT.OBJECT):
  54
  55
  56   def isValid(self,cr='non'):
  57       if self.state == 'unchanged':
  58         return self.valid
  59       for type_permis in self.definition.type:
  60           if hasattr(type_permis, "__class__") and type_permis.__class__.__name__ == 'Matrice':
  61              self.monType=type_permis
  62              return self.valideMatrice(cr=cr)
  63       validite=Validation.V_MCSIMP.MCSIMP.isValid(self,cr=cr)
  64
  65       if self.definition.siValide != None and validite:
  66             self.definition.siValide(self)
  67       return validite
  68
  69
  70   def getNomConcept(self):
  71       p=self
  72       while p.parent :
  73          try :
  74             nomconcept=p.getSdname()
  75             return nomconcept
  76          except:
  77             try :
  78                nomconcept= p.object.getSdname()
  79                return nomconcept
  80             except :
  81                pass
  82          p=p.parent
  83       return ""
  84
  85   def getText(self):
  86     """
  87         Retourne le texte a afficher dans l'arbre representant la valeur de l'objet
  88         pointe par self
  89     """
  90
  91     if self.valeur == None :
  92       return None
  93     elif type(self.valeur) == float :
  94       # traitement d'un flottant isole
  95       txt = str(self.valeur)
  96       clefobj=self.getNomConcept()
  97       if clefobj in self.jdc.appliEficas.dict_reels :
  98         if self.valeur in self.jdc.appliEficas.dict_reels[clefobj]:
  99            txt=self.jdc.appliEficas.dict_reels[clefobj][self.valeur]
 100     elif type(self.valeur) in (list,tuple) :
 101       if self.valeur==[] or self.valeur == (): return str(self.valeur)
 102       # traitement des listes
 103       txt='('
 104       sep=''
 105       for val in self.valeur:
 106         if type(val) == float :
 107            clefobj=self.getNomConcept()
 108            if clefobj in self.jdc.appliEficas.dict_reels:
 109               if val in self.jdc.appliEficas.dict_reels[clefobj]:
 110                  txt=txt + sep +self.jdc.appliEficas.dict_reels[clefobj][val]
 111               else :
 112                  txt=txt + sep + str(val)
 113            else :
 114               txt=txt + sep + str(val)
 115         else:
 116            if isinstance(val,tuple):
 117               texteVal='('
 118               for i in val :
 119                   if isinstance(i, bytes) or isinstance(i,str) : texteVal = texteVal +"'"+str(i)+"',"
 120                   else : texteVal = texteVal + str(i)+','
 121               texteVal=texteVal[:-1]+')'
 122            else :
 123               if isinstance(val,bytes) or isinstance(val, str): texteVal="'"+str(val)+"'"
 124               else :texteVal=str(val)
 125            txt = txt + sep+ texteVal
 126
 127 ##        if len(txt) > 200:
 128 ##            #ligne trop longue, on tronque
 129 ##            txt=txt+" ..."
 130 ##            break
 131         sep=','
 132       # cas des listes de tuples de longueur 1
 133       if isinstance(val,tuple) and len(self.valeur) == 1 : txt=txt+','
 134       txt=txt+')'
 135     else:
 136       # traitement des autres cas
 137       txt = str(self.valeur)
 138
 139     # txt peut etre une longue chaine sur plusieurs lignes.
 140     # Il est possible de tronquer cette chaine au premier \n et
 141     # de limiter la longueur de la chaine a 30 caracteres. Cependant
 142     # ceci provoque une perte d'information pour l'utilisateur
 143     # Pour le moment on retourne la chaine telle que
 144     return txt
 145
 146   def getVal(self):
 147     """
 148        Retourne une chaine de caractere representant la valeur de self
 149     """
 150     val=self.valeur
 151     if type(val) == float :
 152       clefobj=self.getNomConcept()
 153       if clefobj in self.jdc.appliEficas.dict_reels :
 154         if val in self.jdc.appliEficas.appliEficas.dict_reels[clefobj] :
 155            return self.jdc.appliEficas.dict_reels[clefobj][val]
 156     if type(val) != tuple :
 157       try:
 158         return val.getName()
 159       except:
 160         return val
 161     else :
 162       if val ==() or val == [] : return val
 163       s='( '
 164       for item in val :
 165         try :
 166           s=s+item.getName()+','
 167         except:
 168           s=s+repr(item)+','
 169       s=s+' )'
 170       return s
 171
 172   def waitBool(self):
 173       for typ in self.definition.type:
 174           try :
 175             if typ == bool: return True
 176           except :
 177             pass
 178       return False
 179
 180   def waitCo(self):
 181     """
 182         Methode booleenne qui retourne 1 si l'objet attend un objet ASSD
 183         qui n'existe pas encore (type CO()), 0 sinon
 184     """
 185     for typ in self.definition.type:
 186       if type(typ) == type or isinstance(typ,type):
 187         if issubclass(typ,CO) :
 188            return 1
 189     return 0
 190
 191   def waitAssd(self):
 192     """
 193         Methode booleenne qui retourne 1 si le MCS attend un objet de type ASSD ou UserASSD
 194         ou derive, 0 sinon
 195     """
 196     for typ in self.definition.type:
 197       if type(typ) == type or isinstance(typ,type):
 198         if issubclass(typ,ASSD) and not issubclass(typ,GEOM) :
 199           return 1
 200     return 0
 201
 202   def waitUserAssd(self):
 203     """
 204         Methode booleenne qui retourne 1 si le MCS attend un objet de type ASSD
 205         ou derive, 0 sinon
 206     """
 207     for typ in self.definition.type:
 208       if type(typ) == type or isinstance(typ,type):
 209         if issubclass(typ,UserASSD) :
 210           return 1
 211     return 0
 212
 213   def waitUserAssdEnCreation(self):
 214     for typ in self.definition.type:
 215       if typ == 'createObject' :
 216           return 1
 217     return 0
 218
 219
 220   def waitAssdOrGeom(self):
 221     """
 222          Retourne 1 si le mot-cle simple attend un objet de type
 223          assd, ASSD, geom ou GEOM
 224          Retourne 0 dans le cas contraire
 225     """
 226     for typ in self.definition.type:
 227       if type(typ) == type or isinstance(typ,type):
 228         if typ.__name__ in ("GEOM","ASSD","geom","assd") or issubclass(typ,GEOM) :
 229           return 1
 230     return 0
 231
 232   def waitGeom(self):
 233     """
 234          Retourne 1 si le mot-cle simple attend un objet de type GEOM
 235          Retourne 0 dans le cas contraire
 236     """
 237     for typ in self.definition.type:
 238       if type(typ) == type or isinstance(typ,type):
 239         if issubclass(typ,GEOM) : return 1
 240     return 0
 241
 242
 243   def waitTxm(self):
 244     """
 245          Retourne 1 si le mot-cle simple attend un objet de type TXM
 246          Retourne 0 dans le cas contraire
 247     """
 248     for typ in self.definition.type:
 249       if typ == 'TXM' :return 1
 250     return 0
 251
 252   def waitTuple(self):
 253     for ss_type in self.definition.type:
 254         if repr(ss_type).find('Tuple') != -1 :
 255           return 1
 256     return 0
 257
 258
 259   def getListeValeurs(self):
 260     """
 261     """
 262     if self.valeur == None:
 263       return []
 264     elif type(self.valeur) == tuple:
 265       return list(self.valeur)
 266     elif type(self.valeur) == list:
 267       return self.valeur
 268     else:
 269       return [self.valeur]
 270
 271   def isOblig(self):
 272     return self.definition.statut=='o'
 273
 274   def isImmuable(self):
 275     return self.definition.homo=='constant'
 276
 277   def isInformation(self):
 278     return self.definition.homo=='information'
 279
 280
 281
 282   def validVal(self,valeur):
 283       """
 284         Verifie que la valeur passee en argument (valeur) est valide
 285         sans modifier la valeur courante
 286       """
 287       lval=listProto.adapt(valeur)
 288       if lval is None:
 289          valid=0
 290          mess=tr("None n'est pas une valeur autorisee")
 291       else:
 292          try:
 293             for val in lval:
 294                 self.typeProto.adapt(val)
 295                 self.intoProto.adapt(val)
 296             self.cardProto.adapt(lval)
 297             if self.definition.validators:
 298                 self.definition.validators.convert(lval)
 299             valid,mess=1,""
 300          except ValError as e:
 301             mess=str(e)
 302             valid=0
 303       return valid,mess
 304
 305   def validValeur(self,new_valeur):
 306       """
 307         Verifie que la valeur passee en argument (new_valeur) est valide
 308         sans modifier la valeur courante (evite d'utiliser setValeur et est plus performant)
 309       """
 310       validite,mess=self.validVal(new_valeur)
 311       return validite
 312
 313   def validValeurPartielle(self,new_valeur):
 314       """
 315         Verifie que la valeur passee en argument (new_valeur) est une liste partiellement valide
 316         sans modifier la valeur courante du mot cle
 317       """
 318       validite=1
 319       try:
 320           for val in new_valeur:
 321               self.typeProto.adapt(val)
 322               self.intoProto.adapt(val)
 323               #on ne verifie pas la cardinalite
 324               if self.definition.validators:
 325                   validite=self.definition.validators.valideListePartielle(new_valeur)
 326       except ValError as e:
 327           validite=0
 328
 329       return validite
 330
 331   def updateConditionBloc(self):
 332       """ Met a jour les blocs conditionnels dependant du mot cle simple self
 333       """
 334       if self.definition.position == 'global' :
 335          self.etape.deepUpdateConditionBloc()
 336       elif self.definition.position == 'global_jdc' :
 337          self.jdc.deepUpdateConditionBloc(self)
 338       else:
 339          self.parent.updateConditionBloc()
 340
 341   def setValeur(self,new_valeur,evaluation='oui'):
 342         self.initModif()
 343         self.valeur = new_valeur
 344         self.val = new_valeur
 345         if self.valeur and self.waitUserAssd() and not(self.waitUserAssdEnCreation()) :
 346            if type(self.valeur)  in (list,tuple):
 347               for v in self.valeur : v.ajoutUtilisePar(self)
 348            else : self.valeur.ajoutUtilisePar(self)
 349         if self.isValid():self.setValeurObjPyxb(new_valeur)
 350         self.updateConditionBloc()
 351         self.etape.modified()
 352         self.finModif()
 353         return 1
 354
 355   def evalValeur(self,new_valeur):
 356     """
 357         Essaie d'evaluer new_valeur comme une SD, une declaration Python
 358         ou un EVAL: Retourne la valeur evaluee (ou None) et le test de reussite (1 ou 0)
 359     """
 360     sd = self.jdc.getSdAvantEtape(new_valeur,self.etape)
 361     #sd = self.jdc.getContexteAvant(self.etape).get(new_valeur,None)
 362     if sd is not None:
 363       return sd,1
 364     lsd = self.jdc.chercheListAvant(self.etape,new_valeur)
 365     if lsd :
 366       return lsd,1
 367     else:
 368       d={}
 369       # On veut EVAL avec tous ses comportements. On utilise Accas. Perfs ??
 370       d['EVAL']=Accas.EVAL
 371       try :
 372         objet = eval(new_valeur,d)
 373         return objet,1
 374       except Exception:
 375         itparam=self.chercheItemParametre(new_valeur)
 376         if itparam:
 377              return itparam,1
 378         try :
 379              object=eval(new_valeur.valeur,d)
 380         except :
 381              pass
 382         if CONTEXT.debug : traceback.print_exc()
 383         return None,0
 384
 385   def evalVal(self,new_valeur):
 386     """
 387        Tente d'evaluer new_valeur comme un objet du jdc (par appel a evalValItem)
 388        ou comme une liste de ces memes objets
 389        Si new_valeur contient au moins un separateur (,), tente l'evaluation sur
 390        la chaine splittee
 391     """
 392     if new_valeur in ('True','False') and 'TXM' in self.definition.type  :
 393        valeur=self.evalValItem(str(new_valeur))
 394        return new_valeur
 395     if type(new_valeur) in (list,tuple):
 396        valeurretour=[]
 397        for item in new_valeur :
 398           valeurretour.append(self.evalValItem(item))
 399        return valeurretour
 400     else:
 401        valeur=self.evalValItem(new_valeur)
 402        return valeur
 403
 404   def evalValItem(self,new_valeur):
 405     """
 406        Tente d'evaluer new_valeur comme un concept, un parametre, un objet Python ou un UserASSD
 407        Si c'est impossible retourne new_valeur inchange
 408        argument new_valeur : string (nom de concept, de parametre, expression ou simple chaine)
 409     """
 410     if new_valeur in list(self.jdc.sdsDict.keys()) and self.waitUserAssd():
 411        valeur=self.jdc.sdsDict[new_valeur]
 412        return valeur
 413     elif self.etape and self.etape.parent:
 414        valeur=self.etape.parent.evalInContext(new_valeur,self.etape)
 415        return valeur
 416     else:
 417        try :
 418            valeur = eval(val)
 419            return valeur
 420        except:
 421            #traceback.print_exc()
 422            return new_valeur
 423            pass
 424
 425   def chercheItemParametre (self,new_valeur):
 426         try:
 427           nomparam=new_valeur[0:new_valeur.find("[")]
 428           indice=new_valeur[new_valeur.find(u"[")+1:new_valeur.find(u"]")]
 429           for p in self.jdc.params:
 430              if p.nom == nomparam :
 431                 if int(indice) < len(p.getValeurs()):
 432                    itparam=parametre.ITEM_PARAMETRE(p,int(indice))
 433                    return itparam
 434           return None
 435         except:
 436           return None
 437
 438   def updateConcept(self,sd):
 439     if type(self.valeur) in (list,tuple) :
 440        if sd in self.valeur:
 441          if self.objPyxb :
 442             newVal=[]
 443             for v in self.valeur : newVal.append(v.nom)
 444             self.setValeurObjPyxb(newVal)
 445          self.initModif()
 446          self.finModif()
 447     else:
 448        if sd == self.valeur:
 449          if self.objPyxb :  self.setValeurObjPyxb(sd.nom)
 450          self.initModif()
 451          self.finModif()
 452
 453   def deleteConcept(self,sd):
 454     """
 455         Inputs :
 456            - sd=concept detruit
 457         Fonction :
 458         Met a jour la valeur du mot cle simple suite a la disparition
 459         du concept sd
 460         Attention aux matrices
 461     """
 462 ##PNPNPN a tester
 463     if type(self.valeur) == tuple :
 464       if sd in self.valeur:
 465         self.initModif()
 466         self.valeur=list(self.valeur)
 467         while sd in self.valeur : self.valeur.remove(sd)
 468         if self.objPyxb :
 469            newVal=[]
 470            for v in self.valeur : newVal.append(v.nom)
 471            if newVal == [] : self.delObjPyxb()
 472            else : self.setValeurObjPyxb(sd.nom)
 473         self.finModif()
 474     elif type(self.valeur) == list:
 475       if sd in self.valeur:
 476         self.initModif()
 477         while sd in self.valeur : self.valeur.remove(sd)
 478         self.finModif()
 479     else:
 480       if self.valeur == sd:
 481         self.initModif()
 482         self.valeur=None
 483         self.val=None
 484         if self.objPyxb : self.setValeurObjPyxb()
 485         self.finModif()
 486     # Glut Horrible pour les matrices ???
 487     if sd.__class__.__name__== "variable":
 488        for type_permis in self.definition.type:
 489             #if type(type_permis) == types.InstanceType:
 490             # a voir en python 3
 491                if type_permis.__class__.__name__ == 'Matrice' :
 492                    self.state="changed"
 493                    self.isValid()
 494
 495
 496   def replaceConcept(self,old_sd,sd):
 497     """
 498         Inputs :
 499            - old_sd=concept remplace
 500            - sd=nouveau concept
 501         Fonction :
 502         Met a jour la valeur du mot cle simple suite au remplacement
 503         du concept old_sd
 504     """
 505     print ("replaceConcept",old_sd,sd)
 506     if type(self.valeur) == tuple :
 507       if old_sd in self.valeur:
 508         self.initModif()
 509         self.valeur=list(self.valeur)
 510         i=self.valeur.index(old_sd)
 511         self.valeur[i]=sd
 512         self.finModif()
 513     elif type(self.valeur) == list:
 514       if old_sd in self.valeur:
 515         self.initModif()
 516         i=self.valeur.index(old_sd)
 517         self.valeur[i]=sd
 518         self.finModif()
 519     else:
 520       if self.valeur == old_sd:
 521         self.initModif()
 522         self.valeur=sd
 523         self.val=sd
 524         self.finModif()
 525
 526   def setValeurCo(self,nomCO):
 527       """
 528           Affecte a self l'objet de type CO et de nom nomCO
 529       """
 530       step=self.etape.parent
 531       if nomCO == None or nomCO == '':
 532          new_objet=None
 533       else:
 534          # Avant de creer un concept il faut s'assurer du contexte : step
 535          # courant
 536          sd= step.getSdAutourEtape(nomCO,self.etape,avec='oui')
 537          if sd:
 538             # Si un concept du meme nom existe deja dans la portee de l'etape
 539             # on ne cree pas le concept
 540             return 0,tr("un concept de meme nom existe deja")
 541          # Il n'existe pas de concept de meme nom. On peut donc le creer
 542          # Il faut neanmoins que la methode NommerSdProd de step gere les
 543          # contextes en mode editeur
 544          # Normalement la methode  du Noyau doit etre surchargee
 545          # On declare l'etape du mot cle comme etape courante pour nommerSDProd
 546          cs= CONTEXT.getCurrentStep()
 547          CONTEXT.unsetCurrentStep()
 548          CONTEXT.setCurrentStep(step)
 549          step.setEtapeContext(self.etape)
 550          new_objet = Accas.CO(nomCO)
 551          CONTEXT.unsetCurrentStep()
 552          CONTEXT.setCurrentStep(cs)
 553       self.initModif()
 554       self.valeur = new_objet
 555       self.val = new_objet
 556       # On force l'enregistrement de new_objet en tant que concept produit
 557       # de la macro en appelant getType_produit avec force=1
 558       self.etape.getType_produit(force=1)
 559       self.finModif()
 560       step.resetContext()
 561       #print "setValeurCo",new_objet
 562       return 1,tr("Concept cree")
 563
 564   def verifExistenceSd(self):
 565      """
 566         Verifie que les structures de donnees utilisees dans self existent bien dans le contexte
 567         avant etape, sinon enleve la referea ces concepts
 568      """
 569      #print "verifExistenceSd"
 570      # Attention : possible probleme avec include
 571      # A priori il n'y a pas de raison de retirer les concepts non existants
 572      # avant etape. En fait il s'agit uniquement eventuellement de ceux crees par une macro
 573      l_sd_avant_etape = list(self.jdc.getContexteAvant(self.etape).values())
 574      if type(self.valeur) in (tuple,list) :
 575        l=[]
 576        for sd in self.valeur:
 577          if isinstance(sd,ASSD) :
 578             if sd in l_sd_avant_etape or self.etape.getSdprods(sd.nom) is sd:
 579                l.append(sd)
 580          else:
 581             l.append(sd)
 582        if len(l) < len(self.valeur):
 583           self.initModif()
 584           self.valeur=tuple(l)
 585           self.finModif()
 586      else:
 587        if isinstance(self.valeur,ASSD) :
 588           if self.valeur not in l_sd_avant_etape and self.etape.getSdprods(self.valeur.nom) is None:
 589              self.initModif()
 590              self.valeur = None
 591              self.finModif()
 592
 593   def renommeSdCree(self,nouveauNom):
 594       print ( 'dans renommeSdCree', self.jdc.sdsDict, self.valeur)
 595       if nouveauNom in self.jdc.sdsDict : return (0, 'concept deja existant')
 596       if self.valeur == None : return (0, 'pb sur la valeur')
 597       else :   self.valeur.renomme(nouveauNom)
 598       return (1, 'concept renomme')
 599
 600   def renommeSdCreeDsListe(self,objASSD, nouveauNom):
 601       if nouveauNom in self.jdc.sdsDict : return (0, 'concept deja existant')
 602       objASSD.renomme(nouveauNom)
 603       return (1, 'concept renomme')
 604
 605
 606
 607   def getMinMax(self):
 608      """
 609      Retourne les valeurs min et max admissibles pour la valeur de self
 610      """
 611      return self.definition.min,self.definition.max
 612
 613
 614   def getType(self):
 615      """
 616      Retourne le type attendu par le mot-cle simple
 617      """
 618      return self.definition.type
 619
 620   def deleteMcGlobal(self):
 621       """ Retire self des declarations globales
 622       """
 623       if self.definition.position == 'global' :
 624          etape = self.getEtape()
 625          if etape :
 626             del etape.mc_globaux[self.nom]
 627       elif self.definition.position == 'global_jdc' :
 628 # PNPNPN a debuger
 629          print (self.nom)
 630          try :
 631            del self.jdc.mc_globaux[self.nom]
 632          except : pass
 633
 634   def updateMcGlobal(self):
 635      """
 636         Met a jour les mots cles globaux enregistres dans l'etape parente
 637         et dans le jdc parent.
 638         Un mot cle simple peut etre global.
 639      """
 640      if self.definition.position == 'global' :
 641         etape = self.getEtape()
 642         if etape :
 643            etape.mc_globaux[self.nom]=self
 644      elif self.definition.position == 'global_jdc' :
 645         if self.jdc:
 646            self.jdc.mc_globaux[self.nom]=self
 647
 648   def nbrColonnes(self):
 649      genea = self.getGenealogie()
 650      if "VALE_C" in genea and "DEFI_FONCTION" in genea : return 3
 651      if "VALE" in genea and "DEFI_FONCTION" in genea : return 2
 652      return 0
 653
 654   def valideItem(self,item):
 655       """Valide un item isole. Cet item est candidata l'ajout a la liste existante"""
 656       valid=1
 657       try:
 658           #on verifie le type
 659           self.typeProto.adapt(item)
 660           #on verifie les choix possibles
 661           self.intoProto.adapt(item)
 662           #on ne verifie pas la cardinalite
 663           if self.definition.validators:
 664               valid=self.definition.validators.verifItem(item)
 665       except ValError as e:
 666           #traceback.print_exc()
 667           valid=0
 668       return valid
 669
 670   def verifType(self,item):
 671       """Verifie le type d'un item de liste"""
 672       try:
 673           #on verifie le type
 674           self.typeProto.adapt(item)
 675           #on verifie les choix possibles
 676           self.intoProto.adapt(item)
 677           #on ne verifie pas la cardinalite mais on verifie les validateurs
 678           if self.definition.validators:
 679               valid=self.definition.validators.verifItem(item)
 680           comment=""
 681           valid=1
 682       except ValError as e:
 683           #traceback.print_exc()
 684           comment=tr(e.__str__())
 685           valid=0
 686       return valid,comment
 687
 688   def valideMatrice(self,cr):
 689        #Attention, la matrice contient comme dernier tuple l ordre des variables
 690        if self.valideEnteteMatrice()==False :
 691            self.setValid(0)
 692            if cr == "oui" : self.cr.fatal(tr("La matrice n'a pas le bon entete"))
 693            return 0
 694        if self.monType.methodeCalculTaille != None :
 695            MCSIMP.__dict__[self.monType.methodeCalculTaille](*(self,))
 696        try :
 697        #if 1 :
 698            ok=0
 699            if len(self.valeur) == self.monType.nbLigs +1:
 700               ok=1
 701               for i in range(len(self.valeur) -1):
 702                   if len(self.valeur[i])!= self.monType.nbCols:
 703                      ok=0
 704            if ok:
 705               self.setValid(1)
 706               return 1
 707        except :
 708        #else :
 709             pass
 710        if cr == 'oui' :
 711              self.cr.fatal(tr("La matrice n'est pas une matrice %(n_lign)d sur %(n_col)d", \
 712              {'n_lign': self.monType.nbLigs, 'n_col': self.monType.nbCols}))
 713        self.setValid(0)
 714        return 0
 715
 716
 717   def nbDeVariables(self):
 718        listeVariables=self.jdc.getVariables(self.etape)
 719        self.monType.nbLigs=len(listeVariables)
 720        self.monType.nbCols=len(listeVariables)
 721
 722   def valideEnteteMatrice(self):
 723       if self.jdc.getDistributions(self.etape) == () or self.valeur == None : return 0
 724       if self.jdc.getDistributions(self.etape) != self.valeur[0] : return 0
 725       return 1
 726
 727   def changeEnteteMatrice(self):
 728       a=[self.jdc.getDistributions(self.etape),]
 729       for t in self.valeur[1:]:
 730          a.append(t)
 731       self.valeur=a
 732
 733
 734   def nbDeDistributions(self):
 735        listeVariables=self.jdc.getDistributions(self.etape)
 736        self.monType.nbLigs=len(listeVariables)
 737        self.monType.nbCols=len(listeVariables)
 738
 739   def getNomDsXML(self):
 740       nomDsXML=self.parent.getNomDsXML()+"."+self.nom
 741       return nomDsXML
 742
 743
 744   def verifTypeIhm(self,val,cr='non'):
 745       try :
 746          val.eval()
 747          return 1
 748       except :
 749          traceback.print_exc()
 750          pass
 751       return self.verifType(val,cr)
 752
 753   def verifTypeliste(self,val,cr='non') :
 754       verif=0
 755       for v in val :
 756         verif=verif+self.verifTypeIhm(v,cr)
 757       return verif
 758
 759   def initModifUp(self):
 760     Validation.V_MCSIMP.MCSIMP.initModifUp(self)
 761     CONNECTOR.Emit(self,"valid")
 762
 763   def deleteRef(self):
 764     print ('je suis dans deleteRef', self.nom)
 765     if self.definition.creeDesObjets :
 766        if self.valeur :
 767           self.valeur.deleteReference()
 768
 769        for MC in self.valeur.utilisePar:
 770            MC.state='changed'
 771            CONNECTOR.Emit(MC,"valid")
 772