ou eficas.ini un repertoire d'ouverture pour le browser de fichiers avec la variable
de configuration initialdir. Cette variable vaut $HOME/Eficas_install par defaut. On peut donner
un nom absolu de repertoire ou os.curdir ('.') pour le repertoire de lancement d'EFICAS.
Evolution EO2001-064 réalisée : Scrollbar horizontal lorsque les listes sont longues. On ne tronque
plus les listes trop longues. Dans la foulée, float_repr a été remplacé par str pour
l'affichage des flottants.
Correction d'un probleme avec isdeveloppeur = "OUI"
Anomalie AO2001-474 "corrigée". Elle l'était déja probablement en 1.2
Evolution EO2001-111 traitée : la chaine fr ou an (selon la langue) s'affiche maintenant
dans la fenetre info pour tous les objets : commandes, mots clés simples facteurs ...
Adaptation d'EFICAS à l'évolution du noyau sur les commandes avec reuse
path_cata_dev = "/tmp/cata"
# Répertoire temporaire
rep_travail = "/tmp"
+# Répertoire initial
+initialdir=os.curdir
# Choix des catalogues
rep_mat="bidon"
# Par défaut on utilise le répertoire icons dans Editeur
ICONDIR=os.path.join(INSTALLDIR,'Editeur','icons')
+# lang indique la langue utilisée pour les chaines d'aide : fr ou an
+lang='fr'
+
labels= ('Fichier','Edition','Jeu de commandes',
# 'Catalogue','Browsers','Options'
'Aide',
)
-extensions=['readercata','bureau',
+appli_composants=['readercata','bureau',
# 'browser','options'
]
def get_fr(self):
""" Retourne le fr de l'objet pointé par self """
- try:
- return self.object.get_fr()
- except:
- return ''
+ return self.object.get_fr()
def get_docu(self):
""" Retourne la clé de doc de l'objet pointé par self """
import splash
import prefs
import fontes
+import tooltip
VERSION="EFICAS v1.3"
self.format_fichier = Tkinter.StringVar()
self.message=''
self.cree_composants_graphiques()
- self.load_extensions()
+ self.load_appli_composants()
self.affiche_FAQ()
splash.fini_splash()
import statusbar
self.statusbar=statusbar.STATUSBAR(self.top)
- def load_extensions(self):
- splash._splash.configure(text = "Chargement des extensions")
- for mname in self.extensions:
- self.load_extension(mname)
+ def load_appli_composants(self):
+ splash._splash.configure(text = "Chargement des appli_composants")
+ for mname in self.appli_composants:
+ self.load_appli_composant(mname)
- def load_extension(self,mname):
+ def load_appli_composant(self,mname):
module=__import__(mname,globals(),locals())
factory=getattr(module,mname.upper())
- extension=factory(self,self.top)
- setattr(self,mname,extension)
- self.fill_menus(extension,extension.menu_defs)
- self.toolbar.creer_boutons_extension(extension.button_defs,extension)
+ appli_composant=factory(self,self.top)
+ setattr(self,mname,appli_composant)
+ self.fill_menus(appli_composant,appli_composant.menu_defs)
+ self.toolbar.creer_boutons_appli_composant(appli_composant.button_defs,appli_composant)
def affiche_FAQ(self):
import faq
x=event.x
y=event.y
widget=event.widget
- self.aide = Tkinter.Label(widget ,text = aide,
- bg="yellow",relief="ridge",anchor='w')
- self.aide.place(in_=widget,
- relx=0.5,rely=0.5,anchor='center')
- print aide
- return
-
- def fill_menus(self,extension,defs):
+ self.aide=tooltip.TOOLTIP(widget)
+ self.aide.xoffset = 10
+ self.aide.yoffset = - widget.winfo_height()/2
+ self.aide.setText(aide)
+ self.aide._showTip()
+ return
+
+ def fill_menus(self,appli_composant,defs):
menudict=self.menubar.menudict
for mname,itemlist in defs:
menu=menudict.get(mname)
menu.add_separator()
else:
label,method=item
- command=getattr(extension,method)
+ command=getattr(appli_composant,method)
menu.add_command(label=label,command=command)
import generator
import AIDE
from jdcdisplay import JDCDISPLAY
-from utils import extension,stripPath,save_in_file
+from utils import extension_fichier,stripPath,save_in_file
from widgets import Fenetre,Ask_Format_Fichier
from fenetre_mc_inconnus import fenetre_mc_inconnus
def cree_cataitem(self):
"""
- On récupère dans l'extension readercata les variables
+ On récupère dans l'appli_composant readercata les variables
qui servent par la suite pour la création des JDC
"""
self.cataitem=self.appli.readercata.cataitem
else:
filetypes = ( ("format "+self.appli.format_fichier.get(), ".py"),)
if not hasattr(self,'initialdir'):
- self.initialdir = self.appli.CONFIGURATION.rep_user
+ #self.initialdir = self.appli.CONFIGURATION.rep_user
+ self.initialdir = self.appli.CONFIGURATION.initialdir
if not file :
file = askopenfilename(title="Ouverture d'un fichier de commandes Aster",
defaultextension=".comm",
initialdir = self.initialdir)
if file != '':
self.fileName = file
- e=extension(file)
+ e=extension_fichier(file)
self.JDCName=stripPath(file)
self.initialdir = os.path.dirname(file)
else :
sauvegarde = asksaveasfilename(title=titre,
defaultextension=defext,
filetypes = filtyp,
- initialdir = self.appli.CONFIGURATION.rep_user)
+ initialdir = self.appli.CONFIGURATION.initialdir)
+ #initialdir = self.appli.CONFIGURATION.rep_user)
if sauvegarde != '':
if not save_in_file(sauvegarde,self.jdc_fini) :
showinfo("Erreur","Problème à la sauvegarde du fichier "+`sauvegarde`)
#
__version__="$Name: $"
-__Id__="$Id: compomacro.py,v 1.3 2002/04/05 06:32:38 eficas Exp $"
+__Id__="$Id: compomacro.py,v 1.4 2002/05/15 15:31:58 eficas Exp $"
#
class MACROPanel(panels.OngletPanel):
nb.add('Concept', tab_text='Nommer concept')
if ficini == 1:
nb.add('Fichierinit',tab_text = 'Fichier %s' %self.node.item.get_nom())
- nb.add('Commande', tab_text='Insérer Commande')
+ nb.add('Commande', tab_text='Nouvelle Commande')
nb.add('Commentaire',tab_text='Paramètre/Commentaire')
panneau=Pmw.PanedWidget(nb.page("Mocles"),
orient='horizontal')
nb.pack(fill = 'both', expand = 1)
self.nb=nb
nb.add('Mocles', tab_text='Ajouter mots-clés')
- nb.add('Commande', tab_text='Insérer Commande')
+ nb.add('Commande', tab_text='Nouvelle Commande')
nb.add('Commentaire',tab_text='Paramètre/Commentaire')
panneau=Pmw.PanedWidget(nb.page("Mocles"),
orient='horizontal')
Retourne le texte à afficher dans l'arbre représentant la valeur de l'objet
pointé par self
"""
- return self.object.GetText()
+ text= self.object.GetText()
+ return text
def wait_co(self):
"""
print string.join(l[2:])
sys.exit()
for attr in self.l_nom_param:
- nom_attr,statut = attr
- valeur = d.get(nom_attr,None)
+ 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")
traceback.print_exc()
return
for attr in self.l_nom_param:
- nom_attr,statut = attr
+ nom_attr,statut,defaut = attr
valeur = d.get(nom_attr,None)
if valeur :
setattr(self,nom_attr,valeur)
(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))
self.l_nom_param=[]
statut='o'
for tup in self.l_param:
- #self.l_nom_param.append((tup[2],statut))
if tup[1] == 'YesNo':
# les paramètres suivant tup sont facultatifs ...
statut='f'
- self.l_nom_param.append((tup[2],statut))
+ self.l_nom_param.append((tup[2],statut,tup[3])) # nom,statut,defaut
def affichage_fichier_ini(self):
"""
class EFICAS(appli.APPLI):
try:
- from prefs import extensions
+ from prefs import appli_composants
except:
- extensions=['readercata','bureau','browser','options']
+ appli_composants=['readercata','bureau','browser','options']
def get_texte_infos(self):
texte=appli.APPLI.get_texte_infos(self)
self.modified='n'
self.pane=Pmw.PanedWidget(self.parent,orient='horizontal')
- self.pane.add('treebrowser',min=0.5)
- self.pane.add('selected',min=0.5)
+ self.pane.add('treebrowser',min=0.4)
+ self.pane.add('selected',min=0.4)
self.pane.pack(expand=1,fill='both')
self.tree=TREEITEMINCANVAS(jdc,nom_jdc,self.pane.pane('treebrowser'),
self.appli,self.select_node)
Il s'appuie sur la classe READERCATA
"""
# Modules Python
+import time
import os,sys,py_compile
import traceback
import cPickle
import analyse_catalogue
from Noyau.N_CR import CR
from widgets import Fenetre
+from utils import init_rep_cata_dev
#import catabrowser
# 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()
# 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)
# import du catalogue
+ print "Debut import_cata: ",time.clock()
self.cata = self.import_cata(self.fic_cata)
+ print "Fin import_cata: ",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()
# 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)
"""
self.fen_infos.destroy()
- def creer_boutons_extension(self,l_boutons,extension):
+ def creer_boutons_appli_composant(self,l_boutons,appli_composant):
for bouton in l_boutons :
if not bouton :
# on veut afficher un bouton vide (=espace entre boutons)
relief = 'flat').pack(side='left')
continue
nom_fic,commande,texte,statut = bouton
- commande=getattr(extension,commande)
+ commande=getattr(appli_composant,commande)
b = Button(self.barreboutons,
image = images.get_image(nom_fic),
command = commande,
"""
import Tkinter
+import types
+
+def destruct(obj):
+ # assist in breaking circular references
+ if obj is not None:
+ assert type(obj) is types.InstanceType
+ for k in obj.__dict__.keys():
+ obj.__dict__[k] = None
+ ##del obj.__dict__[k]
+
+def after(widget, ms, func, *args):
+ timer = apply(widget.after, (ms, func) + args)
+ command = widget._tclCommands[-1]
+ return (timer, command, widget)
+
+def after_cancel(t):
+ if t is not None:
+ t[2].after_cancel(t[0])
+ try:
+ t[2].deletecommand(t[1])
+ except Tkinter.TclError:
+ pass
class TOOLTIP:
def __init__(self,widget):
self.tooltip.wm_geometry("%+d%+d" % (x, y))
self.tooltip.wm_deiconify()
+if __name__ == "__main__":
+ root=Tkinter.Tk()
+
+ def aide(event):
+ tp=TOOLTIP(root)
+ tp.setText("texte d'aide")
+ tp._showTip()
+
+ label = Tkinter.Label(root, text="coucou")
+ label.bind("<ButtonPress>", aide)
+ label.pack()
+ root.mainloop()
+
#
__version__="$Name: $"
-__Id__="$Id: treewidget.py,v 1.4 2002/04/05 06:32:39 eficas Exp $"
+__Id__="$Id: treewidget.py,v 1.5 2002/05/15 15:31:59 eficas Exp $"
#
Fonte_Standard = fontes.standard
self.dehighlight()
self.text_id = self.canvas.create_window(textx, texty,anchor="w", window=self.text)
self.id.append(self.text_id)
+ # Redefinit la region de scroll du canvas pour inclure tous les items créés
+ self.tree.scrolledcanvas.resizescrollregion()
def highlight(self,event=None):
""" Met en surbrillance self"""
"""
Ce module contient des utilitaires divers
"""
-import os
+import os,re
+import glob
+import traceback
def substract_list(liste1,liste2):
"""
except:
return 0
-def extension(pathAndFile):
+def extension_fichier(pathAndFile):
""" Return ext if path/filename.ext is given """
return os.path.splitext(pathAndFile)[1][1:]
""" Return filename.ext if path/filename.ext is given """
return os.path.split(pathAndFile)[1]
+def init_rep_cata_dev(fic_cata,rep_goal):
+ """ initialise le répertoire des catalogues développeurs (chemin d'accès donné
+ dans le fichier eficas.ini cad :
+ - le crée s'il n'existe pas encore
+ - copie dedans les 3 fichiers nécessaires :
+ * __init__.py (pour que ce répertoire puisse être interprété comme un package)
+ * entete.py (pour réaliser les import nécessaires à l'interprétation des catalogues)
+ * declaration_concepts.py (idem)
+ - crée le fichier cata_developpeur.py qui sera par la suite importé"""
+ try :
+ if not os.path.isdir(rep_goal) :
+ os.mkdir(rep_goal)
+ texte_entete = get_entete_cata(fic_cata)
+ # rep_goal doit contenir les catalogues du développeur sous la forme *.capy
+ # il faut créer le catalogue développeur par concaténation de entete,declaration_concepts
+ # et de tous ces fichiers
+ cur_dir = os.getcwd()
+ os.chdir(rep_goal)
+ l_cata_dev = glob.glob('*.capy')
+ if os.path.isfile('cata_developpeur.py') : os.remove('cata_developpeur.py')
+ if len(l_cata_dev) :
+ # des catalogues développeurs sont effectivement présents : on crée cata_dev.py dans rep_goal
+ str = ''
+ str = str + texte_entete+'\n'
+ for file in l_cata_dev :
+ str = str + open(file,'r').read() +'\n'
+ open('cata_developpeur.py','w+').write(str)
+ os.chdir(cur_dir)
+ except:
+ traceback.print_exc()
+ print "Impossible de transférer les fichiers requis dans :",rep_goal
+
+def get_entete_cata(fic_cata):
+ """ Retrouve l'entete du catalogue """
+ l_lignes = open(fic_cata,'r').readlines()
+ txt = ''
+ flag = 0
+ for ligne in l_lignes :
+ if re.match("# debut entete",ligne) : flag = 1
+ if re.match("# fin entete",ligne) : break
+ if not flag : continue
+ txt = txt + ligne
+ return txt
+
""" Permet de sauvegarder le texte dans un fichier dont on a demandé le nom
à l'utilisateur """
file = asksaveasfilename(defaultextension = '.comm',
- initialdir = self.appli.CONFIGURATION.rep_user,
+ #initialdir = self.appli.CONFIGURATION.rep_user,
+ initialdir = self.appli.CONFIGURATION.initialdir,
title="Sauvegarde du "+self.titre)
if file != '':
if not save_in_file(file,self.texte) :
def verif_existence_sd(self):
pass
+ def get_fr(self):
+ """
+ Retourne le commentaire lui meme
+ """
+ return self.valeur
+
def isoblig(self):
return self.definition.statut=='o'
+ def get_fr(self):
+ """
+ Retourne le texte d'aide dans la langue choisie
+ """
+ try :
+ return getattr(self.definition,prefs.lang)
+ except:
+ return ''
+
def ident(self):
return self.nom
- def get_fr(self):
- """
- Retourne l'attribut fr de self.definition
- """
- try:
- return self.definition.fr
- except:
- return ''
-
def get_sdname(self):
if CONTEXT.debug : print "SDNAME ",self.reuse,self.sd,self.sd.get_name()
if self.reuse != None:
if len(nom) > 8 and self.jdc.definition.code == 'ASTER':
return 0,"Nom de concept trop long (maxi 8 caractères)"
self.init_modif()
- # Cas particulier des opérateurs réentrants
if not self.isvalid(sd='non') : return 0,"Nommage du concept refusé : l'opérateur n'est pas valide"
+ #
+ # Cas particulier des opérateurs obligatoirement réentrants
+ #
if self.definition.reentrant == 'o':
# FR : appel à get_sdprod incorrect : il faut appeler get_sd_avant_etape
#self.sd = self.reuse = self.jdc.get_sdprod(nom)
self.sd = self.reuse = self.jdc.get_sd_avant_etape(nom,self)
if self.sd != None :
+ self.sdnom=self.sd.nom
return 1,"Concept existant"
else:
return 0,"Opérateur réentrant mais concept non existant"
+ #
+ # Cas particulier des opérateurs facultativement réentrants
+ #
+ old_reuse=None
if self.definition.reentrant == 'f' :
sd = self.jdc.get_sd_avant_etape(nom,self)
if sd != None :
# FR : il faut tester que la sd trouvée est du bon type !!!!!!!!!!!!!!!!!
if isinstance(sd,self.get_type_produit()) :
self.sd = self.reuse = sd
+ self.sdnom = sd.nom
return 1,"Opérateur facultativement réentrant et concept existant trouvé"
else:
return 0,"Concept déjà existant et de mauvais type"
else :
- # il faut éventuellement enlever le lien vers une SD existante car si on passe ici
+ # il faut enlever le lien vers une SD existante car si on passe ici
# cela signifie que l'opérateur n'est pas utilisé en mode réentrant.
- # Si on ne fait pas cela, le nom de l'opérateur réutilisé est aussi modifié
- # et on ne peut plus modifier la SD de l'opérateur
+ # Si on ne fait pas cela, on risque de modifier une SD produite par un autre opérateur
if self.reuse :
- self.sd = self.reuse = None
- # l'opérateur n'est pas réentrant ou facultativement reentrant mais pas dans ce cas
+ old_reuse=self.reuse
+ self.sd = self.reuse = self.sdnom = None
+ #
+ # On est dans le cas ou l'opérateur n'est pas réentrant ou est facultativement reentrant
+ # mais est utilisé en mode non réentrant
+ #
if self.sd == None :
if self.parent.get_sd_autour_etape(nom,self):
+ # Un concept de ce nom existe dans le voisinage de l'etape courante
# On force self.valid a 0 car l appel a isvalid precedent l a mis a 1
# mais ceci indique seulement une validité partielle
# isvalid ne devrait peut etre pas mettre l attribut valid à 1 si sd == 'non'
self.valid=0
- return 0,"Nommage du concept refuse : un concept de meme nom existe deja"
- # Il n'existe pas de sd de nom sdnom. On peut donc créer le concept retourné.
- # Il est créé sans nom mais enregistré dans la liste des concepts existants
- self.get_sd_prod()
- self.sd.nom = nom
- return 1,"Nommage du concept effectué"
- else :
- old_nom=self.sd.nom
- if string.find(old_nom,'sansnom') :
- # Dans le cas où old_nom == sansnom, isvalid retourne 0 alors que ...
- # par contre si le concept existe et qu'il s'appelle sansnom c'est que l'étape est valide
- # on peut donc le nommer sans test préalable
- self.sd.nom=nom
- return 1,"Nommage du concept effectué"
- if self.isvalid() :
- # Normalement l appel de isvalid a mis a jour le concept produit (son type)
- # Il suffit de spécifier l attribut nom de sd pour le nommer si le nom n est pas
- # deja attribué
- if self.parent.get_sd_autour_etape(nom,self):
+ # On retablit l'ancien concept reentrant s'il existait
+ if old_reuse:
+ self.sd=self.reuse=old_reuse
+ self.sdnom=old_reuse.nom
return 0,"Nommage du concept refuse : un concept de meme nom existe deja"
else:
- self.sd.nom=nom
+ # Il n'existe pas de concept de ce nom dans le voisinage de l'etape courante
+ # On peut donc créer le concept retourné.
+ # Il est créé sans nom mais enregistré dans la liste des concepts existants
+ self.get_sd_prod()
+ # Il suffit de changer son attribut nom pour le nommer
+ self.sd.nom = nom
+ self.sdnom=nom
return 1,"Nommage du concept effectué"
- else:
- # Normalement on ne devrait pas passer ici
- return 0,'Normalement on ne devrait pas passer ici'
+ else :
+ old_nom=self.sd.nom
+ if string.find(old_nom,'sansnom') :
+ # Dans le cas où old_nom == sansnom, isvalid retourne 0 alors que ...
+ # par contre si le concept existe et qu'il s'appelle sansnom c'est que l'étape est valide
+ # on peut donc le nommer sans test préalable
+ self.sd.nom=nom
+ self.sdnom=nom
+ return 1,"Nommage du concept effectué"
+ if self.isvalid() :
+ # Normalement l appel de isvalid a mis a jour le concept produit (son type)
+ # Il suffit de spécifier l attribut nom de sd pour le nommer si le nom n est pas
+ # deja attribué
+ if self.parent.get_sd_autour_etape(nom,self):
+ return 0,"Nommage du concept refuse : un concept de meme nom existe deja"
+ else:
+ self.sd.nom=nom
+ self.sdnom=nom
+ return 1,"Nommage du concept effectué"
+ else:
+ # Normalement on ne devrait pas passer ici
+ return 0,'Normalement on ne devrait pas passer ici'
def get_sdprods(self,nom_sd):
"""
liste_retraits = []
dict = self.cree_dict_valeurs(self.mc_liste)
for k,v in self.definition.entites.items():
- #dict = self.cree_dict_valeurs(self.mc_liste)
if v.label=='BLOC' :
- if v.verif_presence(dict) :
+ globs= self.jdc and self.jdc.condition_context or {}
+ if v.verif_presence(dict,globs):
# le bloc doit être présent
if not self.get_child(k,restreint = 'oui'):
# le bloc n'est pas présent et il doit être créé
l.extend(motcle.get_sd_utilisees())
return l
+ def get_fr(self):
+ """
+ Retourne la chaine d'aide contenue dans le catalogue
+ en tenant compte de la langue
+ """
+ try :
+ return self.data[0].get_fr()
+ except:
+ return ''
+
if self.valeur == None :
return None
elif type(self.valeur) == types.FloatType :
- txt = repr_float(self.valeur)
+ #txt = repr_float(self.valeur)
+ # Normalement str fait un travail correct
+ txt = str(self.valeur)
elif type(self.valeur) in (types.ListType,types.TupleType) :
txt='('
i=0
for val in self.valeur:
if type(val) == types.FloatType :
- txt=txt + i*',' + repr_float(val)
+ # Normalement str fait un travail correct
+ #txt=txt + i*',' + repr_float(val)
+ txt=txt + i*',' + str(val)
elif type(val) == types.InstanceType and isinstance(val,ASSD):
txt = txt + i*',' + val.get_name()
else:
if isinstance(txt,parametre.PARAMETRE):
return str(txt)
return repr(txt)
- # il faut tronquer txt au delà d'un certain nombre de caractères
- # et avant tout retour chariot (txt peut être une chaîne de caractères
+ # txt peut etre une longue chaine sur plusieurs lignes.
+ # Il est possible de tronquer cette chaine au premier \n et
+ # de limiter la longueur de la chaine a 30 caracteres. Cependant
+ # ceci provoque une perte d'information pour l'utilisateur
+ # Pour le moment on retourne la chaine telle que
+ return txt
+
+ # Partie de code inaccessible (pour memoire)
+ # txt est tronquee au dela d'un certain nombre de caractères
+ # et avant tout retour chariot (txt peut etre une chaine de caractères
# sur plusieurs lignes (ex:shell)
txt = string.split(txt,'\n')[0]
if len(txt) < 30 :
"""
import string
+import prefs
import Noyau
class OBJECT:
self.parent=parent
self.jdc=parent.jdc
+ def get_fr(self):
+ """
+ Retourne la chaine d'aide contenue dans le catalogue
+ en tenant compte de la langue
+ """
+ try :
+ return getattr(self.definition,prefs.lang)
+ except:
+ return ''
+
