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