InterfaceQT4/composimp.py

   1 # -*- coding: iso-8859-1 -*-
   2 # Copyright (C) 2007-2013   EDF R&D
   3 #
   4 # This library is free software; you can redistribute it and/or
   5 # modify it under the terms of the GNU Lesser General Public
   6 # License as published by the Free Software Foundation; either
   7 # version 2.1 of the License.
   8 #
   9 # This library is distributed in the hope that it will be useful,
  10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12 # Lesser General Public License for more details.
  13 #
  14 # You should have received a copy of the GNU Lesser General Public
  15 # License along with this library; if not, write to the Free Software
  16 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  17 #
  18 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  19 #
  20 # Modules Python
  21 import string,types,os
  22
  23 from copy import copy,deepcopy
  24 import traceback
  25 import typeNode
  26
  27 # Modules Eficas
  28 from Editeur import Objecttreeitem
  29 import browser
  30 from Noyau.N_CR   import justify_text
  31 from Accas        import SalomeEntry
  32
  33 class Node(browser.JDCNode,typeNode.PopUpMenuNodeMinimal):
  34
  35     def createPopUpMenu(self):
  36         typeNode.PopUpMenuNodeMinimal.createPopUpMenu(self)
  37
  38
  39     def getPanelGroupe(self,parentQt,maCommande):
  40         maDefinition=self.item.get_definition()
  41         monObjet=self.item.object
  42         monNom=self.item.nom
  43
  44         # label informatif
  45         if monObjet.isInformation():
  46           from monWidgetInfo import MonWidgetInfo
  47           widget=MonWidgetInfo(self,maDefinition,monNom,monObjet,parentQt,maCommande)
  48           self.widget=widget
  49           return widget
  50
  51
  52       # Attention l ordre des if est important
  53       # Attention il faut gerer les blocs et les facteurs
  54       # a gerer comme dans composimp
  55       # Gestion des matrices
  56         if self.item.wait_matrice ():
  57           from monWidgetMatrice import MonWidgetMatrice
  58           widget=MonWidgetMatrice(self,maDefinition,monNom,monObjet,parentQt,maCommande)
  59           self.widget=widget
  60           return widget
  61
  62         #print "____________________________", monNom, self.item.wait_co()
  63         #print "____________________________", monNom, self.item.wait_assd()
  64         # Gestion d'une seule valeur (eventuellement un tuple ou un complexe)
  65         if maDefinition.max == 1 :
  66
  67         # A verifier
  68           if maDefinition.into != [] and maDefinition.into != None:
  69             if len(maDefinition.into) < 4 :
  70               from monWidgetRadioButton import MonWidgetRadioButton
  71               widget=MonWidgetRadioButton(self,maDefinition,monNom,monObjet,parentQt,maCommande)
  72             elif len(maDefinition.into) < 7 :
  73               from monWidget4a6RadioButton import MonWidget4a6RadioButton
  74               widget=MonWidget4a6RadioButton(self,maDefinition,monNom,monObjet,parentQt,maCommande)
  75             else :
  76               from monWidgetCB import MonWidgetCB
  77               widget=MonWidgetCB(self,maDefinition,monNom,monObjet,parentQt,maCommande)
  78
  79           elif self.item.wait_bool() :
  80             from monWidgetSimpBool import MonWidgetSimpBool
  81             widget=MonWidgetSimpBool(self,maDefinition,monNom,monObjet,parentQt,maCommande)
  82           elif self.item.wait_fichier():
  83             from monWidgetSimpFichier import MonWidgetSimpFichier
  84             widget=MonWidgetSimpFichier(self,maDefinition,monNom,monObjet,parentQt,maCommande)
  85
  86           # PNPNPN - a faire
  87           elif self.item.wait_date():
  88             from monWidgetDate import MonWidgetDate
  89             widget=MonWidgetDate(self,maDefinition,monNom,monObjet,parentQt,maCommande)
  90           elif self.item.wait_heure():
  91             from monWidgetHeure import MonWidgetHeure
  92             widget=MonWidgetHeure(self,maDefinition,monNom,monObjet,parentQt,maCommande)
  93
  94           elif self.item.wait_tuple() :
  95             if self.item.object.definition.type[0].ntuple == 2:
  96                from monWidgetSimpTuple2 import MonWidgetSimpTuple2
  97                widget=MonWidgetSimpTuple2(self,maDefinition,monNom,monObjet,parentQt,maCommande)
  98             elif self.item.object.definition.type[0].ntuple == 3 :
  99                from monWidgetSimpTuple3 import MonWidgetSimpTuple3
 100                widget=MonWidgetSimpTuple3(self,maDefinition,monNom,monObjet,parentQt,maCommande)
 101             else :
 102                print ("Pas de Tuple de longueur > 3")
 103                print ("Prevenir la maintenance ")
 104
 105           elif self.item.wait_complex():
 106             from monWidgetSimpComplexe import MonWidgetSimpComplexe
 107             widget=MonWidgetSimpComplexe(self,maDefinition,monNom,monObjet,parentQt,maCommande)
 108
 109           elif self.item.wait_co():
 110             if len(self.item.get_sd_avant_du_bon_type()) == 0 :
 111                from monWidgetUniqueSDCO import MonWidgetUniqueSDCO
 112                widget=MonWidgetUniqueSDCO(self,maDefinition,monNom,monObjet,parentQt,maCommande)
 113             else :
 114                from monWidgetSDCOInto import MonWidgetSDCOInto
 115                widget=MonWidgetSDCOInto(self,maDefinition,monNom,monObjet,parentQt,maCommande)
 116           elif self.item.wait_assd():
 117             if len(self.item.get_sd_avant_du_bon_type()) == 0 :
 118                from monWidgetVide import MonWidgetVide
 119                widget=MonWidgetVide(self,maDefinition,monNom,monObjet,parentQt,maCommande)
 120             if len(self.item.get_sd_avant_du_bon_type()) < 4 :
 121               from monWidgetRadioButton import MonWidgetRadioButtonSD
 122               widget=MonWidgetRadioButtonSD(self,maDefinition,monNom,monObjet,parentQt,maCommande)
 123             elif len(self.item.get_sd_avant_du_bon_type()) < 7 :
 124               from monWidget4a6RadioButton import MonWidget4a6RadioButtonSD
 125               widget=MonWidget4a6RadioButtonSD(self,maDefinition,monNom,monObjet,parentQt,maCommande)
 126             else :
 127               from monWidgetCB import MonWidgetCBSD
 128               widget=MonWidgetCBSD(self,maDefinition,monNom,monObjet,parentQt,maCommande)
 129
 130           elif  self.item.wait_Salome() and self.editor.salome:
 131           # Pas fait
 132             from monWidgetSimpSalome import MonWidgetSimpSalome
 133             widget=MonWidgetSimpSalome(self,maDefinition,monNom,monObjet,parentQt,maCommande)
 134
 135           elif self.item.wait_TXM():
 136             from monWidgetSimpTxt import MonWidgetSimpTxt
 137             widget=MonWidgetSimpTxt(self,maDefinition,monNom,monObjet,parentQt,maCommande)
 138           else :
 139             from monWidgetSimpBase import MonWidgetSimpBase
 140             widget=MonWidgetSimpBase(self,maDefinition,monNom,monObjet,parentQt,maCommande)
 141
 142         # Gestion des listes
 143         else :
 144           #if maDefinition.into != [] and maDefinition.into != None:
 145           # Attention pas fini --> on attend une liste de ASSD avec ordre
 146           if self.item.wait_assd() and self.item.is_list_SansOrdreNiDoublon():
 147                #if self.item.is_list_Chargement():
 148                 #from monWidgetPlusieursTuple2AvecChargement import MonWidgetPlusieursTuple2AvecChargement
 149                 #widget=MonWidgetPlusieursTuple2(self,maDefinition,monNom,monObjet,parentQt,maCommande)
 150                 # pass
 151                #else :
 152                from monWidgetPlusieursInto import MonWidgetPlusieursInto
 153                widget=MonWidgetPlusieursInto(self,maDefinition,monNom,monObjet,parentQt,maCommande)
 154           elif self.item.wait_assd() :
 155                from monWidgetPlusieursASSDIntoOrdonne import MonWidgetPlusieursASSDIntoOrdonne
 156                widget=MonWidgetPlusieursASSDIntoOrdonne(self,maDefinition,monNom,monObjet,parentQt,maCommande)
 157           elif self.item.wait_tuple() :
 158             if self.item.object.definition.type[0].ntuple == 2:
 159                from monWidgetPlusieursTuple2 import MonWidgetPlusieursTuple2
 160                widget=MonWidgetPlusieursTuple2(self,maDefinition,monNom,monObjet,parentQt,maCommande)
 161             elif self.item.object.definition.type[0].ntuple == 3 :
 162                from monWidgetPlusieursTuple3 import MonWidgetPlusieursTuple3
 163                widget=MonWidgetPlusieursTuple3(self,maDefinition,monNom,monObjet,parentQt,maCommande)
 164             else :
 165                print ("Pas de Tuple de longueur > 3")
 166                print ("Prevenir la maintenance ")
 167           elif self.item.has_into():
 168             if self.item.is_list_SansOrdreNiDoublon():
 169
 170                if self.item in self.editor.listeDesListesOuvertes or not(self.editor.afficheListesPliees) :
 171                   from monWidgetPlusieursInto import MonWidgetPlusieursInto
 172                   widget=MonWidgetPlusieursInto(self,maDefinition,monNom,monObjet,parentQt,maCommande)
 173                else :
 174                   from monWidgetPlusieursPlie import MonWidgetPlusieursPlie
 175                   widget=MonWidgetPlusieursPlie(self,maDefinition,monNom,monObjet,parentQt,maCommande)
 176             else :
 177 # tres vite pour le tag mais devra etre gere dans configuration
 178                if self.item in self.editor.listeDesListesOuvertes or not(self.editor.afficheListesPliees) :
 179                   from monWidgetPlusieursIntoOrdonne import MonWidgetPlusieursIntoOrdonne
 180                   widget=MonWidgetPlusieursIntoOrdonne(self,maDefinition,monNom,monObjet,parentQt,maCommande)
 181                else :
 182                   from monWidgetPlusieursPlie import MonWidgetPlusieursPlie
 183                   widget=MonWidgetPlusieursPlie(self,maDefinition,monNom,monObjet,parentQt,maCommande)
 184           else :
 185             #print 8
 186             if self.item in self.editor.listeDesListesOuvertes or not(self.editor.afficheListesPliees)  :
 187                from monWidgetPlusieursBase import MonWidgetPlusieursBase
 188                widget=MonWidgetPlusieursBase(self,maDefinition,monNom,monObjet,parentQt,maCommande)
 189             else :
 190                from monWidgetPlusieursPlie import MonWidgetPlusieursPlie
 191                widget=MonWidgetPlusieursPlie(self,maDefinition,monNom,monObjet,parentQt,maCommande)
 192
 193         self.widget=widget
 194         return widget
 195
 196
 197 class SIMPTreeItem(Objecttreeitem.AtomicObjectTreeItem):
 198   itemNode=Node
 199
 200   def init(self) :
 201       self.expandable = 0
 202
 203
 204   #-----------------------------------------------
 205   #
 206   # Methodes liees aux informations sur le Panel
 207   # ou au mot-clef simple
 208   #
 209   #-----------------------------------------------
 210   # is_list
 211   # get_into                a priori inutile --> commentee
 212   # has_into
 213   # wait_into                a priori inutile --> commentee
 214   # GetMinMax
 215   # GetMultiplicite
 216   # GetIntervalle
 217   # GetListeValeurs
 218   # get_liste_possible
 219
 220   def is_list(self):
 221       """
 222           Cette methode indique si le mot cle simple attend une liste (valeur de retour 1)
 223           ou s'il n'en attend pas (valeur de retour 0)
 224
 225           Deux cas principaux peuvent se presenter : avec validateurs ou bien sans.
 226           Dans le cas sans validateur, l'information est donnee par l'attribut max
 227           de la definition du mot cle.
 228           Dans le cas avec validateur, il faut combiner l'information precedente avec
 229           celle issue de l'appel de la methode is_list sur le validateur.On utilisera
 230           l'operateur ET pour effectuer cette combinaison (AndVal).
 231       """
 232       is_a_list=0
 233       min,max = self.GetMinMax()
 234       assert (min <= max)
 235       if max > 1 :
 236                 is_a_list=1
 237       # Dans le cas avec validateurs, pour que le mot cle soit considere
 238       # comme acceptant une liste, il faut que max soit superieur a 1
 239       # ET que la methode is_list du validateur retourne 1. Dans les autres cas
 240       # on retournera 0 (n'attend pas de liste)
 241       if self.definition.validators :
 242          is_a_list= self.definition.validators.is_list() * is_a_list
 243       return is_a_list
 244
 245   def is_list_SansOrdreNiDoublon(self):
 246       if self.definition.homo=="SansOrdreNiDoublon" : return 1
 247       return 0
 248
 249   def is_list_Chargement(self):
 250       if  self.definition.docu != "" :  return 1
 251       return 0
 252
 253   def has_into(self):
 254       """
 255           Cette methode indique si le mot cle simple propose un choix (valeur de retour 1)
 256           ou s'il n'en propose pas (valeur de retour 0)
 257
 258           Deux cas principaux peuvent se presenter : avec validateurs ou bien sans.
 259           Dans le cas sans validateur, l'information est donnee par l'attribut into
 260           de la definition du mot cle.
 261           Dans le cas avec validateurs, pour que le mot cle soit considere
 262           comme proposant un choix, il faut que into soit present OU
 263           que la methode has_into du validateur retourne 1. Dans les autres cas
 264           on retournera 0 (ne propose pas de choix)
 265       """
 266       has_an_into=0
 267       if self.definition.into:
 268                has_an_into=1
 269       elif self.definition.validators :
 270          has_an_into= self.definition.validators.has_into()
 271       return has_an_into
 272
 273
 274   def GetMinMax(self):
 275       """ Retourne les valeurs min et max de la definition de object """
 276       return self.object.get_min_max()
 277
 278   def GetMultiplicite(self):
 279       """ A preciser.
 280           Retourne la multiplicite des valeurs affectees a l'objet
 281           represente par l'item. Pour le moment retourne invariablement 1.
 282       """
 283       return 1
 284
 285   def GetIntervalle(self):
 286       """
 287            Retourne le domaine de valeur attendu par l'objet represente
 288            par l'item.
 289       """
 290       return self.object.getintervalle()
 291
 292   def GetListeValeurs(self) :
 293       """ Retourne la liste des valeurs de object """
 294       valeurs=self.object.get_liste_valeurs()
 295       try :
 296         if "R" in self.object.definition.type:
 297            clef=self.object.GetNomConcept()
 298            if self.appli.dict_reels.has_key(clef):
 299               if type(valeurs) == types.TupleType:
 300                  valeurs_reelles=[]
 301                  for val in valeurs :
 302                     if self.appli.dict_reels[clef].has_key(val) :
 303                        valeurs_reelles.append(self.appli.dict_reels[clef][val])
 304                     else :
 305                        valeurs_reelles.append(val)
 306               else :
 307                  if self.appli.dict_reels[clef].has_key(valeurs):
 308                     valeurs_reelles=self.appli.dict_reels[clef][valeurs]
 309               valeurs=valeurs_reelles
 310       except :
 311         pass
 312       return valeurs
 313
 314   def get_liste_possible(self,listeActuelle=[]):
 315       if hasattr(self.definition.validators,'into'):
 316          valeurspossibles = self.definition.validators.into
 317       else:
 318          valeurspossibles = self.get_definition().into
 319
 320       if listeActuelle==[] : return valeurspossibles
 321
 322       #On ne garde que les items valides
 323       listevalideitem=[]
 324       if type(valeurspossibles) in (types.ListType,types.TupleType) :
 325          pass
 326       else :
 327          valeurspossibles=(valeurspossibles,)
 328       for item in valeurspossibles:
 329           encorevalide=self.valide_item(item)
 330           if encorevalide :
 331              listevalideitem.append(item)
 332
 333       #on ne garde que les choix possibles qui passent le test de valide_liste_partielle
 334       listevalideliste=[]
 335       for item in listevalideitem:
 336           encorevalide=self.valide_liste_partielle(item,listeActuelle)
 337           if encorevalide :
 338               listevalideliste.append(item)
 339       #print listevalideliste
 340       return listevalideliste
 341
 342   def get_liste_param_possible(self):
 343       liste_param=[]
 344       l1,l2=self.jdc.get_parametres_fonctions_avant_etape(self.get_etape())
 345       for param in self.object.jdc.params:
 346           if param.nom not in l1 : continue
 347           encorevalide=self.valide_item(param.valeur)
 348           if encorevalide:
 349              type_param=param.valeur.__class__.__name__
 350              for typ in self.definition.type:
 351                  if typ=='R':
 352                      liste_param.append(param)
 353                  if typ=='I' and type_param=='int':
 354                      liste_param.append(param)
 355                  if typ=='TXM' and type_param=='str':
 356                      liste_param.append(repr(param))
 357                  if ('grma' in repr(typ)) and type_param=='str':
 358                      liste_param.append(param.nom)
 359       return liste_param
 360
 361   #--------------------------------------------------
 362   #
 363   # Methodes liees a la validite des valeurs saisies
 364   #
 365   #---------------------------------------------------
 366   # valide_item
 367   # valide_liste_partielle
 368   # valide_liste_complete
 369   # info_erreur_item
 370   # info_erreur_liste
 371   # IsInIntervalle
 372   # isvalid
 373
 374   def valide_item(self,item):
 375       """
 376         La validation est realisee directement par l'objet
 377       """
 378       return self.object.valide_item(item)
 379
 380   def valide_liste_partielle(self,item,listecourante):
 381       #On protege la liste en entree en la copiant
 382       valeur=listecourante[:]
 383       valeur.append(item)
 384       return self.object.valid_valeur_partielle(valeur)
 385
 386   def valide_liste_complete (self,valeur):
 387       return self.object.valid_valeur(valeur)
 388
 389   def valide_val (self,valeur):
 390       return self.object.valid_val(valeur)
 391
 392   def info_erreur_item(self) :
 393       commentaire=""
 394       if self.definition.validators :
 395          commentaire=self.definition.validators.info_erreur_item()
 396       return commentaire
 397
 398   def aide(self) :
 399       commentaire=""
 400       if self.definition.validators :
 401          commentaire=self.definition.validators.aide()
 402       return commentaire
 403
 404   def info_erreur_liste(self) :
 405       commentaire=""
 406       if self.definition.validators :
 407          commentaire=self.definition.validators.info_erreur_liste()
 408       return commentaire
 409
 410   def IsInIntervalle(self,valeur):
 411       """
 412           Retourne 1 si la valeur est dans l'intervalle permis par
 413           l'objet represente par l'item.
 414       """
 415       return self.valide_item(valeur)
 416
 417   def isvalid(self):
 418     valide=self.object.isvalid()
 419     return valide
 420
 421   #--------------------------------------------------
 422   #
 423   # Autres ...
 424   #
 425   #---------------------------------------------------
 426   # GetIconName
 427   # GetText
 428   # set_valeur_co
 429   # get_sd_avant_du_bon_type
 430   # delete_valeur_co
 431
 432
 433   def GetIconName(self):
 434     if self.isvalid():
 435       return "ast-green-ball"
 436     elif self.object.isoblig():
 437       return "ast-red-ball"
 438     else:
 439       return "ast-yel-ball"
 440
 441   def GetText(self):
 442     """
 443     Classe SIMPTreeItem
 444     Retourne le texte a afficher dans l'arbre representant la valeur de l'objet
 445     pointe par self
 446     """
 447     text= self.object.GetText()
 448     if text == None : text=""
 449     return text
 450
 451
 452   def set_valeur_co(self,nom_co):
 453       """
 454       Affecte au MCS pointé par self l'objet de type CO et de nom nom_co
 455       """
 456       ret = self.object.set_valeur_co(nom_co)
 457       #print "set_valeur_co",ret
 458       return ret
 459
 460   def get_sd_avant_du_bon_type(self):
 461       """
 462       Retourne la liste des noms des SD présentes avant l'étape qui contient
 463       le MCS pointé par self et du type requis par ce MCS
 464       """
 465       a=self.object.etape.parent.get_sd_avant_du_bon_type(self.object.etape,self.object.definition.type)
 466       return a
 467
 468   def get_sd_avant_du_bon_type_pour_type_de_base(self):
 469       a=self.object.jdc.get_sd_avant_du_bon_type_pour_type_de_base(self.object.etape,"LASSD")
 470       return a
 471
 472
 473
 474
 475   def delete_valeur_co(self,valeur=None):
 476       """
 477            Supprime la valeur du mot cle (de type CO)
 478            il faut propager la destruction aux autres etapes
 479       """
 480       if not valeur : valeur=self.object.valeur
 481       # XXX faut il vraiment appeler del_sdprod ???
 482       #self.object.etape.parent.del_sdprod(valeur)
 483       self.object.etape.parent.delete_concept(valeur)
 484
 485   #-----------------------------------------------
 486   #
 487   # Methodes liees au type de l objet attendu
 488   #
 489   #-----------------------------------------------
 490   # wait_co
 491   # wait_geom
 492   # wait_complex
 493   # wait_reel
 494   # wait_assd
 495   # GetType
 496
 497   def wait_co(self):
 498       """
 499       Méthode booléenne qui retourne 1 si l'objet pointé par self
 500       attend un objet de type ASSD qui n'existe pas encore (type CO()),
 501       0 sinon
 502       """
 503       return self.object.wait_co()
 504
 505   def wait_fichier(self):
 506       maDefinition=self.object.definition
 507       try :
 508         if ('Repertoire' in maDefinition.type[0]) or ('Fichier' in maDefinition.type[0]) :
 509            return 1
 510       except :
 511            return 0
 512
 513   def wait_geom(self):
 514       """
 515       Méthode booléenne qui retourne 1 si l'objet pointé par self
 516       attend un objet GEOM, 0 sinon
 517       """
 518       return self.object.wait_geom()
 519
 520   def wait_TXM(self):
 521      return self.object.wait_TXM()
 522
 523
 524   def wait_complex(self):
 525       """ Méthode booléenne qui retourne 1 si l'objet pointé par self
 526       attend un complexe, 0 sinon """
 527       if 'C' in self.object.definition.type:
 528           return 1
 529       else:
 530           return 0
 531
 532   def wait_reel(self):
 533       """ Méthode booléenne qui retourne 1 si l'objet pointé par self
 534       attend un réel, 0 sinon """
 535       if 'R' in self.object.definition.type:
 536           return 1
 537       else:
 538           return 0
 539
 540   def wait_date(self):
 541       """ Méthode booléenne qui retourne 1 si l'objet pointé par self
 542       attend un réel, 0 sinon """
 543       if 'DateHHMMAAAA' in self.object.definition.type:
 544           return 1
 545       else:
 546           return 0
 547
 548   def wait_heure(self):
 549       """ Méthode booléenne qui retourne 1 si l'objet pointé par self
 550       attend un réel, 0 sinon """
 551       if 'HeureHHMMSS' in self.object.definition.type:
 552           return 1
 553       else:
 554           return 0
 555
 556
 557
 558   def wait_tuple(self):
 559       """ Méthode booléenne qui retourne 1 si l'objet pointé par self
 560       attend un Tuple, 0 sinon """
 561       for ss_type in self.object.definition.type:
 562           if repr(ss_type).find('Tuple') != -1 :
 563              return 1
 564       return 0
 565
 566   def wait_matrice(self):
 567       """ Méthode booléenne qui retourne 1 si l'objet pointé par self
 568       attend un Tuple, 0 sinon """
 569       for ss_type in self.object.definition.type:
 570           if repr(ss_type).find('Matrice') != -1 :
 571              return 1
 572       return 0
 573
 574   def wait_assd(self):
 575       """Méthode booléenne qui retourne 1 si l'objet pointé par self
 576       attend un objet de type ASSD ou dérivé, 0 sinon """
 577       return self.object.wait_assd()
 578
 579   def wait_assd_or_type_base(self) :
 580       boo=0
 581       if len(self.object.definition.type) > 1 :
 582          if self.wait_reel() :
 583             boo = 1
 584          if 'I' in self.object.definition.type :
 585             boo = 1
 586       return boo
 587
 588   def wait_Salome(self):
 589       type = self.object.definition.type[0]
 590       if 'grma' in repr(type) : return True
 591       if 'grno' in repr(type) : return True
 592       if (isinstance(type, types.ClassType) and issubclass(type, SalomeEntry)) : return True
 593       return False
 594
 595   def GetType(self):
 596       """
 597           Retourne le type de valeur attendu par l'objet représenté par l'item.
 598       """
 599       return self.object.get_type()
 600
 601   #-----------------------------------------------------
 602   #
 603   # Methodes liees  a l evaluation de la valeur saisie
 604   #
 605   #-----------------------------------------------------
 606   # eval_valeur
 607   # eval_valeur_item
 608   # is_CO
 609   # traite_reel
 610
 611   def eval_valeur(self,valeur):
 612       """ Lance l'interprétation de 'valeur' (chaine de caractéres) comme valeur de self :
 613              - retourne l'objet associé si on a pu interpréter (entier, réel, ASSD,...)
 614              - retourne 'valeur' (chaine de caractéres) sinon
 615       """
 616       newvaleur=self.eval_val(valeur)
 617       return newvaleur,1
 618
 619   def eval_valeur_BAK(self,valeur):
 620       """ Lance l'interprétation de 'valeur' (chaine de caractéres) comme valeur
 621       de l'objet pointé par self :
 622         - retourne l'objet associé si on a pu interpréter (entier, réel, ASSD,...)
 623         - retourne 'valeur' (chaine de caractéres) sinon
 624         - retourne None en cas d invalidite
 625         - retourne invalide si 1 des objets du tuple l est
 626       """
 627       validite=1
 628       if type(valeur) in (types.ListType,types.TupleType) :
 629          valeurretour=[]
 630          for item in valeur :
 631              newvaleur,validiteitem=self.eval_valeur_item(item)
 632              valeurretour.append(newvaleur)
 633              if validiteitem == 0:
 634                 validite=0
 635       else :
 636          valeurretour,validite= self.eval_valeur_item(valeur)
 637       if validite == 0 :
 638          valeurretour = None
 639       return valeurretour,validite
 640
 641   def eval_valeur_item(self,valeur):
 642       """ Lance l'interprétation de 'valeur' qui doit ne pas etre un tuple
 643           - va retourner la valeur de retour et la validite
 644             selon le type de l objet attendu
 645           - traite les reels et les parametres
 646       """
 647       #print "eval_valeur_item",valeur
 648       if valeur==None or valeur == "" :
 649          return None,0
 650       validite=1
 651       if self.wait_reel():
 652              valeurinter = self.traite_reel(valeur)
 653              if valeurinter != None :
 654                 valeurretour,validite= self.object.eval_valeur(valeurinter)
 655              else:
 656                 valeurretour,validite= self.object.eval_valeur(valeur)
 657       elif self.wait_geom():
 658              valeurretour,validite = valeur,1
 659       else :
 660              valeurretour,validite= self.object.eval_valeur(valeur)
 661       #print "eval_valeur_item",valeurretour,validite
 662
 663       if validite == 0:
 664          if type(valeur) == types.StringType and self.object.wait_TXM():
 665             essai_valeur="'" + valeur + "'"
 666             valeurretour,validite= self.object.eval_valeur(essai_valeur)
 667
 668       if hasattr(valeurretour,'__class__'):
 669          #if valeurretour.__class__.__name__ in ('PARAMETRE','PARAMETRE_EVAL'):
 670          if valeurretour.__class__.__name__ in ('PARAMETRE',):
 671             validite=1
 672
 673       #if self.wait_co():
 674          # CCAR : il ne faut pas essayer de creer un concept
 675          # il faut simplement en chercher un existant ce qui a du etre fait par self.object.eval_valeur(valeur)
 676          #try:
 677             #valeurretour=Accas.CO(valeur)
 678          #except:
 679             #valeurretour=None
 680             #validite=0
 681       # on est dans le cas ou on a évalué et ou on n'aurait pas du
 682       if self.object.wait_TXM() :
 683           if type(valeurretour) != types.StringType:
 684              valeurretour=str(valeur)
 685              validite=1
 686       return valeurretour,validite
 687
 688   def is_CO(self,valeur=None):
 689       """
 690          Indique si valeur est un concept produit de la macro
 691          Cette méthode n'a de sens que pour un MCSIMP d'une MACRO
 692          Si valeur vaut None on teste la valeur du mot cle
 693       """
 694       # Pour savoir si un concept est un nouveau concept de macro
 695       # on regarde s'il est présent dans l'attribut sdprods de l'étape
 696       # ou si son nom de classe est CO.
 697       # Il faut faire les 2 tests car une macro non valide peut etre
 698       # dans un etat pas tres catholique avec des CO pas encore types
 699       # et donc pas dans sdprods (resultat d'une exception dans type_sdprod)
 700       if not valeur:valeur=self.object.valeur
 701       if valeur in self.object.etape.sdprods:return 1
 702       if type(valeur) is not types.InstanceType:return 0
 703       if valeur.__class__.__name__ == 'CO':return 1
 704       return 0
 705
 706   def is_param(self,valeur) :
 707       for param in self.jdc.params:
 708           if (repr(param) == valeur):
 709              return 1
 710       return 0
 711
 712   def traite_reel(self,valeur):
 713       """
 714       Cette fonction a pour but de rajouter le '.' en fin de chaine pour un réel
 715       ou de détecter si on fait référence a un concept produit par DEFI_VALEUR
 716       ou un EVAL ...
 717       """
 718       valeur = string.strip(valeur)
 719       liste_reels = self.get_sd_avant_du_bon_type()
 720       if valeur in liste_reels:
 721           return valeur
 722       if len(valeur) >= 3 :
 723           if valeur[0:4] == 'EVAL' :
 724               # on a trouvé un EVAL --> on retourne directement la valeur
 725               return valeur
 726       if string.find(valeur,'.') == -1 :
 727           # aucun '.' n'a été trouvé dans valeur --> on en rajoute un a la fin
 728           if (self.is_param(valeur)):
 729               return valeur
 730           else:
 731               if string.find(valeur,'e') != -1:
 732                  # Notation scientifique ?
 733                  try :
 734                     r=eval(valeur)
 735                     return valeur
 736                  except :
 737                     return None
 738               else :
 739                  return valeur+'.'
 740       else:
 741           return valeur
 742
 743
 744 import Accas
 745 treeitem = SIMPTreeItem
 746 objet = Accas.MCSIMP
 747