InterfaceQT4/composimp.py

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