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