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