InterfaceQT4/composimp.py

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