+# -*- coding: utf-8 -*-
# CONFIGURATION MANAGEMENT OF EDF VERSION
# ======================================================================
# COPYRIGHT (C) 1991 - 2002 EDF R&D WWW.CODE-ASTER.ORG
import traceback
import cPickle
import Pmw
-from tkMessageBox import showinfo,showerror
# Modules Eficas
import prefs
import fontes
import analyse_catalogue
from Noyau.N_CR import CR
+from widgets import showinfo,showerror
from widgets import Fenetre
from utils import init_rep_cata_dev
#import catabrowser
+import autre_analyse_cata
+import uiinfo
class READERCATA:
self.parent=parent
self.code=self.appli.code
self.appli.format_fichier.set('python')
+ self.version_code=self.appli.version_code
+ self.fic_cata=None
self.OpenCata()
-
self.cataitem=None
- #XXX CCAR : Pour le moment je ne construis pas le CATAItem
- #self.cataitem = catabrowser.CATAItem(self,"Catalogue "+self.code,
- #self.cata,
- #objet_cata_ordonne = self.cata_ordonne_dico)
def OpenCata(self):
"""
dans le répertoire Cata
"""
message1 = "Compilation des fichiers Eficas \n\n Veuillez patienter ..."
- splash._splash.configure(text = message1)
- if len(self.appli.CONFIGURATION.catalogues) == 1:
- self.fic_cata = self.appli.CONFIGURATION.catalogues[0][2]
+ if self.appli.test == 0 :
+ splash._splash.configure(text = message1)
+ self.configure_barre(4)
+
+ liste_cata_possibles=[]
+ for catalogue in self.appli.CONFIGURATION.catalogues:
+ if catalogue[0] == self.code :
+ liste_cata_possibles.append(catalogue)
+
+ if len(liste_cata_possibles)==0:
+ showerror("Import du catalogue","Pas de catalogue defini pour le code %s" % self.code)
+ self.appli.quit()
+ sys.exit(1)
+
+ if self.version_code is not None:
+ # La version a ete fixee
+ for cata in liste_cata_possibles:
+ if self.version_code == cata[1]:
+ self.fic_cata = cata[2]
+ self.appli.format_fichier.set(cata[3])
+ elif len(liste_cata_possibles)==1:
+ self.fic_cata = liste_cata_possibles[0][2]
self.code = self.appli.CONFIGURATION.catalogues[0][0]
- self.version_code = self.appli.CONFIGURATION.catalogues[0][1]
- self.appli.format_fichier.set(self.appli.CONFIGURATION.catalogues[0][3])
- elif len(self.appli.CONFIGURATION.catalogues) == 0:
- # aucun catalogue défini dans le fichier Accas/editeur.ini
- if self.code == 'ASTER' :
- self.fic_cata = os.path.join(prefs.CODE_PATH,'Cata','cata.py')
- elif self.code == 'SATURNE' :
- self.fic_cata = os.path.join(prefs.CODE_PATH,'Cata','cata_saturne.py')
- elif self.code == 'DESCARTES':
- self.fic_cata = os.path.join(prefs.CODE_PATH,'Cata','cata_descartes.py')
- else :
- print 'Code inconnu'
- sys.exit(0)
+ self.version_code = liste_cata_possibles[0][1]
+ self.appli.format_fichier.set(liste_cata_possibles[0][3])
else:
# plusieurs catalogues sont disponibles : il faut demander à l'utilisateur
# lequel il veut utiliser ...
self.ask_choix_catalogue()
+
if self.fic_cata == None :
- self.parent.destroy()
+ print "Pas de catalogue pour code %s, version %s" %(self.code,self.version_code)
sys.exit(0)
+
# détermination de fic_cata_c et fic_cata_p
self.fic_cata_c = self.fic_cata + 'c'
self.fic_cata_p = os.path.splitext(self.fic_cata)[0]+'_pickled.py'
- print "Debut compil cata: ",time.clock()
+
+ #if self.appli.test == 0 :
+ # splash._splash.configure(text = "Debut compil cata: %d s" % time.clock())
# compilation éventuelle du catalogue
- test = self.compile_cata(self.fic_cata,self.fic_cata_c)
- print "Fin compil cata: ",time.clock()
- if not test : showerror("Compilation catalogue","Impossible de compiler le catalogue %s" %self.fic_cata)
+ #test = self.compile_cata(self.fic_cata,self.fic_cata_c)
+ #self.update_barre()
+ #if self.appli.test == 0 :
+ # splash._splash.configure(text = "Fin compil cata: %d s" % time.clock())
+ #if not test : showerror("Compilation catalogue","Impossible de compiler le catalogue %s" %self.fic_cata)
+
# import du catalogue
- print "Debut import_cata: ",time.clock()
+ if self.appli.test == 0 :
+ splash._splash.configure(text = "Debut import_cata: %d s" % time.clock())
self.cata = self.import_cata(self.fic_cata)
- print "Fin import_cata: ",time.clock()
+ self.update_barre()
+ if self.appli.test == 0 :
+ splash._splash.configure(text = "Fin import_cata: %d s" % time.clock())
if not self.cata : showerror("Import du catalogue","Impossible d'importer le catalogue %s" %self.fic_cata)
+
+ #
# analyse du catalogue (ordre des mots-clés)
- #XXX A priori ceci fait double emploi. Il faut d'abord calculer l'ordre
- # puis fabriquer le CATAItem
- #CCAR :self.catalo = catabrowser.CATAItem(self,"Catalogue",self.cata)
- print "Debut Retrouve_Ordre: ",time.clock()
- self.Retrouve_Ordre_Cata_Standard()
- print "Fin Retrouve_Ordre: ",time.clock()
+ #
+ if self.appli.test == 0 :
+ splash._splash.configure(text = "Debut Retrouve_Ordre: %d s" % time.clock())
+ # Retrouve_Ordre_Cata_Standard fait une analyse textuelle du catalogue
+ # remplacé par Retrouve_Ordre_Cata_Standard_autre qui utilise une numerotation
+ # des mots clés à la création
+ #self.Retrouve_Ordre_Cata_Standard()
+ self.Retrouve_Ordre_Cata_Standard_autre()
+ self.update_barre()
+ if self.appli.test == 0 :
+ splash._splash.configure(text = "Fin Retrouve_Ordre: %d s" % time.clock())
+ #
+ # analyse des données liées à l'IHM : UIinfo
+ #
+ uiinfo.traite_UIinfo(self.cata)
+ self.update_barre()
+
+ #
+ # traitement des clefs documentaires
+ #
+ self.traite_clefs_documentaires()
+
# chargement et analyse des catalogues développeur (le cas échéant)
+ #
if self.appli.CONFIGURATION.isdeveloppeur == 'OUI' :
init_rep_cata_dev(self.fic_cata,self.appli.CONFIGURATION.path_cata_dev)
fic_cata_dev = os.path.join(self.appli.CONFIGURATION.path_cata_dev,'cata_developpeur.py')
self.cata = (self.cata,)
else:
self.cata_dev =self.import_cata(fic_cata_dev)
- self.Retrouve_Ordre_Cata_Developpeur()
+ #self.Retrouve_Ordre_Cata_Developpeur()
+ self.Retrouve_Ordre_Cata_Developpeur_autre()
self.cata = (self.cata,self.cata_dev)
else:
self.cata = (self.cata,)
"""
Réalise l'import du catalogue dont le chemin d'accès est donné par cata
"""
- import imp
- splash._splash.configure(text = "Chargement du catalogue")
+ if self.appli.test == 0 :
+ splash._splash.configure(text = "Chargement du catalogue")
nom_cata = os.path.splitext(os.path.basename(cata))[0]
rep_cata = os.path.dirname(cata)
sys.path[:0] = [rep_cata]
try :
- f,p,d = imp.find_module(nom_cata)
- o = imp.load_module(nom_cata,f,p,d)
+ o=__import__(nom_cata)
return o
except Exception,e:
traceback.print_exc()
return 0
+ def Retrouve_Ordre_Cata_Standard_autre(self):
+ """
+ Construit une structure de données dans le catalogue qui permet
+ à EFICAS de retrouver l'ordre des mots-clés dans le texte du catalogue.
+ 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,self.appli.liste_simp_reel=autre_analyse_cata.analyse_catalogue(self.cata)
+
def Retrouve_Ordre_Cata_Standard(self):
"""
Retrouve l'ordre des mots-clés dans le catalogue, cad :
self.Get_Ordre_Cata(mode='cata')
self.appli.affiche_infos("Catalogue standard chargé")
+ def Retrouve_Ordre_Cata_Developpeur(self):
+ """
+ Retrouve l'ordre des mots-clés dans le catalogue, cad :
+ - si ce dernier a été modifié, relance l'analyse du catalogue pour déterminer
+ l'ordre des mots-clés dans le catalogue
+ - s'il n'a pas été modifié, relie le fichier pickle
+ """
+ if self.code != 'ASTER' : return
+ fic_cata = os.path.join(self.appli.CONFIGURATION.path_cata_dev,'cata_developpeur.py')
+ 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 = analyse_cata.analyse_catalogue(self,self.fic_cata)
+ self.cata_dev_ordonne_cr = cata_dev_ordonne.cr
+ cata_dev_ordonne_dico = cata_dev_ordonne.entites
+ self.cata_ordonne_dico.update(cata_dev_ordonne_dico)
+ self.appli.affiche_infos(" catalogue(s) développeur(s) chargé(s)" )
+
+ def Retrouve_Ordre_Cata_Developpeur_autre(self):
+ """
+ Retrouve l'ordre des mots-clés dans le catalogue, cad :
+ - si ce dernier a été modifié, relance l'analyse du catalogue pour déterminer
+ l'ordre des mots-clés dans le catalogue
+ - s'il n'a pas été modifié, relie le fichier pickle
+ """
+ if self.code != 'ASTER' : return
+ 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,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)" )
+
def Get_Ordre_Cata(self,mode='pickle'):
"""
Retrouve l'ordre du catalogue :
try:
f = open(self.fic_cata_p)
u = cPickle.Unpickler(f)
- splash._splash.configure(text = "Analyse du catalogue")
+ if self.appli.test == 0 :
+ splash._splash.configure(text = "Analyse du catalogue")
self.cata_ordonne_dico = u.load()
f.close()
except :
# ou (le plus probable) s'il a été créé sous un autre OS
self.Get_Ordre_Cata(mode='cata')
elif mode == 'cata':
- splash._splash.configure(text = "Analyse du catalogue",barre='oui')
+ if self.appli.test == 0 :
+ splash._splash.configure(text = "Analyse du catalogue",barre='oui')
cata_ordonne = analyse_catalogue.analyse_catalogue(self,self.fic_cata)
self.cata_ordonne_cr = cata_ordonne.cr
- self.cata_ordonne_dico = cata_ordonne.dico
+ self.cata_ordonne_dico = cata_ordonne.entites
splash._splash.configure(text = "Sauvegarde des informations sur le catalogue")
f = open(self.fic_cata_p,'w+')
p = cPickle.Pickler(f)
# test si plusieurs catalogues ou non
if len(liste_choix) == 0:
showerror("Aucun catalogue déclaré pour %s" %self.code)
- self.quit()
+ self.appli.quit()
+ sys.exit(1)
elif len(liste_choix) == 1:
self.fic_cata = self.dico_catalogues[liste_choix[0]][2]
self.version_code = liste_choix[0]
return
# création d'une boîte de dialogue modale
- self.fenetre_choix_cata = Pmw.Dialog(self.parent,
+ self.fenetre_choix_cata = Pmw.Dialog(splash._splash, #avec self.parent, ne marche pas sous Windows
buttons=('OK','ANNULER'),
defaultbutton = 'OK',
title = "Choix d'une version du code %s" %self.code,
if time1 > time2:
try:
# le catalogue doit être recompilé avant d'être importé
- splash._splash.configure(text="Compilation du catalogue\nCela peut prendre une trentaine de secondes ...")
+ if self.appli.test == 0 :
+ splash._splash.configure(text="Compilation du catalogue\nCela peut prendre plusieurs secondes ...")
py_compile.compile(cata)
except:
return 0
""" Configure la barre de progression en lui passant comme paramètre le
nombre de commandes du catalogue qui lui sert à déterminer la longueur de son incrément """
try:
- splash._splash.configure(barre='oui',ratio = nbcommandes)
+ if self.appli.test == 0 :
+ splash._splash.configure(barre='oui',ratio = nbcommandes)
except:
pass
def update_barre(self):
""" Update la position de la barre de progression : la fait progresser de son incrément """
try:
- splash._splash.update_barre()
+ if self.appli.test == 0 :
+ splash._splash.update_barre()
except:
pass
texte_cr = str(cr)
self.visu_texte_cr = Fenetre(self.appli,titre=titre,texte=texte_cr)
+
+ def traite_clefs_documentaires(self):
+ try:
+ self.fic_cata_clef=os.path.splitext(self.fic_cata_c)[0]+'_clefs_docu'
+ f=open(self.fic_cata_clef)
+ except:
+ #print "Pas de fichier associé contenant des clefs documentaires"
+ return
+
+ dict_clef_docu={}
+ for l in f.readlines():
+ clef=l.split(':')[0]
+ docu=l.split(':')[1]
+ docu=docu[0:-1]
+ dict_clef_docu[clef]=docu
+ for oper in self.cata.JdC.commandes:
+ if dict_clef_docu.has_key(oper.nom):
+ oper.docu=dict_clef_docu[oper.nom]
