InterfaceQT4/composimp.py

   1 # -*- coding: utf-8 -*-
   2 # Modules Python
   3 import string,types,os
   4
   5 from copy import copy,deepcopy
   6 import traceback
   7
   8 # Modules Eficas
   9 from Editeur import Objecttreeitem
  10 import browser
  11 from Noyau.N_CR   import justify_text
  12
  13 class Node(browser.JDCNode):
  14     def getPanel(self):
  15         """
  16         """
  17         klass = None
  18
  19         # Attention l ordre des if est important
  20         if self.item.wait_shell():
  21             # l'objet attend un shell
  22             # a priori jamais
  23             print "Pb : Panneau Shell attendu"
  24             print "Pb : Prevenir la maintenance"
  25             klass = None #CS_pbruno todo
  26             return None
  27
  28         # l'objet prend sa (ses) valeur(s) dans un ensemble discret de valeurs
  29         if self.item.has_into():
  30             if self.item.is_list() :
  31                 from monPlusieursIntoPanel import MonPlusieursIntoPanel
  32                 klass = MonPlusieursIntoPanel
  33             else:
  34                 from monUniqueIntoPanel import MonUniqueIntoPanel
  35                 klass = MonUniqueIntoPanel
  36
  37         # l'objet prend une ou des valeurs a priori quelconques
  38         else:
  39             # on attend une liste de valeurs
  40             if self.item.is_list() :
  41                 # on attend une liste de SD
  42                 if self.item.wait_assd():
  43                     from monPlusieursASSDPanel import MonPlusieursASSDPanel
  44                     klass = MonPlusieursASSDPanel
  45                 else:
  46                     # on attend une liste de valeurs de types debase (entiers, réels,...)
  47                     from monPlusieursBasePanel import MonPlusieursBasePanel
  48                     klass = MonPlusieursBasePanel
  49             # on n'attend qu'une seule valeur
  50             else:
  51                 # on attend une SD ou un objet de la classe CO (qui n'existe pas encore)
  52                 if self.item.wait_co():
  53                     if len(self.item.get_sd_avant_du_bon_type()) != 0 :
  54                        from monUniqueSDCOIntoPanel import MonUniqueSDCOIntoPanel
  55                        klass = MonUniqueSDCOIntoPanel
  56                     else :
  57                        from monUniqueSDCOPanel import MonUniqueSDCOPanel
  58                        klass = MonUniqueSDCOPanel
  59
  60                 # on attend une SD
  61                 elif self.item.wait_assd():
  62                     if 'R' in self.item.GetType():
  63                         from monUniqueASSDPanel import MonUniqueASSDReelPanel
  64                         klass = MonUniqueASSDReelPanel
  65                     else :
  66                         from monUniqueASSDPanel import MonUniqueASSDPanel
  67                         klass = MonUniqueASSDPanel
  68
  69                 # on attend une valeur d'un type de base (entier,reel,...)
  70                 else:
  71                         # on attend un complexe
  72                      if self.item.wait_complex():
  73                         from monUniqueCompPanel import MonUniqueCompPanel
  74                         klass = MonUniqueCompPanel
  75                      else:
  76                         # on attend un entier, un réel ou une string
  77                         from monUniqueBasePanel import MonUniqueBasePanel
  78                         klass = MonUniqueBasePanel
  79
  80         # cas particulier des fonctions
  81         genea = self.item.get_genealogie()
  82         if "VALE" in genea or "VALE_C" in genea:
  83             if "DEFI_FONCTION" in genea :
  84                 from monFonctionPanel import MonFonctionPanel
  85                 klass = MonFonctionPanel
  86
  87         if not klass:
  88             return None
  89         return klass( self, self.editor )
  90
  91
  92
  93 class SIMPTreeItem(Objecttreeitem.AtomicObjectTreeItem):
  94   itemNode=Node
  95
  96   def init(self) :
  97       self.expandable = 0
  98
  99
 100   #-----------------------------------------------
 101   #
 102   # Methodes liees aux informations sur le Panel
 103   # ou au mot-clef simple
 104   #
 105   #-----------------------------------------------
 106   # is_list
 107   # get_into                a priori inutile --> commentee
 108   # has_into
 109   # wait_into                a priori inutile --> commentee
 110   # GetMinMax
 111   # GetMultiplicite
 112   # GetIntervalle
 113   # GetListeValeurs
 114   # get_liste_possible
 115
 116   def is_list(self):
 117       """
 118           Cette méthode indique si le mot cle simple attend une liste (valeur de retour 1)
 119           ou s'il n'en attend pas (valeur de retour 0)
 120
 121           Deux cas principaux peuvent se presenter : avec validateurs ou bien sans.
 122           Dans le cas sans validateur, l'information est donnée par l'attribut max
 123           de la definition du mot cle.
 124           Dans le cas avec validateur, il faut combiner l'information précédente avec
 125           celle issue de l'appel de la méthode is_list sur le validateur.On utilisera
 126           l'operateur ET pour effectuer cette combinaison (AndVal).
 127       """
 128       is_a_list=0
 129       min,max = self.GetMinMax()
 130       assert (min <= max)
 131       if max > 1 :
 132                 is_a_list=1
 133       # Dans le cas avec validateurs, pour que le mot cle soit considéré
 134       # comme acceptant une liste, il faut que max soit supérieur a 1
 135       # ET que la méthode is_list du validateur retourne 1. Dans les autres cas
 136       # on retournera 0 (n'attend pas de liste)
 137       if self.definition.validators :
 138          is_a_list= self.definition.validators.is_list() * is_a_list
 139       return is_a_list
 140
 141   #def get_into(self,liste_courante=None):
 142   #    """
 143   #        Cette méthode retourne la liste de choix proposée par le mot cle. Si le mot cle ne propose
 144   #        pas de liste de choix, la méthode retourne None.
 145   #        L'argument d'entrée liste_courante, s'il est différent de None, donne la liste des choix déja
 146   #        effectués par l'utilisateur. Dans ce cas, la méthode get_into doit calculer la liste des choix
 147   #        en en tenant compte.
 148   #        Cette méthode part du principe que la relation entre into du mot clé et les validateurs est
 149   #        une relation de type ET (AndVal).
 150   #    """
 151   #    if not self.object.definition.validators :
 152   #       return self.object.definition.into
 153   #    else:
 154   #       return self.object.definition.validators.get_into(liste_courante,self.definition.into)
 155
 156   def has_into(self):
 157       """
 158           Cette méthode indique si le mot cle simple propose un choix (valeur de retour 1)
 159           ou s'il n'en propose pas (valeur de retour 0)
 160
 161           Deux cas principaux peuvent se presenter : avec validateurs ou bien sans.
 162           Dans le cas sans validateur, l'information est donnée par l'attribut into
 163           de la definition du mot cle.
 164           Dans le cas avec validateurs, pour que le mot cle soit considéré
 165           comme proposant un choix, il faut que into soit présent OU
 166           que la méthode has_into du validateur retourne 1. Dans les autres cas
 167           on retournera 0 (ne propose pas de choix)
 168       """
 169       has_an_into=0
 170       if self.definition.into:
 171                has_an_into=1
 172       elif self.definition.validators :
 173          has_an_into= self.definition.validators.has_into()
 174       return has_an_into
 175
 176
 177   def GetMinMax(self):
 178       """ Retourne les valeurs min et max de la définition de object """
 179       return self.object.get_min_max()
 180
 181   def GetMultiplicite(self):
 182       """ A préciser.
 183           Retourne la multiplicité des valeurs affectées a l'objet
 184           représenté par l'item. Pour le moment retourne invariablement 1.
 185       """
 186       return 1
 187
 188   def GetIntervalle(self):
 189       """
 190            Retourne le domaine de valeur attendu par l'objet représenté
 191            par l'item.
 192       """
 193       return self.object.getintervalle()
 194
 195   def GetListeValeurs(self) :
 196       """ Retourne la liste des valeurs de object """
 197       valeurs=self.object.get_liste_valeurs()
 198       try :
 199         if "R" in self.object.definition.type:
 200            clef=self.object.GetNomConcept()
 201            if self.appli.dict_reels.has_key(clef):
 202               if type(valeurs) == types.TupleType:
 203                  valeurs_reelles=[]
 204                  for val in valeurs :
 205                     if self.appli.dict_reels[clef].has_key(val) :
 206                        valeurs_reelles.append(self.appli.dict_reels[clef][val])
 207                     else :
 208                        valeurs_reelles.append(val)
 209               else :
 210                  if self.appli.dict_reels[clef].has_key(valeurs):
 211                     valeurs_reelles=self.appli.dict_reels[clef][valeurs]
 212               valeurs=valeurs_reelles
 213       except :
 214         pass
 215       return valeurs
 216
 217   def get_liste_possible(self,listeActuelle=[]):
 218       if hasattr(self.definition.validators,'into'):
 219          valeurspossibles = self.definition.validators.into
 220       else:
 221          valeurspossibles = self.get_definition().into
 222
 223       #On ne garde que les items valides
 224       listevalideitem=[]
 225       if type(valeurspossibles) in (types.ListType,types.TupleType) :
 226          pass
 227       else :
 228          valeurspossibles=(valeurspossibles,)
 229       for item in valeurspossibles:
 230           encorevalide=self.valide_item(item)
 231           if encorevalide :
 232              listevalideitem.append(item)
 233
 234       #on ne garde que les choix possibles qui passent le test de valide_liste_partielle
 235       listevalideliste=[]
 236       for item in listevalideitem:
 237           encorevalide=self.valide_liste_partielle(item,listeActuelle)
 238           if encorevalide :
 239               listevalideliste.append(item)
 240       return listevalideliste
 241
 242   def get_liste_param_possible(self):
 243       liste_param=[]
 244       for param in self.object.jdc.params:
 245           encorevalide=self.valide_item(param.valeur)
 246           if encorevalide:
 247              type_param=param.valeur.__class__.__name__
 248              for typ in self.definition.type:
 249                  if typ=='R':
 250                      liste_param.append(param)
 251                  if typ=='I' and type_param=='int':
 252                      liste_param.append(param)
 253                  if typ=='TXM' and type_param=='str':
 254                      liste_param.append(repr(param))
 255                  if ('grma' in repr(typ)) and type_param=='str':
 256                      liste_param.append(param.nom)
 257       return liste_param
 258
 259   #--------------------------------------------------
 260   #
 261   # Methodes liees a la validite des valeurs saisies
 262   #
 263   #---------------------------------------------------
 264   # valide_item
 265   # valide_liste_partielle
 266   # valide_liste_complete
 267   # info_erreur_item
 268   # info_erreur_liste
 269   # IsInIntervalle
 270   # isvalid
 271
 272   def valide_item(self,item):
 273       """
 274         La validation est réalisée directement par l'objet
 275       """
 276       return self.object.valide_item(item)
 277
 278   def valide_liste_partielle(self,item,listecourante):
 279       #On protege la liste en entree en la copiant
 280       valeur=listecourante[:]
 281       valeur.append(item)
 282       return self.object.valid_valeur_partielle(valeur)
 283
 284   def valide_liste_complete (self,valeur):
 285       return self.object.valid_valeur(valeur)
 286
 287   def valide_val (self,valeur):
 288       return self.object.valid_val(valeur)
 289
 290   def info_erreur_item(self) :
 291       commentaire=""
 292       if self.definition.validators :
 293          commentaire=self.definition.validators.info_erreur_item()
 294       return commentaire
 295
 296   def aide(self) :
 297       commentaire=""
 298       if self.definition.validators :
 299          commentaire=self.definition.validators.aide()
 300       return commentaire
 301
 302   def info_erreur_liste(self) :
 303       commentaire=""
 304       if self.definition.validators :
 305          commentaire=self.definition.validators.info_erreur_liste()
 306       return commentaire
 307
 308   def IsInIntervalle(self,valeur):
 309       """
 310           Retourne 1 si la valeur est dans l'intervalle permis par
 311           l'objet représenté par l'item.
 312       """
 313       return self.valide_item(valeur)
 314
 315   def isvalid(self):
 316     valide=self.object.isvalid()
 317     return valide
 318
 319   #--------------------------------------------------
 320   #
 321   # Autres ...
 322   #
 323   #---------------------------------------------------
 324   # GetIconName
 325   # GetText
 326   # set_valeur_co
 327   # get_sd_avant_du_bon_type
 328   # delete_valeur_co
 329
 330
 331   def GetIconName(self):
 332     if self.isvalid():
 333       return "ast-green-ball"
 334     elif self.object.isoblig():
 335       return "ast-red-ball"
 336     else:
 337       return "ast-yel-ball"
 338
 339   def GetText(self):
 340     """
 341     Classe SIMPTreeItem
 342     Retourne le texte a afficher dans l'arbre représentant la valeur de l'objet
 343     pointé par self
 344     """
 345     text= self.object.GetText()
 346     if text == None : text=""
 347     return text
 348
 349
 350   def set_valeur_co(self,nom_co):
 351       """
 352       Affecte au MCS pointé par self l'objet de type CO et de nom nom_co
 353       """
 354       ret = self.object.set_valeur_co(nom_co)
 355       #print "set_valeur_co",ret
 356       return ret
 357
 358   def get_sd_avant_du_bon_type(self):
 359       """
 360       Retourne la liste des noms des SD présentes avant l'étape qui contient
 361       le MCS pointé par self et du type requis par ce MCS
 362       """
 363       a=self.object.etape.parent.get_sd_avant_du_bon_type(self.object.etape,self.object.definition.type)
 364       return a
 365
 366   def get_sd_avant_du_bon_type_pour_type_de_base(self):
 367       a=self.object.jdc.get_sd_avant_du_bon_type_pour_type_de_base(self.object.etape,"LASSD")
 368       return a
 369
 370
 371
 372
 373   def delete_valeur_co(self,valeur=None):
 374       """
 375            Supprime la valeur du mot cle (de type CO)
 376            il faut propager la destruction aux autres etapes
 377       """
 378       if not valeur : valeur=self.object.valeur
 379       # XXX faut il vraiment appeler del_sdprod ???
 380       #self.object.etape.parent.del_sdprod(valeur)
 381       self.object.etape.parent.delete_concept(valeur)
 382
 383   #-----------------------------------------------
 384   #
 385   # Methodes liees au type de l objet attendu
 386   #
 387   #-----------------------------------------------
 388   # wait_co
 389   # wait_geom
 390   # wait_complex
 391   # wait_reel
 392   # wait_shell
 393   # wait_assd
 394   # GetType
 395
 396   def wait_co(self):
 397       """
 398       Méthode booléenne qui retourne 1 si l'objet pointé par self
 399       attend un objet de type ASSD qui n'existe pas encore (type CO()),
 400       0 sinon
 401       """
 402       return self.object.wait_co()
 403
 404   def wait_geom(self):
 405       """
 406       Méthode booléenne qui retourne 1 si l'objet pointé par self
 407       attend un objet GEOM, 0 sinon
 408       """
 409       return self.object.wait_geom()
 410
 411   def wait_complex(self):
 412       """ Méthode booléenne qui retourne 1 si l'objet pointé par self
 413       attend un complexe, 0 sinon """
 414       if 'C' in self.object.definition.type:
 415           return 1
 416       else:
 417           return 0
 418
 419   def wait_reel(self):
 420       """ Méthode booléenne qui retourne 1 si l'objet pointé par self
 421       attend un réel, 0 sinon """
 422       if 'R' in self.object.definition.type:
 423           return 1
 424       else:
 425           return 0
 426
 427   def wait_shell(self):
 428       """ Méthode booléenne qui retourne 1 si l'objet pointé par self
 429       attend un shell, 0 sinon """
 430       if 'shell' in self.object.definition.type:
 431           return 1
 432       else:
 433           return 0
 434
 435   def wait_assd(self):
 436       """Méthode booléenne qui retourne 1 si l'objet pointé par self
 437       attend un objet de type ASSD ou dérivé, 0 sinon """
 438       return self.object.wait_assd()
 439
 440   def wait_assd_or_type_base(self) :
 441       boo=0
 442       if len(self.object.definition.type) > 1 :
 443          if self.wait_reel() :
 444             boo = 1
 445          if 'I' in self.object.definition.type :
 446             boo = 1
 447       return boo
 448
 449
 450   def GetType(self):
 451       """
 452           Retourne le type de valeur attendu par l'objet représenté par l'item.
 453       """
 454       return self.object.get_type()
 455
 456   #-----------------------------------------------------
 457   #
 458   # Methodes liees  a l evaluation de la valeur saisie
 459   #
 460   #-----------------------------------------------------
 461   # eval_valeur
 462   # eval_valeur_item
 463   # is_CO
 464   # traite_reel
 465
 466   def eval_valeur(self,valeur):
 467       """ Lance l'interprétation de 'valeur' (chaine de caractéres) comme valeur de self :
 468              - retourne l'objet associé si on a pu interpréter (entier, réel, ASSD,...)
 469              - retourne 'valeur' (chaine de caractéres) sinon
 470       """
 471       newvaleur=self.eval_val(valeur)
 472       return newvaleur,1
 473
 474   def eval_valeur_BAK(self,valeur):
 475       """ Lance l'interprétation de 'valeur' (chaine de caractéres) comme valeur
 476       de l'objet pointé par self :
 477         - retourne l'objet associé si on a pu interpréter (entier, réel, ASSD,...)
 478         - retourne 'valeur' (chaine de caractéres) sinon
 479         - retourne None en cas d invalidite
 480         - retourne invalide si 1 des objets du tuple l est
 481       """
 482       validite=1
 483       if type(valeur) in (types.ListType,types.TupleType) :
 484          valeurretour=[]
 485          for item in valeur :
 486              newvaleur,validiteitem=self.eval_valeur_item(item)
 487              valeurretour.append(newvaleur)
 488              if validiteitem == 0:
 489                 validite=0
 490       else :
 491          valeurretour,validite= self.eval_valeur_item(valeur)
 492       if validite == 0 :
 493          valeurretour = None
 494       return valeurretour,validite
 495
 496   def eval_valeur_item(self,valeur):
 497       """ Lance l'interprétation de 'valeur' qui doit ne pas etre un tuple
 498           - va retourner la valeur de retour et la validite
 499             selon le type de l objet attendu
 500           - traite les reels et les parametres
 501       """
 502       #print "eval_valeur_item",valeur
 503       if valeur==None or valeur == "" :
 504          return None,0
 505       validite=1
 506       if self.wait_reel():
 507              valeurinter = self.traite_reel(valeur)
 508              if valeurinter != None :
 509                 valeurretour,validite= self.object.eval_valeur(valeurinter)
 510              else:
 511                 valeurretour,validite= self.object.eval_valeur(valeur)
 512       elif self.wait_geom():
 513              valeurretour,validite = valeur,1
 514       else :
 515              valeurretour,validite= self.object.eval_valeur(valeur)
 516       #print "eval_valeur_item",valeurretour,validite
 517
 518       if validite == 0:
 519          if type(valeur) == types.StringType and self.object.wait_TXM():
 520             essai_valeur="'" + valeur + "'"
 521             valeurretour,validite= self.object.eval_valeur(essai_valeur)
 522
 523       if hasattr(valeurretour,'__class__'):
 524          #if valeurretour.__class__.__name__ in ('PARAMETRE','PARAMETRE_EVAL'):
 525          if valeurretour.__class__.__name__ in ('PARAMETRE',):
 526             validite=1
 527
 528       #if self.wait_co():
 529          # CCAR : il ne faut pas essayer de creer un concept
 530          # il faut simplement en chercher un existant ce qui a du etre fait par self.object.eval_valeur(valeur)
 531          #try:
 532             #valeurretour=Accas.CO(valeur)
 533          #except:
 534             #valeurretour=None
 535             #validite=0
 536       # on est dans le cas ou on a évalué et ou on n'aurait pas du
 537       if self.object.wait_TXM() :
 538           if type(valeurretour) != types.StringType:
 539              valeurretour=str(valeur)
 540              validite=1
 541       return valeurretour,validite
 542
 543   def is_CO(self,valeur=None):
 544       """
 545          Indique si valeur est un concept produit de la macro
 546          Cette méthode n'a de sens que pour un MCSIMP d'une MACRO
 547          Si valeur vaut None on teste la valeur du mot cle
 548       """
 549       # Pour savoir si un concept est un nouveau concept de macro
 550       # on regarde s'il est présent dans l'attribut sdprods de l'étape
 551       # ou si son nom de classe est CO.
 552       # Il faut faire les 2 tests car une macro non valide peut etre
 553       # dans un etat pas tres catholique avec des CO pas encore types
 554       # et donc pas dans sdprods (resultat d'une exception dans type_sdprod)
 555       if not valeur:valeur=self.object.valeur
 556       if valeur in self.object.etape.sdprods:return 1
 557       if type(valeur) is not types.InstanceType:return 0
 558       if valeur.__class__.__name__ == 'CO':return 1
 559       return 0
 560
 561   def is_param(self,valeur) :
 562       for param in self.jdc.params:
 563           if (repr(param) == valeur):
 564              return 1
 565       return 0
 566
 567   def traite_reel(self,valeur):
 568       """
 569       Cette fonction a pour but de rajouter le '.' en fin de chaine pour un réel
 570       ou de détecter si on fait référence a un concept produit par DEFI_VALEUR
 571       ou un EVAL ...
 572       """
 573       valeur = string.strip(valeur)
 574       liste_reels = self.get_sd_avant_du_bon_type()
 575       if valeur in liste_reels:
 576           return valeur
 577       if len(valeur) >= 3 :
 578           if valeur[0:4] == 'EVAL' :
 579               # on a trouvé un EVAL --> on retourne directement la valeur
 580               return valeur
 581       if string.find(valeur,'.') == -1 :
 582           # aucun '.' n'a été trouvé dans valeur --> on en rajoute un a la fin
 583           if (self.is_param(valeur)):
 584               return valeur
 585           else:
 586               if string.find(valeur,'e') != -1:
 587                  # Notation scientifique ?
 588                  try :
 589                     r=eval(valeur)
 590                     return valeur
 591                  except :
 592                     return None
 593               else :
 594                  return valeur+'.'
 595       else:
 596           return valeur
 597
 598
 599 import Accas
 600 treeitem = SIMPTreeItem
 601 objet = Accas.MCSIMP
 602