# -----------------------------
class ReaderCataCommun(object):
# -----------------------------
+# le catacommun a ete mis en place
+# lors des tentatives pour decrire le catalogue en XML
+# Garde pour pouvoir demander un cata en web
+# mais il va falloir revoir quelle fonction est ou (exple askChoixCata est mal place)
+# en tenant compte de cette nouvelle division
def askChoixCatalogue(self, cataListeChoix):
#____________________________________________
def _div(a, b):
- import six
import types
- if isinstance(a, six.integer_types) and isinstance(b, six.integer_types):
+ if isinstance(a, str) and isinstance(b, int):
if a % b:
return a / b
else:
s = s + "".join(self.crexception_belle)
for subcr in self.subcr:
if self.verbeux == "oui":
- s = s + six.text_type(subcr) + "\n"
+ s = s + str.text_type(subcr) + "\n"
else:
if not subcr.estvide():
- s = s + six.text_type(subcr)
+ s = s + str(subcr)
if s != "":
s = self.debut + "\n" + self.indent(s) + self.fin + "\n"
else:
from Accas.processing import P_CR
from Accas.processing import P_OPS
-import six
-
-stringTypes = (str, six.text_type)
+stringTypes = ((str,))
class ENTITE(object):
# Modules EFICAS
from .strfunc import getEncoding, toUnicode
-import six
-
class AsException(Exception):
def __unicode__(self):
args = []
for x in self.args:
ustr = toUnicode(x)
- if type(ustr) is not six.text_type:
- ustr = six.text_type(repr(x))
+ if type(ustr) is not (str,):
+ ustr = str(repr(x))
args.append(ustr)
return " ".join(args)
def __str__(self):
- return six.text_type(self).encode(getEncoding())
+ return self.encode(getEncoding())
class InterruptParsingError(Exception):
return valeur
def verifItem(self, valeur):
- if type(valeur) not in six.integer_types:
+ if type(valeur) not in (int,):
return 0
return valeur % 2 == 0
return valeur
-# MC ca ne devrait plus servir !
-# PN : commenter le 22.11.19
-# CoercableFuncs = {int: int,
-# int: int,
-# float: float,
-# complex: complex,
-# str: six.text_type}
-
-
class TypeVal(ListVal):
"""
def isStr(obj):
- import six
-
- return isinstance(obj, (str, six.text_type))
-
+ return isinstance(obj, str)
def isList(obj):
return type(obj) is list
if frame == None:
return 0, "inconnu", 0, {}
try:
- # Python 2.7 compile function does not accept unicode filename, so we encode it
- # with the current locale encoding in order to have a correct traceback.
- # Here, we convert it back to unicode.
- import six
-
- filename = six.text_type(frame.f_code.co_filename, getEncoding())
+ filename = str(frame.f_code.co_filename, getEncoding())
return frame.fLineNo, filename, frame.f_code.co_firstlineno, frame.f_locals
except:
return 0, "inconnu", 0, {}
if sys.version_info >= (3, 0):
filename = co.co_filename
else:
- import six
-
- filename = six.text_type(co.co_filename, getEncoding())
+ filename = co.co_filename.encode(getEncoding())
name = co.co_name
# pattern pour identifier le debut de la commande
pattern_oper = re.compile(regex1 % ope)
import locale
-import six
_encoding = None
def toUnicode(string):
"""Try to convert string into a unicode string."""
- if type(string) is six.text_type:
+ if type(string) in (str,) :
return string
elif type(string) is dict:
new = {}
assert type(string) is str, "unsupported object: %s" % string
for encoding in ("utf-8", "iso-8859-15", "cp1252"):
try:
- s = six.text_type(string, encoding)
+ s = string.encode(encoding)
return s
except UnicodeDecodeError:
- pass
- return six.text_type(string, "utf-8", "replace")
+ return string
dico = self.myWriter.generDico(self.jdc)
return dico
- # -----------------------#
- def viewJdcSource(self):
- # -----------------------#
- if self.fichier == None:
- return
+ # --------------------------#
+ def getJdcFichierSource(self):
+ # --------------------------#
+ if self.fichier == None: return "fichier source non defini"
if os.path.isfile(self.fichier):
f = open(self.fichier, "r")
texteSource = f.read()
f.close()
- self._viewText(texteSource, "JDC_SOURCE")
+ return texteSource
else:
+ return "le fichier source n existe pas"
self._viewText("file doesn't exist", "JDC_SOURCE")
- # -----------------------#
- def viewJdcPy(self):
- # -----------------------#
- strSource = str(self.getTextJDC(self.formatFichierOut))
- self._viewText(strSource, "JDC_RESULTAT")
+ # -----------------------------#
+ def getJdcFichierResultat(self):
+ # -----------------------------#
+ strResult = str(self.getTextJDC(self.formatFichierOut))
+ return strResult
# -----------------------#
- def viewJdcRapport(self):
+ def getJdcRapport(self):
# -----------------------#
# on ajoute les regles
strRapport = str(self.jdc.report())
- self._viewText(strRapport, "JDC_RAPPORT")
-
- # -----------------------#
- def viewJdcRegles(self):
- # -----------------------#
- # on ajoute les regles
- texte_global, test_global = self.jdc.verifRegles()
- self._viewText(texte_global, "JDC_REGLES")
+ return strRapport
# -----------------------#
- def getJdcRapport(self):
+ def getJdcRegles(self):
# -----------------------#
# on ajoute les regles
- strRapport = str(self.jdc.report())
- return strRapport
+ texteGlobal, testOK = self.jdc.verifRegles()
+ return texteGglobal
# ---------------------#
def getFileName(self):
#
import os
+from uuid import uuid1
# --------------------------
class EditorManager(object):
permettent de gerer plusieurs ouvertures de fichiers simultannees en IHM
utilisee sans etre derivee pour le dumpXSD ou les transformations
"""
- counter = 0
# remplace par l index du viewManager
# --------------------------------
self.appliEficas.afficheMessage('Eficas sans Ihm', 'impossible d allouer un editor')
return None
self.editors.append(editor)
- self.dictEditors[EditorManager.counter] = editor
- EditorManager.counter += 1
+ idEditor = uuid1().hex
+ self.dictEditors[idEditor] = editor
+ editor.idEditor = idEditor
return editor
+ # ------------------------
+ def getEditorById(self,id):
+ # ------------------------
+ if id in self.dictEditors:
+ editor = self.dictEditors[indexEditor]
+ return editor
+ return None
+
+ # --------------------------------
+ def setCurrentEditorById(self,id):
+ # --------------------------------
+ print ('a Programmer')
+ return True
+
+
# -------------------------
def samePath(self, f1, f2):
# --------------------------
Class implementing the main user interface.
"""
- def __init__(self, code=None, versionCode=None, salome=1, multi=False, langue="fr", ssCode=None, fichierCata=None, GUIPath=None):
- #--------------------------------------------------------------------------------------------------------------------------------
+ #---------------------------------------------------------------------------------------------------------------------------------------------
+ def __init__(self, code=None, versionCode=None, salome=1, multi=False, langue="fr", ssCode=None, fichierCata=None, GUIPath=None, appWeb=None):
+ #---------------------------------------------------------------------------------------------------------------------------------------------
"""
Constructor d appli eficas. classe mere de appli-qtEficas et de appli-web eficas et utilisee sans IHM pour les
transformations des catas en XSD, des comm en XML et de validation des donnees
self.ssCode = ssCode
self.multi = multi
self.salome = salome
+ self.appWeb = appWeb
version = getEficasVersion()
self.versionEficas = "Eficas Salome " + version
self.genereXSD = False
from Editeur.editor_manager import EditorManager
self.editorManager = EditorManager(self)
+ # Attention n appelle pas openFiles car les classes derivees
+ # changent l editorManager
- def ajoutUQ(self):
- #-----------------
- self.withUQ = True
- self.formatFichierIn = "pythonUQ" # par defaut
+ #--------------------
+ def getVersion(self):
+ #--------------------
+ return getEficasVersion()
+ #-----------------------------------
def definitCode(self, code, ssCode):
#-----------------------------------
# ssCode sert pour Map
if hasattr(self, "maConfiguration") and self.maConfiguration.translatorFile:
from Accas.extensions import localisation
localisation.localise( None, self.langue,
- translatorFile=self.maConfiguration.translatorFile,
- )
+ translatorFile=self.maConfiguration.translatorFile,)
# Comment faire si Multi ?
self.withXSD = session.d_env.withXSD
+ #-------------------------
def getSource(self, file):
#-------------------------
# appele par Editeur/session.py
texte = p.convert("execnoparseur")
return texte
- def initEditor(self, fichier=None, jdc=None, units=None, include=0):
#------------------------------------------------------------------
+ def newEditor(self, fichier=None, jdc=None, units=None, include=0):
+ #------------------------------------------------------------------
+ #PN reflechir a ce que cela veut dire d avoir plusieurs editeurs
if (hasattr(self, "editor")) and self.editor != None:
print("un seul editeur par application eficas_appli ")
sys.exit()
self.editor = self.editorManager.getNewEditor()
+ return self.editorId
- def fileNew(self):
- #-----------------
- self.editor = self.initEditor()
-
+ #-------------------
def getEditor(self):
#-------------------
- if (hasattr(self, "editor")) and self.editor != None:
- return self.editor
- self.initEditor()
+ if (hasattr(self, "editor")) and self.editor != None: return self.editor
+ self.newEditor()
return self.editor
- def fileOpen(self, fichier):
+ #--------------------------
+ def getEditorById(self,id):
+ #--------------------------
+ return self.editorManager.getEditorById(self,id)
+
+ #----------------------------------
+ def setCurrentEditorById(self,id):
+ #----------------------------------
+ return self.editorManager.setCurrentEditorById(self,id)
+
+ #---------------------------
+ def openFile(self, fichier):
#---------------------------
- fichierIn = os.path.abspath(fichier)
try:
- monEditor = self.editorManager.handleOpen(fichierIn)
+ monEditor = self.editorManager.openFile(fichier)
except EficasException as exc:
- print("poum")
+ afficheMessage(self, 'erreur ouverture fichier', str(exc),critical=True)
monEditor = None
return monEditor
+ #------------------
def fileSave(self):
#-------------------
- if self.editor == None:
- return False
- ok, newName = editor.saveFileAs()
- print("ok, newName ", ok, newName)
+ return self.editorManager.saveFile()
+ #------------------------------
def fileSaveAs(self, fileName):
- #-----------------_------------
+ #------------------------------
+ return self.editorManager.saveFile()
if self.editor == None:
return False
ok = editor.saveFileAs()
print("ok ", ok)
+ #-----------------------------------------
def dumpXsd(self, avecEltAbstrait=False):
#-----------------------------------------
currentCata = CONTEXT.getCurrentCata()
texteXSD = currentCata.dumpXsd(avecEltAbstrait)
return texteXSD
+ #---------------------------------------------------
def afficheMessage(self, titre, texte,critical=True):
- #-----------------------------------------------------
+ #----------------------------------------------------
print ('__________________________')
print (tr(titre))
print ('')
print ('__________________________')
+ #-------------------
+ def saveUQFile(self):
+ #-------------------
+ self.editorManager.saveUQFile()
+
+ #----------------------
+ def exeUQScript(self):
+ #----------------------
+ self.editorManager.exeUQScript()
+
+ #----------------------
+ def savePersalys(self):
+ #----------------------
+ self.editorManager.savePersalys()
+
+ #----------------------
+ def ajoutCommentaire(self):
+ #----------------------
+ self.editorManager.ajoutCommentaire()
+
+ #----------------------
+ def openFiles(self):
+ #----------------------
+ # Ouverture des fichiers de commandes donnes sur la ligne de commande
+ cwd = os.getcwd()
+ self.dir = cwd
+ for study in session.d_env.studies:
+ os.chdir(cwd)
+ d = session.getUnit(study, self)
+ self.editorManager.openFile(fichier=study["comm"], units=d)
+
+
+ #----------------------
+ def saveFullFile(self):
+ #----------------------
+ # Pour Telemac
+ return self.editorManager.saveCompleteCurrentEditor()
+
+ #-----------------
+ def fileNew(self):
+ #-------------------
+ try:
+ self.editorManager.newEditor()
+ except EficasException as exc:
+ msg = str(exc)
+ if msg != "":
+ QMessageBox.warning(self, tr("Erreur"), msg)
+
+
+ #------------------------------
+ def fileSaveInLigneFormat(self):
+ #------------------------------
+ return self.editorManager.fileSaveInLigneFormat()
+
+ #------------------
+ def fileSave(self):
+ #------------------
+ return self.editorManager.handleSave()
+
+ #--------------------
+ def fileSaveAs(self):
+ #--------------------
+ return self.editorManager.handleSaveAs()
+
+ #-------------------
+ def fileClose(self):
+ #-------------------
+ return self.editorManager.fileClose()
+
+ #-------------------
+ def closeAllFiles(self):
+ #-------------------
+ self.editorManager.closeAllFiles()
+
+ #------------
+ def run(self):
+ #-------------
+ self.editorManager.run()
+
+ #----------------
+ def saveRun(self):
+ #----------------
+ self.editorManager.saveRun()
+
+ #--------------------------
+ def getJdcFichierSource(self):
+ #--------------------------
+ return self.editorManager.getJdcFichierSource()
+
+ #-----------------------
+ def getJdcRapport(self):
+ #-----------------------
+ return self.editorManager.getJdcRapport()
+
+ #-----------------------
+ def getJjdcRegles(self):
+ #-----------------------
+ return self.editorManager.JdcRegles()
+
+ #------------------------------
+ def getJdcFichierResultat(self):
+ #------------------------------
+ self.editorManager.getJdcFichierResultat()
+
+ #------------------------------------
+ def handleAjoutEtape(self, nomEtape):
+ #------------------------------------
+ self.editorManager.handleAjoutEtape(nomEtape)
+
+ #----------------
+ def ajoutUQ(self):
+ #----------------
+ self.withUQ = True
+ self.formatFichierIn = "pythonUQ" # par defaut
+
+
if __name__ == "__main__":
# Modules Eficas
pass
sys.exit(res)
-def getEficas( code=None, multi=False, langue="en", forceXML=False, fichierCata=None,GUIPath=None):
+def getEficas( code=None, multi=False, langue="en", forceXML=False, fichierCata=None,GUIPath=None, appWeb = None):
# ------------------------------------------------------------------------------------------------------------------
"""
instancie l'appli EFICAS sans Ihm
print ('lancement de Eficas avec GUIPath = {}'.format(GUIPath))
from Editeur.eficas_appli import EficasAppli
- Eficas = EficasAppli(code=code, multi=multi, langue=langue, ssCode=ssCode, versionCode=versionCode, fichierCata=fichierCata, GUIPath=GUIPath)
+ Eficas = EficasAppli(code=code, multi=multi, langue=langue, ssCode=ssCode, versionCode=versionCode, fichierCata=fichierCata, GUIPath=GUIPath, appWeb=None)
return Eficas
if self.maConfiguration.closeArbre: self.fermeArbre()
if self.maConfiguration.closeOptionnel: self.fermeOptionnel()
- if self.maConfiguration.boutonDsMenuBar:
- self.appliEficas.remplitIconesCommandes()
+ if self.maConfiguration.boutonDsMenuBar: self.appliEficas.remplitIconesCommandes()
self.formatFichierOut = self.appliEficas.formatFichierOut
self.formatFichierIn = self.appliEficas.formatFichierIn
self.node_selected[0].deleteMultiple(self.node_selected)
# ------------------------#
- def handleRechercher(self):
+ def rechercherConceptOuMotClef(self):
# ------------------------#
from InterfaceGUI.QT5.monRecherche import DRecherche
monRechercheDialg = DRecherche(parent=self, fl=0)
monRechercheDialg.show()
# -----------------------------------#
- def handleRechercherDsCatalogue(self):
+ def rechercherMotClefDsCatalogue(self):
# -----------------------------------#
from InterfaceGUI.QT5.monRechercheCatalogue import DRechercheCatalogue
monRechercheDialg.show()
# ---------------------#
- def handleDeplier(self):
+ def deplier(self):
# ---------------------#
if self.tree == None:
return
# -----------------------------------------#
- def handleAjoutGroup(self, listeGroup):
+ def ajoutGroupe(self, listeGroup):
# -----------------------------------------#
try:
# if 1:
- from InterfaceGUI.QT5.ajoutGroupe import handleAjoutGroupFiltre
+ from InterfaceGUI.QT5.ajoutGroupe import ajoutGroupeFiltre
# print listeGroup
- handleAjoutGroupFiltre(self, listeGroup)
- # print "apres handleAjoutGroupFiltre"
+ ajoutGroupeFiltre(self, listeGroup)
+ # print "apres ajoutGroupeFiltre"
except:
# else :
pass
pass
return indexNoeud
+ # ----------------------------#
+ def viewJdcFichierSource(self):
+ # ----------------------------#
+ strSource = self.getJdcFichierSource()
+ self._viewText(strSource, "JDC Source")
+
+ # ----------------------------#
+ def viewJdcFichierResultat(self):
+ # ----------------------------#
+ strResultat = self.getJdcFichierResultat()
+ self._viewText(strResultat, "JDC Resultat")
+ # -----------------------#
+ def viewJdcRegles(self):
+ # -----------------------#
+ strRegle = self.getJdcRegles()
+ self._viewText(strRegle, "Regles du JDC")
+
+ # ----------------------------#
+ def viewJdcRapport(self):
+ # ----------------------------#
+ strRapport = self.getJdcRapport()
+ self._viewText(strRappoer, "Rapport Validation du JDC")
+
# ------------------#
def _newJDCCND(self):
# ------------------#
""" obsolete """
- # allait chercher les groupes moed. gardé pour l exemple
+ # allait chercher les groupes med. gardé pour l exemple
extensions = tr("Fichiers Med (*.med);;" "Tous les Fichiers (*)")
QMessageBox.information(
self, tr("Fichier Med"), tr("Veuillez selectionner un fichier Med")
def indexChanged(self):
#----------------------
index = self.myQtab.currentIndex()
- EditorManager.indexChanged(self,index)
-
- #----------------------------------------------
- def handleOpen(self, fichier=None, units=None):
- #----------------------------------------------
+ if index in self.dictEditors:
+ editor = self.dictEditors[index]
+ if editor.jdc != None:
+ CONTEXT.unsetCurrentJdC()
+ CONTEXT.setCurrentJdC(editor.jdc)
+ self.appliEficas.maConfiguration = editor.maConfiguration
+ self.appliEficas.code = editor.maConfiguration.code
+ self.appliEficas.setWindowTitle(editor.titre)
+ self.appliEficas.construitMenu()
+
+
+ #-------------------------------------------------------
+ def openFile(self, fichier=None, units=None, patron =0):
+ #-------------------------------------------------------
result = None
if self.appliEficas.code == None:
self.appliEficas.definitCode(None, None)
self.appliEficas.maConfiguration.saveDir,
extensions,)
fichier = fichier[0]
-
- if len(fichier) == 0: return None
+ if len(fichier) == 0: return None
fichier = os.path.abspath(fichier)
ulfile = os.path.abspath(fichier)
#--------------------------------
def closeTab(self, indexAFermer):
#--------------------------------
- self.handleClose(indexAFermer=indexAFermer)
+ self.fileClose(index=indexAFermer)
- #--------------------------------------------------------
- def handleClose(self, index = None, texte=tr("&Quitter")):
- #--------------------------------------------------------
- self.appliEficas.sauveRecents()
+ #-------------------------------
+ def fileClose(self, index=None):
+ #--------------------------------
+ self.appliEficas.saveListRecentlyOpen()
if not index : index = self.myQtab.currentIndex()
if index < 0: return
- res = self.checkDirty(self.dictEditors[index], texte)
+ res = self.checkDirty(self.dictEditors[index], tr("&Quitter"))
if res == 2: return 2 # l utilisateur a annule
idx = index
while idx < len(self.dictEditors) - 1:
editor.saveRun()
#---------------------------------------------
- def handleCloseAll(self, texte=tr("Quitter")):
+ def closeAllFiles(self, texte=tr("Quitter")):
#---------------------------------------------
res = 0
- self.appliEficas.sauveRecents()
+ self.appliEficas.saveListRecentlyOpen()
while len(self.dictEditors) > 0:
self.myQtab.setCurrentIndex(0)
- res = self.handleClose(0, texte)
+ res = self.fileClose(0)
if res == 2: return res # l utilsateur a annule
return res
#--------------------------
- def handleRechercher(self):
+ def rechercherConceptOuMotClef(self):
#--------------------------
- # print "passage dans handleRechercher"
+ # print "passage dans rechercherConceptOuMotClef"
index = self.myQtab.currentIndex()
if index < 0: return
editor = self.dictEditors[index]
- editor.handleRechercher()
+ editor.rechercherConceptOuMotClef()
#-------------------------------------
- def handleRechercherDsCatalogue(self):
+ def rechercherMotClefDsCatalogue(self):
#-------------------------------------
- # print "passage dans handleRechercher"
+ # print "passage dans rechercherConceptOuMotClef"
index = self.myQtab.currentIndex()
if index < 0:
return
editor = self.dictEditors[index]
- editor.handleRechercherDsCatalogue()
+ editor.rechercherMotClefDsCatalogue()
#-----------------------
- def handleDeplier(self):
+ def deplier(self):
#-----------------------
index = self.myQtab.currentIndex()
if index < 0: return
editor = self.dictEditors[index]
- editor.handleDeplier()
+ editor.deplier()
#------------------------
def handleEditCopy(self):
self.newEditor(include=1)
#------------------------------------
- def handleViewJdcFichierSource(self):
+ def viewJdcFichierSource(self):
#------------------------------------
index = self.myQtab.currentIndex()
if index < 0:
return
- self.dictEditors[index].viewJdcSource()
+ self.dictEditors[index].viewJdcFichierSource()
#--------------------
def ouvreArbre(self):
editor = self.dictEditors[index]
editor.ajoutCommentaire()
- #-----------------------------
- def handleViewJdcRegles(self):
- #-----------------------------
+ #----------------------
+ def viewJdcRegles(self):
+ #-----------------------
index = self.myQtab.currentIndex()
if index < 0: return
self.dictEditors[index].viewJdcRegles()
return
self.dictEditors[index].gestionParam()
- #------------------------------
- def handleViewJdcRapport(self):
- #------------------------------
+ #------------------------
+ def viewJdcRapport(self):
+ #-------------------------
index = self.myQtab.currentIndex()
if index < 0: return
self.dictEditors[index].viewJdcRapport()
#-------------------------
- def handleViewJdcPy(self):
+ def viewJdcPy(self):
#-------------------------
index = self.myQtab.currentIndex()
if index < 0:
return ok
#------------------------
- def handleSortieUQ(self):
+ def saveUQFile(self):
#------------------------
index = self.myQtab.currentIndex()
if index < 0:
return ok
#---------------------------------
- def handleSauvePourPersalys(self):
+ def savePersalys(self):
#---------------------------------
index = self.myQtab.currentIndex()
if index < 0:
return ok
#---------------------
- def handleExeUQ(self):
+ def exeUQScript(self):
#---------------------
index = self.myQtab.currentIndex()
if index < 0: return
return ok
#-------------------------
- def handleSaveLigne(self):
+ def fileSaveInLigneFormat(self):
#-------------------------
index = self.myQtab.currentIndex()
if index < 0: return
return ok
return res
- #---------------------------------------
- def handleAjoutGroup(self, listeGroup):
- #---------------------------------------
+ #---------------------------------
+ def ajoutGroupe(self, listeGroup):
+ #---------------------------------
index = self.myQtab.currentIndex()
if index < 0: return
editor = self.dictEditors[index]
- editor.handleAjoutGroup(listeGroup)
+ editor.ajoutGroupe(listeGroup)
#------------------------------------------------------------------------
def handleFonctionUtilisateur(self, laFonctionUtilisateur, lesArguments):
class QtEficasAppli(EficasAppli, Ui_Eficas, QMainWindow):
"""
Class implementing the main QT user interface.
+ contains mainly overloading with qt widgets
+ manages the main window and connect qt
"""
#----------------------------------------------------------------------------------------------------------------------------------------------
- def __init__(self, code=None, versionCode=None, salome=1, multi=False, langue="fr", ssCode=None, fichierCata=None, GUIPath="InterfaceGUI.QT5"):
+ def __init__(self, code=None, versionCode=None, salome=1, multi=False, langue="fr", ssCode=None, fichierCata=None, GUIPath="InterfaceGUI.QT5", appWeb = None):
#----------------------------------------------------------------------------------------------------------------------------------------------
"""
Constructor
QMainWindow.__init__(self)
Ui_Eficas.__init__(self)
self.setupUi(self)
-
- EficasAppli.__init__( self, code, versionCode, salome, multi, langue, ssCode, fichierCata, GUIPath)
- print (self.myQtab)
+ EficasAppli.__init__( self, code, versionCode, salome, multi, langue, ssCode, fichierCata, GUIPath, appWeb)
self.editorManager = QtEditorManager(self)
self.GUIPath = GUIPath
self.suiteTelemac = self.maConfiguration.suiteTelemac
-
self.multi = multi
if self.multi :
self.definitCode(code, None)
from Accas.extensions import localisation
localisation.localise(None, self.langue, translatorFile=self.maConfiguration.translatorFile,)
-
self.repIcon = os.path.join( os.path.dirname(os.path.abspath(__file__)),"..", "..", "Editeur", "icons")
- app = QApplication
if not self.salome:
self.resize(self.maConfiguration.taille, self.height())
if self.code != None: self.construitMenu()
self.setWindowTitle(self.versionEficas)
-
- try:
- # if 1 :
- # print ('attention try devient if 1')
- self.ouvreFichiers()
+ try :
+ #if 1 :
+ #print ('attention try devient if 1')
+ self.openFiles()
except EficasException as exc:
- # except:
- print("je suis dans le except du ouvreFichier")
- if self.salome == 0 : exit(1)
+ print ("je suis dans le except", exc)
+ if self.salome == 0 : exit()
+
+ #-------------------------
+ def openFileFromMenu(self):
+ #-------------------------
+ self.editorManager.openFile()
#--------------------
def closeEntete(self):
def construitMenu(self):
#-----------------------
self.initPatrons()
- self.initRecents()
+ self.readListRecentlyOpen()
self.initAides()
for intituleMenu in (
"menuTraduction",
tr("Sauvegarde des fichiers pour l'étude incertaine")
)
self.menuUQ.addAction(self.actionSaveUQ)
- self.actionSaveUQ.triggered.connect(self.handleSortieUQ)
+ self.actionSaveUQ.triggered.connect(self.saveUQFile)
self.actionExeUQ = QAction(self)
self.actionExeUQ.setText(tr("Sauvegarde et Lancement de l'étude"))
self.menuUQ.addAction(self.actionExeUQ)
- self.actionExeUQ.triggered.connect(self.handleExeUQ)
+ self.actionExeUQ.triggered.connect(self.exeUQScript)
self.actionSauvePersalys = QAction(self)
self.actionSauvePersalys.setText(tr("Sauvegarde du script Persalys"))
self.menuUQ.addAction(self.actionSauvePersalys)
- self.actionSauvePersalys.triggered.connect(self.handleSauvePourPersalys)
+ self.actionSauvePersalys.triggered.connect(self.savePersalys)
# self.actionEnregistrer.setDisabled(True)
# self.actionEnregistrer_sous.setDisabled(True)
#-------------------------------------
def connectRechercherDsCatalogue(self):
#------------------------------------
- if hasattr(self, "rechercherDejaLa"):
- return
+ if hasattr(self, "rechercherDejaLa"): return
self.rechercherDejaLa = True
- self.actionRechercherDsCatalogue.triggered.connect(
- self.handleRechercherDsCatalogue
- )
+ self.actionRechercherDsCatalogue.triggered.connect( self.rechercherDejaLaechercherMotClefDsCatalogue)
#-----------------------------
def ajoutSortieComplete(self):
self.menuFichier.insertAction(
self.actionEnregistrer_sous, self.actionSortieComplete
)
- self.actionSortieComplete.triggered.connect(self.handleSortieComplete)
-
+ self.actionSortieComplete.triggered.connect(self.saveFullFile)
+ #--------------
def ADAO(self):
+ #--------------
self.enleverActionsStructures()
self.enlevernewInclude()
-
+ #-----------------
def TELEMAC(self):
+ #-----------------
self.enleverActionsStructures()
self.enlevernewInclude()
self.connectRechercherDsCatalogue()
self.ajoutSortieComplete()
+ #-------------------------
def lookSuiteTelemac(self):
+ #-------------------------
self.enleverActionsStructures()
self.enlevernewInclude()
self.enleverParametres()
self.enleverSupprimer()
self.enleverRechercherDsCatalogue()
+ #------------------------
def ChercheGrpMesh(self):
+ #------------------------
Msg, listeGroup = self.ChercheGrpMeshInSalome()
if Msg == None:
- self.editorManager.handleAjoutGroup(listeGroup)
+ self.editorManager.ajoutGroupe(listeGroup)
else:
print("il faut gerer les erreurs")
+ #------------------------
def ChercheGrpMaille(self):
+ #------------------------
# Normalement la variable self.salome permet de savoir si on est ou non dans Salome
try:
Msg, listeGroup = self.ChercheGrpMailleInSalome() # recherche dans Salome
except:
raise ValueError("Salome non ouvert")
if Msg == None:
- self.editorManager.handleAjoutGroup(listeGroup)
+ self.editorManager.ajoutGroupe(listeGroup)
else:
print("il faut gerer les erreurs")
-
+ #---------------------
def ajoutIcones(self):
+ #----------------------
# Pour pallier les soucis de repertoire d icone
# print self.repIcon
icon = QIcon(self.repIcon + "/new_file.png")
self.actionExecution.setIcon(icon7)
+ #--------------------------
def connecterSignaux(self):
- self.recentMenu.aboutToShow.connect(self.handleShowRecentMenu)
+ #--------------------------
+ self.recentMenu.aboutToShow.connect(self.showRecentMenu)
self.action_Nouveau.triggered.connect(self.fileNew)
self.actionNouvel_Include.triggered.connect(self.newInclude)
- self.actionOuvrir.triggered.connect(self.fileOpen)
+ self.actionOuvrir.triggered.connect(self.openFileFromMenu)
self.actionEnregistrer.triggered.connect(self.fileSave)
self.actionEnregistrer_sous.triggered.connect(self.fileSaveAs)
self.actionFermer.triggered.connect(self.fileClose)
- self.actionFermer_tout.triggered.connect(self.fileCloseAll)
+ self.actionFermer_tout.triggered.connect(self.closeAllFiles)
self.actionQuitter.triggered.connect(self.fileExit)
self.actionEficas.triggered.connect(self.aidePPal)
self.actionParametres.triggered.connect(self.gestionParam)
self.actionCommentaire.triggered.connect(self.ajoutCommentaire)
- self.actionCouper.triggered.connect(self.editCut)
- self.actionCopier.triggered.connect(self.editCopy)
- self.actionColler.triggered.connect(self.editPaste)
+ self.actionCouper.triggered.connect(self.handleEditCut)
+ self.actionCopier.triggered.connect(self.handleEditCopy)
+ self.actionColler.triggered.connect(self.handleEditPaste)
self.actionSupprimer.triggered.connect(self.supprimer)
self.actionRechercher.triggered.connect(self.rechercher)
- self.actionDeplier_replier.triggered.connect(self.handleDeplier)
+ self.actionDeplier_replier.triggered.connect(self.deplier)
- self.actionRapport_de_Validation.triggered.connect(self.jdcRapport)
- self.actionRegles_du_JdC.triggered.connect(self.jdcRegles)
- self.actionFichier_Source.triggered.connect(self.jdcFichierSource)
- self.actionFichier_Resultat.triggered.connect(self.visuJdcPy)
+ self.actionRapport_de_Validation.triggered.connect(self.viewJdcRapport)
+ self.actionRegles_du_JdC.triggered.connect(self.viewJdcRegles)
+ self.actionFichier_Source.triggered.connect(self.viewJdcFichierSource)
+ self.actionFichier_Resultat.triggered.connect(self.viewJdcFichierResultat)
self.actionAfficher_l_Arbre.triggered.connect(self.ouvreArbre)
self.actionCacher_l_Arbre.triggered.connect(self.fermeArbre)
self.actionTraduitV9V10.triggered.connect(self.traductionV9V10)
self.actionTraduitV10V11.triggered.connect(self.traductionV10V11)
self.actionTraduitV11V12.triggered.connect(self.traductionV11V12)
- self.actionSaveLigne.triggered.connect(self.saveLigne)
+ self.actionSaveLigne.triggered.connect(self.fileSaveInLigneFormat)
# Pour Carmel
self.actionChercheGrpMaille = QAction(self)
self.actionCode.setText(tr("Specificites Maille"))
self.actionCode.triggered.connect(self.aideCode)
- def handleDeplier(self):
- self.editorManager.handleDeplier()
-
- def handleSortieUQ(self):
- self.editorManager.handleSortieUQ()
-
- def handleExeUQ(self):
- self.editorManager.handleExeUQ()
-
- def handleSauvePourPersalys(self):
- self.editorManager.handleSauvePourPersalys()
+ #----------------
+ def deplier(self):
+ #-----------------
+ self.editorManager.deplier()
+ #-------------------------
def ajoutCommentaire(self):
+ #-------------------------
self.editorManager.ajoutCommentaire()
- def ouvreFichiers(self):
- # Ouverture des fichiers de commandes donnes sur la ligne de commande
- cwd = os.getcwd()
- self.dir = cwd
- for study in session.d_env.studies:
- os.chdir(cwd)
- d = session.getUnit(study, self)
- self.editorManager.handleOpen(fichier=study["comm"], units=d)
-
- def getSource(self, file):
- # appele par Editeur/session.py
- import Accas.IO.reader
-
- p = convert.plugins["python"]()
- p.readfile(file)
- texte = p.convert("execnoparseur")
- return texte
-
+ #---------------------
def initPatrons(self):
+ #---------------------
# Mise a jour du menu des fichiers recemment ouverts
from Editeur import listePatrons
for fichier in self.listePatrons.liste[nomSsMenu]:
id = ssmenu.addAction(fichier)
self.ficPatrons[id] = fichier
- self.id.triggered.connect(self.handleOpenPatrons)
+ self.id.triggered.connect(self.openPatrons)
# self.Patrons.setItemParameter(id,idx)
idx = idx + 1
- #----------------------
- def initRecents(self):
- #----------------------
+ #------------------------------
+ def readListRecentlyOpen(self):
+ #------------------------------
self.recemmentUtilises = []
rep = self.maConfiguration.repUser
monFichier = rep + "/listefichiers_" + self.code
except:
pass
- #------------------------------
+ #----------------------------
def addToRecentList(self, fn):
- #------------------------------
+ #-----------------------------
while fn in self.recemmentUtilises:
self.recemmentUtilises.remove(fn)
self.recemmentUtilises.insert(0, fn)
if len(self.recemmentUtilises) > 9:
self.recemmentUtilises = self.recemmentUtilises[:9]
- #----------------------
- def sauveRecents(self):
- #----------------------
+ #-----------------------------
+ def saveListRecentlyOpen(self):
+ #-----------------------------
if len(self.recemmentUtilises) == 0: return
rep = self.maConfiguration.repUser
if not (os.path.isdir(rep)) :
#------------------------
def optionEditeur(self):
#------------------------
+ # a revoir entierement
+ # en particulier pour le nom de la configuration
+ # obsolete
try:
name = "monOptions_" + self.code
except:
- QMessageBox.critical(
- self, tr("Parametrage"), tr("Veuillez d abord choisir un code")
- )
+ QMessageBox.critical( self, tr("Parametrage"), tr("Veuillez d abord choisir un code"))
return
try:
- # if 1:
+ # if 1:
optionCode = __import__(name)
except:
- # else :
- QMessageBox.critical(
- self,
- tr("Parametrage"),
- tr("Pas de possibilite de personnalisation de la configuration "),
- )
+ # else :
+ QMessageBox.critical( self, tr("Parametrage"), tr("Pas de possibilite de personnalisation de la configuration "),)
return
monOption = optionCode.Options(
parent=self, modal=0, configuration=self.maConfiguration
)
monOption.show()
+ #------------------
def optionPdf(self):
+ #---------------------
from InterfaceGUI.QT5.monOptionsPdf import OptionPdf
-
monOption = OptionPdf(parent=self, modal=0, configuration=self.maConfiguration)
monOption.show()
- def handleSortieComplete(self):
- return self.editorManager.saveCompleteCurrentEditor()
-
- def handleShowRecentMenu(self):
+ #------------------------
+ def showRecentMenu(self):
+ #------------------------
"""
Private method to set up recent files menu.
"""
for rp in self.recemmentUtilises:
id = self.recentMenu.addAction(rp)
self.ficRecents[id] = rp
- id.triggered.connect(self.handleOpenRecent)
+ id.triggered.connect(self.openRecentFile)
self.recentMenu.addSeparator()
- self.recentMenu.addAction(tr("&Effacer"), self.handleClearRecent)
+ self.recentMenu.addAction(tr("&Effacer"), self.clearListRecent)
- def handleOpenPatrons(self):
+ #---------------------
+ def openPatrons(self):
+ #---------------------
+ repPatrons = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..","..","Codes","Patrons","self.code")
idx = self.sender()
- fichier = (
- self.repIni
- + "/../Editeur/Patrons/"
- + self.code
- + "/"
- + self.ficPatrons[idx]
- )
- self.editorManager.handleOpen(fichier=fichier, patron=1)
+ fichier = self.repPatrons+"/"+ self.ficPatrons[idx]
+ self.editorManager.openFile(fichier=fichier, patron=1)
- def handleOpenRecent(self):
+ #------------------------
+ def openRecentFile(self):
+ #------------------------
idx = self.sender()
fichier = self.ficRecents[idx]
- self.editorManager.handleOpen(fichier=fichier, patron=0)
+ self.editorManager.openFile(fichier=fichier, patron=0)
- def handleClearRecent(self):
+ #-------------------------
+ def clearListRecent(self):
+ #------------------------
self.recemmentUtilises = []
- self.sauveRecents()
+ self.saveListRecentlyOpen()
- def handleRechercherDsCatalogue(self):
- if not self.editorManager:
- return
- self.editorManager.handleRechercherDsCatalogue()
+ #--------------------------------------
+ def rechercherMotClefDsCatalogue(self):
+ #--------------------------------------
+ if not self.editorManager: return
+ self.editorManager.rechercherMotClefDsCatalogue()
+ #----------------
def fileNew(self):
+ #----------------
try:
self.editorManager.newEditor()
except EficasException as exc:
QMessageBox.warning(self, tr("Erreur"), msg)
- def fileOpen(self):
- try:
- self.editorManager.handleOpen()
- except EficasException as exc:
- msg = str(exc)
- if msg != "":
- QMessageBox.warning(self, tr("Erreur"), msg)
-
- def saveLigne(self):
- return self.editorManager.handleSaveLigne()
-
- def fileSave(self):
- return self.editorManager.handleSave()
-
- def fileSaveAs(self):
- return self.editorManager.handleSaveAs()
-
- def fileClose(self):
- self.editorManager.handleClose(texte="&Fermer")
-
- def fileCloseAll(self):
- self.editorManager.handleCloseAll(texte="&Fermer")
-
+ #-----------------
def fileExit(self):
+ #-----------------
# On peut sortir sur Abort
- res = self.editorManager.handleCloseAll()
- if res != 2:
- self.close()
+ # equivalent du closeEvent sur la fenetre
+ res = self.editorManager.closeAllFiles()
+ if res != 2: self.close()
return res
- def editCopy(self):
+ #------------------------
+ def handleEditCopy(self):
+ #------------------------
self.editorManager.handleEditCopy()
- def editCut(self):
+ #------------------------
+ def handleEditCut(self):
+ #------------------------
self.editorManager.handleEditCut()
- def editPaste(self):
+ #------------------------
+ def handleEditPaste(self):
+ #------------------------
self.editorManager.handleEditPaste()
+ #-------------------
def rechercher(self):
- self.editorManager.handleRechercher()
-
- def run(self):
- self.editorManager.run()
-
- def saveRun(self):
- self.editorManager.saveRun()
+ #---------------------
+ self.editorManager.rechercherConceptOuMotClef()
+ #----------------
def supprimer(self):
+ #----------------
self.editorManager.handleSupprimer()
- def jdcFichierSource(self):
- self.editorManager.handleViewJdcFichierSource()
+ #-----------------------------
+ def viewJdcFichierSource(self):
+ #-----------------------------
+ self.editorManager.viewJdcFichierSource()
- def jdcRapport(self):
- self.editorManager.handleViewJdcRapport()
+ #------------------------
+ def viewJdcRapport(self):
+ #------------------------
+ self.editorManager.viewJdcRapport()
- def jdcRegles(self):
+ #------------------------
+ def viewJdcRegles(self):
+ #------------------------
self.editorManager.handleViewJdcRegles()
+ #------------------------------
+ def viewJdcFichierResultat(self):
+ #-------------------------------
+ self.editorManager.viewJdcFichierResultat()
+
+ #------------------------
def gestionParam(self):
+ #------------------------
self.editorManager.handleGestionParam()
- def visuJdcPy(self):
- self.editorManager.handleViewJdcPy()
-
+ #--------------------
def ouvreArbre(self):
+ #--------------------
self.editorManager.ouvreArbre()
+ #--------------------
def fermeArbre(self):
+ #--------------------
self.editorManager.fermeArbre()
+ #--------------------
def newInclude(self):
+ #--------------------
self.editorManager.newIncludeEditor()
+ #---------------------------
def closeEvent(self, event):
+ #---------------------------
res = self.fileExit()
- if res == 2:
- event.ignore()
+ if res == 2: event.ignore()
+ #-------------------------------
def remplitIconesCommandes(self):
- if self.maConfiguration.boutonDsMenuBar == False:
- return
- if not hasattr(self, "readercata"):
- return
- from InterfaceGUI.QT5.monLayoutBouton import MonLayoutBouton
+ #-------------------------------
+ # permet de remplacer les commandes par des icones
+ # plus usite depuis machine tournante
+ # a retester
+ if self.maConfiguration.boutonDsMenuBar == False: return
+ if not hasattr(self, "readercata"): return
- if hasattr(self, "monLayoutBoutonRempli"):
- return
+ from InterfaceGUI.QT5.monLayoutBouton import MonLayoutBouton
+ if hasattr(self, "monLayoutBoutonRempli"): return
self.monLayoutBoutonRempli = MonLayoutBouton(self)
- def handleAjoutEtape(self, nomEtape):
- self.editorManager.handleAjoutEtape(nomEtape)
+ #-----------------------------------
def metMenuAJourUtilisateurs(self):
+ #----------------------------------
self.lesFonctionsUtilisateurs = {}
if self.code not in self.mesScripts:
return
)
self.menuOptions.triggered.connect(self.handleFonctionUtilisateur)
+ #-------------------------------------------
def handleFonctionUtilisateur(self, action):
+ #-------------------------------------------
(laFonctionUtilisateur, lesArguments) = self.lesFonctionsUtilisateurs[action]
self.editorManager.handleFonctionUtilisateur(laFonctionUtilisateur, lesArguments)
Eficas = Appli()
Eficas.show()
- # mw.ouvreFichiers()
# mw.show()
res = app.exec_()
--- /dev/null
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2021 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+"""
+ Ce module sert a lancer EFICAS configure pour le Web
+"""
+# Modules Python
+import os, sys
+import os, sys
+sys.path.append(os.path.join(os.path.abspath(os.path.dirname(__file__)),'..'))
+
+
+# Modules Eficas
+
+from collections import OrderedDict
+import pprint
+
+
+if sys.version_info[0] < 3:
+ print("Must be using Python 3")
+ sys.exit()
+
+class AccasConnecteur :
+ def __init__(self,code, fichierCata=None, langue=None, fichierComm=None,appWeb=None) :
+ #-------------------------------------------------------------------------------------
+
+ self.appWeb=appWeb
+
+ if code == None : multi = True
+ else : multi = False
+ from Editeur.eficas_go import getEficasSsIhm
+ self.monEficas=getEficasSsIhm(code=code, salome=0, multi=multi, langue=langue,fichierCata=fichierCata, GUIPath='Web')
+
+ if self.monEficas == None :
+ self.toWebApp('afficheInfos', 'erreur à la construction de l appli Eficas', 'rouge')
+ return
+ # faire l equivalent du editorManager
+ if fichierCata == None and fichierComm :
+ self.toWebApp('afficheInfos', 'pour ouvrir un JDC, il faut connaitre le catalogue', 'rouge')
+ return
+ self.litFichierComm(fichierComm)
+
+ def toWebApp(self,fction,*args, **kwargs):
+ #-----------------------------------------
+ #if fction =='propageValide' :
+ debug=0
+ if debug : print ('PNPNPN : self.appWeb.toWebApp', fction, *args, **kwargs)
+ if self.appWeb == None :
+ #if fction =='propageValide' : print ('self.appWeb.toWebApp propageValide', self.monEditeur.getNodeById(args[0]).nom)
+ return
+ self.appWeb.fromConnecteur(fction, *args, **kwargs)
+
+ def litFichierComm(self,fichierComm=None):
+ #-----------------------------------------
+ from InterfaceGUI.Web.editor import JDCWebEditor
+ self.monEditeur=JDCWebEditor(self.monEficas,fichierComm,connecteur=self)
+
+ def getListeCommandes(self):
+ #---------------------------
+ if self.monEditeur == None : return
+ return (self.monEditeur.jdc.getListeCmd())
+
+ def getListeMotsClesFilsPossibles(self,nomCommande):
+ #-----------------------------------------
+ # ici il faut programmer getListeMotsClesFilsPossibles dans P_ENTITE
+ # Pour l instant on renvoie entites
+ # doit aussi pouvoir etre appele sur FACT et BLOC
+ maCommande= getattr(self.monEditeur.jdc.cata,nomCommande)
+ laListe=maCommande.entites
+ return laListe
+
+
+ def getDicoForFancy(self,obj,debug=0) :
+ #---------------------------------
+ dico=self.monEditeur.getDicoForFancy(obj)
+ if debug :
+ import pprint
+ pprint.pprint (dico)
+ return dico
+
+
+ def changeValeur(self,id,valeur) :
+ #---------------------------------
+ """
+ id : identifiant unique
+ valeur : valeur saisie dans le formulaire
+ doit-on mettre l ancienne valeur en retour qui serait utile si validité = Non
+ """
+ monNode=self.monEditeur.getNodeById(id)
+ #print (' change Valeur', monNode)
+ #(idUnique, commentaire, validite)=monNode.fauxNoeudGraphique.traiteValeurSaisie(valeur)
+ #print ('retour ChangeValeur',idUnique, commentaire, validite )
+ return monNode.fauxNoeudGraphique.traiteValeurSaisie(valeur)
+
+ def updateSDName(self,id,sdnom) :
+ #---------------------------------
+ monNode=self.monEditeur.getNodeById(id)
+ return monNode.fauxNoeudGraphique.updateSDName(sdnom)
+
+ def suppNode(self,id):
+ #-------------------
+
+ monNode=self.monEditeur.getNodeById(id)
+ print ('monNode', monNode)
+ retour=monNode.fauxNoeudGraphique.delete()
+ return retour
+
+ def appendChild(self,id,name,pos=None):
+ #-------------------------------------
+ """
+ Methode pour ajouter un objet fils name a l objet associe au noeud id.
+ On peut l'ajouter en debut de liste (pos='first'), en fin (pos='last')
+ ou en position pos_ieme de la liste.
+ retour = nouvelIdUnique ou None
+ """
+ monNode=self.monEditeur.getNodeById(id)
+ if monNode.fauxNoeudGraphique == None :
+ print ('PNPN pas de noeud Graphique associe a l id')
+ return
+ if debug : print (monNode.fauxNoeudGraphique)
+ retour = monNode.fauxNoeudGraphique.appendChild(name,pos)
+ return retour
+
+ def saveFile(self,fileName):
+ #----------------------------
+ """
+ sauve le .comm dans fileName (si fileName = None,
+ alors la sauvegarde est faite dans le fichier courant)
+ retour = True/False et le nom du fichier sauvegarde
+ """
+ return self.monEditeur.saveFile(fileName)
+
+
+if __name__ == "__main__":
+ import prefs
+ name='prefs_'+prefs.code
+ __import__(name)
+ code=prefs.code
+ monEficasConnecteur=accasConnecteur(code, langue='ang')
+
+ testAjoutSuppProc=0
+ if testAjoutSuppProc :
+ monEficasConnecteur.litFichierComm('../WebTest/web_tres_simple_avec_2Procs.comm')
+ idRacine=monEficasConnecteur.monEditeur.tree.racine.item.idUnique
+ r=monEficasConnecteur.appendChild(idRacine,'MonProc',0)
+ print ('ajout de MonProc en postion 0', r)
+ r=monEficasConnecteur.appendChild(idRacine,'MonProc2',1)
+ print ('ajout de MonProc2 en postion 1', r)
+ r=monEficasConnecteur.appendChild(idRacine,'MonProc2','last')
+ print ('ajout de MonProc2 en postion last', r)
+ r=monEficasConnecteur.appendChild(idRacine,'MonProc2','first')
+ print ('ajout de MonProc2 en postion first', r)
+ r=monEficasConnecteur.appendChild(idRacine,'MonProc2',)
+ print ('ajout de MonProc2 sans poistion ne fonctionne pas', r)
+ d=monEficasConnecteur.getDicoForFancy(monEficasConnecteur.monEditeur.tree.racine)
+ etape2=d['children'][0]['key']
+ print ('je detruis' ,etape2)
+ r=monEficasConnecteur.suppNode(etape2)
+ print (r)
+ monProc2=d['children'][0]['key']
+ r=monEficasConnecteur.appendChild(monProc2,'Fact2')
+ (ok,newFile)=monEficasConnecteur.saveFile('/tmp/ajoutProc.comm')
+
+ testAjoutSuppFact2=0
+ if testAjoutSuppFact2 :
+ monEficasConnecteur.litFichierComm('../WebTest/web_tres_simple_avec_2Procs.comm')
+ idRacine=monEficasConnecteur.monEditeur.tree.racine.item.idUnique
+ r=monEficasConnecteur.appendChild(idRacine,'MonProc2','last')
+ d=monEficasConnecteur.getDicoForFancy(monEficasConnecteur.monEditeur.tree.racine)
+ monProc2=d['children'][2]['key']
+ r=monEficasConnecteur.appendChild(monProc2,'Fact2')
+ #print (r)
+ (ok,newFile)=monEficasConnecteur.saveFile('/tmp/ajoutFact2.comm')
+
+ testAjoutSuppFact=0
+ if testAjoutSuppFact :
+ monEficasConnecteur.litFichierComm('../WebTest/web_tres_simple_avec_2Fact.comm')
+ idRacine=monEficasConnecteur.monEditeur.tree.racine.item.idUnique
+ d=monEficasConnecteur.getDicoForFancy(monEficasConnecteur.monEditeur.tree.racine)
+ monProc2=d['children'][0]['key']
+ print ('id monProc2 : ', monProc2)
+ #r=monEficasConnecteur.appendChild(monProc2,'Fact2')
+ #print ('ajout de Fact2 dans monProc2 reussi', r)
+ #r=monEficasConnecteur.appendChild(monProc2,'Fact2')
+ #print ('ajout de Fact2 dans monProc2 inadequat', r)
+ d=monEficasConnecteur.getDicoForFancy(monEficasConnecteur.monEditeur.tree.racine)
+ fact11=d['children'][0]['children'][2]['key']
+ fact12=d['children'][0]['children'][3]['key']
+ fact13=d['children'][0]['children'][4]['key']
+ fact14=d['children'][0]['children'][5]['key']
+ pprint.pprint(d)
+ #print (d)
+ #monFact2=d['children'][0]['children'][3]['key']
+ #print (monFact2)
+ #r=monEficasConnecteur.suppNode(monFact2)
+ #print (r)
+ #fact11=d['children'][0]['children'][2]['key']
+ #monNode=monEficasConnecteur.monEditeur.getNodeById(fact11)
+ #print ('monNode', monNode)
+ r=monEficasConnecteur.suppNode(fact11)
+ r=monEficasConnecteur.suppNode(fact12)
+ r=monEficasConnecteur.suppNode(fact13)
+ print ('________________________________________________')
+ print ('________________________________________________')
+ print ('________________________________________________')
+ print ('________________________________________________')
+ print ('________________________________________________')
+ r=monEficasConnecteur.suppNode(fact14)
+ print (r)
+ #r=monEficasConnecteur.appendChild(monProc2,'Fact1')
+ #r=monEficasConnecteur.appendChild(monProc2,'Fact1')
+ #r=monEficasConnecteur.appendChild(monProc2,'Fact1')
+ #r=monEficasConnecteur.appendChild(monProc2,'Fact2')
+ #r=monEficasConnecteur.appendChild(monProc2,'Fact1')
+ #print (d)
+ #d=monEficasConnecteur.getDicoForFancy(monEficasConnecteur.monEditeur.tree.racine)
+ #pprint.pprint(d)
+ #r=monEficasConnecteur.appendChild(monProc2,'Fact1')
+ #print (r)
+ #d=monEficasConnecteur.getDicoForFancy(monEficasConnecteur.monEditeur.tree.racine)
+ #fact12=d['children'][0]['children'][3]['key']
+ #print(d['children'][0]['children'][3]['title'])
+ #r=monEficasConnecteur.appendChild(fact12,'paramInFact1')
+ #fact1=d['children'][0]['children'][2]
+ #print (fact1)
+ #fact11=d['children'][0]['children'][2]['key']
+ #print (fact11)
+ #print ('******************************************************')
+ #r=monEficasConnecteur.suppNode(fact11)
+ #r=monEficasConnecteur.appendChild(fact11,'paramInFact1')
+ #d=monEficasConnecteur.getDicoForFancy(monEficasConnecteur.monEditeur.tree.racine)
+ #paramInFact12=d['children'][0]['children'][2]['children'][0]['key']
+ #r=monEficasConnecteur.suppNode(paramInFact12)
+ #print (r)
+ (ok,newFile)=monEficasConnecteur.saveFile('/tmp/ajoutFact.comm')
+ exit()
+
+ testChangeValeur=0
+ if testChangeValeur :
+ monEficasConnecteur.litFichierComm('../WebTest/web_tres_simple_avec_2Fact.comm')
+ idRacine=monEficasConnecteur.monEditeur.tree.racine.item.idUnique
+ print ('idRacine', idRacine)
+ d=monEficasConnecteur.getDicoForFancy(monEficasConnecteur.monEditeur.tree.racine)
+ #pprint.pprint(d)
+
+ monProc=d['children'][0]['key']
+ print ('monProc', monProc)
+ param1=d['children'][0]['children'][0]['key']
+ print ('param1', param1)
+ r=monEficasConnecteur.changeValeur(param1,'65')
+ param12=d['children'][0]['children'][1]['key']
+ print ('param12', param12)
+ r=monEficasConnecteur.changeValeur(param12,'9')
+ r=monEficasConnecteur.appendChild(monProc,'param11')
+ d=monEficasConnecteur.getDicoForFancy(monEficasConnecteur.monEditeur.tree.racine)
+ param11=d['children'][0]['children'][1]['key']
+ print ('param11', param11)
+ r=monEficasConnecteur.changeValeur(param11,'11')
+
+ print ('______________ creation du bloc _____________________')
+ r=monEficasConnecteur.changeValeur(param1,'2')
+ d=monEficasConnecteur.getDicoForFancy(monEficasConnecteur.monEditeur.tree.racine)
+ #pprint.pprint(d)
+ param1_inBloc=d['children'][0]['children'][3]['key']
+ # on supprime le bloc
+ r=monEficasConnecteur.changeValeur(param1_inBloc,'1')
+ # on le rajoute (pb du bloc dans le bloc)
+ r=monEficasConnecteur.changeValeur(param1_inBloc,'2')
+ d=monEficasConnecteur.getDicoForFancy(monEficasConnecteur.monEditeur.tree.racine)
+ param1_inBlocDeBloc=d['children'][0]['children'][4]['key']
+ r=monEficasConnecteur.changeValeur(param1_inBlocDeBloc,'2')
+ print ('______________ creation du bloc _____________________')
+ param2_inBloc=d['children'][0]['children'][6]['key']
+ r=monEficasConnecteur.changeValeur(param1_inBlocDeBloc,'2')
+ (ok,newFile)=monEficasConnecteur.saveFile('/tmp/changeValeur.comm')
+ exit()
+
+ # creation du bloc
+ #r=monEficasConnecteur.changeValeur(i,'2')
+ #d=monEficasConnecteur.getDicoForFancy(monEficasConnecteur.monEditeur.tree.racine)
+ #(ok,newFile)=monEficasConnecteur.saveFile('/tmp/ajoutProcEtBloc.comm')
+ #pprint.pprint(d)
+
+ # suppression du bloc
+ #r=monEficasConnecteur.changeValeur(i,'1')
+ #d=monEficasConnecteur.getDicoForFancy(monEficasConnecteur.monEditeur.tree.racine)
+ #(ok,newFile)=monEficasConnecteur.saveFile('/tmp/suppressionBloc.comm')
+ #pprint.pprint(d)
+
+ # ajout du Fact2
+ d=monEficasConnecteur.getDicoForFancy(monEficasConnecteur.monEditeur.tree.racine)
+ e=d['children'][2]['key']
+ r=monEficasConnecteur.appendChild(e,'Fact2')
+ (ok,newFile)=monEficasConnecteur.saveFile('/tmp/ajoutFact2.comm')
+ d=monEficasConnecteur.getDicoForFancy(monEficasConnecteur.monEditeur.tree.racine)
+ mf=d['children'][2]['children'][4]['key']
+ print (mf)
+ r=monEficasConnecteur.appendChild(mf,'paramFacultatif')
+ (ok,newFile)=monEficasConnecteur.saveFile('/tmp/ajoutFacultatif.comm')
+ d=monEficasConnecteur.getDicoForFancy(monEficasConnecteur.monEditeur.tree.racine)
+ mf=d['children'][2]['children'][4]['children'][1]['key']
+ r=monEficasConnecteur.suppNode(mf)
+ print (r)
+ (ok,newFile)=monEficasConnecteur.saveFile('/tmp/ajoutFacultatifEtSuppresse.comm')
+ # essai enlever un mot clef qu on ne peut pas enlever
+ d=monEficasConnecteur.getDicoForFancy(monEficasConnecteur.monEditeur.tree.racine)
+ mf=d['children'][2]['children'][1]['key']
+ r=monEficasConnecteur.suppNode(mf)
+ print (r)
+ #(ok,newFile)=monEficasConnecteur.saveFile('/tmp/ajoutPuisSuppresFact2.comm')
+ #d=monEficasConnecteur.getDicoForFancy(monEficasConnecteur.monEditeur.tree.racine)
+ #pprint.pprint(d)
+ #print ('_________', r)
+
+ testPropageValide = 0
+ if testPropageValide :
+ monEficasConnecteur.litFichierComm('propageValide.comm')
+ idRacine=monEficasConnecteur.monEditeur.tree.racine.item.idUnique
+ #r=monEficasConnecteur.appendChild(idRacine,'MonProc',0)
+ #print ('ajout de MonProc en position 0', r)
+ #r=monEficasConnecteur.appendChild(idRacine,'MonProc2','last')
+ r=monEficasConnecteur.appendChild(idRacine,'MonProc','last')
+ d=monEficasConnecteur.getDicoForFancy(monEficasConnecteur.monEditeur.tree.racine)
+ param1PLast = d['children'][1]['children'][0]['key']
+ r=monEficasConnecteur.changeValeur(param1PLast,'1')
+ (ok,newFile)=monEficasConnecteur.saveFile('/tmp/propageValide.comm')
+ print ('ajout de MonProc2 en postion last', r)
+
+ testUpdateInfo = 0
+ if testUpdateInfo :
+ print ('________________________ testUpdateInfo ___________________________')
+ monEficasConnecteur.litFichierComm('../WebTest/web_tres_simple_avec_2Fact.comm')
+ idRacine=monEficasConnecteur.monEditeur.tree.racine.item.idUnique
+ print ('idRacine', idRacine)
+ d=monEficasConnecteur.getDicoForFancy(monEficasConnecteur.monEditeur.tree.racine)
+ badMonProc2 = d['children'][0]['children'][0]['key']
+ r=monEficasConnecteur.appendChild(badMonProc2,'Fact1')
+ monProc2 = d['children'][0]['key']
+ #print ('idProc2', monProc2)
+ #print (d)
+ r=monEficasConnecteur.appendChild(monProc2,'Fact1')
+ r=monEficasConnecteur.appendChild(monProc2,'Fact1')
+ r=monEficasConnecteur.appendChild(monProc2,'Fact1')
+ r=monEficasConnecteur.appendChild(monProc2,'Fact1')
+ d=monEficasConnecteur.getDicoForFancy(monEficasConnecteur.monEditeur.tree.racine)
+ print (['children'][0])
+
+ testAjoutSimpListe=0
+ if testAjoutSimpListe :
+ monEficasConnecteur.litFichierComm('../WebTest/web_tres_simple_avec_2Procs.comm')
+ idRacine=monEficasConnecteur.monEditeur.tree.racine.item.idUnique
+ r=monEficasConnecteur.appendChild(idRacine,'MonProc2','last')
+ d=monEficasConnecteur.getDicoForFancy(monEficasConnecteur.monEditeur.tree.racine)
+ monProc2=d['children'][2]['key']
+
+ testNommeProc=1
+ if testNommeProc :
+ monEficasConnecteur.litFichierComm('../WebTest/web_tres_simple_avec_2Procs.comm')
+ idRacine=monEficasConnecteur.monEditeur.tree.racine.item.idUnique
+ r=monEficasConnecteur.appendChild(idRacine,'MonOper','last')
+ d=monEficasConnecteur.getDicoForFancy(monEficasConnecteur.monEditeur.tree.racine)
+ monOper=d['children'][2]['key']
+ bOk, message = monEficasConnecteur.updateSDName(monOper,'toto')
+ print ('in testNommeProc, bOk, message', bOk, message)
+ d=monEficasConnecteur.getDicoForFancy(monEficasConnecteur.monEditeur.tree.racine)
+ monParam=d['children'][2]['children'][0]['key']
+ r=monEficasConnecteur.changeValeur(monParam,'65')
+ bOk, message = monEficasConnecteur.updateSDName(monOper,'toto')
+ print ('in testNommeProc, bOk, message', bOk, message)
+
+ #print ( '\n Fichier /home/A96028/QT5GitEficasTravail/Web/eficas/WebTest/web_tres_simple_avec_2Procs.comm')
+ #monEficasConnecteur.litFichierComm('../WebTest/web_tres_simple_avec_2Procs.comm')
+ #pprint.pprint (monEficasConnecteur.getDicoObjetsCompletsPourTree(monEficasConnecteur.monEditeur.tree.racine))
+
+ #print ( '\n Fichier /home/A96028/QT5GitEficasTravail/Web/eficas/WebTest/web_tres_simple_avec_Bloc.comm')
+ #monEficasConnecteur.litFichierComm('../WebTest/web_tres_simple_avec_Bloc.comm')
+ #print (monEficasConnecteur.generDicoPourWeb())
+ #print (monEficasConnecteur.getDicoObjetsPourWeb(monEficasConnecteur.monEditeur.tree.racine))
+ #pprint.pprint (monEficasConnecteur.getDicoObjetsCompletsPourTree(monEficasConnecteur.monEditeur.tree.racine))
+ #print ('\n')
+
+ #print ( '\n Fichier /home/A96028/QT5GitEficasTravail/Web/eficas/WebTest/web_tres_simple_avec_2Fact.comm')
+ #monEficasConnecteur.litFichierComm('../WebTest/web_tres_simple_avec_2Fact.comm')
+ #print (monEficasConnecteur.generDicoPourWeb())
+ #monDicoAAfficher = (monEficasConnecteur.getDicoObjetsPourWeb(monEficasConnecteur.monEditeur.tree.racine))
+ #monEficasConnecteur.traiteDico(monDicoAAfficher)
+ #pprint.pprint (monEficasConnecteur.getDicoObjetsCompletsPourTree(monEficasConnecteur.monEditeur.tree.racine))
+
+ #print ('/home/A96028/QT5GitEficasTravail/Web/eficas/WebTest/web_tres_simple_avec_Fact.comm')
+ #monEficasConnecteur.litFichierComm('../WebTest/web_tres_simple_avec_Fact.comm')
+ #print (monEficasConnecteur.generDicoPourWeb())
+ #pprint.pprint (monEficasConnecteur.getDicoObjetsCompletsPourTree(monEficasConnecteur.monEditeur.tree.racine))
+ #print ('\n')
+
--- /dev/null
+#!/usr/bin/env python
+# -*- coding: iso-8859-1 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+import os, sys
+
+from Editeur.eficas_appli import EficasAppli
+from InterfaceGUI.Web.web_editor_manager import WebEditorManager
+
+class WebEficasAppli(EficasAppli):
+ """
+ Class implementing the main QT user interface.
+ """
+
+ #----------------------------------------------------------------------------------------------------------------------------------------------
+ def __init__(self, code=None, versionCode=None, salome=1, multi=False, langue="fr", ssCode=None, fichierCata=None, GUIPath="InterfaceGUI.QT5"):
+ #----------------------------------------------------------------------------------------------------------------------------------------------
+ """
+ Constructor
+ """
+ EficasAppli.__init__( self, code, versionCode, salome, multi, langue, ssCode, fichierCata, GUIPath)
+ self.WebEditorManager = WebEditorManager(self)
+ self.GUIPath = GUIPath
+
+ if code == None : multi = True
+ else : multi = False
+ from Editeur.eficas_go import getEficasSsIhm
+
+ if fichierCata == None and fichierComm :
+ self.toWebApp('afficheInfos', 'pour ouvrir un JDC, il faut connaitre le catalogue', 'rouge')
+ return
+ self.litFichierComm(fichierComm)
+
+
+ #def fileOpen(self):
+ # try:
+ # self.editorManager.openFile()
+ # except EficasException as exc:
+ # msg = str(exc)
+ # if msg != "":
+ # QMessageBox.warning(self, tr("Erreur"), msg)
+
+ #def fileSave(self):
+ # return self.editorManager.handleSave()
+
+ #def fileSaveAs(self):
+ # return self.editorManager.handleSaveAs()
+
+ #def fileClose(self):
+ # self.editorManager.handleClose(texte="&Fermer")
+
+ #def fileCloseAll(self):
+ # self.editorManager.closeAllFiles(texte="&Fermer")
+
+ #def fileExit(self):
+ # On peut sortir sur Abort
+ # res = self.editorManager.closeAllFiles()
+ # if res != 2:
+ # self.close()
+ # return res
+
+
+
+
+
+ def toWebApp(self,fction,*args, **kwargs):
+ #-----------------------------------------
+ #if fction =='propageValide' :
+ debug=0
+ if debug : print ('PNPNPN : self.appWeb.toWebApp', fction, *args, **kwargs)
+ if self.appWeb == None :
+ #if fction =='propageValide' : print ('self.appWeb.toWebApp propageValide', self.monEditeur.getNodeById(args[0]).nom)
+ return
+ self.appWeb.fromConnecteur(fction, *args, **kwargs)
+
+ def litFichierComm(self,fichierComm=None):
+ #-----------------------------------------
+ from InterfaceGUI.Web.editor import JDCWebEditor
+ self.monEditeur=JDCWebEditor(self.monEficas,fichierComm,connecteur=self)
+
+ def getListeCommandes(self):
+ #---------------------------
+ if self.monEditeur == None : return
+ return (self.monEditeur.jdc.getListeCmd())
+
+ def getListeMotsClesFilsPossibles(self,nomCommande):
+ #-----------------------------------------
+ # ici il faut programmer getListeMotsClesFilsPossibles dans P_ENTITE
+ # Pour l instant on renvoie entites
+ # doit aussi pouvoir etre appele sur FACT et BLOC
+ maCommande= getattr(self.monEditeur.jdc.cata,nomCommande)
+ laListe=maCommande.entites
+ return laListe
+
+
+ def getDicoForFancy(self,obj,debug=0) :
+ #---------------------------------
+ dico=self.monEditeur.getDicoForFancy(obj)
+ if debug :
+ import pprint
+ pprint.pprint (dico)
+ return dico
+
+
+ def changeValeur(self,id,valeur) :
+ #---------------------------------
+ """
+ id : identifiant unique
+ valeur : valeur saisie dans le formulaire
+ doit-on mettre l ancienne valeur en retour qui serait utile si validité = Non
+ """
+ monNode=self.monEditeur.getNodeById(id)
+ #print (' change Valeur', monNode)
+ #(idUnique, commentaire, validite)=monNode.fauxNoeudGraphique.traiteValeurSaisie(valeur)
+ #print ('retour ChangeValeur',idUnique, commentaire, validite )
+ return monNode.fauxNoeudGraphique.traiteValeurSaisie(valeur)
+
+ def updateSDName(self,id,sdnom) :
+ #---------------------------------
+ monNode=self.monEditeur.getNodeById(id)
+ return monNode.fauxNoeudGraphique.updateSDName(sdnom)
+
+ def suppNode(self,id):
+ #-------------------
+
+ monNode=self.monEditeur.getNodeById(id)
+ print ('monNode', monNode)
+ retour=monNode.fauxNoeudGraphique.delete()
+ return retour
+
+ def appendChild(self,id,name,pos=None):
+ #-------------------------------------
+ """
+ Methode pour ajouter un objet fils name a l objet associe au noeud id.
+ On peut l'ajouter en debut de liste (pos='first'), en fin (pos='last')
+ ou en position pos_ieme de la liste.
+ retour = nouvelIdUnique ou None
+ """
+ monNode=self.monEditeur.getNodeById(id)
+ if monNode.fauxNoeudGraphique == None :
+ print ('PNPN pas de noeud Graphique associe a l id')
+ return
+ if debug : print (monNode.fauxNoeudGraphique)
+ retour = monNode.fauxNoeudGraphique.appendChild(name,pos)
+ return retour
+
+ def saveFile(self,fileName):
+ #----------------------------
+ """
+ sauve le .comm dans fileName (si fileName = None,
+ alors la sauvegarde est faite dans le fichier courant)
+ retour = True/False et le nom du fichier sauvegarde
+ """
+ return self.monEditeur.saveFile(fileName)
+
+
+if __name__ == "__main__":
+ import prefs
+ name='prefs_'+prefs.code
+ __import__(name)
+ code=prefs.code
+ monEficasConnecteur=WebEficasAppli(code, langue='ang', GUIPath)
+
+ testAjoutSuppProc=0
+ if testAjoutSuppProc :
+ monEficasConnecteur.litFichierComm('../WebTest/web_tres_simple_avec_2Procs.comm')
+ idRacine=monEficasConnecteur.monEditeur.tree.racine.item.idUnique
+ r=monEficasConnecteur.appendChild(idRacine,'MonProc',0)
+ print ('ajout de MonProc en postion 0', r)
+ r=monEficasConnecteur.appendChild(idRacine,'MonProc2',1)
+ print ('ajout de MonProc2 en postion 1', r)
+ r=monEficasConnecteur.appendChild(idRacine,'MonProc2','last')
+ print ('ajout de MonProc2 en postion last', r)
+ r=monEficasConnecteur.appendChild(idRacine,'MonProc2','first')
+ print ('ajout de MonProc2 en postion first', r)
+ r=monEficasConnecteur.appendChild(idRacine,'MonProc2',)
+ print ('ajout de MonProc2 sans poistion ne fonctionne pas', r)
+ d=monEficasConnecteur.getDicoForFancy(monEficasConnecteur.monEditeur.tree.racine)
+ etape2=d['children'][0]['key']
+ print ('je detruis' ,etape2)
+ r=monEficasConnecteur.suppNode(etape2)
+ print (r)
+ monProc2=d['children'][0]['key']
+ r=monEficasConnecteur.appendChild(monProc2,'Fact2')
+ (ok,newFile)=monEficasConnecteur.saveFile('/tmp/ajoutProc.comm')
+
+ testAjoutSuppFact2=0
+ if testAjoutSuppFact2 :
+ monEficasConnecteur.litFichierComm('../WebTest/web_tres_simple_avec_2Procs.comm')
+ idRacine=monEficasConnecteur.monEditeur.tree.racine.item.idUnique
+ r=monEficasConnecteur.appendChild(idRacine,'MonProc2','last')
+ d=monEficasConnecteur.getDicoForFancy(monEficasConnecteur.monEditeur.tree.racine)
+ monProc2=d['children'][2]['key']
+ r=monEficasConnecteur.appendChild(monProc2,'Fact2')
+ #print (r)
+ (ok,newFile)=monEficasConnecteur.saveFile('/tmp/ajoutFact2.comm')
+
+ testAjoutSuppFact=0
+ if testAjoutSuppFact :
+ monEficasConnecteur.litFichierComm('../WebTest/web_tres_simple_avec_2Fact.comm')
+ idRacine=monEficasConnecteur.monEditeur.tree.racine.item.idUnique
+ d=monEficasConnecteur.getDicoForFancy(monEficasConnecteur.monEditeur.tree.racine)
+ monProc2=d['children'][0]['key']
+ print ('id monProc2 : ', monProc2)
+ #r=monEficasConnecteur.appendChild(monProc2,'Fact2')
+ #print ('ajout de Fact2 dans monProc2 reussi', r)
+ #r=monEficasConnecteur.appendChild(monProc2,'Fact2')
+ #print ('ajout de Fact2 dans monProc2 inadequat', r)
+ d=monEficasConnecteur.getDicoForFancy(monEficasConnecteur.monEditeur.tree.racine)
+ fact11=d['children'][0]['children'][2]['key']
+ fact12=d['children'][0]['children'][3]['key']
+ fact13=d['children'][0]['children'][4]['key']
+ fact14=d['children'][0]['children'][5]['key']
+ pprint.pprint(d)
+ #print (d)
+ #monFact2=d['children'][0]['children'][3]['key']
+ #print (monFact2)
+ #r=monEficasConnecteur.suppNode(monFact2)
+ #print (r)
+ #fact11=d['children'][0]['children'][2]['key']
+ #monNode=monEficasConnecteur.monEditeur.getNodeById(fact11)
+ #print ('monNode', monNode)
+ r=monEficasConnecteur.suppNode(fact11)
+ r=monEficasConnecteur.suppNode(fact12)
+ r=monEficasConnecteur.suppNode(fact13)
+ print ('________________________________________________')
+ print ('________________________________________________')
+ print ('________________________________________________')
+ print ('________________________________________________')
+ print ('________________________________________________')
+ r=monEficasConnecteur.suppNode(fact14)
+ print (r)
+ #r=monEficasConnecteur.appendChild(monProc2,'Fact1')
+ #r=monEficasConnecteur.appendChild(monProc2,'Fact1')
+ #r=monEficasConnecteur.appendChild(monProc2,'Fact1')
+ #r=monEficasConnecteur.appendChild(monProc2,'Fact2')
+ #r=monEficasConnecteur.appendChild(monProc2,'Fact1')
+ #print (d)
+ #d=monEficasConnecteur.getDicoForFancy(monEficasConnecteur.monEditeur.tree.racine)
+ #pprint.pprint(d)
+ #r=monEficasConnecteur.appendChild(monProc2,'Fact1')
+ #print (r)
+ #d=monEficasConnecteur.getDicoForFancy(monEficasConnecteur.monEditeur.tree.racine)
+ #fact12=d['children'][0]['children'][3]['key']
+ #print(d['children'][0]['children'][3]['title'])
+ #r=monEficasConnecteur.appendChild(fact12,'paramInFact1')
+ #fact1=d['children'][0]['children'][2]
+ #print (fact1)
+ #fact11=d['children'][0]['children'][2]['key']
+ #print (fact11)
+ #print ('******************************************************')
+ #r=monEficasConnecteur.suppNode(fact11)
+ #r=monEficasConnecteur.appendChild(fact11,'paramInFact1')
+ #d=monEficasConnecteur.getDicoForFancy(monEficasConnecteur.monEditeur.tree.racine)
+ #paramInFact12=d['children'][0]['children'][2]['children'][0]['key']
+ #r=monEficasConnecteur.suppNode(paramInFact12)
+ #print (r)
+ (ok,newFile)=monEficasConnecteur.saveFile('/tmp/ajoutFact.comm')
+ exit()
+
+ testChangeValeur=0
+ if testChangeValeur :
+ monEficasConnecteur.litFichierComm('../WebTest/web_tres_simple_avec_2Fact.comm')
+ idRacine=monEficasConnecteur.monEditeur.tree.racine.item.idUnique
+ print ('idRacine', idRacine)
+ d=monEficasConnecteur.getDicoForFancy(monEficasConnecteur.monEditeur.tree.racine)
+ #pprint.pprint(d)
+
+ monProc=d['children'][0]['key']
+ print ('monProc', monProc)
+ param1=d['children'][0]['children'][0]['key']
+ print ('param1', param1)
+ r=monEficasConnecteur.changeValeur(param1,'65')
+ param12=d['children'][0]['children'][1]['key']
+ print ('param12', param12)
+ r=monEficasConnecteur.changeValeur(param12,'9')
+ r=monEficasConnecteur.appendChild(monProc,'param11')
+ d=monEficasConnecteur.getDicoForFancy(monEficasConnecteur.monEditeur.tree.racine)
+ param11=d['children'][0]['children'][1]['key']
+ print ('param11', param11)
+ r=monEficasConnecteur.changeValeur(param11,'11')
+
+ print ('______________ creation du bloc _____________________')
+ r=monEficasConnecteur.changeValeur(param1,'2')
+ d=monEficasConnecteur.getDicoForFancy(monEficasConnecteur.monEditeur.tree.racine)
+ #pprint.pprint(d)
+ param1_inBloc=d['children'][0]['children'][3]['key']
+ # on supprime le bloc
+ r=monEficasConnecteur.changeValeur(param1_inBloc,'1')
+ # on le rajoute (pb du bloc dans le bloc)
+ r=monEficasConnecteur.changeValeur(param1_inBloc,'2')
+ d=monEficasConnecteur.getDicoForFancy(monEficasConnecteur.monEditeur.tree.racine)
+ param1_inBlocDeBloc=d['children'][0]['children'][4]['key']
+ r=monEficasConnecteur.changeValeur(param1_inBlocDeBloc,'2')
+ print ('______________ creation du bloc _____________________')
+ param2_inBloc=d['children'][0]['children'][6]['key']
+ r=monEficasConnecteur.changeValeur(param1_inBlocDeBloc,'2')
+ (ok,newFile)=monEficasConnecteur.saveFile('/tmp/changeValeur.comm')
+ exit()
+
+ # creation du bloc
+ #r=monEficasConnecteur.changeValeur(i,'2')
+ #d=monEficasConnecteur.getDicoForFancy(monEficasConnecteur.monEditeur.tree.racine)
+ #(ok,newFile)=monEficasConnecteur.saveFile('/tmp/ajoutProcEtBloc.comm')
+ #pprint.pprint(d)
+
+ # suppression du bloc
+ #r=monEficasConnecteur.changeValeur(i,'1')
+ #d=monEficasConnecteur.getDicoForFancy(monEficasConnecteur.monEditeur.tree.racine)
+ #(ok,newFile)=monEficasConnecteur.saveFile('/tmp/suppressionBloc.comm')
+ #pprint.pprint(d)
+
+ # ajout du Fact2
+ d=monEficasConnecteur.getDicoForFancy(monEficasConnecteur.monEditeur.tree.racine)
+ e=d['children'][2]['key']
+ r=monEficasConnecteur.appendChild(e,'Fact2')
+ (ok,newFile)=monEficasConnecteur.saveFile('/tmp/ajoutFact2.comm')
+ d=monEficasConnecteur.getDicoForFancy(monEficasConnecteur.monEditeur.tree.racine)
+ mf=d['children'][2]['children'][4]['key']
+ print (mf)
+ r=monEficasConnecteur.appendChild(mf,'paramFacultatif')
+ (ok,newFile)=monEficasConnecteur.saveFile('/tmp/ajoutFacultatif.comm')
+ d=monEficasConnecteur.getDicoForFancy(monEficasConnecteur.monEditeur.tree.racine)
+ mf=d['children'][2]['children'][4]['children'][1]['key']
+ r=monEficasConnecteur.suppNode(mf)
+ print (r)
+ (ok,newFile)=monEficasConnecteur.saveFile('/tmp/ajoutFacultatifEtSuppresse.comm')
+ # essai enlever un mot clef qu on ne peut pas enlever
+ d=monEficasConnecteur.getDicoForFancy(monEficasConnecteur.monEditeur.tree.racine)
+ mf=d['children'][2]['children'][1]['key']
+ r=monEficasConnecteur.suppNode(mf)
+ print (r)
+ #(ok,newFile)=monEficasConnecteur.saveFile('/tmp/ajoutPuisSuppresFact2.comm')
+ #d=monEficasConnecteur.getDicoForFancy(monEficasConnecteur.monEditeur.tree.racine)
+ #pprint.pprint(d)
+ #print ('_________', r)
+
+ testPropageValide = 0
+ if testPropageValide :
+ monEficasConnecteur.litFichierComm('propageValide.comm')
+ idRacine=monEficasConnecteur.monEditeur.tree.racine.item.idUnique
+ #r=monEficasConnecteur.appendChild(idRacine,'MonProc',0)
+ #print ('ajout de MonProc en position 0', r)
+ #r=monEficasConnecteur.appendChild(idRacine,'MonProc2','last')
+ r=monEficasConnecteur.appendChild(idRacine,'MonProc','last')
+ d=monEficasConnecteur.getDicoForFancy(monEficasConnecteur.monEditeur.tree.racine)
+ param1PLast = d['children'][1]['children'][0]['key']
+ r=monEficasConnecteur.changeValeur(param1PLast,'1')
+ (ok,newFile)=monEficasConnecteur.saveFile('/tmp/propageValide.comm')
+ print ('ajout de MonProc2 en postion last', r)
+
+ testUpdateInfo = 0
+ if testUpdateInfo :
+ print ('________________________ testUpdateInfo ___________________________')
+ monEficasConnecteur.litFichierComm('../WebTest/web_tres_simple_avec_2Fact.comm')
+ idRacine=monEficasConnecteur.monEditeur.tree.racine.item.idUnique
+ print ('idRacine', idRacine)
+ d=monEficasConnecteur.getDicoForFancy(monEficasConnecteur.monEditeur.tree.racine)
+ badMonProc2 = d['children'][0]['children'][0]['key']
+ r=monEficasConnecteur.appendChild(badMonProc2,'Fact1')
+ monProc2 = d['children'][0]['key']
+ #print ('idProc2', monProc2)
+ #print (d)
+ r=monEficasConnecteur.appendChild(monProc2,'Fact1')
+ r=monEficasConnecteur.appendChild(monProc2,'Fact1')
+ r=monEficasConnecteur.appendChild(monProc2,'Fact1')
+ r=monEficasConnecteur.appendChild(monProc2,'Fact1')
+ d=monEficasConnecteur.getDicoForFancy(monEficasConnecteur.monEditeur.tree.racine)
+ print (['children'][0])
+
+ testAjoutSimpListe=0
+ if testAjoutSimpListe :
+ monEficasConnecteur.litFichierComm('../WebTest/web_tres_simple_avec_2Procs.comm')
+ idRacine=monEficasConnecteur.monEditeur.tree.racine.item.idUnique
+ r=monEficasConnecteur.appendChild(idRacine,'MonProc2','last')
+ d=monEficasConnecteur.getDicoForFancy(monEficasConnecteur.monEditeur.tree.racine)
+ monProc2=d['children'][2]['key']
+
+ testNommeProc=1
+ if testNommeProc :
+ monEficasConnecteur.litFichierComm('../WebTest/web_tres_simple_avec_2Procs.comm')
+ idRacine=monEficasConnecteur.monEditeur.tree.racine.item.idUnique
+ r=monEficasConnecteur.appendChild(idRacine,'MonOper','last')
+ d=monEficasConnecteur.getDicoForFancy(monEficasConnecteur.monEditeur.tree.racine)
+ monOper=d['children'][2]['key']
+ bOk, message = monEficasConnecteur.updateSDName(monOper,'toto')
+ print ('in testNommeProc, bOk, message', bOk, message)
+ d=monEficasConnecteur.getDicoForFancy(monEficasConnecteur.monEditeur.tree.racine)
+ monParam=d['children'][2]['children'][0]['key']
+ r=monEficasConnecteur.changeValeur(monParam,'65')
+ bOk, message = monEficasConnecteur.updateSDName(monOper,'toto')
+ print ('in testNommeProc, bOk, message', bOk, message)
+
+ #print ( '\n Fichier /home/A96028/QT5GitEficasTravail/Web/eficas/WebTest/web_tres_simple_avec_2Procs.comm')
+ #monEficasConnecteur.litFichierComm('../WebTest/web_tres_simple_avec_2Procs.comm')
+ #pprint.pprint (monEficasConnecteur.getDicoObjetsCompletsPourTree(monEficasConnecteur.monEditeur.tree.racine))
+
+ #print ( '\n Fichier /home/A96028/QT5GitEficasTravail/Web/eficas/WebTest/web_tres_simple_avec_Bloc.comm')
+ #monEficasConnecteur.litFichierComm('../WebTest/web_tres_simple_avec_Bloc.comm')
+ #print (monEficasConnecteur.generDicoPourWeb())
+ #print (monEficasConnecteur.getDicoObjetsPourWeb(monEficasConnecteur.monEditeur.tree.racine))
+ #pprint.pprint (monEficasConnecteur.getDicoObjetsCompletsPourTree(monEficasConnecteur.monEditeur.tree.racine))
+ #print ('\n')
+
+ #print ( '\n Fichier /home/A96028/QT5GitEficasTravail/Web/eficas/WebTest/web_tres_simple_avec_2Fact.comm')
+ #monEficasConnecteur.litFichierComm('../WebTest/web_tres_simple_avec_2Fact.comm')
+ #print (monEficasConnecteur.generDicoPourWeb())
+ #monDicoAAfficher = (monEficasConnecteur.getDicoObjetsPourWeb(monEficasConnecteur.monEditeur.tree.racine))
+ #monEficasConnecteur.traiteDico(monDicoAAfficher)
+ #pprint.pprint (monEficasConnecteur.getDicoObjetsCompletsPourTree(monEficasConnecteur.monEditeur.tree.racine))
+
+ #print ('/home/A96028/QT5GitEficasTravail/Web/eficas/WebTest/web_tres_simple_avec_Fact.comm')
+ #monEficasConnecteur.litFichierComm('../WebTest/web_tres_simple_avec_Fact.comm')
+ #print (monEficasConnecteur.generDicoPourWeb())
+ #pprint.pprint (monEficasConnecteur.getDicoObjetsCompletsPourTree(monEficasConnecteur.monEditeur.tree.racine))
+ #print ('\n')
+
Class implementing the 5C user interface.
"""
- def __init__(self,code='5C', salome=0, multi = 0, versionCode=None, langue='en', GUIPath="InterfaceGUI.cinqC"):
+ def __init__(self,code='5C', salome=0, multi = 0, versionCode=None, langue='en', GUIPath="InterfaceGUI.cinqC",appWeb=None):
super().__init__(code=code, salome=salome, multi=multi, langue=langue, versionCode=versionCode, GUIPath=GUIPath)
self.withXSD = True
self.GUIPath = GUIPath
self.actionCode = QAction(self)
self.actionCode.setText(tr("Aide 5C"))
self.actionCode.triggered.connect(self.aideCode)
- self.actionOuvrir.triggered.connect(self.fileOpen)
+ self.actionOuvrir.triggered.connect(self.openFile)
- def fileOpen(self) :
+ def openFile(self) :
print ('aChanger')
print ( self.editorManager)
