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       print self.object.jdc.params
 234       for param in self.object.jdc.params:
 235           encorevalide=self.valide_item(param.valeur)
 236           if encorevalide:
 237              type_param=param.valeur.__class__.__name__
 238              for typ in self.definition.type:
 239                  if typ=='R':
 240                      liste_param.append(param)
 241                  if typ=='I' and type_param=='int':
 242                      liste_param.append(param)
 243                  if typ=='TXM' and type_param=='str':
 244                      liste_param.append(repr(param))
 245                  if ('grma' in repr(typ)) and type_param=='str':
 246                      liste_param.append(param.nom)
 247       return liste_param
 248
 249   #--------------------------------------------------
 250   #
 251   # Methodes liees a la validite des valeurs saisies
 252   #
 253   #---------------------------------------------------
 254   # valide_item
 255   # valide_liste_partielle
 256   # valide_liste_complete
 257   # info_erreur_item
 258   # info_erreur_liste
 259   # IsInIntervalle
 260   # isvalid
 261
 262   def valide_item(self,item):
 263       """
 264         La validation est réalisée directement par l'objet
 265       """
 266       return self.object.valide_item(item)
 267
 268   def valide_liste_partielle(self,item,listecourante):
 269       #On protege la liste en entree en la copiant
 270       valeur=listecourante[:]
 271       valeur.append(item)
 272       return self.object.valid_valeur_partielle(valeur)
 273
 274   def valide_liste_complete (self,valeur):
 275       return self.object.valid_valeur(valeur)
 276
 277   def valide_val (self,valeur):
 278       return self.object.valid_val(valeur)
 279
 280   def info_erreur_item(self) :
 281       commentaire=""
 282       if self.definition.validators :
 283          commentaire=self.definition.validators.info_erreur_item()
 284       return commentaire
 285
 286   def aide(self) :
 287       commentaire=""
 288       if self.definition.validators :
 289          commentaire=self.definition.validators.aide()
 290       return commentaire
 291
 292   def info_erreur_liste(self) :
 293       commentaire=""
 294       if self.definition.validators :
 295          commentaire=self.definition.validators.info_erreur_liste()
 296       return commentaire
 297
 298   def IsInIntervalle(self,valeur):
 299       """
 300           Retourne 1 si la valeur est dans l'intervalle permis par
 301           l'objet représenté par l'item.
 302       """
 303       return self.valide_item(valeur)
 304
 305   def isvalid(self):
 306     valide=self.object.isvalid()
 307     return valide
 308
 309   #--------------------------------------------------
 310   #
 311   # Autres ...
 312   #
 313   #---------------------------------------------------
 314   # GetIconName
 315   # GetText
 316   # set_valeur_co
 317   # get_sd_avant_du_bon_type
 318   # delete_valeur_co
 319
 320
 321   def GetIconName(self):
 322     if self.isvalid():
 323       return "ast-green-ball"
 324     elif self.object.isoblig():
 325       return "ast-red-ball"
 326     else:
 327       return "ast-yel-ball"
 328
 329   def GetText(self):
 330     """
 331     Classe SIMPTreeItem
 332     Retourne le texte a afficher dans l'arbre représentant la valeur de l'objet
 333     pointé par self
 334     """
 335     text= self.object.GetText()
 336     if text == None : text=""
 337     return text
 338
 339
 340   def set_valeur_co(self,nom_co):
 341       """
 342       Affecte au MCS pointé par self l'objet de type CO et de nom nom_co
 343       """
 344       ret = self.object.set_valeur_co(nom_co)
 345       #print "set_valeur_co",ret
 346       return ret
 347
 348   def get_sd_avant_du_bon_type(self):
 349       """
 350       Retourne la liste des noms des SD présentes avant l'étape qui contient
 351       le MCS pointé par self et du type requis par ce MCS
 352       """
 353       a=self.object.etape.parent.get_sd_avant_du_bon_type(self.object.etape,self.object.definition.type)
 354       return a
 355
 356   def get_sd_avant_du_bon_type_pour_type_de_base(self):
 357       a=self.object.jdc.get_sd_avant_du_bon_type_pour_type_de_base(self.object.etape,"LASSD")
 358       return a
 359
 360
 361
 362
 363   def delete_valeur_co(self,valeur=None):
 364       """
 365            Supprime la valeur du mot cle (de type CO)
 366            il faut propager la destruction aux autres etapes
 367       """
 368       if not valeur : valeur=self.object.valeur
 369       # XXX faut il vraiment appeler del_sdprod ???
 370       #self.object.etape.parent.del_sdprod(valeur)
 371       self.object.etape.parent.delete_concept(valeur)
 372
 373   #-----------------------------------------------
 374   #
 375   # Methodes liees au type de l objet attendu
 376   #
 377   #-----------------------------------------------
 378   # wait_co
 379   # wait_geom
 380   # wait_complex
 381   # wait_reel
 382   # wait_assd
 383   # GetType
 384
 385   def wait_co(self):
 386       """
 387       Méthode booléenne qui retourne 1 si l'objet pointé par self
 388       attend un objet de type ASSD qui n'existe pas encore (type CO()),
 389       0 sinon
 390       """
 391       return self.object.wait_co()
 392
 393   def wait_geom(self):
 394       """
 395       Méthode booléenne qui retourne 1 si l'objet pointé par self
 396       attend un objet GEOM, 0 sinon
 397       """
 398       return self.object.wait_geom()
 399
 400   def wait_complex(self):
 401       """ Méthode booléenne qui retourne 1 si l'objet pointé par self
 402       attend un complexe, 0 sinon """
 403       if 'C' in self.object.definition.type:
 404           return 1
 405       else:
 406           return 0
 407
 408   def wait_reel(self):
 409       """ Méthode booléenne qui retourne 1 si l'objet pointé par self
 410       attend un réel, 0 sinon """
 411       if 'R' in self.object.definition.type:
 412           return 1
 413       else:
 414           return 0
 415
 416   def wait_tuple(self):
 417       """ Méthode booléenne qui retourne 1 si l'objet pointé par self
 418       attend un Tuple, 0 sinon """
 419       for ss_type in self.object.definition.type:
 420           if repr(ss_type).find('Tuple') != -1 :
 421              return 1
 422       return 0
 423
 424   def wait_matrice(self):
 425       """ Méthode booléenne qui retourne 1 si l'objet pointé par self
 426       attend un Tuple, 0 sinon """
 427       for ss_type in self.object.definition.type:
 428           if repr(ss_type).find('Matrice') != -1 :
 429              return 1
 430       return 0
 431
 432   def wait_assd(self):
 433       """Méthode booléenne qui retourne 1 si l'objet pointé par self
 434       attend un objet de type ASSD ou dérivé, 0 sinon """
 435       return self.object.wait_assd()
 436
 437   def wait_assd_or_type_base(self) :
 438       boo=0
 439       if len(self.object.definition.type) > 1 :
 440          if self.wait_reel() :
 441             boo = 1
 442          if 'I' in self.object.definition.type :
 443             boo = 1
 444       return boo
 445
 446
 447   def GetType(self):
 448       """
 449           Retourne le type de valeur attendu par l'objet représenté par l'item.
 450       """
 451       return self.object.get_type()
 452
 453   #-----------------------------------------------------
 454   #
 455   # Methodes liees  a l evaluation de la valeur saisie
 456   #
 457   #-----------------------------------------------------
 458   # eval_valeur
 459   # eval_valeur_item
 460   # is_CO
 461   # traite_reel
 462
 463   def eval_valeur(self,valeur):
 464       """ Lance l'interprétation de 'valeur' (chaine de caractéres) comme valeur de self :
 465              - retourne l'objet associé si on a pu interpréter (entier, réel, ASSD,...)
 466              - retourne 'valeur' (chaine de caractéres) sinon
 467       """
 468       newvaleur=self.eval_val(valeur)
 469       return newvaleur,1
 470
 471   def eval_valeur_BAK(self,valeur):
 472       """ Lance l'interprétation de 'valeur' (chaine de caractéres) comme valeur
 473       de l'objet pointé par self :
 474         - retourne l'objet associé si on a pu interpréter (entier, réel, ASSD,...)
 475         - retourne 'valeur' (chaine de caractéres) sinon
 476         - retourne None en cas d invalidite
 477         - retourne invalide si 1 des objets du tuple l est
 478       """
 479       validite=1
 480       if type(valeur) in (types.ListType,types.TupleType) :
 481          valeurretour=[]
 482          for item in valeur :
 483              newvaleur,validiteitem=self.eval_valeur_item(item)
 484              valeurretour.append(newvaleur)
 485              if validiteitem == 0:
 486                 validite=0
 487       else :
 488          valeurretour,validite= self.eval_valeur_item(valeur)
 489       if validite == 0 :
 490          valeurretour = None
 491       return valeurretour,validite
 492
 493   def eval_valeur_item(self,valeur):
 494       """ Lance l'interprétation de 'valeur' qui doit ne pas etre un tuple
 495           - va retourner la valeur de retour et la validite
 496             selon le type de l objet attendu
 497           - traite les reels et les parametres
 498       """
 499       #print "eval_valeur_item",valeur
 500       if valeur==None or valeur == "" :
 501          return None,0
 502       validite=1
 503       if self.wait_reel():
 504              valeurinter = self.traite_reel(valeur)
 505              if valeurinter != None :
 506                 valeurretour,validite= self.object.eval_valeur(valeurinter)
 507              else:
 508                 valeurretour,validite= self.object.eval_valeur(valeur)
 509       elif self.wait_geom():
 510              valeurretour,validite = valeur,1
 511       else :
 512              valeurretour,validite= self.object.eval_valeur(valeur)
 513       #print "eval_valeur_item",valeurretour,validite
 514
 515       if validite == 0:
 516          if type(valeur) == types.StringType and self.object.wait_TXM():
 517             essai_valeur="'" + valeur + "'"
 518             valeurretour,validite= self.object.eval_valeur(essai_valeur)
 519
 520       if hasattr(valeurretour,'__class__'):
 521          #if valeurretour.__class__.__name__ in ('PARAMETRE','PARAMETRE_EVAL'):
 522          if valeurretour.__class__.__name__ in ('PARAMETRE',):
 523             validite=1
 524
 525       #if self.wait_co():
 526          # CCAR : il ne faut pas essayer de creer un concept
 527          # il faut simplement en chercher un existant ce qui a du etre fait par self.object.eval_valeur(valeur)
 528          #try:
 529             #valeurretour=Accas.CO(valeur)
 530          #except:
 531             #valeurretour=None
 532             #validite=0
 533       # on est dans le cas ou on a évalué et ou on n'aurait pas du
 534       if self.object.wait_TXM() :
 535           if type(valeurretour) != types.StringType:
 536              valeurretour=str(valeur)
 537              validite=1
 538       return valeurretour,validite
 539
 540   def is_CO(self,valeur=None):
 541       """
 542          Indique si valeur est un concept produit de la macro
 543          Cette méthode n'a de sens que pour un MCSIMP d'une MACRO
 544          Si valeur vaut None on teste la valeur du mot cle
 545       """
 546       # Pour savoir si un concept est un nouveau concept de macro
 547       # on regarde s'il est présent dans l'attribut sdprods de l'étape
 548       # ou si son nom de classe est CO.
 549       # Il faut faire les 2 tests car une macro non valide peut etre
 550       # dans un etat pas tres catholique avec des CO pas encore types
 551       # et donc pas dans sdprods (resultat d'une exception dans type_sdprod)
 552       if not valeur:valeur=self.object.valeur
 553       if valeur in self.object.etape.sdprods:return 1
 554       if type(valeur) is not types.InstanceType:return 0
 555       if valeur.__class__.__name__ == 'CO':return 1
 556       return 0
 557
 558   def is_param(self,valeur) :
 559       for param in self.jdc.params:
 560           if (repr(param) == valeur):
 561              return 1
 562       return 0
 563
 564   def traite_reel(self,valeur):
 565       """
 566       Cette fonction a pour but de rajouter le '.' en fin de chaine pour un réel
 567       ou de détecter si on fait référence a un concept produit par DEFI_VALEUR
 568       ou un EVAL ...
 569       """
 570       valeur = string.strip(valeur)
 571       liste_reels = self.get_sd_avant_du_bon_type()
 572       if valeur in liste_reels:
 573           return valeur
 574       if len(valeur) >= 3 :
 575           if valeur[0:4] == 'EVAL' :
 576               # on a trouvé un EVAL --> on retourne directement la valeur
 577               return valeur
 578       if string.find(valeur,'.') == -1 :
 579           # aucun '.' n'a été trouvé dans valeur --> on en rajoute un a la fin
 580           if (self.is_param(valeur)):
 581               return valeur
 582           else:
 583               if string.find(valeur,'e') != -1:
 584                  # Notation scientifique ?
 585                  try :
 586                     r=eval(valeur)
 587                     return valeur
 588                  except :
 589                     return None
 590               else :
 591                  return valeur+'.'
 592       else:
 593           return valeur
 594
 595
 596 import Accas
 597 treeitem = SIMPTreeItem
 598 objet = Accas.MCSIMP
 599