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