self.top.title(VERSION + ' pour '+self.code)
self.top.withdraw()
self.initializeTk(master)
+ self.dict_reels={}
+ self.liste_simp_reel=[]
# L'attribut test permet d'activer les panneaux de splash et d'erreur (test=0)
# Si test est different de 0, les panneaux ne sont pas activés
self.test=test
self.message=''
self.cree_composants_graphiques()
self.load_appli_composants() # Creation du BUREAU
+ # PN : ajout d un attribut pour indiquer si
+ # l appli a ete lance depuis Salome
+ self.salome=0
if (self.test == 0):
splash.fini_splash()
self.affiche_FAQ()
else:
self.bureau.openJDC( fich)
# AY : fin
- # PN : ajout d un attribut pour indiquer si
- # l appli a ete lance depuis Salome
- self.salome=0
-
def send_message(self,message):
self.message=message
"""
entite.ordre_mc=[]
-def traite_entite(entite):
+def traite_entite(entite,liste_simp_reel):
"""
Cette fonction ajoute a l'objet entite un attribut de nom ordre_mc
qui est une liste contenant le nom des sous entites dans l'ordre
if isinstance(v,NUPL):
traite_entiteNUPL(v)
else:
- traite_entite(v)
+ traite_reel(v,liste_simp_reel)
+ traite_entite(v,liste_simp_reel)
l.append((v._no,k))
l.sort()
entite.ordre_mc=[ item for index, item in l ]
-def analyse_niveau(cata_ordonne_dico,niveau):
+def traite_reel(objet,liste_simp_reel):
+ if objet.__class__.__name__ == "SIMP":
+ if ( 'R' in objet.type):
+ if objet.nom not in liste_simp_reel :
+ liste_simp_reel.append(objet.nom)
+
+def analyse_niveau(cata_ordonne_dico,niveau,liste_simp_reel):
"""
Analyse un niveau dans un catalogue de commandes
"""
if niveau.l_niveaux == ():
# Il n'y a pas de sous niveaux
for oper in niveau.entites:
- traite_entite(oper)
+ traite_entite(oper,liste_simp_reel)
cata_ordonne_dico[oper.nom]=oper
else:
for niv in niveau.l_niveaux:
du catalogue indexées par leur nom
"""
cata_ordonne_dico={}
+ liste_simp_reel=[]
if cata.JdC.l_niveaux == ():
# Il n'y a pas de niveaux
+ a=1
for oper in cata.JdC.commandes:
- traite_entite(oper)
+ traite_entite(oper,liste_simp_reel)
cata_ordonne_dico[oper.nom]=oper
else:
for niv in cata.JdC.l_niveaux:
- analyse_niveau(cata_ordonne_dico,niv)
- return cata_ordonne_dico
+ analyse_niveau(cata_ordonne_dico,niv,liste_simp_reel)
+ return cata_ordonne_dico,liste_simp_reel
if __name__ == "__main__" :
self.liste_JDCDisplay=[]
comploader.charger_composants()
self.cree_cataitem()
+ self.text_reel=""
def cree_cataitem(self):
"""
# Le convertisseur existe on l'utilise
p=convert.plugins[format]()
p.readfile(file)
- text=p.convert('exec')
+ text=p.convert('exec',self.appli)
if not p.cr.estvide():
self.appli.affiche_infos("Erreur à la conversion")
Fenetre(self.appli,
def update_jdc_courant(self):
self.JDCDisplay_courant.update()
-
def GetListeValeurs(self) :
""" Retourne la liste des valeurs de object """
- return self.object.get_liste_valeurs()
+ valeurs=self.object.get_liste_valeurs()
+ try :
+ if "R" in self.object.definition.type:
+ clef=self.object.GetNomConcept()
+ if self.appli.dict_reels.has_key(clef):
+ valeurs=self.appli.dict_reels[clef]
+ except :
+ pass
+ return valeurs
def get_liste_possible(self,listeActuelle=[]):
if hasattr(self.definition.validators,'into'):
except:
pass
+# ----------------------------------------------------------------------------------------
+# Méthodes utilisées pour la manipulation des items en notation scientifique
+# ----------------------------------------------------------------------------------------
+ def set_valeur_texte(self,texte_valeur) :
+ """ Sert à mettre à jour la notation scientifique"""
+ try :
+ if "R" in self.node.item.object.definition.type:
+ if texte_valeur[0] != "'":
+ clef=eval(texte_valeur)
+ if str(clef) != str(texte_valeur) :
+ clefobj=self.node.item.object.GetNomConcept()
+ self.parent.appli.dict_reels[clefobj][clef]=texte_valeur
+ except:
+ pass
+
+
+ def get_valeur_texte(self,valeur) :
+ valeur_texte=""
+ if "R" in self.node.item.object.definition.type:
+ clefobj=self.node.item.object.GetNomConcept()
+ if self.parent.appli.dict_reels.has_key(clefobj):
+ if self.parent.appli.dict_reels[clefobj].has_key(valeur):
+ valeur_texte=self.parent.appli.dict_reels[clefobj][valeur]
+ return valeur_texte
+
Pour chaque entité du catlogue on crée une liste de nom ordre_mc qui
contient le nom des mots clés dans le bon ordre
"""
- self.cata_ordonne_dico=autre_analyse_cata.analyse_catalogue(self.cata)
+ self.cata_ordonne_dico,self.appli.liste_simp_reel=autre_analyse_cata.analyse_catalogue(self.cata)
def Retrouve_Ordre_Cata_Standard(self):
"""
message="Chargement catalogue développeur présent dans :\n %s..." % self.appli.CONFIGURATION.path_cata_dev
if self.appli.test == 0 :
splash._splash.configure(text = message,barre='oui')
- cata_dev_ordonne_dico = autre_analyse_cata.analyse_catalogue(self.cata_dev)
+ cata_dev_ordonne_dico,self.appli.liste_simp_reel=autre_analyse_cata.analyse_catalogue(self.cata)
self.cata_ordonne_dico.update(cata_dev_ordonne_dico)
self.appli.affiche_infos(" catalogue(s) développeur(s) chargé(s)" )
"""
valeur = self.node.item.get_valeur()
if valeur == None or valeur == '' : return # pas de valeur à afficher ...
+ valeur_texte=self.get_valeur_texte(valeur)
+ if valeur_texte != "":
+ valeur=valeur_texte
self.entry.delete(0,END)
self.entry.insert(0,valeur)
self.entry.focus()
"""
return self.entry.get()
+
def valid_valeur(self):
"""
Teste si la valeur fournie par l'utilisateur est une valeur permise :
return
test = self.node.item.set_valeur(valeur)
+ if test :
+ self.set_valeur_texte(str(valeurentree))
if not test :
mess = "impossible d'évaluer : %s " %`valeur`
import I_OBJECT
class MCSIMP(I_OBJECT.OBJECT):
+
+ def GetNomConcept(self):
+ p=self
+ while p.parent :
+ try :
+ nomconcept=p.get_sdname()
+ return nomconcept
+ except:
+ try :
+ nomconcept= p.object.get_sdname()
+ return nomconcept
+ except :
+ pass
+ p=p.parent
+ return ""
+
def GetText(self):
"""
Retourne le texte à afficher dans l'arbre représentant la valeur de l'objet
pointé par self
"""
+
if self.valeur == None :
return None
elif type(self.valeur) == types.FloatType :
# Traitement d'un flottant isolé
- #txt = repr_float(self.valeur)
+ # txt = repr_float(self.valeur)
# Normalement str fait un travail correct
txt = str(self.valeur)
+ clefobj=self.GetNomConcept()
+ if self.jdc.appli.dict_reels.has_key(clefobj):
+ if self.jdc.appli.dict_reels[clefobj].has_key(self.valeur):
+ txt=self.jdc.appli.dict_reels[clefobj][self.valeur]
elif type(self.valeur) in (types.ListType,types.TupleType) :
# Traitement des listes
txt='('
Retourne une chaîne de caractère représentant la valeur de self
"""
val=self.valeur
+ if type(val) == types.FloatType :
+ clefobj=self.GetNomConcept()
+ if self.jdc.appli.dict_reels.has_key(clefobj):
+ if self.jdc.appli.dict_reels[clefobj].has_key(val):
+ return self.jdc.appli.dict_reels[clefobj][val]
if type(val) != types.TupleType :
try:
return val.get_name()
except:
self.cr.fatal("Impossible ouvrir fichier %s" % filename)
return
-
- def convert(self,outformat):
+
+ def convert(self,outformat,appli=None):
if outformat == 'exec':
try:
- return parseur_python.PARSEUR_PYTHON(self.text).get_texte()
+ return parseur_python.PARSEUR_PYTHON(self.text).get_texte(appli)
except:
# Erreur lors de la conversion
l=traceback.format_exception(sys.exc_info()[0],sys.exc_info()[1],
raise "Format de sortie : %s, non supporté"
return None
+
def __init__(self,texte):
self.texte = texte
self.l_objets=None
+ self.appli=None
def is_affectation(self,texte):
"""
commande_courante.append_text(ligne)
if commande_courante.get_nb_par() == 0:
# la commande courante est terminée (autant de parenthèses fermantes qu'ouvrantes)
+ try :
+ self.analyse_reel(commande_courante.texte)
+ except :
+ pass
commande_courante = None
else:
# il peut s'agir d'une commande ou d'une affectation ...
affectation_courante = None
if commande_courante.get_nb_par() == 0:
# la commande courante est terminée (autant de parenthèses fermantes qu'ouvrantes)
+ self.analyse_reel(commande_courante.texte)
commande_courante = None
else:
#--> poursuite d'une affectation
#affectation_courante.append_text(ligne)
- def get_texte(self):
+ def enleve (self,texte) :
+ i=0
+ chaine=""
+ while (i<len(texte)):
+ if (texte[i] == " " or texte[i] == "\n" or texte[i] == "\t") :
+ i=i+1
+ else :
+ chaine=chaine+texte[i]
+ i=i+1
+ return chaine
+
+ def construit_genea(self,texte):
+ indiceC=0
+ mot=""
+ dict_reel_concept={}
+
+ # traitement pour chaque caractere
+ while (indiceC < len(texte)):
+ c=texte[indiceC]
+ if ( c == "," or c == "(" or c == ")"):
+ mot=""
+ elif ( c== "="):
+ valeur=""
+ nouvelindice=indiceC+1
+ if texte[nouvelindice] != "(":
+ while ( texte[nouvelindice] != ","):
+ valeur=valeur+texte[nouvelindice]
+ nouvelindice=nouvelindice+1
+ if nouvelindice == len(texte) :
+ nouvelindice=nouvelindice -1
+ break
+ if mot in self.appli.liste_simp_reel:
+ if valeur[0] != "'":
+ try :
+ clef=eval(valeur)
+ if str(clef) != str(valeur) :
+ dict_reel_concept[clef]=valeur
+ except :
+ pass
+ mot=""
+ indiceC=nouvelindice
+ else:
+ # s agit -il d un tuple
+ if texte[nouvelindice+1] != "(":
+ tuple=False
+ while ( texte[nouvelindice] != "="):
+ if texte[nouvelindice] == ")" :
+ tuple=True
+ break
+ else :
+ nouvelindice=nouvelindice+1
+ if nouvelindice == len(texte) :
+ nouvelindice=nouvelindice -1
+ break
+ if tuple :
+ valeur=texte[indiceC+1:nouvelindice+1]
+ indiceC=nouvelindice+1
+ if mot in self.appli.liste_simp_reel:
+ valeur=valeur[1:-1]
+ for val in valeur.split(',') :
+ # Attention la derniere valeur est""
+ try :
+ if val[0] != "'":
+ clef=eval(val)
+ if str(clef) != str(val) :
+ dict_reel_concept[clef]=val
+ except :
+ pass
+ mot=""
+ # ou de ( imbriqueés
+ else :
+ mot=""
+ else :
+ mot=mot+texte[indiceC]
+ indiceC=indiceC+1
+ # traitement du dernier inutile
+ # c est un ;
+ return dict_reel_concept
+
+ def analyse_reel(self,commande) :
+ nomConcept=None
+ # On verifie qu on a bien un OPER
+ # et pas une MACRO
+ if commande.find("=") > commande.find("(") :
+ return
+ if commande.find("=") > 0:
+ epure1=self.enleve(commande)
+ nomConcept=epure1.split("=")[0]
+ index=epure1.find("=")
+ epure2=epure1[index+1:len(epure1)].replace("_F(","(")
+ dict_reel_concept=self.construit_genea(epure2)
+ if nomConcept !=None :
+ if len(dict_reel_concept) != 0:
+ self.appli.dict_reels[nomConcept]=dict_reel_concept
+
+ def get_texte(self,appli=None):
"""
Retourne le texte issu de l'analyse
"""
+ self.appli=appli
if not self.l_objets : self.analyse()
txt=''
for obj in self.l_objets:
