]> SALOME platform Git repositories - tools/eficas.git/blob - InterfaceQT4/composimp.py
Salome HOME
pb d accent. on les enleve en français
[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           if maDefinition.into != [] and maDefinition.into != None:
146             if len(maDefinition.into) < 4 :
147               from monWidgetRadioButton import MonWidgetRadioButton
148               widget=MonWidgetRadioButton(self,maDefinition,monNom,monObjet,parentQt,maCommande)
149             elif len(maDefinition.into) < 7 :
150               from monWidget4a6RadioButton import MonWidget4a6RadioButton
151               widget=MonWidget4a6RadioButton(self,maDefinition,monNom,monObjet,parentQt,maCommande)
152             else :
153               from monWidgetCB import MonWidgetCB
154               widget=MonWidgetCB(self,maDefinition,monNom,monObjet,parentQt,maCommande)
155
156           elif self.item.wait_bool() :
157             from monWidgetSimpBool import MonWidgetSimpBool
158             widget=MonWidgetSimpBool(self,maDefinition,monNom,monObjet,parentQt,maCommande)
159           elif self.item.wait_fichier():
160             from monWidgetSimpFichier import MonWidgetSimpFichier
161             widget=MonWidgetSimpFichier(self,maDefinition,monNom,monObjet,parentQt,maCommande)
162
163           # PNPNPN - a faire
164           elif self.item.wait_date():
165             from monWidgetDate import MonWidgetDate
166             widget=MonWidgetDate(self,maDefinition,monNom,monObjet,parentQt,maCommande)
167           elif self.item.wait_heure():
168             from monWidgetHeure import MonWidgetHeure
169             widget=MonWidgetHeure(self,maDefinition,monNom,monObjet,parentQt,maCommande)
170
171           elif self.item.wait_tuple() :
172             if self.item.object.definition.type[0].ntuple == 2:
173                from monWidgetSimpTuple2 import MonWidgetSimpTuple2
174                widget=MonWidgetSimpTuple2(self,maDefinition,monNom,monObjet,parentQt,maCommande)
175             elif self.item.object.definition.type[0].ntuple == 3 :
176                from monWidgetSimpTuple3 import MonWidgetSimpTuple3
177                widget=MonWidgetSimpTuple3(self,maDefinition,monNom,monObjet,parentQt,maCommande)
178             else :
179                print "Pas de Tuple de longueur > 3"
180                print "Prevenir la maintenance "
181
182           elif self.item.wait_complex():
183             from monWidgetSimpComplexe import MonWidgetSimpComplexe
184             widget=MonWidgetSimpComplexe(self,maDefinition,monNom,monObjet,parentQt,maCommande)
185
186           elif self.item.wait_co():
187             if len(self.item.get_sd_avant_du_bon_type()) == 0 :
188                from monWidgetUniqueSDCO import MonWidgetUniqueSDCO
189                widget=MonWidgetUniqueSDCO(self,maDefinition,monNom,monObjet,parentQt,maCommande)
190             else :      
191                from monWidgetSDCOInto import MonWidgetSDCOInto
192                widget=MonWidgetSDCOInto(self,maDefinition,monNom,monObjet,parentQt,maCommande)
193           elif self.item.wait_assd():
194             if len(self.item.get_sd_avant_du_bon_type()) == 0 :
195                from monWidgetVide import MonWidgetVide
196                widget=MonWidgetVide(self,maDefinition,monNom,monObjet,parentQt,maCommande)
197             if len(self.item.get_sd_avant_du_bon_type()) < 4 :
198               from monWidgetRadioButton import MonWidgetRadioButtonSD
199               widget=MonWidgetRadioButtonSD(self,maDefinition,monNom,monObjet,parentQt,maCommande)
200             elif len(self.item.get_sd_avant_du_bon_type()) < 7 :
201               from monWidget4a6RadioButton import MonWidget4a6RadioButtonSD
202               widget=MonWidget4a6RadioButtonSD(self,maDefinition,monNom,monObjet,parentQt,maCommande)
203             else :
204               from monWidgetCB import MonWidgetCBSD
205               widget=MonWidgetCBSD(self,maDefinition,monNom,monObjet,parentQt,maCommande)
206           
207           elif  self.item.wait_Salome() and self.editor.salome:
208           # Pas fait
209             from monWidgetSimpSalome import MonWidgetSimpSalome
210             widget=MonWidgetSimpSalome(self,maDefinition,monNom,monObjet,parentQt,maCommande)
211
212           elif self.item.wait_TXM():
213             from monWidgetSimpTxt import MonWidgetSimpTxt
214             widget=MonWidgetSimpTxt(self,maDefinition,monNom,monObjet,parentQt,maCommande)
215           else :
216             from monWidgetSimpBase import MonWidgetSimpBase
217             widget=MonWidgetSimpBase(self,maDefinition,monNom,monObjet,parentQt,maCommande)
218
219         # Gestion des listes
220         else :
221           if maDefinition.into != [] and maDefinition.into != None:
222             if self.item.is_list_SansOrdreNiDoublon():
223                from monWidgetPlusieursInto import MonWidgetPlusieursInto
224                widget=MonWidgetPlusieursInto(self,maDefinition,monNom,monObjet,parentQt,maCommande)
225             else :
226                from monWidgetPlusieursIntoOrdonne import MonWidgetPlusieursIntoOrdonne
227                widget=MonWidgetPlusieursIntoOrdonne(self,maDefinition,monNom,monObjet,parentQt,maCommande)
228           else :
229             from monWidgetPlusieursBase import MonWidgetPlusieursBase
230             widget=MonWidgetPlusieursBase(self,maDefinition,monNom,monObjet,parentQt,maCommande)
231         self.widget=widget
232         return widget
233          
234     
235 class SIMPTreeItem(Objecttreeitem.AtomicObjectTreeItem):
236   itemNode=Node
237
238   def init(self) :
239       self.expandable = 0
240   
241
242   #-----------------------------------------------
243   #
244   # Methodes liees aux informations sur le Panel
245   # ou au mot-clef simple
246   #
247   #-----------------------------------------------
248   # is_list
249   # get_into                a priori inutile --> commentee
250   # has_into
251   # wait_into                a priori inutile --> commentee
252   # GetMinMax
253   # GetMultiplicite
254   # GetIntervalle
255   # GetListeValeurs
256   # get_liste_possible
257
258   def is_list(self):
259       """
260           Cette methode indique si le mot cle simple attend une liste (valeur de retour 1)
261           ou s'il n'en attend pas (valeur de retour 0)
262
263           Deux cas principaux peuvent se presenter : avec validateurs ou bien sans.
264           Dans le cas sans validateur, l'information est donnee par l'attribut max
265           de la definition du mot cle.
266           Dans le cas avec validateur, il faut combiner l'information precedente avec
267           celle issue de l'appel de la methode is_list sur le validateur.On utilisera
268           l'operateur ET pour effectuer cette combinaison (AndVal).
269       """
270       is_a_list=0
271       min,max = self.GetMinMax()
272       assert (min <= max)
273       if max > 1 :
274                 is_a_list=1
275       # Dans le cas avec validateurs, pour que le mot cle soit considere
276       # comme acceptant une liste, il faut que max soit superieur a 1
277       # ET que la methode is_list du validateur retourne 1. Dans les autres cas
278       # on retournera 0 (n'attend pas de liste)
279       if self.definition.validators :
280          is_a_list= self.definition.validators.is_list() * is_a_list
281       return is_a_list 
282
283   def is_list_SansOrdreNiDoublon(self):
284       if self.definition.homo=="SansOrdreNiDoublon": return 1
285       return 0 
286
287   def has_into(self):
288       """
289           Cette methode indique si le mot cle simple propose un choix (valeur de retour 1)
290           ou s'il n'en propose pas (valeur de retour 0)
291
292           Deux cas principaux peuvent se presenter : avec validateurs ou bien sans.
293           Dans le cas sans validateur, l'information est donnee par l'attribut into
294           de la definition du mot cle.
295           Dans le cas avec validateurs, pour que le mot cle soit considere
296           comme proposant un choix, il faut que into soit present OU
297           que la methode has_into du validateur retourne 1. Dans les autres cas
298           on retournera 0 (ne propose pas de choix)
299       """
300       has_an_into=0
301       if self.definition.into:
302                has_an_into=1
303       elif self.definition.validators :
304          has_an_into= self.definition.validators.has_into()
305       return has_an_into
306
307
308   def GetMinMax(self):
309       """ Retourne les valeurs min et max de la definition de object """
310       return self.object.get_min_max()
311
312   def GetMultiplicite(self):
313       """ A preciser.
314           Retourne la multiplicite des valeurs affectees a l'objet
315           represente par l'item. Pour le moment retourne invariablement 1.
316       """
317       return 1
318
319   def GetIntervalle(self):
320       """ 
321            Retourne le domaine de valeur attendu par l'objet represente 
322            par l'item.
323       """
324       return self.object.getintervalle()
325
326   def GetListeValeurs(self) :
327       """ Retourne la liste des valeurs de object """
328       valeurs=self.object.get_liste_valeurs()
329       try :
330         if "R" in self.object.definition.type:
331            clef=self.object.GetNomConcept()
332            if self.appli.dict_reels.has_key(clef):
333               if type(valeurs) == types.TupleType:
334                  valeurs_reelles=[]
335                  for val in valeurs :
336                     if self.appli.dict_reels[clef].has_key(val) : 
337                        valeurs_reelles.append(self.appli.dict_reels[clef][val])
338                     else :
339                        valeurs_reelles.append(val)
340               else :
341                  if self.appli.dict_reels[clef].has_key(valeurs):
342                     valeurs_reelles=self.appli.dict_reels[clef][valeurs]
343               valeurs=valeurs_reelles
344       except :
345         pass
346       return valeurs
347     
348   def get_liste_possible(self,listeActuelle=[]):
349       if hasattr(self.definition.validators,'into'):
350          valeurspossibles = self.definition.validators.into 
351       else:
352          valeurspossibles = self.get_definition().into
353
354       #On ne garde que les items valides
355       listevalideitem=[]
356       if type(valeurspossibles) in (types.ListType,types.TupleType) :
357          pass
358       else :
359          valeurspossibles=(valeurspossibles,)
360       for item in valeurspossibles:
361           encorevalide=self.valide_item(item)
362           if encorevalide :
363              listevalideitem.append(item)
364
365       #on ne garde que les choix possibles qui passent le test de valide_liste_partielle
366       listevalideliste=[]
367       for item in listevalideitem:
368           encorevalide=self.valide_liste_partielle(item,listeActuelle)
369           if encorevalide :
370               listevalideliste.append(item)
371       return listevalideliste
372
373   def get_liste_param_possible(self):
374       liste_param=[]
375       l1,l2=self.jdc.get_parametres_fonctions_avant_etape(self.get_etape())
376       for param in self.object.jdc.params:
377           if param.nom not in l1 : continue
378           encorevalide=self.valide_item(param.valeur)
379           if encorevalide:
380              type_param=param.valeur.__class__.__name__
381              for typ in self.definition.type:
382                  if typ=='R':
383                      liste_param.append(param)
384                  if typ=='I' and type_param=='int':
385                      liste_param.append(param)
386                  if typ=='TXM' and type_param=='str':
387                      liste_param.append(repr(param))
388                  if ('grma' in repr(typ)) and type_param=='str':
389                      liste_param.append(param.nom)
390       return liste_param
391
392   #--------------------------------------------------
393   #
394   # Methodes liees a la validite des valeurs saisies
395   #
396   #---------------------------------------------------
397   # valide_item
398   # valide_liste_partielle
399   # valide_liste_complete
400   # info_erreur_item
401   # info_erreur_liste
402   # IsInIntervalle
403   # isvalid
404
405   def valide_item(self,item):
406       """
407         La validation est realisee directement par l'objet
408       """
409       return self.object.valide_item(item)
410      
411   def valide_liste_partielle(self,item,listecourante):
412       #On protege la liste en entree en la copiant
413       valeur=listecourante[:]
414       valeur.append(item)
415       return self.object.valid_valeur_partielle(valeur)
416
417   def valide_liste_complete (self,valeur):
418       return self.object.valid_valeur(valeur)
419
420   def valide_val (self,valeur):
421       return self.object.valid_val(valeur)
422
423   def info_erreur_item(self) :
424       commentaire=""
425       if self.definition.validators :
426          commentaire=self.definition.validators.info_erreur_item()
427       return commentaire
428       
429   def aide(self) :
430       commentaire=""
431       if self.definition.validators :
432          commentaire=self.definition.validators.aide()
433       return commentaire
434
435   def info_erreur_liste(self) :
436       commentaire=""
437       if self.definition.validators :
438          commentaire=self.definition.validators.info_erreur_liste()
439       return commentaire
440
441   def IsInIntervalle(self,valeur):
442       """ 
443           Retourne 1 si la valeur est dans l'intervalle permis par
444           l'objet represente par l'item.
445       """
446       return self.valide_item(valeur)
447
448   def isvalid(self):
449     valide=self.object.isvalid()
450     return valide
451
452   #--------------------------------------------------
453   #
454   # Autres ...
455   #
456   #---------------------------------------------------
457   # GetIconName
458   # GetText
459   # set_valeur_co
460   # get_sd_avant_du_bon_type
461   # delete_valeur_co
462
463
464   def GetIconName(self):
465     if self.isvalid():
466       return "ast-green-ball"
467     elif self.object.isoblig():
468       return "ast-red-ball"
469     else:
470       return "ast-yel-ball"
471     print "invalide"
472
473   def GetText(self):
474     """
475     Classe SIMPTreeItem
476     Retourne le texte a afficher dans l'arbre representant la valeur de l'objet
477     pointe par self 
478     """
479     text= self.object.GetText()
480     if text == None : text=""
481     return text
482     
483
484   def set_valeur_co(self,nom_co):
485       """
486       Affecte au MCS pointé par self l'objet de type CO et de nom nom_co
487       """
488       ret = self.object.set_valeur_co(nom_co)
489       #print "set_valeur_co",ret
490       return ret
491       
492   def get_sd_avant_du_bon_type(self):
493       """
494       Retourne la liste des noms des SD présentes avant l'étape qui contient
495       le MCS pointé par self et du type requis par ce MCS
496       """
497       a=self.object.etape.parent.get_sd_avant_du_bon_type(self.object.etape,self.object.definition.type)
498       return a
499
500   def get_sd_avant_du_bon_type_pour_type_de_base(self):
501       a=self.object.jdc.get_sd_avant_du_bon_type_pour_type_de_base(self.object.etape,"LASSD")
502       return a
503
504
505
506
507   def delete_valeur_co(self,valeur=None):
508       """
509            Supprime la valeur du mot cle (de type CO)
510            il faut propager la destruction aux autres etapes
511       """
512       if not valeur : valeur=self.object.valeur
513       # XXX faut il vraiment appeler del_sdprod ???
514       #self.object.etape.parent.del_sdprod(valeur)
515       self.object.etape.parent.delete_concept(valeur)
516
517   #-----------------------------------------------
518   #
519   # Methodes liees au type de l objet attendu
520   #
521   #-----------------------------------------------
522   # wait_co 
523   # wait_geom
524   # wait_complex
525   # wait_reel
526   # wait_assd
527   # GetType
528
529   def wait_co(self):
530       """
531       Méthode booléenne qui retourne 1 si l'objet pointé par self
532       attend un objet de type ASSD qui n'existe pas encore (type CO()),
533       0 sinon
534       """
535       return self.object.wait_co()
536
537   def wait_fichier(self):
538       maDefinition=self.object.definition
539       try : 
540         if ('Repertoire' in maDefinition.type[0]) or ('Fichier' in maDefinition.type[0]) :
541            return 1
542       except :
543            return 0
544
545   def wait_geom(self):
546       """
547       Méthode booléenne qui retourne 1 si l'objet pointé par self
548       attend un objet GEOM, 0 sinon
549       """
550       return self.object.wait_geom()
551     
552   def wait_complex(self):
553       """ Méthode booléenne qui retourne 1 si l'objet pointé par self
554       attend un complexe, 0 sinon """
555       if 'C' in self.object.definition.type:
556           return 1
557       else:
558           return 0
559
560   def wait_reel(self):
561       """ Méthode booléenne qui retourne 1 si l'objet pointé par self
562       attend un réel, 0 sinon """
563       if 'R' in self.object.definition.type:
564           return 1
565       else:
566           return 0
567
568   def wait_date(self):
569       """ Méthode booléenne qui retourne 1 si l'objet pointé par self
570       attend un réel, 0 sinon """
571       if 'DateHHMMAAAA' in self.object.definition.type:
572           return 1
573       else:
574           return 0
575         
576   def wait_heure(self):
577       """ Méthode booléenne qui retourne 1 si l'objet pointé par self
578       attend un réel, 0 sinon """
579       if 'HeureHHMMSS' in self.object.definition.type:
580           return 1
581       else:
582           return 0
583         
584         
585         
586   def wait_tuple(self):
587       """ Méthode booléenne qui retourne 1 si l'objet pointé par self
588       attend un Tuple, 0 sinon """
589       for ss_type in self.object.definition.type:
590           if repr(ss_type).find('Tuple') != -1 :
591              return 1
592       return 0
593
594   def wait_matrice(self):
595       """ Méthode booléenne qui retourne 1 si l'objet pointé par self
596       attend un Tuple, 0 sinon """
597       for ss_type in self.object.definition.type:
598           if repr(ss_type).find('Matrice') != -1 :
599              return 1
600       return 0
601
602   def wait_assd(self):
603       """Méthode booléenne qui retourne 1 si l'objet pointé par self
604       attend un objet de type ASSD ou dérivé, 0 sinon """
605       return self.object.wait_assd()
606     
607   def wait_assd_or_type_base(self) :
608       boo=0
609       if len(self.object.definition.type) > 1 :
610          if self.wait_reel() :
611             boo = 1
612          if 'I' in self.object.definition.type :
613             boo = 1
614       return boo
615
616   def wait_Salome(self):
617       type = self.object.definition.type[0]
618       if 'grma' in repr(type) : return True
619       if 'grno' in repr(type) : return True
620       if (isinstance(type, types.ClassType) and issubclass(type, SalomeEntry)) : return True
621       return False
622    
623   def GetType(self):
624       """ 
625           Retourne le type de valeur attendu par l'objet représenté par l'item.
626       """
627       return self.object.get_type()
628
629   #-----------------------------------------------------
630   #
631   # Methodes liees  a l evaluation de la valeur saisie
632   #
633   #-----------------------------------------------------
634   # eval_valeur
635   # eval_valeur_item
636   # is_CO
637   # traite_reel
638
639   def eval_valeur(self,valeur):
640       """ Lance l'interprétation de 'valeur' (chaine de caractéres) comme valeur de self :
641              - retourne l'objet associé si on a pu interpréter (entier, réel, ASSD,...)
642              - retourne 'valeur' (chaine de caractéres) sinon
643       """
644       newvaleur=self.eval_val(valeur)
645       return newvaleur,1
646
647   def eval_valeur_BAK(self,valeur):
648       """ Lance l'interprétation de 'valeur' (chaine de caractéres) comme valeur
649       de l'objet pointé par self :
650         - retourne l'objet associé si on a pu interpréter (entier, réel, ASSD,...)
651         - retourne 'valeur' (chaine de caractéres) sinon
652         - retourne None en cas d invalidite
653         - retourne invalide si 1 des objets du tuple l est
654       """
655       validite=1
656       if type(valeur) in (types.ListType,types.TupleType) :
657          valeurretour=[]
658          for item in valeur :
659              newvaleur,validiteitem=self.eval_valeur_item(item)
660              valeurretour.append(newvaleur)
661              if validiteitem == 0:
662                 validite=0
663       else :
664          valeurretour,validite= self.eval_valeur_item(valeur)
665       if validite == 0 :
666          valeurretour = None
667       return valeurretour,validite
668
669   def eval_valeur_item(self,valeur):
670       """ Lance l'interprétation de 'valeur' qui doit ne pas etre un tuple 
671           - va retourner la valeur de retour et la validite
672             selon le type de l objet attendu
673           - traite les reels et les parametres 
674       """ 
675       #print "eval_valeur_item",valeur
676       if valeur==None or valeur == "" :
677          return None,0
678       validite=1
679       if self.wait_reel():
680              valeurinter = self.traite_reel(valeur)
681              if valeurinter != None :
682                 valeurretour,validite= self.object.eval_valeur(valeurinter)
683              else:
684                 valeurretour,validite= self.object.eval_valeur(valeur)
685       elif self.wait_geom():
686              valeurretour,validite = valeur,1
687       else :
688              valeurretour,validite= self.object.eval_valeur(valeur)
689       #print "eval_valeur_item",valeurretour,validite
690
691       if validite == 0:
692          if type(valeur) == types.StringType and self.object.wait_TXM():
693             essai_valeur="'" + valeur + "'"
694             valeurretour,validite= self.object.eval_valeur(essai_valeur)
695
696       if hasattr(valeurretour,'__class__'):
697          #if valeurretour.__class__.__name__ in ('PARAMETRE','PARAMETRE_EVAL'):
698          if valeurretour.__class__.__name__ in ('PARAMETRE',):
699             validite=1
700
701       #if self.wait_co():
702          # CCAR : il ne faut pas essayer de creer un concept
703          # il faut simplement en chercher un existant ce qui a du etre fait par self.object.eval_valeur(valeur)
704          #try:
705             #valeurretour=Accas.CO(valeur)
706          #except:
707             #valeurretour=None
708             #validite=0
709       # on est dans le cas ou on a évalué et ou on n'aurait pas du
710       if self.object.wait_TXM() :
711           if type(valeurretour) != types.StringType:
712              valeurretour=str(valeur)
713              validite=1
714       return valeurretour,validite
715       
716   def is_CO(self,valeur=None):
717       """
718          Indique si valeur est un concept produit de la macro
719          Cette méthode n'a de sens que pour un MCSIMP d'une MACRO
720          Si valeur vaut None on teste la valeur du mot cle
721       """
722       # Pour savoir si un concept est un nouveau concept de macro
723       # on regarde s'il est présent dans l'attribut sdprods de l'étape
724       # ou si son nom de classe est CO.
725       # Il faut faire les 2 tests car une macro non valide peut etre
726       # dans un etat pas tres catholique avec des CO pas encore types
727       # et donc pas dans sdprods (resultat d'une exception dans type_sdprod)
728       if not valeur:valeur=self.object.valeur
729       if valeur in self.object.etape.sdprods:return 1
730       if type(valeur) is not types.InstanceType:return 0
731       if valeur.__class__.__name__ == 'CO':return 1
732       return 0
733
734   def is_param(self,valeur) :
735       for param in self.jdc.params:
736           if (repr(param) == valeur):
737              return 1
738       return 0
739
740   def traite_reel(self,valeur):
741       """
742       Cette fonction a pour but de rajouter le '.' en fin de chaine pour un réel
743       ou de détecter si on fait référence a un concept produit par DEFI_VALEUR
744       ou un EVAL ...
745       """
746       valeur = string.strip(valeur)
747       liste_reels = self.get_sd_avant_du_bon_type()
748       if valeur in liste_reels:
749           return valeur
750       if len(valeur) >= 3 :
751           if valeur[0:4] == 'EVAL' :
752               # on a trouvé un EVAL --> on retourne directement la valeur
753               return valeur
754       if string.find(valeur,'.') == -1 :
755           # aucun '.' n'a été trouvé dans valeur --> on en rajoute un a la fin
756           if (self.is_param(valeur)):
757               return valeur
758           else:
759               if string.find(valeur,'e') != -1:
760                  # Notation scientifique ?
761                  try :
762                     r=eval(valeur)
763                     return valeur
764                  except :
765                     return None
766               else :
767                  return valeur+'.'
768       else:
769           return valeur
770         
771
772 import Accas
773 treeitem = SIMPTreeItem
774 objet = Accas.MCSIMP
775