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