def getMcPresents(self):
""" Retourne le dictionnaire des mots-cles presents de l'objet pointe par self """
- return self.object.dict_mc_presents()
+ return self.object.dictMcPresents()
def verifConditionRegles(self,l_mc_presents):
return self.object.verifConditionRegles(l_mc_presents)
return d.get(nom_sd,None)
return None
- def getContexteJdc(self,fichier,text):
+ def getContexteJdc(self,fichier,text,doitEtreValide=1):
"""
Interprete text comme un texte de jdc et retourne le contexte final.
#print ("getContexteJdc",self,self.nom)
# On recupere l'etape courante
step=CONTEXT.getCurrentStep()
- try:
- #if 1 :
+ #try:
+ if 1 :
# on essaie de creer un objet JDC auxiliaire avec un contexte initial
# Attention getContexteAvant retourne un dictionnaire qui contient
# le contexte courant. Ce dictionnaire est reactualise regulierement.
# Si on veut garder l'etat du contexte fige, il faut en faire une copie.
context_ini = self.parent.getContexteAvant(self).copy()
- #print "getContexteJdc",context_ini.keys()
+ print ("getContexteJdc",context_ini.keys())
# Indispensable avant de creer un nouveau JDC
CONTEXT.unsetCurrentStep()
self.jdc_aux=j
self.jdc.jdcDict=self.jdc_aux
- except:
- #else :
+ #except:
+ else :
traceback.print_exc()
# On retablit l'etape courante step
CONTEXT.unsetCurrentStep()
CONTEXT.setCurrentStep(step)
return None
- if not j.cr.estvide():
+
+ if not j.cr.estvide() and doitEtreValide:
# Erreurs dans l'INCLUDE. On garde la memoire du fichier
# mais on n'insere pas les concepts
# On retablit l'etape courante step
- #print j.cr
- #print j.isValid()
+ print (j.cr)
+ print ("valid ",j.isValid())
CONTEXT.unsetCurrentStep()
CONTEXT.setCurrentStep(step)
raise EficasException(tr("Impossible de relire le fichier %s \n ")+ six.text_type(j.cr))
- if not j.isValid():
+ if not j.isValid() and doitEtreValide:
# L'INCLUDE n'est pas valide.
# on produit un rapport d'erreurs
cr=j.report()
+ print ('cr', cr)
# On retablit l'etape courante step
CONTEXT.unsetCurrentStep()
CONTEXT.setCurrentStep(step)
# Si aucune erreur rencontree
+ # ou qu on accepte un jdc incomplet
# On recupere le contexte de l'include verifie
try:
j_context=j.getVerifContexte()
- def buildIncludeEtape(self,text):
+ def buildIncludeEtape(self,text,doitEtreValide):
import Extensions.jdc_include
self.JdC_aux=Extensions.jdc_include.JdC_include
# un include partage la table des unites avec son parent (jdc)
# Attention fonctionne pour import_Zone de MT
# a adapter eventuellement
try :
- contexte = self.getContexteJdc(None,text)
+ contexte = self.getContexteJdc(None,text,doitEtreValide)
except EficasException:
return 0
index=index+1
return index
- def ordonneListeMc(self,liste_mc_a_ordonner,liste_noms_mc_ordonnee):
+ def ordonneListeMc(self,listeMc_a_ordonner,liste_noms_mc_ordonnee):
"""
- Retourne liste_mc_a_ordonner ordonnee suivant l'ordre
+ Retourne listeMc_a_ordonner ordonnee suivant l'ordre
donne par liste_noms_mc_ordonnee
"""
liste = []
# on transforme liste_a_ordonner en un dictionnaire (plus facile a consulter)
d_mc = {}
- for mc in liste_mc_a_ordonner:
+ for mc in listeMc_a_ordonner:
d_mc[mc.nom]=mc
# on construit la liste des objets ordonnes
for nom_mc in liste_noms_mc_ordonnee:
def informe(self,titre,txt,critique=True):
#--------------------------------#
if critique :
- self.affiche_infos(tr(txt),Qt.red)
+ self.afficheInfos(tr(txt),Qt.red)
QMessageBox.critical( self, tr(titre), tr(txt))
else :
QMessageBox.warning( self, tr(titre),tr(txt))
# ajoute une etape de JdC a partir d un texte
monItem=itemApres
etape=monItem.item.object
+
CONTEXT.setCurrentStep(etape)
try :
ok=etape.buildIncludeEtape(texte)
self.tree.racine.buildChildren()
return ok
+ #-------------------------------------------#
+ def updateJdcAfterEtape(self, etape,texte):
+ #--------------------------------------------#
+ # ajoute une etape de JdC a partir d un texte
+ CONTEXT.setCurrentStep(etape)
+ try :
+ ok=etape.buildIncludeEtape(texte,doitEtreValide=0)
+ except :
+ ok=0
+ if not ok :
+ QMessageBox.information( self,
+ tr("Import texte"),
+ tr("Impossible d importer le texte"))
+ self.tree.racine.buildChildren()
+ return ok
#-------------------------------------#
self.widgetTree.show()
#self.restoreSplitterSizes(3)
+ #-----------------------
+ def getEtapeCourante(self) :
+ #-----------------------
+ print (self.tree.selectedItems())
+ if len(self.tree.selectedItems()) != 1 : return None
+ etape=self.tree.selectedItems()[0].item.object.getEtape()
+ return etape
#-----------------------------
def getTreeIndex(self,noeud):
#----------------------------
self.editor.ajoutOptionnel()
self.editor.inhibeSplitter=0
self.afficheOptionnel()
- spacerItem = QSpacerItem(21, 20, QSizePolicy.MinimumExpanding, QSizePolicy.MinimumExpanding)
- self.commandesLayout.addItem(spacerItem)
+ spacerItem = QSpacerItem(21, 20, QSizePolicy.Expanding, QSizePolicy.Expanding)
+ #spacerItem = QSpacerItem(21, 20, QSizePolicy.Preferred, QSizePolicy.Preferred)
+ #self.commandesLayout.addItem(spacerItem)
+ self.verticalLayoutCommande.addItem(spacerItem)
#self.editor.restoreSplitterSizes()
if len(listeComplete) > max :
texte=tr("Nombre maximum de valeurs ")+str(max)+tr(" atteint")
- self.editor.affiche_infos(texte,Qt.red)
+ self.editor.afficheInfos(texte,Qt.red)
return
validite,comm,comm2,listeRetour= self.politique.ajoutNTuple(listeComplete)
if self.code.upper() in Appli.__dict__:
Appli.__dict__[self.code.upper()](self,)
if self.suiteTelemac : self.lookSuiteTelemac()
+ self.metMenuAJourUtilisateurs()
def initAides(self):
#print "je passe la"
self.actionSortieLegere.triggered.connect(self.handleSortieLegere)
+ def MT(self):
+ self.enlevernewInclude()
+ self.toolBar.addSeparator()
+
+
def ZCRACKS(self):
self.enlevernewInclude()
self.toolBar.addSeparator()
def handleAjoutEtape(self,nomEtape):
self.viewmanager.handleAjoutEtape(nomEtape)
+ def metMenuAJourUtilisateurs(self):
+ self.lesFonctionsUtilisateurs={}
+ if self.code not in self.mesScripts : return
+ if not hasattr(self.mesScripts[self.code],'dict_menu') : return
+ titre,lesFonctions=self.mesScripts[self.code].dict_menu.items()[0]
+ self.menuOptions = self.menubar.addMenu("menuOptions")
+ self.menuOptions.setTitle(tr(titre))
+ for elt in lesFonctions :
+ laFonctionUtilisateur, label, lesArguments = elt
+ action = QAction(self)
+ action.setText(label)
+ #action.triggered.connect(self.appelleFonctionUtilisateur)
+ self.menuOptions.addAction(action)
+ self.lesFonctionsUtilisateurs[action]=(laFonctionUtilisateur, lesArguments)
+ self.menuOptions.triggered.connect(self.handleFonctionUtilisateur)
+
+ def handleFonctionUtilisateur(self,action) :
+ (laFonctionUtilisateur, lesArguments)=self.lesFonctionsUtilisateurs[action]
+ self.viewmanager.handleFonctionUtilisateur(laFonctionUtilisateur, lesArguments)
if __name__=='__main__':
def ajoutScript(self):
# cochon mais je n arrive pas a faire mieux avec le mecanisme de plugin
+ # a revoir avec un menu et un connect sur le triggered sur le menu ?
if hasattr(self.appliEficas, 'mesScripts'):
if self.editor.code in self.editor.appliEficas.mesScripts :
self.dict_commandes_mesScripts=self.appliEficas.mesScripts[self.editor.code].dict_commandes
if index < 0 : return
editor=self.dict_editors[index]
editor.handleAjoutGroup(listeGroup)
+
+ def handleFonctionUtilisateur(self,laFonctionUtilisateur, lesArguments):
+ # Peut-etre a blinder un peu plus sur le nb d argument
+ index=self.myQtab.currentIndex()
+ if index < 0 : return
+ editor=self.dict_editors[index]
+ if editor.getEtapeCourante == None :
+ QMessageBox.information( self,
+ tr("Selectionner une etape"),
+ tr("Le texte sera inséré après l étape selectionnée"))
+
+ listeParam = []
+ for p in lesArguments:
+ print (p)
+ if hasattr(editor,p): listeParam.append(getattr(editor,p))
+ if p=="editor" : listeParam.append(editor)
+ if p=="etapeCourante" : listeParam.append(editor.getEtapeCourante())
+ apply(laFonctionUtilisateur,listeParam)
+
Cette fonction recherche dans la pile des appels, l'appel à la commande
qui doit etre situé à 2 niveaux au-dessus (cur_frame(2)).
On retrouve d'abord la frame d'exécution f. Puis le numéro de la ligne
- dans le source f.fLineNo et le nom du fichier source (f.f_code.co_filename).
+ dans le source f.f_lineno et le nom du fichier source (f.f_code.co_filename).
A partir de là, on récupère la ligne de source avec linecache.getline
et on vérifie que cette ligne correspond véritablement à l'appel.
"""
f = N_utils.cur_frame(level)
- lineno = f.fLineNo # XXX Too bad if -O is used
- # lineno = fLineNo(f) # Ne marche pas toujours
+ lineno = f.f_lineno # XXX Too bad if -O is used
+ # lineno = f_lineno(f) # Ne marche pas toujours
co = f.f_code
filename = six.text_type(co.co_filename, getEncoding())
name = co.co_name
return lll
-def fLineNo(f):
+def f_lineno(f):
"""
Calcule le numero de ligne courant
Devrait marcher meme avec -O
"""
c = f.f_code
if not hasattr(c, 'co_lnotab'):
- return f.fLineNo
+ return f.f_lineno
tab = c.co_lnotab
line = c.co_firstlineno
stopat = f.f_lasti
