InterfaceQT4/composimp.py

   1 # -*- coding: iso-8859-1 -*-
   2 # Copyright (C) 2007-2017   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 InterfaceQT4 import typeNode
  32
  33 # Modules Eficas
  34 from Editeur      import Objecttreeitem
  35 from InterfaceQT4 import browser
  36 from Noyau.N_CR   import justifyText
  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 InterfaceQT4.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.waitMatrice ():
  63           from InterfaceQT4.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.waitCo()
  69         #print "____________________________", monNom, self.item.waitAssd()
  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.intoSug != [] and maDefinition.intoSug != None:
  80             from InterfaceQT4.monWidgetCBIntoSug import MonWidgetCBIntoSug
  81             widget=MonWidgetCBIntoSug(self,maDefinition,monNom,monObjet,parentQt,maCommande)
  82           elif  maDefinition.into != [] and maDefinition.into != None:
  83             if maDefinition.fenetreIhm=='menuDeroulant' :
  84               from InterfaceQT4.monWidgetCB import MonWidgetCB
  85               widget=MonWidgetCB(self,maDefinition,monNom,monObjet,parentQt,maCommande)
  86             elif len(monInto) < 4 :
  87               from InterfaceQT4.monWidgetRadioButton import MonWidgetRadioButton
  88               widget=MonWidgetRadioButton(self,maDefinition,monNom,monObjet,parentQt,maCommande)
  89             elif len(monInto) < 7 :
  90               from InterfaceQT4.monWidget4a6RadioButton import MonWidget4a6RadioButton
  91               widget=MonWidget4a6RadioButton(self,maDefinition,monNom,monObjet,parentQt,maCommande)
  92             else :
  93               from InterfaceQT4.monWidgetCB import MonWidgetCB
  94               widget=MonWidgetCB(self,maDefinition,monNom,monObjet,parentQt,maCommande)
  95
  96           elif self.item.waitBool() :
  97             from InterfaceQT4.monWidgetSimpBool import MonWidgetSimpBool
  98             widget=MonWidgetSimpBool(self,maDefinition,monNom,monObjet,parentQt,maCommande)
  99           elif self.item.waitFichier():
 100             from InterfaceQT4.monWidgetSimpFichier import MonWidgetSimpFichier
 101             widget=MonWidgetSimpFichier(self,maDefinition,monNom,monObjet,parentQt,maCommande)
 102
 103           # PNPNPN - a faire
 104           elif self.item.waitDate():
 105             from InterfaceQT4.monWidgetDate import MonWidgetDate
 106             widget=MonWidgetDate(self,maDefinition,monNom,monObjet,parentQt,maCommande)
 107           elif self.item.waitHeure():
 108             from InterfaceQT4.monWidgetHeure import MonWidgetHeure
 109             widget=MonWidgetHeure(self,maDefinition,monNom,monObjet,parentQt,maCommande)
 110
 111           elif self.item.waitTuple() :
 112             num=self.item.object.definition.type[0].ntuple
 113             nomDeLaClasse = 'MonWidgetSimpTuple'+str(num)
 114             nomDuFichier  = 'InterfaceQT4.monWidgetSimpTupleN'
 115             try :
 116             #if 1 :
 117                _temp = __import__(nomDuFichier, globals(), locals(), [nomDeLaClasse], 0)
 118                #print (_temp)
 119                MonWidgetSimpTuple =  getattr(_temp,nomDeLaClasse)
 120             except :
 121                print ("Pas de Tuple de longueur : ", num)
 122             #   print ("Prevenir la maintenance ")
 123             widget=MonWidgetSimpTuple(self,maDefinition,monNom,monObjet,parentQt,maCommande)
 124
 125           elif self.item.waitComplex():
 126             from InterfaceQT4.monWidgetSimpComplexe import MonWidgetSimpComplexe
 127             widget=MonWidgetSimpComplexe(self,maDefinition,monNom,monObjet,parentQt,maCommande)
 128
 129           elif self.item.waitCo():
 130             if len(self.item.getSdAvantDuBonType()) == 0 :
 131                from InterfaceQT4.monWidgetUniqueSDCO import MonWidgetUniqueSDCO
 132                widget=MonWidgetUniqueSDCO(self,maDefinition,monNom,monObjet,parentQt,maCommande)
 133             else :
 134                from InterfaceQT4.monWidgetSDCOInto import MonWidgetSDCOInto
 135                widget=MonWidgetSDCOInto(self,maDefinition,monNom,monObjet,parentQt,maCommande)
 136           elif self.item.waitAssd():
 137             if len(self.item.getSdAvantDuBonType()) == 0 :
 138                from InterfaceQT4.monWidgetVide import MonWidgetVide
 139                widget=MonWidgetVide(self,maDefinition,monNom,monObjet,parentQt,maCommande)
 140             elif len(self.item.getSdAvantDuBonType()) < 4 :
 141               from InterfaceQT4.monWidgetRadioButton import MonWidgetRadioButtonSD
 142               widget=MonWidgetRadioButtonSD(self,maDefinition,monNom,monObjet,parentQt,maCommande)
 143             elif len(self.item.getSdAvantDuBonType()) < 7 :
 144               from InterfaceQT4.monWidget4a6RadioButton import MonWidget4a6RadioButtonSD
 145               widget=MonWidget4a6RadioButtonSD(self,maDefinition,monNom,monObjet,parentQt,maCommande)
 146             else :
 147               from InterfaceQT4.monWidgetCB import MonWidgetCBSD
 148               widget=MonWidgetCBSD(self,maDefinition,monNom,monObjet,parentQt,maCommande)
 149
 150           elif  self.item.waitSalome() and self.editor.salome:
 151             from InterfaceQT4.monWidgetSimpSalome import MonWidgetSimpSalome
 152             widget=MonWidgetSimpSalome(self,maDefinition,monNom,monObjet,parentQt,maCommande)
 153
 154           elif self.item.waitTxm():
 155             from InterfaceQT4.monWidgetSimpTxt import MonWidgetSimpTxt
 156             widget=MonWidgetSimpTxt(self,maDefinition,monNom,monObjet,parentQt,maCommande)
 157           else :
 158             from InterfaceQT4.monWidgetSimpBase import MonWidgetSimpBase
 159             widget=MonWidgetSimpBase(self,maDefinition,monNom,monObjet,parentQt,maCommande)
 160
 161         # Gestion des listes
 162         else :
 163           if maDefinition.intoSug != [] and maDefinition.intoSug != None:
 164                if self.item in self.editor.listeDesListesOuvertes or not(self.editor.afficheListesPliees) :
 165                  from InterfaceQT4.monWidgetIntoSug import MonWidgetIntoSug
 166                  widget=MonWidgetIntoSug(self,maDefinition,monNom,monObjet,parentQt,maCommande)
 167                else :
 168                   from InterfaceQT4.monWidgetPlusieursPlie import MonWidgetPlusieursPlie
 169                   widget=MonWidgetPlusieursPlie(self,maDefinition,monNom,monObjet,parentQt,maCommande)
 170           #if maDefinition.into != [] and maDefinition.into != None:
 171           # Attention pas fini --> on attend une liste de ASSD avec ordre
 172           elif self.item.waitAssd() and self.item.isListSansOrdreNiDoublon():
 173                listeAAfficher = self.item.getSdAvantDuBonType()
 174                if len(listeAAfficher) == 0:
 175                  from InterfaceQT4.monWidgetVide import MonWidgetVide
 176                  widget = MonWidgetVide(self,maDefinition,monNom,monObjet,parentQt,maCommande)
 177                else :
 178                  from InterfaceQT4.monWidgetPlusieursInto import MonWidgetPlusieursInto
 179                  widget=MonWidgetPlusieursInto(self,maDefinition,monNom,monObjet,parentQt,maCommande)
 180           elif self.item.waitAssd() :
 181                listeAAfficher = self.item.getSdAvantDuBonType()
 182                mctype=maDefinition.type[0]
 183                enable_salome_selection = self.editor.salome and \
 184                       (('grma' in repr(mctype)) or ('grno' in repr(mctype)) or ('SalomeEntry' in repr(mctype)) or \
 185                       (hasattr(mctype, "enable_salome_selection") and mctype.enable_salome_selection))
 186                if enable_salome_selection:
 187                   from InterfaceQT4.monWidgetPlusieursBase import MonWidgetPlusieursBase
 188                   widget=MonWidgetPlusieursBase(self,maDefinition,monNom,monObjet,parentQt,maCommande)
 189                elif len(listeAAfficher) == 0:
 190                  from InterfaceQT4.monWidgetVide import MonWidgetVide
 191                  widget = MonWidgetVide(self,maDefinition,monNom,monObjet,parentQt,maCommande)
 192                elif self.item in self.editor.listeDesListesOuvertes or not(self.editor.afficheListesPliees) :
 193                  from InterfaceQT4.monWidgetPlusieursASSDIntoOrdonne import MonWidgetPlusieursASSDIntoOrdonne
 194                  widget=MonWidgetPlusieursASSDIntoOrdonne(self,maDefinition,monNom,monObjet,parentQt,maCommande)
 195                else :
 196                   from InterfaceQT4.monWidgetPlusieursPlie import MonWidgetPlusieursPlieASSD
 197                   widget=MonWidgetPlusieursPlieASSD(self,maDefinition,monNom,monObjet,parentQt,maCommande)
 198           elif self.item.waitTuple() :
 199             if self.item.object.definition.fenetreIhm == 'Tableau' :
 200                from InterfaceQT4.monWidgetTableau import MonWidgetTableau
 201                widget=MonWidgetTableau(self,maDefinition,monNom,monObjet,parentQt,maCommande)
 202             else  :
 203                num=self.item.object.definition.type[0].ntuple
 204                nomDeLaClasse = 'MonWidgetPlusieursTuple'+str(num)
 205                nomDuFichier  = 'InterfaceQT4.monWidgetPlusieursTupleN'
 206                #try:
 207                if 1 :
 208                   _temp = __import__(nomDuFichier, globals(), locals(), [nomDeLaClasse], 0)
 209                   MonWidgetPlusieursTuple =  getattr(_temp,nomDeLaClasse)
 210                #except :
 211                #   print ("Pas de Tuple de longueur : ", num)
 212                #   print ("Prevenir la maintenance ")
 213                widget=MonWidgetPlusieursTuple(self,maDefinition,monNom,monObjet,parentQt,maCommande)
 214
 215           elif self.item.hasInto():
 216             if self.item.isListSansOrdreNiDoublon():
 217
 218                if self.item in self.editor.listeDesListesOuvertes or not(self.editor.afficheListesPliees) :
 219                   from InterfaceQT4.monWidgetPlusieursInto import MonWidgetPlusieursInto
 220                   widget=MonWidgetPlusieursInto(self,maDefinition,monNom,monObjet,parentQt,maCommande)
 221                else :
 222                   from InterfaceQT4.monWidgetPlusieursPlie import MonWidgetPlusieursPlie
 223                   widget=MonWidgetPlusieursPlie(self,maDefinition,monNom,monObjet,parentQt,maCommande)
 224             else :
 225                if self.item in self.editor.listeDesListesOuvertes or not(self.editor.afficheListesPliees) :
 226                   from InterfaceQT4.monWidgetPlusieursIntoOrdonne import MonWidgetPlusieursIntoOrdonne
 227                   widget=MonWidgetPlusieursIntoOrdonne(self,maDefinition,monNom,monObjet,parentQt,maCommande)
 228                else :
 229                   from InterfaceQT4.monWidgetPlusieursPlie import MonWidgetPlusieursPlie
 230                   widget=MonWidgetPlusieursPlie(self,maDefinition,monNom,monObjet,parentQt,maCommande)
 231           else :
 232             if self.item in self.editor.listeDesListesOuvertes or not(self.editor.afficheListesPliees)  :
 233                from InterfaceQT4.monWidgetPlusieursBase import MonWidgetPlusieursBase
 234                widget=MonWidgetPlusieursBase(self,maDefinition,monNom,monObjet,parentQt,maCommande)
 235             else :
 236                from InterfaceQT4.monWidgetPlusieursPlie import MonWidgetPlusieursPlie
 237                widget=MonWidgetPlusieursPlie(self,maDefinition,monNom,monObjet,parentQt,maCommande)
 238
 239         self.widget=widget
 240         return widget
 241
 242
 243 class SIMPTreeItem(Objecttreeitem.AtomicObjectTreeItem):
 244   itemNode=Node
 245
 246   def init(self) :
 247       self.expandable = 0
 248
 249
 250   #-----------------------------------------------
 251   #
 252   # Methodes liees aux informations sur le Panel
 253   # ou au mot-clef simple
 254   #
 255   #-----------------------------------------------
 256   # isList
 257   # hasInto
 258   # getMinMax
 259   # getMultiplicite
 260   # getIntervalle
 261   # getListeValeurs
 262   # getListePossible
 263
 264   def isList(self):
 265       """
 266           Cette methode indique si le mot cle simple attend une liste (valeur de retour 1)
 267           ou s'il n'en attend pas (valeur de retour 0)
 268
 269           Deux cas principaux peuvent se presenter : avec validateurs ou bien sans.
 270           Dans le cas sans validateur, l'information est donnee par l'attribut max
 271           de la definition du mot cle.
 272           Dans le cas avec validateur, il faut combiner l'information precedente avec
 273           celle issue de l'appel de la methode isList sur le validateur.On utilisera
 274           l'operateur ET pour effectuer cette combinaison (AndVal).
 275       """
 276       is_a_list=0
 277       min,max = self.getMinMax()
 278       assert (min <= max)
 279       if max > 1 :
 280                 is_a_list=1
 281       # Dans le cas avec validateurs, pour que le mot cle soit considere
 282       # comme acceptant une liste, il faut que max soit superieur a 1
 283       # ET que la methode isList du validateur retourne 1. Dans les autres cas
 284       # on retournera 0 (n'attend pas de liste)
 285       if self.definition.validators :
 286          is_a_list= self.definition.validators.isList() * is_a_list
 287       return is_a_list
 288
 289   def isListSansOrdreNiDoublon(self):
 290       if self.definition.homo=="SansOrdreNiDoublon" : return 1
 291       return 0
 292
 293
 294   def hasInto(self):
 295       """
 296           Cette methode indique si le mot cle simple propose un choix (valeur de retour 1)
 297           ou s'il n'en propose pas (valeur de retour 0)
 298
 299           Deux cas principaux peuvent se presenter : avec validateurs ou bien sans.
 300           Dans le cas sans validateur, l'information est donnee par l'attribut into
 301           de la definition du mot cle.
 302           Dans le cas avec validateurs, pour que le mot cle soit considere
 303           comme proposant un choix, il faut que into soit present OU
 304           que la methode hasInto du validateur retourne 1. Dans les autres cas
 305           on retournera 0 (ne propose pas de choix)
 306       """
 307       has_an_into=0
 308       if self.definition.into:
 309                has_an_into=1
 310       elif self.definition.validators :
 311          has_an_into= self.definition.validators.hasInto()
 312       return has_an_into
 313
 314   def hasIntoSug(self):
 315       if self.definition.intoSug: return 1
 316       return 0
 317
 318
 319   def getMinMax(self):
 320       """ Retourne les valeurs min et max de la definition de object """
 321       return self.object.getMinMax()
 322
 323   def getMultiplicite(self):
 324       """ A preciser.
 325           Retourne la multiplicite des valeurs affectees a l'objet
 326           represente par l'item. Pour le moment retourne invariablement 1.
 327       """
 328       return 1
 329
 330   def getIntervalle(self):
 331       """
 332            Retourne le domaine de valeur attendu par l'objet represente
 333            par l'item.
 334       """
 335       return self.object.getintervalle()
 336
 337   def getListeValeurs(self) :
 338       """ Retourne la liste des valeurs de object """
 339       valeurs=self.object.getListeValeurs()
 340       try :
 341         if "R" in self.object.definition.type:
 342            clef=self.object.getNomConcept()
 343            if clef in self.appli.dict_reels:
 344               if type(valeurs) == tuple:
 345                  valeurs_reelles=[]
 346                  for val in valeurs :
 347                     if val in self.appli.dict_reels[clef]:
 348                        valeurs_reelles.append(self.appli.dict_reels[clef][val])
 349                     else :
 350                        valeurs_reelles.append(val)
 351               else :
 352                  if valeurs in self.appli.dict_reels[clef]:
 353                     valeurs_reelles=self.appli.dict_reels[clef][valeurs]
 354               valeurs=valeurs_reelles
 355       except :
 356         pass
 357       return valeurs
 358
 359   def getListePossible(self,listeActuelle=[]):
 360       if hasattr(self.definition.validators,'into'):
 361          valeurspossibles = self.definition.validators.into
 362       else:
 363          valeurspossibles = self.get_definition().into
 364
 365       if listeActuelle==[] : return valeurspossibles
 366
 367       #On ne garde que les items valides
 368       listevalideitem=[]
 369       if type(valeurspossibles) in (list,tuple) :
 370          pass
 371       else :
 372          valeurspossibles=(valeurspossibles,)
 373       for item in valeurspossibles:
 374           encorevalide=self.valideItem(item)
 375           if encorevalide :
 376              listevalideitem.append(item)
 377
 378       #on ne garde que les choix possibles qui passent le test de valideListePartielle
 379       listevalideliste=[]
 380       for item in listevalideitem:
 381           encorevalide=self.valideListePartielle(item,listeActuelle)
 382           if encorevalide :
 383               listevalideliste.append(item)
 384       #print listevalideliste
 385       return listevalideliste
 386
 387   def getListePossibleAvecSug(self,listeActuelle=[]):
 388       if hasattr(self.definition,'intoSug'):
 389          valeurspossibles = self.definition.intoSug
 390       else:
 391          return listeActuelle
 392
 393       if listeActuelle==[] :  return valeurspossibles
 394       valeurspossibles = valeurspossibles+listeActuelle
 395
 396       #On ne garde que les items valides
 397       listevalideitem=[]
 398       if type(valeurspossibles) in (list,tuple) :
 399          pass
 400       else :
 401          valeurspossibles=(valeurspossibles,)
 402       for item in valeurspossibles:
 403           encorevalide=self.valideItem(item)
 404           if encorevalide :
 405              listevalideitem.append(item)
 406
 407       #on ne garde que les choix possibles qui passent le test de valideListePartielle
 408       listevalideliste=[]
 409       for item in listevalideitem:
 410           encorevalide=self.valideListePartielle(item,listeActuelle)
 411           if encorevalide :
 412               listevalideliste.append(item)
 413       return listevalideliste
 414
 415   def getListeParamPossible(self):
 416       liste_param=[]
 417       l1,l2=self.jdc.getParametresFonctionsAvantEtape(self.getEtape())
 418       for param in self.object.jdc.params:
 419           if param.nom not in l1 : continue
 420           encorevalide=self.valideItem(param.valeur)
 421           if encorevalide:
 422              type_param=param.valeur.__class__.__name__
 423              for typ in self.definition.type:
 424                  if typ=='R':
 425                      liste_param.append(param)
 426                  if typ=='I' and type_param=='int':
 427                      liste_param.append(param)
 428                  if typ=='TXM' and type_param=='str':
 429                      liste_param.append(repr(param))
 430                  if ('grma' in repr(typ)) and type_param=='str':
 431                      liste_param.append(param.nom)
 432       return liste_param
 433
 434   #--------------------------------------------------
 435   #
 436   # Methodes liees a la validite des valeurs saisies
 437   #
 438   #---------------------------------------------------
 439   # valideItem
 440   # valideListePartielle
 441   # valideListeComplete
 442   # infoErreurItem
 443   # infoErreurListe
 444   # isInIntervalle
 445   # isValid
 446
 447   def valideItem(self,item):
 448       """
 449         La validation est realisee directement par l'objet
 450       """
 451       return self.object.valideItem(item)
 452
 453   def valideListePartielle(self,item,listecourante):
 454       #On protege la liste en entree en la copiant
 455       valeur=list(listecourante)
 456       if item : valeur.append(item)
 457       return self.object.validValeurPartielle(valeur)
 458
 459   def valideListeComplete (self,valeur):
 460       return self.object.validValeur(valeur)
 461
 462   def infoErreurItem(self) :
 463       commentaire=""
 464       if self.definition.validators :
 465          commentaire=self.definition.validators.infoErreurItem()
 466       return commentaire
 467
 468   def aide(self) :
 469       commentaire=""
 470       if self.definition.validators :
 471          commentaire=self.definition.validators.aide()
 472       return commentaire
 473
 474   def infoErreurListe(self) :
 475       commentaire=""
 476       if self.definition.validators :
 477          commentaire=self.definition.validators.infoErreurListe()
 478       return commentaire
 479
 480   def isInIntervalle(self,valeur):
 481       """
 482           Retourne 1 si la valeur est dans l'intervalle permis par
 483           l'objet represente par l'item.
 484       """
 485       return self.valideItem(valeur)
 486
 487   def isValid(self):
 488     valide=self.object.isValid()
 489     return valide
 490
 491   #--------------------------------------------------
 492   #
 493   # Autres ...
 494   #
 495   #---------------------------------------------------
 496   # getIconName
 497   # getText
 498   # setValeurCo
 499   # getSdAvantDuBonType
 500
 501
 502   def getIconName(self):
 503     if self.appli.maConfiguration.differencieSiDefaut and self.isValid():
 504       if self.object.definition.defaut != None :
 505          if self.object.valeur == self.object.definition.defaut : return "ast-green-dark-ball"
 506          if self.object.definition.max > 1 and list(self.object.valeur) == list(self.object.definition.defaut) : return "ast-green-dark-ball"
 507       return "ast-green-ball"
 508     elif self.isValid():
 509       return "ast-green-ball"
 510     elif self.object.isOblig():
 511       return "ast-red-ball"
 512     else:
 513       return "ast-yel-ball"
 514
 515   def getText(self):
 516     """
 517     Classe SIMPTreeItem
 518     Retourne le texte a afficher dans l'arbre representant la valeur de l'objet
 519     pointe par self
 520     """
 521     text= self.object.getText()
 522     if text == None : text=""
 523     return text
 524
 525
 526   def setValeurCo(self,nom_co):
 527       """
 528       Affecte au MCS pointé par self l'objet de type CO et de nom nom_co
 529       """
 530       ret = self.object.setValeurCo(nom_co)
 531       #print "setValeurCo",ret
 532       return ret
 533
 534   def getSdAvantDuBonType(self):
 535       """
 536       Retourne la liste des noms des SD présentes avant l'étape qui contient
 537       le MCS pointé par self et du type requis par ce MCS
 538       """
 539       a=self.object.etape.parent.getSdAvantDuBonType(self.object.etape,self.object.definition.type)
 540       return a
 541
 542   def getSdAvantDuBonTypePourTypeDeBase(self):
 543       a=self.object.jdc.getSdAvantDuBonTypePourTypeDe_Base(self.object.etape,"LASSD")
 544       return a
 545
 546
 547
 548   def deleteValeurCo(self,valeur=None):
 549       """
 550            Supprime la valeur du mot cle (de type CO)
 551            il faut propager la destruction aux autres etapes
 552       """
 553       if not valeur : valeur=self.object.valeur
 554       # XXX faut il vraiment appeler delSdprod ???
 555       #self.object.etape.parent.delSdprod(valeur)
 556       self.object.etape.parent.deleteConcept(valeur)
 557
 558   #-----------------------------------------------
 559   #
 560   # Methodes liees au type de l objet attendu
 561   #
 562   #-----------------------------------------------
 563   # waitCo
 564   # waitGeom
 565   # waitComplex
 566   # waitReel
 567   # waitAssd
 568   # getType
 569
 570   def waitCo(self):
 571       """
 572       Méthode booléenne qui retourne 1 si l'objet pointé par self
 573       attend un objet de type ASSD qui n'existe pas encore (type CO()),
 574       0 sinon
 575       """
 576       return self.object.waitCo()
 577
 578   def waitFichier(self):
 579       maDefinition=self.object.definition
 580       try :
 581         if ('Repertoire' in maDefinition.type[0]) or ('Fichier' in maDefinition.type[0]) :
 582            return 1
 583       except :
 584            return 0
 585
 586   def waitGeom(self):
 587       """
 588       Méthode booléenne qui retourne 1 si l'objet pointé par self
 589       attend un objet GEOM, 0 sinon
 590       """
 591       return self.object.waitGeom()
 592
 593   def waitTxm(self):
 594      return self.object.waitTxm()
 595
 596
 597   def waitComplex(self):
 598       """ Méthode booléenne qui retourne 1 si l'objet pointé par self
 599       attend un complexe, 0 sinon """
 600       if 'C' in self.object.definition.type:
 601           return 1
 602       else:
 603           return 0
 604
 605   def waitReel(self):
 606       """ Méthode booléenne qui retourne 1 si l'objet pointé par self
 607       attend un réel, 0 sinon """
 608       if 'R' in self.object.definition.type:
 609           return 1
 610       else:
 611           return 0
 612
 613   def waitTuple(self) :
 614       return  self.object.waitTuple()
 615
 616   def waitDate(self):
 617       """ Méthode booléenne qui retourne 1 si l'objet pointé par self
 618       attend un réel, 0 sinon """
 619       if 'DateHHMMAAAA' in self.object.definition.type:
 620           return 1
 621       else:
 622           return 0
 623
 624   def waitHeure(self):
 625       """ Méthode booléenne qui retourne 1 si l'objet pointé par self
 626       attend un réel, 0 sinon """
 627       if 'HeureHHMMSS' in self.object.definition.type:
 628           return 1
 629       else:
 630           return 0
 631
 632
 633
 634   def waitTuple(self):
 635       """ Méthode booléenne qui retourne 1 si l'objet pointé par self
 636       attend un Tuple, 0 sinon """
 637       for ss_type in self.object.definition.type:
 638           if repr(ss_type).find('Tuple') != -1 :
 639              return 1
 640       return 0
 641
 642   def waitMatrice(self):
 643       """ Méthode booléenne qui retourne 1 si l'objet pointé par self
 644       attend un Tuple, 0 sinon """
 645       for ss_type in self.object.definition.type:
 646           if repr(ss_type).find('Matrice') != -1 :
 647              return 1
 648       return 0
 649
 650   def waitAssd(self):
 651       """Méthode booléenne qui retourne 1 si l'objet pointé par self
 652       attend un objet de type ASSD ou dérivé, 0 sinon """
 653       return self.object.waitAssd()
 654
 655   def waitAssdOrTypeBase(self) :
 656       boo=0
 657       if len(self.object.definition.type) > 1 :
 658          if self.waitReel() :
 659             boo = 1
 660          if 'I' in self.object.definition.type :
 661             boo = 1
 662       return boo
 663
 664   def waitSalome(self):
 665       monType = self.object.definition.type[0]
 666       if 'grma' in repr(monType) : return True
 667       if 'grno' in repr(monType) : return True
 668       try :
 669          if issubclass(monType, SalomeEntry) : return True
 670       except :
 671          pass
 672       return False
 673
 674   def getType(self):
 675       """
 676           Retourne le type de valeur attendu par l'objet représenté par l'item.
 677       """
 678       return self.object.getType()
 679
 680   #-----------------------------------------------------
 681   #
 682   # Methodes liees  a l evaluation de la valeur saisie
 683   #
 684   #-----------------------------------------------------
 685   # evalValeur
 686   # evalValeurItem
 687   # isCO
 688   # traiteReel
 689
 690   def evalValeur(self,valeur):
 691       """ Lance l'interpretation de 'valeur' (chaine de caracteres) comme valeur de self :
 692              - retourne l'objet associe si on a pu interpreter (entier, reel, ASSD,...)
 693              - retourne 'valeur' (chaine de caracteres) sinon
 694       """
 695       newvaleur=self.evalVal(valeur)
 696       return newvaleur,1
 697
 698
 699   def evalValeurItem(self,valeur):
 700       """ Lance l'interprétation de 'valeur' qui doit ne pas etre un tuple
 701           - va retourner la valeur de retour et la validite
 702             selon le type de l objet attendu
 703           - traite les reels et les parametres
 704       """
 705       #print "evalValeurItem",valeur
 706       if valeur==None or valeur == "" :
 707          return None,0
 708       validite=1
 709       if self.waitReel():
 710              valeurinter = self.traiteReel(valeur)
 711              if valeurinter != None :
 712                 valeurretour,validite= self.object.evalValeur(valeurinter)
 713              else:
 714                 valeurretour,validite= self.object.evalValeur(valeur)
 715       elif self.waitGeom():
 716              valeurretour,validite = valeur,1
 717       else :
 718              valeurretour,validite= self.object.evalValeur(valeur)
 719       #print "evalValeurItem",valeurretour,validite
 720
 721       if validite == 0:
 722          if (type(valeur) == bytes  or type(valeur) == str )and self.object.waitTxm():
 723             essai_valeur="'" + valeur + "'"
 724             valeurretour,validite= self.object.evalValeur(essai_valeur)
 725
 726       if hasattr(valeurretour,'__class__'):
 727          #if valeurretour.__class__.__name__ in ('PARAMETRE','PARAMETRE_EVAL'):
 728          if valeurretour.__class__.__name__ in ('PARAMETRE',):
 729             validite=1
 730
 731       #if self.waitCo():
 732          # CCAR : il ne faut pas essayer de creer un concept
 733          # il faut simplement en chercher un existant ce qui a du etre fait par self.object.evalValeur(valeur)
 734          #try:
 735             #valeurretour=Accas.CO(valeur)
 736          #except:
 737             #valeurretour=None
 738             #validite=0
 739       # on est dans le cas ou on a évalué et ou on n'aurait pas du
 740       if self.object.waitTxm() :
 741           if type(valeurretour) != bytes:
 742              valeurretour=str(valeur)
 743              validite=1
 744       return valeurretour,validite
 745
 746   def isCO(self,valeur=None):
 747       """
 748          Indique si valeur est un concept produit de la macro
 749          Cette méthode n'a de sens que pour un MCSIMP d'une MACRO
 750          Si valeur vaut None on teste la valeur du mot cle
 751       """
 752       # Pour savoir si un concept est un nouveau concept de macro
 753       # on regarde s'il est présent dans l'attribut sdprods de l'étape
 754       # ou si son nom de classe est CO.
 755       # Il faut faire les 2 tests car une macro non valide peut etre
 756       # dans un etat pas tres catholique avec des CO pas encore types
 757       # et donc pas dans sdprods (resultat d'une exception dans typeSDProd)
 758       if not valeur:valeur=self.object.valeur
 759       if valeur in self.object.etape.sdprods:return 1
 760       #if type(valeur) is not types.InstanceType:return 0
 761       if type(valeur) is not object:return 0
 762       if valeur.__class__.__name__ == 'CO':return 1
 763       return 0
 764
 765   def isParam(self,valeur) :
 766       for param in self.jdc.params:
 767           if (repr(param) == valeur):
 768              return 1
 769       return 0
 770
 771   def traiteReel(self,valeur):
 772       """
 773       Cette fonction a pour but de rajouter le '.' en fin de chaine pour un réel
 774       ou de détecter si on fait référence a un concept produit par DEFI_VALEUR
 775       ou un EVAL ...
 776       """
 777       valeur = valeur.strip()
 778       liste_reels = self.getSdAvantDuBonType()
 779       if valeur in liste_reels:
 780           return valeur
 781       if len(valeur) >= 3 :
 782           if valeur[0:4] == 'EVAL' :
 783               # on a trouvé un EVAL --> on retourne directement la valeur
 784               return valeur
 785       if valeur.find('.') == -1 :
 786           # aucun '.' n'a été trouvé dans valeur --> on en rajoute un a la fin
 787           if (self.isParam(valeur)):
 788               return valeur
 789           else:
 790               if valeur.find('e') != -1:
 791                  # Notation scientifique ?
 792                  try :
 793                     r=eval(valeur)
 794                     return valeur
 795                  except :
 796                     return None
 797               else :
 798                  return valeur+'.'
 799       else:
 800           return valeur
 801
 802
 803 import Accas
 804 treeitem = SIMPTreeItem
 805 objet = Accas.MCSIMP
 806