elif pos == 'after':
index = index +1
else:
- print tr("%d n'est pas un index valide pour append_brother", pos)
+ print (tr("%d n'est pas un index valide pour append_brother", pos))
return
return self.parent.addobject(name,index)
g.init_jdc(self.node.get_jdc())
texte=g.gener(self.node)
else:
- print "Le generateur n'a pas ete trouve"
- print "Erreur ! Erreur!"
+ print ("Le generateur n'a pas ete trouve")
+ print ("Erreur ! Erreur!")
return ""
from Extensions.param2 import originalMath
originalMath.toOriginal()
mc = SIMP_CATA(nom_mc,self)
self.children.append(mc)
else :
- print tr("Erreur dans la creation du mot-cle : %s", nom_mc)
+ print (tr("Erreur dans la creation du mot-cle : %s", nom_mc))
def construit_liste_dico(self):
l=[]
self.ordre_mc = l
self.entites = d
except:
- print "erreur : ", self.nom, self.__class__
+ print (("erreur : ", self.nom, self.__class__))
class COMMANDE_CATA(ENTITE) :
def __init__(self,nom,args,parent):
self.texte_complet=f.read()
f.close()
except :
- print tr("Impossible d'ouvrir le fichier : %s ", str(self.fichier))
+ print (tr("Impossible d'ouvrir le fichier : %s ", str(self.fichier)))
self.cr.fatal(tr("Impossible d'ouvrir le fichier : %s ", str(self.fichier)))
def constr_list_txt_cmd(self,text):
if len(liste) < 2 :
liste = re.split(u'MACRO *\(u',text,1)
if len(liste) < 2 :
- print tr("le texte a analyser n'est pas celui d'une commande ou d'un operateur : "), text
+ print ((tr("le texte a analyser n'est pas celui d'une commande ou d'un operateur : "), text))
self.cr.fatal(tr("le texte a analyser n'est pas celui d'une commande ou \
d'un operateur : %s", text))
return
fin = liste[1]
nom_cmd = cherche_nom(debut)
if nom_cmd == 'erreur !':
- print tr("Erreur dans la recherche du nom de la commande : "), debut
+ print (tr("Erreur dans la recherche du nom de la commande : "), debut)
args_cmd,toto = cherche_args(u'(u'+fin)
if args_cmd == 'erreur !':
- print tr("Erreur dans la recherche des args de la commande :") , debut
+ print (tr("Erreur dans la recherche des args de la commande :") , debut)
cmd=COMMANDE_CATA(nom_cmd,args_cmd,self)
self.liste_commandes.append(cmd)
liste = re.split(nom_cmd+' *\(u',text,1)
if len(liste) == 2 : break
if len(liste) < 2 :
- print tr("le texte a analyser n'est pas celui d'une commande connue : \
- %(v_1)s %(v_2)s", {'v_1': str(l_noms_commandes), 'v_2': text})
+ print (tr("le texte a analyser n'est pas celui d'une commande connue : \
+ %(v_1)s %(v_2)s", {'v_1': str(l_noms_commandes), 'v_2': text}))
self.cr.fatal(tr("le texte a analyser n'est pas celui d'une commande connue : \
%(v_1)s %(v_2)s", {'v_1': str(l_noms_commandes), 'v_2': text}))
return
fin = liste[1]
nom_cmd = cherche_nom(debut)
if nom_cmd == 'erreur !':
- print tr("Erreur dans la recherche du nom de la commande : "), debut
+ print ( tr("Erreur dans la recherche du nom de la commande : "), debut)
args_cmd,toto = cherche_args(u'(u'+fin)
if args_cmd == 'erreur !':
- print tr("Erreur dans la recherche des args de la commande : "), debut
- print tr(fin)
+ print ( tr("Erreur dans la recherche des args de la commande : "), debut)
+ print (tr(fin))
cmd=COMMANDE_CATA(nom_cmd,args_cmd,self)
self.liste_commandes.append(cmd)
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
de leur apparition dans le catalogue.
- L'ordre d'apparition dans le catalogue est donné par l'attribut _no
+ L'ordre d'apparition dans le catalogue est donne par l'attribut _no
de l'entite
La fonction active le meme type de traitement pour les sous entites
de entite
def analyse_catalogue(cata):
"""
Cette fonction analyse le catalogue cata pour construire avec l'aide
- de traite_entite la structure de données ordre_mc qui donne l'ordre
- d'apparition des mots clés dans le catalogue
+ de traite_entite la structure de donnees ordre_mc qui donne l'ordre
+ d'apparition des mots cles dans le catalogue
Elle retourne un dictionnaire qui contient toutes les commandes
- du catalogue indexées par leur nom
+ du catalogue indexees par leur nom
"""
cata_ordonne_dico={}
liste_simp_reel=[]
#dico=analyse_catalogue(cata_saturne)
def print_entite(entite,dec=' '):
- print dec,entite.nom,entite.__class__.__name__
+ print (dec,entite.nom,entite.__class__.__name__)
for mocle in entite.ordre_mc:
print_entite(entite.entites[mocle],dec=dec+' ')
for k,v in dico.items():
print_entite(v,dec='')
- print dico.keys()
+ print (dico.keys())
def construitListeInto(self,e):
if isinstance(e,Accas.A_BLOC.BLOC) :
- print e.condition
+ print (e.condition)
for nomFils, fils in e.entites.items():
self.construitListeInto(fils)
self.cata=cata
self.dictInto={}
mesCommandes=self.cata.JdC.commandes
- print "________________________"
for maCommande in mesCommandes:
- print maCommande.nom
- print maCommande.entites
- print len(maCommande.entites)
+ print (maCommande.nom)
+ print (maCommande.entites )
+ print (len(maCommande.entites) )
# def construitListeInto(self,e):
# if isinstance(e,Accas.A_BLOC.BLOC) :
-# print e.condition
+# print (e.condition.
# for nomFils, fils in e.entites.items():
# self.construitListeInto(fils)
# Les fichiers includes d'abord
for k,v in d_pours.items():
if k in (u"pours","comm"):continue
- print tr("%(v_1)s include %(v_2)s : %(v_3)s", {'v_1': str(dec), 'v_2': str(k), 'v_3': str(v)})
+ print ( tr("%(v_1)s include %(v_2)s : %(v_3)s", {'v_1': str(dec), 'v_2': str(k), 'v_3': str(v)}))
if d_pours.has_key(u"pours"):
# Description de la poursuite
- print tr("%(v_1)s fichier poursuite: %(v_2)s", {'v_1': dec, 'v_2': d_pours["pours"]["comm"]})
+ print (tr("%(v_1)s fichier poursuite: %(v_2)s", {'v_1': dec, 'v_2': d_pours["pours"]["comm"]}))
print_pours(d_pours["pours"],dec=dec+"++")
def print_d_env():
- #print d_env
if d_env.studies is None:return
for study in d_env.studies:
- print tr("nom etude : %s", study["comm"])
+ print (tr("nom etude : %s", study["comm"]))
print_pours(study,dec="++")
- print
def create_parser():
# creation du parser des options de la ligne de commande
options.comm.append(file)
options.studies.append({"comm":file})
elif len(args) == 1 and options.locale:
- print tr("Localisation specifiee pour l'application.")
+ print (tr("Localisation specifiee pour l'application."))
else:
parser.error(tr("Nombre incorrect d'arguments"))
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
"""
- Ce module sert à construire les structures de données porteuses
- des informations liées aux groupes de commandes
+ Ce module sert a construire les structures de donnees porteuses
+ des informations liees aux groupes de commandes
"""
import types
"""
Pour le moment la classe UIINFO ne sait traiter que des infos
portant sur la definition des groupes de commandes
- Les autres informations sont ignorées
+ Les autres informations sont ignorees
"""
def __init__(self,parent,groupes=None,**args):
"""
Initialiseur de la classe UIINFO.
- Initialise a partir du dictionnaire UIinfo passé à
+ Initialise a partir du dictionnaire UIinfo passe a
un objet ENTITE les attributs de la classe
"""
- # L'attribut parent stocke le lien vers l'objet ENTITE relié à UIINFO
+ # L'attribut parent stocke le lien vers l'objet ENTITE relie a UIINFO
self.parent=parent
self.groupes=groupes
if groupes == None:
- # L'entite n'a pas de groupe associé. On lui associe le groupe "DEFAUT"
+ # L'entite n'a pas de groupe associe. On lui associe le groupe "DEFAUT"
self.groupes=("DEFAUT",)
if type(self.groupes) != types.TupleType:
self.groupes=(self.groupes,)
def traite_commande(commande,niveau):
"""
Cette fonction cree l'attribut UI de l'objet commande
- à partir des informations contenues dans UIinfo
+ a partir des informations contenues dans UIinfo
"""
uiinfo=commande.UIinfo or {}
UI=UIINFO(commande,**uiinfo)
# A la fin les cles du dictionnaire dict_groupes donnent la liste des groupes
# sans doublon
niveau.liste_groupes=niveau.dict_groupes.keys()
- # On ordonne les listes alphabétiquement
+ # On ordonne les listes alphabetiquement
niveau.liste_groupes.sort()
for v in niveau.dict_groupes.values():v.sort()
#print niveau.liste_groupes
def traite_UIinfo(cata):
"""
Cette fonction parcourt la liste des commandes d'un catalogue (cata)
- construit les objets UIINFO à partir de l'attribut UIinfo de la commande
- et construit la liste complète de tous les groupes présents
+ construit les objets UIINFO a partir de l'attribut UIinfo de la commande
+ et construit la liste complete de tous les groupes presents
"""
#dict_groupes["CACHE"]=[]
#XXX Ne doit pas marcher avec les niveaux
# A la fin les cles du dictionnaire dict_groupes donnent la liste des groupes
# sans doublon
cata.JdC.liste_groupes=cata.JdC.dict_groupes.keys()
- # On ordonne les listes alphabétiquement
+ # On ordonne les listes alphabetiquement
cata.JdC.liste_groupes.sort()
for v in cata.JdC.dict_groupes.values():v.sort()
#print cata.JdC.liste_groupes
#print cata.JdC.dict_groupes
else:
- # Le catalogue de commandes contient des définitions de niveau
+ # Le catalogue de commandes contient des definitions de niveau
for niv in cata.JdC.l_niveaux:
traite_niveau(niv)
rep_user_eficas= os.path.join(os.environ['HOME'],dir)
if os.path.exists(rep_user_eficas):
if os.path.isfile(rep_user_eficas) :
- print tr("Un fichier de nom %s existe deja : impossible de creer un repertoire de meme nom", rep_user_eficas)
+ print (tr("Un fichier de nom %s existe deja : impossible de creer un repertoire de meme nom", rep_user_eficas))
rep_user_eficas=None
else :
try:
os.mkdir(rep_user_eficas)
except:
- print tr("Creation du repertoire %s impossible\n Verifiez vos droits d'acces", rep_user_eficas)
+ print (tr("Creation du repertoire %s impossible\n Verifiez vos droits d'acces", rep_user_eficas))
return rep_user_eficas
def read_file(file):
os.chdir(cur_dir)
except:
traceback.print_exc()
- print tr("Impossible de transferer les fichiers requis dans : %s", str(rep_goal))
+ print ( tr("Impossible de transferer les fichiers requis dans : %s", str(rep_goal)))
def get_entete_cata(fic_cata):
""" Retrouve l'entete du catalogue """
