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