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