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