From: eficas <> Date: Mon, 24 Apr 2006 14:35:53 +0000 (+0000) Subject: Pn pour tests ancien parseur X-Git-Tag: V1_10b2~44 X-Git-Url: http://git.salome-platform.org/gitweb/?a=commitdiff_plain;h=c003753fff621ed7a029f9da4769f02146c29db5;p=modules%2Feficas.git Pn pour tests ancien parseur --- diff --git a/Editeur/TroisDPal.py b/Editeur/TroisDPal.py index 28a92944..c0cc0d07 100644 --- a/Editeur/TroisDPal.py +++ b/Editeur/TroisDPal.py @@ -38,6 +38,7 @@ class TroisDPilote: if generator.plugins.has_key(format): # Le generateur existe on l'utilise g=generator.plugins[format]() + g.init_jdc(self.node.get_jdc()) texte=g.gener(self.node) else: print "Le generateur n a pas ete trouvé" diff --git a/Editeur/appli.py b/Editeur/appli.py index e72113d7..c7551ae4 100644 --- a/Editeur/appli.py +++ b/Editeur/appli.py @@ -119,6 +119,7 @@ class APPLI: splash._splash.configure(text = "Chargement des paramètres utilisateur") import configuration self.CONFIGURATION = configuration.make_config(self,prefs.REPINI) + self.CONFIGStyle = configuration.make_config_style(self,prefs.REPINI) def cree_composants_graphiques(self): """ diff --git a/Editeur/configuration.py b/Editeur/configuration.py index 1596562e..c748a61f 100644 --- a/Editeur/configuration.py +++ b/Editeur/configuration.py @@ -29,191 +29,134 @@ import traceback from widgets import showinfo,showerror,askretrycancel import utils -class CONFIG: - def __init__(self,appli,rep_ini): - # si appli == None on est en mode commande (hors EFICAS) +class CONFIGbase: + + #----------------------------------- + def __init__(self,appli): + #----------------------------------- + + # Classe de base permettant de lire, afficher + # et sauvegarder les fichiers utilisateurs editeur.ini + # et style.py + # Classe Mere de : class CONFIG(CONFIGbase) + # class CONFIGStyle(CONFIGbase): + self.appli = appli - if self.appli:self.parent=appli.top - else:self.parent=None - self.rep_ini = rep_ini + if self.appli: + self.parent=appli.top + else: + self.parent=None self.rep_user = utils.get_rep_user() - self.lecture_parametres() - - def lecture_parametres(self): - """ - Cette méthode teste l'existence du fichier editeur.ini au bon endroit et lance - son interprétation - """ - fic_ini = os.path.join(self.rep_ini,'editeur.ini') - if not os.path.exists(fic_ini) or not os.path.isfile(fic_ini): - if self.appli : - showerror("Erreur","Impossible de trouver le fichier %s ! \n Prévenez la maintenance ..." %fic_ini) - else: - print "Impossible de trouver le fichier %s ! \n Prévenez la maintenance ..." %fic_ini - sys.exit(0) - self.fic_ini = fic_ini - self.init_liste_param() self.lecture_fichier_ini_standard() self.lecture_fichier_ini_utilisateur() - + self.init_liste_param() + + + #-------------------------------------- def lecture_fichier_ini_standard(self): - """ - Relit les paramètres du fichier eficas.ini - """ - txt = utils.read_file(self.fic_ini) - d={} + #-------------------------------------- + # Verifie l'existence du fichier "standard" + # appelle la lecture de ce fichier + if not os.path.isfile(self.fic_ini): + showerror("Erreur","Pas de fichier de configuration" + self.fic_ini+"\n"+string.join(l[2:])) + print "Erreur à la lecture du fichier de configuration : %s" % fic + sys.exit(0) + self.lecture_fichier(self.fic_ini) + + #----------------------------- + def lecture_fichier(self,fic): + #------------------------------ + # lit les paramètres du fichier eficas.ini ou style.py + # les transforme en attribut de l 'objet + # utilisation du dictionnaire local pour récuperer style + txt = utils.read_file(fic) + from styles import style + d=locals() try: exec txt in d except: l=traceback.format_exception(sys.exc_info()[0],sys.exc_info()[1],sys.exc_info()[2]) - showerror("Erreur","Une erreur s'est produite dans la relecture du fichier de configuration : " - + self.fic_ini+"\n"+string.join(l[2:])) - print "Erreur à la lecture du fichier de configuration : %s" % self.fic_ini - print string.join(l[2:]) + showerror("Erreur","Une erreur s'est produite lors de la lecture du fichier : " + fic + "\n") + print "Erreur à la lecture du fichier de configuration : %s" % fic sys.exit() - for attr in self.l_nom_param: - nom_attr,statut,defaut = attr - #valeur = d.get(nom_attr,None) - valeur = d.get(nom_attr,defaut) - if not valeur and statut=='o': - showerror("Erreur","Une erreur s'est produite dans la relecture du fichier de configuration : " - + self.fic_ini+"\n EFICAS va vous demander les nouveaux paramètres") - return - setattr(self,nom_attr,valeur) - self.init_liste_param() + for k in d.keys() : + if k in self.labels.keys() : + setattr(self,k,d[k]) + + for k in d['style'].__dict__.keys() : + setattr(self,k,d['style'].__dict__[k]) + + #-------------------------------------- def lecture_fichier_ini_utilisateur(self): - """ - Surcharge les paramètres standards par les paramètres utilisateur s'ils existent - """ - self.fic_ini_utilisateur = os.path.join(self.rep_user,'eficas.ini') + #-------------------------------------- + # Surcharge les paramètres standards par les paramètres utilisateur s'ils existent + self.fic_ini_utilisateur = os.path.join(self.rep_user,self.fichier) if not os.path.isfile(self.fic_ini_utilisateur): - # pas de fichier de configuration utilisateur --> on passe - return - txt = utils.read_file(self.fic_ini_utilisateur) - d={} - try: - exec txt in d - except : - showinfo("Erreur","Impossible d'interpréter le fichier de configuration utilisateur : %s" %self.fic_ini_utilisateur) - traceback.print_exc() return - for attr in self.l_nom_param: - nom_attr,statut,defaut = attr - valeur = d.get(nom_attr,None) - if valeur : - setattr(self,nom_attr,valeur) - self.init_liste_param() + self.lecture_fichier(self.fic_ini_utilisateur) - def init_liste_param(self): - """ - Génère la liste des paramètres - l_param est une liste de tuples où chaque tuple est de la forme : - (label,nature,nom_var,defaut) - """ - self.l_param=[] - # répertoire initial pour OPEN/SAVE des fichiers de commande - # Par defaut, EFICAS utilise le repertoire utilisateur $HOME/Eficas_install - # Il est possible de specifier dans editeur.ini ou eficas.ini un autre chemin - # Ce peut etre un chemin absolu ou le repertoire courant (os.curdir) - if hasattr(self,'initialdir'): - self.l_param.append(("Répertoire initial pour Open/save des fichiers de commande",'rep','initialdir',self.initialdir)) - else: - self.l_param.append(("Répertoire initial pour Open/save des fichiers de commande",'rep','initialdir',self.rep_user)) - # répertoire de travail - if hasattr(self,'rep_travail'): - self.l_param.append(("Répertoire de travail",'rep','rep_travail',self.rep_travail)) - else: - self.l_param.append(("Répertoire de travail",'rep','rep_travail', - os.path.join(self.rep_user,'uaster','tmp_eficas'))) - # répertoire des catalogues matériaux - if hasattr(self,'rep_mat'): - self.l_param.append(("Répertoire materiaux",'rep','rep_mat',self.rep_mat)) - else: - self.l_param.append(("Répertoire materiaux",'rep','rep_mat','/aster/v4/materiau')) - # chemin d'accès exécutable acrobat reader - if hasattr(self,'exec_acrobat'): - self.l_param.append(("Ligne de commande Acrobat Reader",'file','exec_acrobat',self.exec_acrobat)) - else: - self.l_param.append(("Ligne de commande Acrobat Reader",'file','exec_acrobat',self.rep_user)) - # répertoire contenant la doc Aster - if hasattr(self,'path_doc'): - self.l_param.append(("Chemin d'accès à la doc Aster",'rep','path_doc',self.path_doc)) - else: - self.l_param.append(("Chemin d'accès à la doc Aster",'rep','path_doc',self.rep_user)) - # chemin(s) d'accès au(x) catalogue(s) - if hasattr(self,'catalogues'): - self.l_param.append(("Versions du code ",'cata','catalogues',self.catalogues)) - else: - self.l_param.append(("Versions du code ",'cata','catalogues',os.path.join(self.rep_ini,'..','Cata/cata.py'))) - # attribut développeur - if hasattr(self,'isdeveloppeur'): - # self.l_param.append(("Etes-vous développeur ?",'YesNo','isdeveloppeur',self.isdeveloppeur)) - self.l_param.append(("Niveau de message ",'YesNo','isdeveloppeur',self.isdeveloppeur,'Deboggage','Utilisation')) - else: - # self.l_param.append(("Etes-vous développeur ?",'YesNo','isdeveloppeur','NON')) - self.l_param.append(("Niveau de message ",'YesNo','isdeveloppeur','NON','Deboggage','Utilisation')) - # répertoire où sont contenus les catalogues développeurs - if hasattr(self,'path_cata_dev') and hasattr(self,'isdeveloppeur') and self.isdeveloppeur == 'OUI': - self.l_param.append(("Chemin d'accès aux catalogues développeurs",'rep','path_cata_dev',self.path_cata_dev)) - else: - self.l_param.append(("Chemin d'accès aux catalogues développeurs",'rep','path_cata_dev', - os.path.join(self.rep_user,'cata'))) - self.l_param = tuple(self.l_param) - self.l_nom_param=[] - statut='o' - for tup in self.l_param: - if tup[1] == 'YesNo': - # les paramètres suivant tup sont facultatifs ... - statut='f' - self.l_nom_param.append((tup[2],statut,tup[3])) # nom,statut,defaut + #-------------------------------------- def affichage_fichier_ini(self): + #-------------------------------------- """ Affichage des valeurs des paramètres relus par Eficas """ import widgets result = widgets.Formulaire(self.parent, obj_pere = self, - titre = "Paramètres nécessaires à la configuration d'EFICAS", - texte = "Voici les paramètres que requiert Eficas", + titre = self.titre, + texte = self.texte_ini, items = self.l_param, mode='display', - commande=('Modifier',self.creation_fichier_ini_si_possible)) + commande=('Modifier',self.commande)) if result.resultat : - print 'on sauvegarde les nouveaux paramètres :',result.resultat + #print 'on sauvegarde les nouveaux paramètres :',result.resultat self.save_param_ini(result.resultat) + #-------------------------------------- def save_param_ini(self,dico): - """ - Sauvegarde les nouveaux paramètres dans le fichier de configuration utilisateur - """ + #-------------------------------------- + # sauvegarde + # les nouveaux paramètres dans le fichier de configuration utilisateur + # f=open(self.fic_ini_utilisateur,'w+') for k,v in dico.items(): - if k == 'catalogues' : + if self.types[k] in ('mot2','mot3','mot4'): + v1=v[1:-1] + val=v1.split(",") + p = "(" + listeval="" + for valeur in val: + listeval = listeval+ p + str(valeur) + p=" , " + listeval = listeval + ")" + f.write(str(self.pref)+str(k) + '=' + str(listeval) + '\n') + elif k == 'catalogues' : f.write(k + '\t=\t' + str(v) + '\n') else: - f.write(k + '\t=\t"' + str(v) + '"\n') + f.write(str(self.pref)+str(k) + '\t=\t"' + str(v) + '"\n') f.close() self.lecture_fichier_ini_utilisateur() + #------------------------------------------- def creation_fichier_ini_si_possible(self): + #------------------------------------------- return self.creation_fichier_ini(mode='ignorer_annuler') + #-------------------------------------------------------- def creation_fichier_ini(self,mode='considerer_annuler'): - """ - Récupération des valeurs des paramétres requis pour la création du fichier - eficas.ini - """ + #--------------------------------------------------------- + # Récupération des valeurs des paramétres requis pour la création du fichier + # eficas.ini + # import widgets - texte = "EFICAS a besoin de certains renseignements pour se configurer\n"+\ - "Veuillez remplir TOUS les champs ci-dessous et appuyer sur 'Valider'\n"+\ - "Si vous annulez, EFICAS ne se lancera pas !!" items = self.l_param result = widgets.Formulaire(self.parent, obj_pere = self, titre = "Saisie des données indispensables à la configuration d'EFICAS", - texte = texte, + texte = self.texte, items = items, mode='query') if not result.resultat : @@ -230,7 +173,119 @@ class CONFIG: self.save_param_ini(result.resultat) return result.resultat + #-------------------------- + def init_liste_param (self): + #-------------------------- + # construit self.l_param + # a partir de self.labels et des attributs + # de l objet (mis a jour lors de la lecture du fichier) + # l_param est une liste de tuples où chaque tuple est de la forme : + # (label,nature,nom_var,defaut) + + self.l_param=[] + for k in self.labels.keys() : + if hasattr(self,k) : + if k in self.YesNo.keys(): + self.l_param.append((self.labels[k],self.types[k],k,self.__dict__[k], + self.YesNo[k][0],self.YesNo[k][1])) + else : + self.l_param.append((self.labels[k],self.types[k],k,self.__dict__[k])) + self.l_param = tuple(self.l_param) + + +class CONFIG(CONFIGbase): + def __init__(self,appli,rep_ini): + self.texte = "EFICAS a besoin de certains renseignements pour se configurer\n"+\ + "Veuillez remplir TOUS les champs ci-dessous et appuyer sur 'Valider'\n"+\ + "Si vous annulez, EFICAS ne se lancera pas !!" + self.fichier="editeur.ini" + self.rep_ini = rep_ini + self.fic_ini = os.path.join(self.rep_ini,self.fichier) + self.titre = "Paramètres nécessaires à la configuration d'EFICAS" + self.texte_ini = "Voici les paramètres que requiert Eficas" + self.commande = self.creation_fichier_ini_si_possible + self.pref="" + self.labels={"initialdir" : "Répertoire initial pour Open/Save des fichiers", + "rep_travail" : "Répertoire de travail", + "rep_mat" : "Répertoire materiaux", + "path_doc" : "Chemin d'accès à la doc Aster", + "exec_acrobat" : "Ligne de commande Acrobat Reader", + "catalogues" : "Versions du code ", + "isdeveloppeur" : "Niveau de message ", + "path_cata_dev" : "Chemin d'accès aux catalogues développeurs"} + + self.types ={"initialdir":"rep", "rep_travail":"rep","rep_mat":"rep", + "path_doc": "rep","exec_acrobat":"file","exec_acrobat":"file", + "catalogues" :"cata","isdeveloppeur":"YesNo","path_cata_dev":"rep"} + + self.YesNo={} + self.YesNo['isdeveloppeur']=('Deboggage','Utilisation') + + # Valeurs par defaut + self.rep_user = utils.get_rep_user() + self.initialdir=self.rep_user + self.rep_travail=os.path.join(self.rep_user,'uaster','tmp_eficas') + self.rep_mat='/aster/v7/materiau' + self.path_doc=self.rep_user + self.exec_acrobat=self.rep_user + self.catalogues= os.path.join(self.rep_ini,'..','Cata/cata.py') + self.isdeveloppeur='NON' + self.path_cata_dev=os.path.join(self.rep_user,'cata') + + CONFIGbase.__init__ (self,appli) + + +class CONFIGStyle(CONFIGbase): + def __init__(self,appli,rep_ini): + self.texte = "Pour prendre en compte les modifications \n"+\ + " RELANCER EFICAS" + self.fichier="style.py" + self.rep_ini = rep_ini + self.fic_ini = os.path.join(self.rep_ini,self.fichier) + self.titre = "Paramètres d affichage" + self.texte_ini = "Voici les paramètres configurables : " + self.commande = self.creation_fichier_ini_si_possible + self.pref="style." + self.labels={"background":"couleur du fonds", + "foreground":"couleur de la police standard" , + "standard":" police et taille standard", + "standard_italique":"police utilisée pour l'arbre ", + "standard_gras_souligne":"police utilisée pour le gras souligné", + "canvas_italique":"police italique", + "standard_gras":"gras", + #"canvas":"police", + #"canvas_gras":"police gras", + #"canvas_gras_italique":"police gras italique", + #"standard12":"police 12", + #"standard12_gras":"police 12 gras", + #"standard12_gras_italique":"police 12 gras italique", + #"standardcourier10":"courrier " + } + self.types ={"background":"mot", + "foreground":"mot" , + "standard":"mot2", + "standard_italique":"mot3", + "standard_gras":"mot3", + "standard_gras_souligne":"mot4", + "canvas":"mot2", + "canvas_italique":"mot3", + "canvas_gras":"mot3", + "canvas_gras_italique":"mot4", + "standard12":"mot2", + "standard12_gras":"mot3", + "standard12_gras_italique":"mot4", + "standardcourier10":"mot2"} + self.YesNo={} + self.l_param=[] + CONFIGbase.__init__ (self,appli) + + def affichage_style_ini(self): + self.affichage_fichier_ini() + def make_config(appli,rep): return CONFIG(appli,rep) +def make_config_style(appli,rep): + return CONFIGStyle(appli,rep) + diff --git a/Editeur/options.py b/Editeur/options.py index 5093ee33..9d0da1e4 100644 --- a/Editeur/options.py +++ b/Editeur/options.py @@ -38,6 +38,7 @@ class OPTIONS: #("Couleur",(("fond",'change_fond'),("barre",'change_barre'))), # ("Catalogue développeur",'choix_cata_developpeur'), ('Paramètres Eficas','affichage_fichier_ini'), + ('Paramètres Affichage','affichage_style_ini'), ] ) @@ -124,4 +125,8 @@ class OPTIONS: def affichage_fichier_ini(self): - self.appli.bureau.affichage_fichier_ini() + self.appli.CONFIGURATION.affichage_fichier_ini() + + + def affichage_style_ini(self): + self.appli.CONFIGStyle.affichage_style_ini() diff --git a/Editeur/widgets.py b/Editeur/widgets.py index 34d9bff3..23414579 100644 --- a/Editeur/widgets.py +++ b/Editeur/widgets.py @@ -476,6 +476,7 @@ class Formulaire: on affiche un formulaire à remplir par l'utilisateur """ def __init__(self,fen_pere,obj_pere=None,titre="",texte="",items=(),mode='query',commande=None): + self.resultat=0 if items in ((),[]) : return self.items = items self.titre = titre @@ -501,6 +502,10 @@ class Formulaire: self.d_validateurs['rep'] = self.repvalidator self.d_validateurs['file'] = self.filevalidator self.d_validateurs['cata']= self.catavalidator + self.d_validateurs['mot']= self.motvalidator + self.d_validateurs['mot2']= self.mot2validator + self.d_validateurs['mot3']= self.mot3validator + self.d_validateurs['mot4']= self.mot4validator def init_fenetre(self): """ @@ -550,12 +555,13 @@ class Formulaire: chaine2="No" else : label,nature,nom_var,defaut,chaine,chaine2 = item + # création de la frame fr_item = Frame(window,height=40,width=700) fr_item.pack(side='top',fill='x',expand=1) # création du label Label(fr_item,text = label).place(relx=0.05,rely=0.4) - if nature in ('rep','file','cata'): + if nature in ('rep','file','cata','mot','mot2','mot3','mot4'): # création de l'entry e_item = Entry(fr_item) e_item.place(relx=0.5,rely=0.4,relwidth=0.45) @@ -608,6 +614,27 @@ class Formulaire: # Validateurs des noms de répertoire, de fichiers et de catalogues # ------------------------------------------------------------------------------- + def motvalidator(self,text): + text2="("+text+")" + return self.motlongueurvalidator(text2,1) + + def mot2validator(self,text): + return self.motlongueurvalidator(text,2) + + def mot3validator(self,text): + return self.motlongueurvalidator(text,3) + + def mot4validator(self,text): + return self.motlongueurvalidator(text,4) + + def motlongueurvalidator(self,text,longueur): + try : + if ((text[0] != "(") or (text[-1] != ")")) : return 0 + if len(text.split(",")) != longueur : return 0 + return 1 + except : + return 0 + def repvalidator(self,text): """ Teste si text peut faire référence à un répertoire ou non diff --git a/convert/convert_python.py b/convert/convert_python.py index 995984f7..999dac50 100644 --- a/convert/convert_python.py +++ b/convert/convert_python.py @@ -50,7 +50,7 @@ """ import sys,string,traceback -from autre_parseur import PARSEUR_PYTHON +import parseur_python from Noyau import N_CR def entryPoint(): @@ -103,21 +103,18 @@ class PythonParser: self.cr.fatal("Impossible ouvrir fichier %s" % filename) return - def settext(self,texte) : - self.text=texte - def convert(self,outformat,appli=None): if outformat == 'exec': try: - return PARSEUR_PYTHON(self.text).get_texte(appli) + 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], sys.exc_info()[2]) - self.cr.exception("Impossible de convertir le fichier python " - "qui doit contenir des erreurs.\n" - "On retourne le fichier non converti.\n" - "Prévenir la maintenance. \n" + string.join(l)) + self.cr.exception("Impossible de convertir le fichier python \ + qui doit contenir des erreurs.\n \ + On retourne le fichier non converti \n \ + Prévenir la maintenance. \n" + string.join(l)) # On retourne néanmoins le source initial non converti (au cas où) return self.text elif outformat == 'execnoparseur': diff --git a/generator/generator_vers3DSalome.py b/generator/generator_vers3DSalome.py index 3ead9a95..21de10c6 100644 --- a/generator/generator_vers3DSalome.py +++ b/generator/generator_vers3DSalome.py @@ -79,6 +79,9 @@ class vers3DSalomeGenerator(PythonGenerator): self.init_ligne() + def init_jdc(self,jdc) : + self.jdc=jdc + def init_ligne (self) : self.boolGpMa = 0 self.commande = "" @@ -176,15 +179,24 @@ class vers3DSalomeGenerator(PythonGenerator): self.clefs=(obj.val,) def VALE(self,obj) : + atraiter=obj.val if len(self.clefs) > 1 : - assert (len(obj.val) == len(self.clefs)) + assert (len(atraiter) == len(self.clefs)) else : - obj.val=(obj.val,) - for k in range(len(obj.val)) : + atraiter=(atraiter,) + for k in range(len(atraiter)) : clef=self.clefs[k] - val =obj.val[k] + val =atraiter[k] if isinstance (val, Extensions.parametre.PARAMETRE): val=val.valeur + print val.__class__ + context={} + if type(val) == type("aaa") : + for p in self.jdc.params: + context[p.nom]=eval(p.val,self.jdc.const_context, context) + print context[p.nom] + res=eval(val,self.jdc.const_context, context) + val=res self.dict_attributs[clef]=val def ANGL_REP(self,obj) :