# Normalement on ne devrait pas passer ici
return 0, "Normalement on ne devrait pas passer ici"
+ def getIndexDsParent(self):
+ return self.parent.getIndex(self)
+
def getSdprods(self, nom_sd):
"""
Fonction : retourne le concept produit par l etape de nom nom_sd
self.recorded_units = {}
self.old_recorded_units = {}
+ def isOblig(self):
+ return 1
+
def getIndex(self, objet):
"""
Retourne la position d'objet dans la liste self
# Apres suppression de l'etape il faut controler que les etapes
# suivantes ne produisent pas des concepts DETRUITS dans op_init de etape
+ etapeSup = etape
if index_etape > 0:
index_etape = index_etape - 1
etape = self.etapes[index_etape]
self.controlContextApres(etape)
self.resetContext()
- CONNECTOR.Emit(self, "supp", etape)
+ CONNECTOR.Emit(self, "supp", etapeSup)
self.finModif()
return 1
itemMCPath = mc.getChild("MCPath")
itemMCPath.setValeur(mc.variableDeterministe.getMCPath())
- # ATTENTION SURCHARGE : les methodes ci-dessus surchargent des methodes de processing et Accas.validation : a reintegrer
+ def getDicoForFancy(self):
+ monDico = {}
+ monDico["title"] = self.code
+ monDico["key"] = self.idUnique
+ monDico["classeAccas"] = "JDC"
+ monDico["validite"] = self.getValid()
+ if not (monDico["validite"]):
+ monDico["validite"] = 0
+ # self.editor.fichier ?
+ listNodes = []
+ for e in self.etapes:
+ listNodes.append(e.getDicoForFancy())
+ monDico["children"] = listNodes
+ return monDico
+
+
+
+ # ATTENTION SURCHARGE : les methodes ci-dessus surchargent des methodes de Noyau et Validation : a reintegrer
def getFile(self, unite=None, fic_origine=""):
"""
for i in self.data:
listeDict.append(i.getDicoObjetsCompletsPourTree())
return listeDict
-
def getDicoForFancy(self):
listeDict = []
nbFactDejaLa = len(self.data)
dico["repetable"] = 0
listeDict.append(dico)
return listeDict
+
def isOblig(self):
"""
Une MCList n'est jamais obligatoire (meme si le MCFACT qu'elle represente l'est
self.definition.siValide(self)
return validite
+
+ def getDicoForFancy(self):
+ # print ('MCSIMP getDicoForFancy ', self)
+ monDico = {}
+ monDico["title"] = self.nom
+ monDico["key"] = self.idUnique
+ if self.valeur != None:
+ monDico["wValue"] = str(self.valeur)
+ else:
+ monDico["wValue"] = ""
+ monDico["classeAccas"] = self.nature
+ monDico["validite"] = self.getValid()
+ if monDico["validite"] == None:
+ monDico["validite"] = self.isValid()
+ monDico["max"] = self.definition.max
+ monDico["min"] = self.definition.min
+ monDico["into"] = self.definition.into
+ monDico["statut"] = self.definition.statut
+ # a priori jamais vrai sauf si on a change un nom de userassd
+ if monDico["validite"] == 0 and monDico["statut"] == "f":
+ monDico["validite"] == 2
+
+ return monDico
def getNomConcept(self):
p = self
while p.parent:
for leNode in lesNodes:
listeNodes.append(leNode)
monDico["children"] = listeNodes
- print (self.nature)
+ #print (self.nature)
if self.nature != "MCSIMP" and self.nature != "MCLIST" and self.nature != "JDC":
monDico["infoOptionnels"] = self.calculOptionnelInclutBlocs()
return monDico
import Accas.IO.reader as reader
import Accas.IO.writer as writer
+from Accas.extensions.eficas_exception import EficasException
Dictextensions = {"MAP": ".map", "TELEMAC": ".cas"}
debug = False
Editeur de jdc
"""
- def __init__(self, appliEficas, fichier=None, jdc=None, units=None, include=0):
+ def __init__(self, appliEficas, fichier=None, jdc=None, include=0):
# ----------------------------------------------------------------------------#
if debug: print("dans le init de Editor")
self.appliEficas = appliEficas
try:
#if 1 :
self.jdc = self.readFile(self.fichier)
- except:
+ except Exception as e :
#else :
print("mauvaise lecture du fichier")
+ raise EficasException("str(e)")
if self.appliEficas.salome:
try:
self.appliEficas.addJdcInSalome(self.fichier)
- except:
+ except Exception as e:
print("mauvais enregistrement dans Salome")
+ raise EficasException("str(e)")
else:
self.jdc = jdc
- if self.jdc is not None and units is not None:
- self.jdc.recorded_units = units
- self.jdc.old_recorded_units = units
-
else:
if not self.jdc: # nouveau jdc
if not include:
- self.jdc = self._newJDC(units=units)
+ self.jdc = self._newJDC()
else:
- self.jdc = self._newJDCInclude(units=units)
+ self.jdc = self._newJDCInclude()
self.nouveau = 1
if self.jdc:
monJDCReader.text = texteNew
text = monJDCReader.convert("exec", self.appliEficas)
if not monJDCReader.cr.estvide():
- self.afficheInfos("Erreur a la conversion", "red")
+ self.afficheMessage("Erreur a la conversion", "red")
else:
text = monJDCReader.text
else:
- self.afficheInfos("Type de fichier non reconnu", "red")
+ self.afficheMessage("Type de fichier non reconnu", "red")
self.informe(
"Type de fichier non reconnu",
"EFICAS ne sait pas ouvrir le type de fichier "
self.monJDCReader = monJDCReader
return jdc
- # ---------------------------------------#
- def _newJDC(self, texte = "", units=None):
- # ---------------------------------------#
+ # ----------------------------#
+ def _newJDC(self, texte = ""):
+ # ----------------------------#
"""
Initialise un nouveau JDC avec le texte passe en parametre
"""
)
jdc.lang = self.appliEficas.langue
- if units is not None:
- jdc.recorded_units = units
- jdc.old_recorded_units = units
jdc.editor = self
return jdc
- # --------------------------------#
- def _newJDCInclude(self, units=None):
- # --------------------------------#
+ # ----------------------#
+ def _newJDCInclude(self):
+ # ----------------------#
"""
Initialise un nouveau JDC include vierge
Inutilise depuis Aster mais interessant
)
J.editor = self
J.analyse()
- if units is not None:
- J.recorded_units = units
- J.old_recorded_units = units
return J
# -----------------------#
p.readfile(file)
text = p.convert("execnoparseur")
if not p.cr.estvide():
- self.afficheInfos("Erreur a la conversion", "red")
+ self.afficheMessage("Erreur a la conversion", "red")
return text
else:
# Il n'existe pas c'est une erreur
- self.afficheInfos("Type de fichier non reconnu", "red")
+ self.afficheMessage("Type de fichier non reconnu", "red")
self.informe(
"Type de fichier non reconnu",
"EFICAS ne sait pas ouvrir le type de fichier "
# -----------------------#
# on ajoute les regles
texteGlobal, testOK = self.jdc.verifRegles()
- return texteGglobal
+ return texteGlobal
# ---------------------#
def getFileName(self):
"Le fichier" + str(fn) + "n a pas pu etre sauvegarde :",
str(why),
)
- self.afficheInfos(
+ self.afficheMessage(
"Le fichier" + str(fn) + "n a pas pu etre sauvegarde ", "red"
)
return 0
dico = self.myWriter.Dico
return dico
else:
- self.afficheInfos(
+ self.afficheMessage(
tr("Format %s non reconnu", "Dictionnaire Imbrique"), "red"
)
return ""
print("!!!!!!!!!!!!!!!!!!!!!!!!!!!")
# --------------------------------------#
- def afficheInfos(self, txt, couleur=None):
+ def afficheMessage(self, txt, couleur=None):
# --------------------------------------#
# methode differenre avec et sans ihm
print(txt)
self.doubles = {}
- # ----------------------------------------------------------------
- def getEditor(self, fichier=None, jdc=None, units=None, include=0):
- # ----------------------------------------------------------------
+ # -----------------------------------------------------
+ def getEditor(self, fichier=None, jdc=None, include=0):
+ # -----------------------------------------------------
"""
Retourne un nouvel editeur ou None si doublon
"""
self.appliEficas.afficheMessage('Eficas sans Ihm', 'Fichier deja ouvert')
return None
from Editeur.editor import Editor
- editor = Editor(self.appliEficas, fichier, jdc, units, include)
+ editor = Editor(self.appliEficas, fichier, jdc, include)
if not editor.jdc :
self.appliEficas.afficheMessage('Eficas sans Ihm', 'impossible d allouer un editor')
return None
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):
# --------------------------------
#
import os, sys
+
from Accas.extensions.eficas_exception import EficasException
from Editeur import session
from Editeur.getVersion import getEficasVersion
+from Accas.extensions.eficas_translation import tr
class EficasAppli:
try:
from Accas import eficasSalome
Accas.SalomeEntry = eficasSalome.SalomeEntry
- except e:
+ except Exception as e:
print ("impossible d importer les salome entry")
print (str(e))
texte = p.convert("execnoparseur")
return texte
- #------------------------------------------------------------------
- def newEditor(self, fichier=None, jdc=None, units=None, include=0):
- #------------------------------------------------------------------
+ #------------------------------------------------------
+ def getEditor(self, fichier=None, jdc=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 getEditor(self):
- #-------------------
- if (hasattr(self, "editor")) and self.editor != None: return self.editor
- self.newEditor()
+ self.editor = self.editorManager.getEditor(fichier, jdc, include)
return self.editor
+
#--------------------------
def getEditorById(self,id):
#--------------------------
try:
monEditor = self.editorManager.openFile(fichier)
except EficasException as exc:
- afficheMessage(self, 'erreur ouverture fichier', str(exc),critical=True)
+ self.afficheMessage( 'erreur ouverture fichier', str(exc),critical=True)
monEditor = None
return monEditor
for study in session.d_env.studies:
os.chdir(cwd)
d = session.getUnit(study, self)
- self.editorManager.openFile(fichier=study["comm"], units=d)
+ self.editorManager.openFile(fichier=study["comm"])
- #----------------------
+ #---------------------
def saveFullFile(self):
#----------------------
# Pour Telemac
def fileNew(self):
#-------------------
try:
- self.editorManager.newEditor()
+ self.editorManager.getEditor()
except EficasException as exc:
msg = str(exc)
if msg != "":
sys.exit(res)
-def getEficas( code=None, multi=False, langue="en", forceXML=False, fichierCata=None,GUIPath=None, appWeb = None):
-# ------------------------------------------------------------------------------------------------------------------
+def getEficas( code=None, ssCode = None, versionCode = None , multi=False, langue="en", GUIPath=None, appWeb = None, fichierCata = None):
+# ---------------------------------------------------------------------------------------------------------------------------------------
"""
instancie l'appli EFICAS sans Ihm
"""
options = session.parse(sys.argv)
if options.code != None:
code = options.code
- if forceXML: options.withXSD = True
if GUIPath in ('QT5', 'cinqC') :
pathAbso=os.path.abspath(os.path.join(os.path.dirname(__file__),'..','InterfaceGUI',GUIPath))
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, appWeb=None)
+ Eficas = EficasAppli(code=code, multi=multi, langue=langue, ssCode=ssCode, versionCode=versionCode, fichierCata=fichierCata, GUIPath=GUIPath, appWeb=appWeb)
return Eficas
--- /dev/null
+from builtins import object
+import logging
+import os
+
+msgGetDico='d=monEficasConnecteur.getDicoForFancy(monEficasConnecteur.monEditeur.tree.racine)'
+msgId='leMotClef={}'
+
+class loggingEnvironnement(object):
+ _instance = None
+
+ def __new__(cls, *args, **kwargs):
+ if not cls._instance:
+ cls._instance = super(loggingEnvironnement, cls).__new__(cls, *args, **kwargs)
+ return cls._instance
+
+ def __init__(self):
+ self.fichier=None
+
+ def setFile(self,fichier, code='Essai'):
+ loggerForTrace = logging.getLogger('loggingForTrace')
+ if self.fichier != None : print ('La log est deja ecrite dans : ', self.fichier); return
+ if (os.path.isfile(fichier)) :
+ print ('le fichier {} existe deja'.format(fichier))
+ loggerForTrace.info('#_________________ redemarrage de la log _________________')
+ fileHandler = logging.FileHandler(fichier)
+ formatter = logging.Formatter('%(message)s')
+ fileHandler.setFormatter(formatter)
+ loggerForTrace.addHandler(fileHandler)
+ loggerForTrace.setLevel(logging.INFO)
+ loggerForTrace.info('from connectEficas import accasConnecteur')
+ loggerForTrace.info('monEficasConnecteur=accasConnecteur("{}")'.format(code))
+
+
+def fonctionLoguee(laFonction, debug=True):
+#-------------------------------------------
+ from inspect import getfullargspec
+ from functools import wraps
+ listeArgs=getfullargspec(laFonction)
+ @wraps(laFonction)
+ def laFonctionLoguee(*args, **kwargs):
+ if debug : print('Appel {} avec args={} et kwargs={}'.format( laFonction.__name__, args, kwargs))
+ loggerForTrace = logging.getLogger('loggingForTrace')
+ if 'id' in listeArgs.args :
+ indexId=listeArgs.args.index('id')
+ id = args[indexId]
+ if debug : print ('id est le parametre ', str(indexId), ' de la fonction :', laFonction.__name__)
+ monConnecteur=args[0]
+ loggerForTrace.info(msgGetDico)
+ finMsgId = monConnecteur.reconstruitChaineDIndex(id)
+ if debug : print ('finMsgId', finMsgId)
+ loggerForTrace.info(msgId.format(finMsgId))
+ else :
+ if debug : print ('id n est pas un parametre de la fonction :', laFonction.__name__,)
+ indexId=-1
+
+ i=1
+ chaineDArgs='('
+ for monArg in args[1:] :
+ #if debug : print ('chaineDArgs', chaineDArgs)
+ #if debug : print ('monArg', monArg)
+ if indexId == i:
+ chaineDArgs+='leMotClef,'
+ i=i+1
+ continue
+ if isinstance(monArg, str) : chaineDArgs+='"'+str(monArg)+'",'
+ else : chaineDArgs+=str(monArg)+','
+ i=i+1
+ for (k,v) in kwargs :
+ if isinstance(v, str) : chaineDArgs+=str(k)+'="'+str(v)+'",'
+ else : chaineDArgs+=str(k)+'='+str(v)+','
+ chaineDArgs=chaineDArgs[:-1]+')'
+ if debug : print ('chaineDArgs', chaineDArgs)
+ msg='print (monEficasConnecteur.{}{})'.format(laFonction.__name__, chaineDArgs)
+ if debug : print ('msg', msg)
+ loggerForTrace.info(msg)
+ return laFonction(*args, **kwargs)
+ return laFonctionLoguee
+
+
+if __name__=='__main__':
+ monSingleton=loggingEnvironnement()
+ monSingleton.setFile('/tmp/toto.txt')
+ loggerForTrace = logging.getLogger('loggingForTrace')
+ loggerForTrace.info('Our First Log Message')
ret, commentaire = self.vraiParent.item.suppItem(self.item)
if ret == 0:
- self.editor.afficheInfos(commentaire, Qt.red)
+ self.editor.afficheMessage(commentaire, Qt.red)
else:
- self.editor.afficheInfos(commentaire)
+ self.editor.afficheMessage(commentaire)
self.treeParent.buildChildren()
if self.treeParent.childrenComplete:
toselect = self.treeParent.childrenComplete[index]
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
-from InterfaceGUI.common import Objecttreeitem
+from InterfaceGUI.common import objecttreeitem
from InterfaceGUI.QT5 import compofact
from InterfaceGUI.QT5 import browser
#
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
-from InterfaceGUI.common import Objecttreeitem
+from InterfaceGUI.common import objecttreeitem
from InterfaceGUI.QT5 import browser
from InterfaceGUI.QT5 import typeNode
from Accas.extensions.eficas_translation import tr
self.setText(1, tr(debComm))
-class COMMTreeItem(Objecttreeitem.ObjectTreeItem):
+class COMMTreeItem(objecttreeitem.ObjectTreeItem):
itemNode = Node
def init(self):
def getObjetCommentarise(self):
"""
La methode getObjetCommentarise() de la classe compocomm.COMMTreeItem
- surcharge la methode getObjetCommentarise de la classe Objecttreeitem.ObjectTreeItem
+ surcharge la methode getObjetCommentarise de la classe objecttreeitem.ObjectTreeItem
elle a pour but d'empecher l'utilisateur final de commentariser un commentaire.
"""
raise EficasException("Impossible de commentariser un commentaire")
import traceback
-from InterfaceGUI.common import Objecttreeitem
+from InterfaceGUI.common import objecttreeitem
from Accas.extensions.eficas_exception import EficasException
from InterfaceGUI.QT5 import compocomm
-class COMMANDE_COMMTreeItem(Objecttreeitem.ObjectTreeItem):
+class COMMANDE_COMMTreeItem(objecttreeitem.ObjectTreeItem):
itemNode = compocomm.Node
def init(self):
from InterfaceGUI.QT5 import typeNode
from Accas.extensions.eficas_translation import tr
-from InterfaceGUI.common import Objecttreeitem
+from InterfaceGUI.common import objecttreeitem
import traceback
else:
self.niveau = 1
if hasattr(self, "plie") and self.plie == True:
- from InterfaceGUI.QT5.nterfaceGUI.QT5.monWidgetFactPlie import MonWidgetFactPlie
+ from InterfaceGUI.QT5.monWidgetFactPlie import MonWidgetFactPlie
widget = MonWidgetFactPlie(
self,
elif self.editor.maConfiguration.afficheFirstPlies and self.firstAffiche:
self.firstAffiche = False
self.setPlie()
- from InterfaceGUI.QT5.nterfaceGUI.QT5.monWidgetFactPlie import MonWidgetFactPlie
+ from InterfaceGUI.QT5.monWidgetFactPlie import MonWidgetFactPlie
widget = MonWidgetFactPlie(
self,
maCommande,
)
else:
- from InterfaceGUI.QT5.nterfaceGUI.QT5.monWidgetFact import MonWidgetFact
+ from InterfaceGUI.QT5.monWidgetFact import MonWidgetFact
widget = MonWidgetFact(
self,
typeNode.PopUpMenuNodeMinimal.createPopUpMenu(self)
-class FACTTreeItem(Objecttreeitem.ObjectTreeItem):
+class FACTTreeItem(objecttreeitem.ObjectTreeItem):
itemNode = Node
def isExpandable(self):
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
-from InterfaceGUI.common import Objecttreeitem
+from InterfaceGUI.common import objecttreeitem
from InterfaceGUI.QT5 import browser
from InterfaceGUI.QT5 import typeNode
from Accas.extensions.eficas_translation import tr
return param
-class JDCTreeItem(Objecttreeitem.ObjectTreeItem):
+class JDCTreeItem(objecttreeitem.ObjectTreeItem):
itemNode = Node
def isExpandable(self):
import traceback
# Modules Eficas
-from InterfaceGUI.common import Objecttreeitem
+from InterfaceGUI.common import objecttreeitem
from Accas.extensions.eficas_translation import tr
from InterfaceGUI.QT5 import compooper
from InterfaceGUI.QT5 import browser
from InterfaceGUI.QT5 import typeNode
from Accas.extensions.eficas_translation import tr
-from InterfaceGUI.common import Objecttreeitem
+from InterfaceGUI.common import objecttreeitem
from Accas.processing.P_OBJECT import ErrorObj
return child
-class MCListTreeItem(Objecttreeitem.SequenceTreeItem, compofact.FACTTreeItem):
+class MCListTreeItem(objecttreeitem.SequenceTreeItem, compofact.FACTTreeItem):
"""La classe MCListTreeItem joue le role d'un adaptateur pour les objets
du processing Accas instances de la classe MCLIST.
Elle adapte ces objets pour leur permettre d'etre integres en tant que
def isExpandable(self):
if len(self._object) > 1:
- return Objecttreeitem.SequenceTreeItem.isExpandable(self)
+ return objecttreeitem.SequenceTreeItem.isExpandable(self)
else:
return compofact.FACTTreeItem.isExpandable(self)
from Accas.extensions.eficas_translation import tr
from Accas.extensions.eficas_exception import EficasException
-from InterfaceGUI.common import Objecttreeitem
+from InterfaceGUI.common import objecttreeitem
from InterfaceGUI.QT5 import browser
from InterfaceGUI.QT5 import typeNode
self.editor.initModif()
test, mess = self.item.nommeSd(nom)
if test == 0:
- self.editor.afficheInfos(mess, "red")
+ self.editor.afficheMessage(mess, "red")
old = self.item.getText()
self.monWidgetNom.setText(old)
else:
# troisD.envoievisu()
-class EtapeTreeItem(Objecttreeitem.ObjectTreeItem):
+class EtapeTreeItem(objecttreeitem.ObjectTreeItem):
"""La classe EtapeTreeItem est un adaptateur des objets ETAPE du processing
Accas. Elle leur permet d'etre affichés comme des noeuds
d'un arbre graphique.
from Accas.extensions.eficas_translation import tr
# import modules EFICAS
-from InterfaceGUI.common import Objecttreeitem
+from InterfaceGUI.common import objecttreeitem
from InterfaceGUI.QT5 import browser
from InterfaceGUI.QT5 import typeNode
return None
-class PARAMTreeItem(Objecttreeitem.ObjectTreeItem):
+class PARAMTreeItem(objecttreeitem.ObjectTreeItem):
"""
Classe servant a definir l'item porte par le noeud de l'arbre d'EFICAS
qui represente le PARAMETRE
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
-from InterfaceGUI.common import Objecttreeitem
+from InterfaceGUI.common import objecttreeitem
from InterfaceGUI.QT5 import compooper
from InterfaceGUI.QT5 import browser
from InterfaceGUI.QT5 import typeNode
from InterfaceGUI.QT5 import typeNode
# Modules Eficas
-from InterfaceGUI.common import Objecttreeitem
+from InterfaceGUI.common import objecttreeitem
from InterfaceGUI.QT5 import browser
from Accas import SalomeEntry
from Accas import ASSD
typeNode.PopUpMenuNodeMinimal.createPopUpMenu(self)
-class SIMPTreeItemCommun(Objecttreeitem.AtomicObjectTreeItem):
+class SIMPTreeItemCommun(objecttreeitem.AtomicObjectTreeItem):
def init(self):
self.expandable = 0
)
if commentaire != "":
- self.editor.afficheInfos(tr(str(commentaire)))
+ self.editor.afficheMessage(tr(str(commentaire)))
if selection == []:
return
if valeur:
ok, msgError = self.appliEficas.displayShape(valeur)
if not ok:
- self.editor.afficheInfos(msgError, Qt.red)
+ self.editor.afficheMessage(msgError, Qt.red)
def BParametresPressed(self):
liste = self.node.item.getListeParamPossible()
if len(self.listeValeursCourantes) < self.monSimpDef.max:
self.chercheLigneVide()
else:
- self.editor.afficheInfos(
+ self.editor.afficheMessage(
"nb max de valeurs : " + str(self.monSimpDef.max) + " atteint",
Qt.red,
)
return
if len(listeNode) == 1:
listeNode[0].delete()
- self.editor.afficheInfos("")
+ self.editor.afficheMessage("")
return
for noeud in listeNode:
noeud.treeParent.item.suppItem(noeud.item)
noeud.treeParent.buildChildren()
- self.editor.afficheInfos("")
+ self.editor.afficheMessage("")
def ajoutMC(self, texteListeNom):
listeNom = texteListeNom.split("+")[1:]
if firstNode == None:
firstNode = nouveau
if nouveau == None or nouveau == 0:
- self.editor.afficheInfos(
+ self.editor.afficheMessage(
tr("insertion impossible a cet endroit pour " + nom), Qt.red
)
try:
message = tr(
"La cardinalite n'est pas correcte, la derniere valeur est ignoree"
)
- self.editor.afficheInfos(message, Qt.red)
+ self.editor.afficheMessage(message, Qt.red)
i = 0
while i < len(liste):
try:
commentaire += str(self.nbValeursASaisir)
commentaire += tr(" valeurs")
self.LEValeur.setText(str(liste))
- self.editor.afficheInfos(commentaire, Qt.red)
+ self.editor.afficheMessage(commentaire, Qt.red)
return
if self.node.item.waitTuple() == 1:
)
self.Commentaire.setText(tr(comm2))
if not validite:
- self.editor.afficheInfos(comm, Qt.red)
+ self.editor.afficheMessage(comm, Qt.red)
else:
self.LEValeur.setText("")
l1 = self.listeValeursCourantes[:indexListe]
if len(liste) % self.nbValeurs != 0:
texte = "Nombre de valeur incorrecte"
# self.Commentaire.setText(texte)
- self.editor.afficheInfos(texte, Qt.red)
+ self.editor.afficheMessage(texte, Qt.red)
return
listeDecoupee = self.decoupeListeValeurs(liste)
for vals in listeDecoupee:
def __init__(self, editor, name=None, fl=0):
self.editor = editor
- self.editor.afficheInfos("")
+ self.editor.afficheMessage("")
QDialog.__init__(self, editor)
self.setupUi(self)
self.connecterSignaux()
exec("from InterfaceGUI.QT5.ath import *", contexte)
jdc = self.editor.jdc
if jdc == None:
- self.editor.afficheInfos(
+ self.editor.afficheMessage(
tr(
"La Creation de parametre n est possible que dans un jeu de donnees"
),
monTexte = "monParam='" + valString + "'"
self.val = "'" + valString + "'"
except:
- self.editor.afficheInfos(tr("Valeur incorrecte"), Qt.red)
+ self.editor.afficheMessage(tr("Valeur incorrecte"), Qt.red)
if self.lineEditNom.text() != "" and self.dejaExistant == False:
self.creeParametre()
if not pattern_name.match(nom):
self.lineEditNom.setText("")
commentaire = nom + tr(" n est pas un identifiant correct\n ")
- self.editor.afficheInfos(commentaire, Qt.red)
+ self.editor.afficheMessage(commentaire, Qt.red)
for p in self.editor.jdc.params:
if p.nom == nom:
commentaire = nom + tr(" existe deja\n ")
- self.editor.afficheInfos(commentaire, Qt.red)
+ self.editor.afficheMessage(commentaire, Qt.red)
return
if self.lineEditVal.text() != "":
self.editor.afficheCommentaire(commentaire)
self.oldValeurTexte = self.lineEditVal.text()
else:
- self.editor.afficheInfos(commentaire, Qt.red)
+ self.editor.afficheMessage(commentaire, Qt.red)
self.lineEditVal.setText("")
self.oldValeurTexte = ""
self.parentQt.propageChange(self.objSimp.definition.type[0], self)
test, erreur = self.node.item.verifNom(nomFormule)
if test:
commentaire = nomFormule + tr(" est un nom valide pour une FORMULE")
- self.editor.afficheInfos(commentaire)
+ self.editor.afficheMessage(commentaire)
else:
commentaire = nomFormule + tr(" n'est pas un nom valide pour une FORMULE")
- self.editor.afficheInfos(commentaire, Qt.red)
+ self.editor.afficheMessage(commentaire, Qt.red)
return
if str(self.LENomsArgs.text()) != "" and str(self.LECorpsFormule.text()) != "":
self.BOkPressedFormule()
test, erreur = self.node.item.verifArguments(arguments)
if test:
commentaire = tr("Argument(s) valide(s) pour une FORMULE")
- self.editor.afficheInfos(commentaire)
+ self.editor.afficheMessage(commentaire)
else:
commentaire = tr("Argument(s) invalide(s) pour une FORMULE")
- self.editor.afficheInfos(commentaire, Qt.red)
+ self.editor.afficheMessage(commentaire, Qt.red)
if (
str(self.LECorpsFormule.text()) != ""
and str(self.LENomFormule.text()) != ""
if test:
commentaire = tr("Corps de FORMULE valide")
- self.editor.afficheInfos(commentaire)
+ self.editor.afficheMessage(commentaire)
else:
commentaire = tr("Corps de FORMULE invalide")
- self.editor.afficheInfos(commentaire, Qt.red)
+ self.editor.afficheMessage(commentaire, Qt.red)
if str(self.LENomsArgs.text()) != "" and str(self.LENomFormule.text()) != "":
self.BOkPressedFormule()
nomFormule = str(self.LENomFormule.text())
test, erreur = self.node.item.verifNom(nomFormule)
if not test:
- self.editor.afficheInfos(erreur, Qt.red)
+ self.editor.afficheMessage(erreur, Qt.red)
return
arguments = str(self.LENomsArgs.text())
test, erreur = self.node.item.verifArguments(arguments)
if not test:
- self.editor.afficheInfos(erreur, Qt.red)
+ self.editor.afficheMessage(erreur, Qt.red)
return
expression = str(self.LECorpsFormule.text())
(nomFormule, "REEL", arguments, expression)
)
if not test:
- self.editor.afficheInfos(erreur, Qt.red)
+ self.editor.afficheMessage(erreur, Qt.red)
return
test = self.node.item.object.updateFormulePython(
self.node.onValid()
self.node.update_valid()
commentaire = "Formule saisie"
- self.editor.afficheInfos(commentaire)
+ self.editor.afficheMessage(commentaire)
else:
commentaire = "Formule incorrecte : " + erreur
- self.editor.afficheInfos(commentaire, Qt.red)
+ self.editor.afficheMessage(commentaire, Qt.red)
self.editor.initModif()
return
boolOk, commentaire = self.monType.verifItem(texte, self.node.item.object)
if not boolOk:
- self.editor.afficheInfos(tr(commentaire), Qt.red)
+ self.editor.afficheMessage(tr(commentaire), Qt.red)
monItem.setText("")
return
if self.monType.coloree:
except:
ok = False
if ok == False:
- self.editor.afficheInfos(tr("Entrer un float SVP"), Qt.red)
+ self.editor.afficheMessage(tr("Entrer un float SVP"), Qt.red)
monItem.setText("")
return
if self.monType.valSup != None:
if val > self.monType.valSup:
- self.editor.afficheInfos(
+ self.editor.afficheMessage(
tr("Entrer un float inferieur a ") + repr(self.monType.valSup),
Qt.red,
)
return
if self.monType.valMin != None:
if val < self.monType.valMin:
- self.editor.afficheInfos(
+ self.editor.afficheMessage(
tr("Entrer un float superieur a ") + repr(self.monType.valMin),
Qt.red,
)
monItem.setText("")
return
- self.editor.afficheInfos("")
+ self.editor.afficheMessage("")
if self.monType.structure != None:
MonWidgetMatrice.__dict__[self.monType.structure](*(self,))
self.acceptVal()
if len(listeComplete) > max:
texte = tr("Nombre maximum de valeurs ") + str(max) + tr(" atteint")
- self.editor.afficheInfos(texte, Qt.red)
+ self.editor.afficheMessage(texte, Qt.red)
return
validite, comm, comm2, listeRetour = self.politique.ajoutNTuple(listeComplete)
if valeur != None and valeur != "":
commentaire = self.ajout1Valeur(valeur)
if commentaire != None:
- self.editor.afficheInfos(commentaire, Qt.red)
+ self.editor.afficheMessage(commentaire, Qt.red)
courant.setText("")
donneFocus = courant
self.reaffiche()
return
else:
- self.editor.afficheInfos("")
+ self.editor.afficheMessage("")
elif donneFocus == None:
donneFocus = courant
return
min, max = self.node.item.getMinMax()
if len(self.listeValeursCourantes) < self.monSimpDef.min:
- self.editor.afficheInfos(
+ self.editor.afficheMessage(
tr("nb min de valeurs : ") + str(self.monSimpDef.min)
)
if len(self.listeValeursCourantes) < min and oblige == True:
return
retour = self.node.item.setValeur(self.listeValeursCourantes)
if len(self.listeValeursCourantes) == self.monSimpDef.max:
- self.editor.afficheInfos(tr("nb max de valeurs atteint"))
+ self.editor.afficheMessage(tr("nb max de valeurs atteint"))
self.setValide()
self.reaffiche()
self.inhibeChangeValeur = False
oldValeurUserAssd, valeur
)
if commentaire != "" and not validite:
- self.editor.afficheInfos(commentaire, Qt.red)
+ self.editor.afficheMessage(commentaire, Qt.red)
self.lineEditEnCours.setText(oldValeurUserAssd.nom)
nomDernierLineEdit = "lineEditVal" + str(self.numLineEditEnCours + 1)
dernier = getattr(self, nomDernierLineEdit)
validite, objASSD, commentaire = self.objSimp.creeUserASSD(valeur)
if commentaire != "" and not validite:
- self.editor.afficheInfos(commentaire, Qt.red)
+ self.editor.afficheMessage(commentaire, Qt.red)
self.lineEditEnCours.setText("")
if objASSD:
objASSD.supprime(self.objSimp)
dernier = getattr(self, nomDernierLineEdit)
dernier.setFocus()
else:
- self.editor.afficheInfos("ajout impossible", Qt.red)
+ self.editor.afficheMessage("ajout impossible", Qt.red)
if objASSD:
objASSD.supprime(self.objSimp)
self.lineEditEnCours.setText("")
min, max = self.node.item.getMinMax()
if max < len(self.listeAAfficher):
commentaire = tr("impossible de tout selectionner : max =") + str(max)
- self.editor.afficheInfos(commentaire, Qt.red)
+ self.editor.afficheMessage(commentaire, Qt.red)
self.inhibe = False
return
for i in range(len(self.listeAAfficher)):
if valeur != None and valeur != "":
commentaire = self.ajout1Valeur(valeur)
if commentaire != None:
- self.editor.afficheInfos(commentaire, Qt.red)
+ self.editor.afficheMessage(commentaire, Qt.red)
self.listeValeursCourantesAvant = self.listeValeursCourantes
self.setValeurs()
min, max = self.node.item.getMinMax()
if len(self.listeValeursCourantes) < min:
- self.editor.afficheInfos(
+ self.editor.afficheMessage(
tr("Nombre minimal de valeurs : ") + str(min), Qt.red
)
elif len(self.listeValeursCourantes) > max:
- self.editor.afficheInfos(
+ self.editor.afficheMessage(
tr("Nombre maximal de valeurs : ") + str(max), Qt.red
)
self.listeValeursCourantes = self.node.item.getListeValeurs()
min, max = self.node.item.getMinMax()
if len(self.listeValeursCourantes) + 1 > max:
- self.editor.afficheInfos(
+ self.editor.afficheMessage(
tr("Nombre maximal de valeurs : ") + str(max), Qt.red
)
return
else:
- self.editor.afficheInfos("")
+ self.editor.afficheMessage("")
affiche = False
for i in range(1, self.indexDernierLabel + 1):
self.listeValeursCourantes = self.node.item.getListeValeurs()
min, max = self.node.item.getMinMax()
if len(self.listeValeursCourantes) < min:
- self.editor.afficheInfos(
+ self.editor.afficheMessage(
tr("Nombre minimal de valeurs : ") + str(min), Qt.red
)
else:
- self.editor.afficheInfos("")
+ self.editor.afficheMessage("")
if len(listeRetour) == 0:
self.node.item.setValeur(None)
self.node.item.setValeur(listeRetour)
else:
commentaire = comm + " " + comm2
- self.editor.afficheInfos(commentaire, Qt.red)
+ self.editor.afficheMessage(commentaire, Qt.red)
self.setValide()
self.reaffiche()
listeValeur = []
for v in listeValeursBrutes:
if v == None or pattern_blanc.match(v):
- self.editor.afficheInfos(
+ self.editor.afficheMessage(
str(listeValeur) + " Valeurs saisies incorrectes", Qt.red
)
return
liste, validite = SaisieValeur.TraiteLEValeur(self, str(v))
if not validite:
- self.editor.afficheInfos(
+ self.editor.afficheMessage(
str(listeValeur) + " Valeurs saisies incorrectes", Qt.red
)
return
self.node.item.isValid()
self.setValeurs()
else:
- self.editor.afficheInfos(str(listeValeur) + " " + comm, Qt.red)
+ self.editor.afficheMessage(str(listeValeur) + " " + comm, Qt.red)
self.lineEditVal.setText("")
if not validite:
if comm2 != "":
comm += " " + comm2
- self.editor.afficheInfos(
+ self.editor.afficheMessage(
comm + " " + str(self.objSimp.definition.validators.typeDesTuples),
Qt.red,
)
return
min, max = self.node.item.getMinMax()
if self.indexDernierLabel == max:
- self.editor.afficheInfos(tr("Nb maximum de valeurs atteint"))
+ self.editor.afficheMessage(tr("Nb maximum de valeurs atteint"))
if self.indexDernierLabel < max and libre == False:
self.ajoutLineEdit()
self.listeAffichageWidget[-2].setFocus(True)
if len(liste) % self.nbValeurs != 0:
texte = "Nombre incorrect de valeurs"
- self.editor.afficheInfos(tr(texte), Qt.red)
+ self.editor.afficheMessage(tr(texte), Qt.red)
return
i = 0
if len(listeComplete) > max:
texte = tr("Nombre maximum de valeurs ") + str(max) + tr(" atteint")
- self.editor.afficheInfos(texte, Qt.red)
+ self.editor.afficheMessage(texte, Qt.red)
return
validite, comm, comm2, listeRetour = self.politique.ajoutNTuple(listeComplete)
if not validite:
- self.editor.afficheInfos(comm + comm2, Qt.red)
+ self.editor.afficheMessage(comm + comm2, Qt.red)
return
# on calcule le dernier lineedit rempli avant de changer la valeur
else:
commentaire = self.node.item.getCr()
self.reset_old_valeur(anc_val, mess=mess)
- self.editor.afficheInfos(commentaire, Qt.red)
+ self.editor.afficheMessage(commentaire, Qt.red)
self.Commentaire.setText(tr(commentaire))
if type(valeur) not in (list, tuple):
self.LEComp.setText(str(valeur))
commentaire = tr("complexe form deprecated, od value : ", valeur)
- self.editor.afficheInfos(commentaire, Qt.red)
+ self.editor.afficheMessage(commentaire, Qt.red)
else:
typ_cplx, x1, x2 = valeur
self.LEReel.setText(str(x1))
# v=eval(valeur,d)
# except :
# commentaire=tr("expression invalide")
- # self.editor.afficheInfos(commentaire,Qt.red)
+ # self.editor.afficheMessage(commentaire,Qt.red)
# return
# try :
# i=v.imag
- # self.editor.afficheInfos(commentaire)
+ # self.editor.afficheMessage(commentaire)
# self.valeurPressed()
# except :
# commentaire=tr("l expression n est pas de la forme a+bj")
- # self.editor.afficheInfos(commentaire,Qt.red)
+ # self.editor.afficheMessage(commentaire,Qt.red)
def LEReelRPressed(self):
# self.LEComp.clear()
valeur = str(self.LEReel.text())
try:
a = locale.atof(valeur)
- self.editor.afficheInfos(commentaire)
+ self.editor.afficheMessage(commentaire)
except:
commentaire = tr("expression invalide")
- self.editor.afficheInfos(commentaire, Qt.red)
+ self.editor.afficheMessage(commentaire, Qt.red)
if self.LEImag.text() != "":
self.valeurPressed()
else:
valeur = str(self.LEImag.text())
try:
a = locale.atof(valeur)
- self.editor.afficheInfos(commentaire)
+ self.editor.afficheMessage(commentaire)
except:
commentaire = tr("expression invalide")
- self.editor.afficheInfos(commentaire, Qt.red)
+ self.editor.afficheMessage(commentaire, Qt.red)
if self.LEReel.text() != "":
self.valeurPressed()
else:
# v=eval(valeur,d)
# except :
# commentaire=tr("expression invalide")
- # self.editor.afficheInfos(commentaire,Qt.red)
+ # self.editor.afficheMessage(commentaire,Qt.red)
# return None
# try :
# i=v.imag
# except :
# commentaire=tr("expression n est pas de la forme a+bj")
- # self.editor.afficheInfos(commentaire,Qt.red)
+ # self.editor.afficheMessage(commentaire,Qt.red)
# return None
# return v
elif self.RBRI.isChecked() == 1:
l.append("RI")
else:
- self.editor.afficheInfos(commentaire, Qt.red)
+ self.editor.afficheMessage(commentaire, Qt.red)
self.RBMP.setFocus(True)
return None
try:
def valeursPressed(self):
aLeFocus = self.focusWidget()
- self.editor.afficheInfos("")
+ self.editor.afficheMessage("")
texteValeur = ""
for i in range(self.nbValeurs):
nomLineEdit = "lineEditVal" + str(i + 1)
texteValeur += ","
validite, commentaire = self.politique.recordValeur(texteValeur)
if not validite:
- self.editor.afficheInfos(
+ self.editor.afficheMessage(
commentaire
+ " "
+ str(self.objSimp.definition.validators.typeDesTuples),
from Accas.extensions.eficas_translation import tr
from Editeur import session
from InterfaceGUI.common import comploader
-from InterfaceGUI.common import Objecttreeitem
+from InterfaceGUI.common import objecttreeitem
from InterfaceGUI.QT5 import browser
from UiQT5.desBaseWidget import Ui_baseWidget
Editeur de jdc
"""
- def __init__( self, appliEficas, fichier=None, jdc=None, QWParent=None, units=None, include=0):
+ def __init__( self, appliEficas, fichier=None, jdc=None, QWParent=None, include=0):
# -----------------------------------------------------------------------------------------------
QWidget.__init__(self, None)
self.sb = None
self.QWParent = QWParent
- Editor.__init__(self, appliEficas, fichier, jdc, units, include)
+ Editor.__init__(self, appliEficas, fichier, jdc, include)
if self.jdc:
comploader.chargerComposants(self.appliEficas.GUIPath)
- self.jdc_item = Objecttreeitem.makeObjecttreeitem(self, "nom", self.jdc)
+ self.jdc_item = objecttreeitem.makeObjecttreeitem(self, "nom", self.jdc)
# Particularites IHM : met la fenetre a jour
self.initSplitterSizes()
def informe(self, titre, txt, critique=True):
# ------------------------------------------#
if critique:
- self.afficheInfos(tr(txt), Qt.red)
+ self.afficheMessage(tr(txt), Qt.red)
QMessageBox.critical(self, tr(titre), tr(txt))
else:
QMessageBox.warning(self, tr(titre), tr(txt))
self.close()
# ----------------------------------------------#
- def afficheInfos(self, message, couleur=Qt.black):
+ def afficheMessage(self, message, couleur=Qt.black):
# ----------------------------------------------#
if couleur == "red": couleur = Qt.red
if self.sb:
tr("Eficas n a pas reussi a copier l objet"),
)
self.message = ""
- self.afficheInfos("Copie refusee", Qt.red)
+ self.afficheMessage("Copie refusee", Qt.red)
if noeudACopier.treeParent.editor != noeudOuColler.treeParent.editor:
try:
nom = noeudACopier.item.sd.nom
self, tr("Copie refusee"), tr("Copie refusee pour ce type d objet")
)
self.message = ""
- self.afficheInfos("Copie refusee", Qt.red)
+ self.afficheMessage("Copie refusee", Qt.red)
return
# il faut declarer le JDCDisplay_courant modifie
def viewJdcRapport(self):
# ----------------------------#
strRapport = self.getJdcRapport()
- self._viewText(strRappoer, "Rapport Validation du JDC")
+ self._viewText(strRapport, "Rapport Validation du JDC")
# ------------------#
def _newJDCCND(self):
self.appliEficas.construitMenu()
- #-------------------------------------------------------
- def openFile(self, fichier=None, units=None, patron =0):
- #-------------------------------------------------------
+ #--------------------------------------------
+ def openFile(self, fichier=None, patron =0):
+ #--------------------------------------------
result = None
if self.appliEficas.code == None:
self.appliEficas.definitCode(None, None)
ulfile = os.path.abspath(fichier)
self.appliEficas.maConfiguration.saveDir = os.path.split(ulfile)[0]
self.appliEficas.addToRecentList(fichier)
- maPage = self.getEditor(fichier, units=units)
+ maPage = self.getEditor(fichier)
if maPage: result = maPage
if maPage: self.myQtab.setTabText(
self.myQtab.indexOf(maPage), os.path.basename(fichier))
editor = self.dictEditors[index]
editor.handleAjoutEtape(nomEtape)
- #------------------------------
- def newEditor(self, include=0):
- #------------------------------
- if self.appliEficas.multi == True:
- self.appliEficas.definitCode(None, None)
- if self.appliEficas.code == None:
- return
- maPage = self.getEditor(include=include)
#--------------------------
def newIncludeEditor(self):
#--------------------------
- self.newEditor(include=1)
+ self.getEditor(include=1)
#------------------------------------
def viewJdcFichierSource(self):
if index < 0: return
self.dictEditors[index].viewJdcRapport()
- #-------------------------
- def viewJdcPy(self):
- #-------------------------
+ #--------------------------------
+ def viewJdcFichierResultat(self):
+ #--------------------------------
index = self.myQtab.currentIndex()
if index < 0:
return
- self.dictEditors[index].viewJdcPy()
+ self.dictEditors[index].viewJdcFichierResultat()
#--------------------
def handleSave(self):
editor = self.getEditor(fichier=fn, jdc=jdc, include=1)
self.appliEficas.addToRecentList(editor.getFileName())
+
#------------------------------------------------------------------
- def getEditor(self, fichier=None, jdc=None, units=None, include=0):
+ def getEditor(self, fichier=None, jdc=None, include=0):
#------------------------------------------------------------------
+ if self.appliEficas.multi == True:
+ self.appliEficas.definitCode(None, None)
+ if self.appliEficas.code == None:
+ return
newWin = 0
double = None
for indexEditor in self.dictEditors:
double = editor
else:
from qt_editor import QtEditor
- editor = QtEditor(self.appliEficas, fichier, jdc, self.myQtab, units, include)
+ editor = QtEditor(self.appliEficas, fichier, jdc, self.myQtab, include)
if double != None: self.doubles[editor] = double
if editor.jdc: # le fichier est bien un jdc
self.editors.append(editor)
def fileNew(self):
#----------------
try:
- self.editorManager.newEditor()
+ self.editorManager.getEditor()
except EficasException as exc:
msg = str(exc)
if msg != "":
#------------------------
def viewJdcRegles(self):
#------------------------
- self.editorManager.handleViewJdcRegles()
+ self.editorManager.viewJdcRegles()
#------------------------------
def viewJdcFichierResultat(self):
+++ /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')
-
#
-from InterfaceGUI.common import Objecttreeitem
+from InterfaceGUI.common import objecttreeitem
from InterfaceGUI.Web import compofact
from InterfaceGUI.Web import browser
from InterfaceGUI.Web import browser
from InterfaceGUI.Web import typeNode
-from InterfaceGUI.common import Objecttreeitem
+from InterfaceGUI.common import objecttreeitem
from Accas.extensions.eficas_translation import tr
-class FACTTreeItem(Objecttreeitem.ObjectTreeItem):
+class FACTTreeItem(objecttreeitem.ObjectTreeItem):
itemNode=Node
def isExpandable(self):
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
-from InterfaceGUI.common import Objecttreeitem
+from InterfaceGUI.common import objecttreeitem
from InterfaceGUI.Web import browser
from InterfaceGUI.Web import typeNode
from Accas.extensions.eficas_translation import tr
return param
-class JDCTreeItem(Objecttreeitem.ObjectTreeItem):
+class JDCTreeItem(objecttreeitem.ObjectTreeItem):
itemNode=Node
def isExpandable(self):
from InterfaceGUI.Web import typeNode
from Accas.extensions.eficas_translation import tr
-from InterfaceGUI.common import Objecttreeitem
+from InterfaceGUI.common import objecttreeitem
from Accas.processing.P_OBJECT import ErrorObj
-class MCListTreeItem(Objecttreeitem.SequenceTreeItem,compofact.FACTTreeItem):
+class MCListTreeItem(objecttreeitem.SequenceTreeItem,compofact.FACTTreeItem):
""" La classe MCListTreeItem joue le role d'un adaptateur pour les objets
du processing Accas instances de la classe MCLIST.
Elle adapte ces objets pour leur permettre d'etre integres en tant que
def isExpandable(self):
if len(self._object) > 1:
- return Objecttreeitem.SequenceTreeItem.isExpandable(self)
+ return objecttreeitem.SequenceTreeItem.isExpandable(self)
else:
return compofact.FACTTreeItem.isExpandable(self)
from Accas.extensions.eficas_translation import tr
from Accas.extensions.eficas_exception import EficasException
-from InterfaceGUI.common import Objecttreeitem
+from InterfaceGUI.common import objecttreeitem
from InterfaceGUI.Web import browser
from InterfaceGUI.Web import typeNode
# typeNode.PopUpMenuNode.createPopUpMenu(self)
-class EtapeTreeItem(Objecttreeitem.ObjectTreeItem):
+class EtapeTreeItem(objecttreeitem.ObjectTreeItem):
""" La classe EtapeTreeItem est un adaptateur des objets ETAPE du processing
Accas. Elle leur permet d'etre affichés comme des noeuds
d'un arbre graphique.
# import modules EFICAS
-from InterfaceGUI.common import Objecttreeitem
+from InterfaceGUI.common import objecttreeitem
from InterfaceGUI.Web import browser
from InterfaceGUI.Web import typeNode
from Accas.extensions.eficas_translation import tr
-class PARAMTreeItem(Objecttreeitem.ObjectTreeItem):
+class PARAMTreeItem(objecttreeitem.ObjectTreeItem):
"""
Classe servant a definir l'item porte par le noeud de l'arbre d'EFICAS
qui represente le PARAMETRE
#
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
-from InterfaceGUI.common import Objecttreeitem
+from InterfaceGUI.common import objecttreeitem
from InterfaceGUI.Web import compooper
from InterfaceGUI.Web import browser
from InterfaceGUI.Web import typeNode
import traceback
# Modules Eficas
-from InterfaceGUI.common import Objecttreeitem
+from InterfaceGUI.common import objecttreeitem
from Accas.processing.P_CR import justifyText
from Accas import SalomeEntry
from Accas import ASSD
-class SIMPTreeItem(Objecttreeitem.AtomicObjectTreeItem):
+class SIMPTreeItem(objecttreeitem.AtomicObjectTreeItem):
itemNode=Node
def init(self) :
# Modules Eficas
from Accas.extensions.eficas_translation import tr
+from Accas.extensions.eficas_exception import EficasException
-from Editeur import session
from InterfaceGUI.common import comploader
-from InterfaceGUI.common import Objecttreeitem
+from InterfaceGUI.common import objecttreeitem
from InterfaceGUI.Web import browser
debug = False
-from InterfaceGUI.editorSsIhm import JDCEditorSsIhm
+from Editeur.editor import Editor
-class JDCWebEditor(JDCEditorSsIhm):
-# ------------------------------- #
+# -------------------- #
+class WebEditor(Editor):
+# -------------------- #
"""
Editeur de jdc
"""
- def __init__ (self,appliEficas,fichier = None, jdc= None, connecteur = None ):
- #------------------------------------------------------------------------
+ #--------------------------------------------------------------------------
+ def __init__ (self,appliEficas,fichier = None, jdc= None, session = None ):
+ #--------------------------------------------------------------------------
- self.connecteur=connecteur
- JDCEditorSsIhm.__init__(self,appliEficas,fichier)
+ self.connecteur=appliEficas
+ Editor.__init__(self,appliEficas,fichier)
self.dicoIdNode={}
comploader.chargerComposants('Web')
self.tree=None
if self.jdc:
- self.jdc_item=Objecttreeitem.makeObjecttreeitem( self, "nom", self.jdc )
+ self.jdc_item=objecttreeitem.makeObjecttreeitem( self, "nom", self.jdc )
if self.jdc_item :
self.tree = browser.JDCTree( self.jdc_item, self )
+ #-----------------------------
def getNodeById(self,nodeId ):
#-----------------------------
if nodeId in self.dicoIdNode : return self.dicoIdNode[nodeId]
else : return None
+ #---------------------------------------
def reconstruitChaineDIndex(self,nodeId):
#---------------------------------------
+ """ utilise pour logguer les fonctions """
if nodeId in self.dicoIdNode :
node=self.dicoIdNode[nodeId]
- return JDCEditorSsIhm.reconstruitChaineDIndex(self,node)
+ if node.object == self.jdc :
+ return 'monEficasConnecteur.monEditeur.tree.racine.item.idUnique'
+ chaine="['key']"
+ templateChaine='["children"][{}]'
+ aTraiter=node.object
+ while hasattr(aTraiter,'parent') and aTraiter.parent:
+ chaine=templateChaine.format(aTraiter.getIndexDsParent())+chaine
+ aTraiter=aTraiter.parent
+ chaine='d'+chaine
+ return (chaine)
else : return None
- def getDicoObjetsCompletsPourTree(self,obj) :
- #-----------------------------------
- #print ('editor getDicoObjetsCompletsPourTree pour ' ,self, obj)
- if self.tree == None : return {}
- return obj.getDicoObjetsCompletsPourTree()
-
- def getDicoObjetsPourWeb(self,obj) :
- #-----------------------------------
- if self.tree == None : return {}
- return obj.getDicoObjetsPourWeb()
-
+ #-----------------------------
def getDicoForFancy(self,obj) :
- #-----------------------------------
+ #-----------------------------
if self.tree == None : return {}
return obj.getDicoForFancy()
- def afficheInfos(self,txt,couleur=None):
+ #-------------------------------------
+ def afficheMessage(self,txt,couleur=None):
#---------------------------------------
- self.connecteur.toWebApp('afficheInfos', txt, couleur)
- JDCEditorSsIhm.afficheInfos(self,txt,couleur)
+ self.connecteur.toWebApp('afficheMessage', txt, couleur)
+ Editor.afficheMessage(self,'message to webapp',txt,couleur)
+ #-------------------------------------
def afficheAlerte(self,titre,message):
#-------------------------------------
self.connecteur.toWebApp('afficheAlerte', titre , message)
- JDCEditorSsIhm.afficheAlerte(self,titre,message)
+ Editor.afficheMessage(self,titre,message)
+ #---------------------------
+ def getListeCommandes(self):
+ #---------------------------
+ return (self.jdc.getListeCmd())
--- /dev/null
+# -*- coding: utf-8 -*-
+# 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
+from Accas.extensions.eficas_translation import tr
+from Editeur.editor_manager import EditorManager
+
+#-----------------------------------#
+class WebEditorManager(EditorManager):
+#-----------------------------------#
+ """
+ classe qui gere quel est l editor web actif
+ """
+
+ #--------------------------------
+ def __init__(self, appliEficas):
+ #--------------------------------
+ super().__init__(appliEficas)
+ self.dictSessions={}
+
+
+ #---------------------------------------
+ def afficheInfos(self,txt,couleur=None):
+ #---------------------------------------
+ """
+ Est-ce que le web_manager a des infos a afficher ?
+ sans session ?
+ """
+ self.appliEficas.toWebApp('afficheInfos', txt, couleur)
+
+
+ # ------------------------------------------------------
+ def getEditor(self, fichier=None, jdc=None, session = 1 ):
+ # ------------------------------------------------------
+ """
+ Retourne un nouvel editeur ou le meme si doublon
+ gere la liste des connexions pour propager les infos
+ a affiner : le nom du fichier n est pas determinant
+ il faut aussi la machine dont il provient
+ """
+ for indexEditor in self.dictEditors:
+ editor = self.dictEditors[indexEditor]
+ if self.samePath(fichier, editor.getFileName()):
+ double = editor
+
+ else:
+ from web_editor import WebEditor
+ editor = WebEditor(self.appliEficas, fichier)
+ if editor.jdc: # le fichier est bien un jdc
+ self.editors.append(editor)
+ else:
+ editor=None
+ return editor
+
+
from Editeur.eficas_appli import EficasAppli
from InterfaceGUI.Web.web_editor_manager import WebEditorManager
+from Accas.extensions.eficas_exception import EficasException
+activeLogging=0
+if activeLogging :
+ from Editeur.loggingEnvironnement import loggingEnvironnement, fonctionLoguee
+else :
+ fonctionLoguee = lambda func: func
+
+#--------------------------------#
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"):
- #----------------------------------------------------------------------------------------------------------------------------------------------
+ #---------------------------------------------------------------------------------------------------------------------------------------------------------
+ def __init__(self, code=None, versionCode=None, salome=0, multi=False, langue="fr", ssCode=None, fichierCata=None, GUIPath="InterfaceGUI.QT5", appWeb=None):
+ #---------------------------------------------------------------------------------------------------------------------------------------------------------
"""
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')
+ EficasAppli.__init__( self, code, versionCode, salome, multi, langue, ssCode, fichierCata, GUIPath, appWeb)
+ self.editorManager = WebEditorManager(self)
+ if self.appWeb == None :
+ super().afficheMessage ('lancement Eficas WEB' , 'le parametre appWeb est obligatoire')
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):
+ #-----------------------------------------
+ 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
+ if debug : print ('PNPNPN : WebEficasAppli.toWebApp', fction, *args, **kwargs)
+ if self.appWeb == None : return
+ #if fction =='propageValide' : print ('self.appWeb.toWebApp propageValide', self.monEditeur.getNodeById(args[0]).nom)
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 createEditor(self):
+ #-----------------------
+ monEditor = self.editorManager.getEditor(self)
+ return monEditor
- 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)
+ @fonctionLoguee
+ #---------------------------
+ def openFile(self, fichier):
+ #---------------------------
+ try:
+ monEditor = self.editorManager.getEditor(fichier)
+ except EficasException as exc:
+ self.afficheMessage('erreur ouverture fichier', str(exc),critical=True)
+ monEditor = None
+ return monEditor
+
+ @fonctionLoguee
+ #-----------------------------------------------------
+ def afficheMessage (self, titre, texte,critical=True):
+ #-----------------------------------------------------
+#TODO : le afficheMessage doit tenir compte de qui
+ if critical :
+ self.toWebApp('afficheMessage', titre+texte, 'rouge')
+ else :
+ self.toWebApp('afficheMessage', titre+texte)
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')
-
+ print ('todo')
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
from __future__ import absolute_import
-from Editeur import Objecttreeitem
+from Editeur import objecttreeitem
from InterfaceGUI.cinqC import browser
from InterfaceGUI.cinqC import compoproc
from Accas.extensions.eficas_translation import tr
-from InterfaceGUI.common import Objecttreeitem
+from InterfaceGUI.common import objecttreeitem
import traceback
typeNode.PopUpMenuNodeMinimal.createPopUpMenu(self)
-class FACTTreeItem(Objecttreeitem.ObjectTreeItem):
+class FACTTreeItem(objecttreeitem.ObjectTreeItem):
itemNode=Node
def isExpandable(self):
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
-from InterfaceGUI.common import Objecttreeitem
+from InterfaceGUI.common import objecttreeitem
from InterfaceGUI.cinqC import browser
from Accas.extensions.eficas_translation import tr
-class JDCTreeItem(Objecttreeitem.ObjectTreeItem):
+class JDCTreeItem(objecttreeitem.ObjectTreeItem):
itemNode=Node
def isExpandable(self):
from InterfaceGUI.QT5 import typeNode
from Accas.extensions.eficas_translation import tr
-from InterfaceGUI.common import Objecttreeitem
+from InterfaceGUI.common import objecttreeitem
from Accas.processing.P_OBJECT import ErrorObj
-class MCListTreeItem(Objecttreeitem.SequenceTreeItem,compofact.FACTTreeItem):
+class MCListTreeItem(objecttreeitem.SequenceTreeItem,compofact.FACTTreeItem):
""" La classe MCListTreeItem joue le role d'un adaptateur pour les objets
du processing Accas instances de la classe MCLIST.
Elle adapte ces objets pour leur permettre d'etre integres en tant que
def isExpandable(self):
if len(self._object) > 1:
- return Objecttreeitem.SequenceTreeItem.isExpandable(self)
+ return objecttreeitem.SequenceTreeItem.isExpandable(self)
else:
return compofact.FACTTreeItem.isExpandable(self)
import os
import tempfile
-from InterfaceGUI.common import Objecttreeitem
+from InterfaceGUI.common import objecttreeitem
from InterfaceGUI.cinqC import browser
class Node(browser.JDCNode ):
return MonWidgetCommande(self,self.editor,self.item.object)
-class EtapeTreeItem(Objecttreeitem.ObjectTreeItem):
+class EtapeTreeItem(objecttreeitem.ObjectTreeItem):
""" La classe EtapeTreeItem est un adaptateur des objets ETAPE du processing
Accas. Elle leur permet d'etre affichés comme des noeuds
d'un arbre graphique.
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
from __future__ import absolute_import
-from InterfaceGui.common import Objecttreeitem
+from InterfaceGui.common import objecttreeitem
from InterfaceGUI.cinqC import browser
from InterfaceGUI.cinqC import compooper
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
-from InterfaceGUI.common import Objecttreeitem
+from InterfaceGUI.common import objecttreeitem
from InterfaceGUI.cinqC import browser
from InterfaceGUI.QT5.compojdc import JDCTreeItem
from Editeur.editor import Editor
from UiQT5.editor5C import Ui_editor5C
from InterfaceGui.common import comploader
-from InterfaceGui.common import Objecttreeitem
+from InterfaceGui.common import objecttreeitem
from InterfaceGUI.cinqC import browser
from InterfaceGUI.cinqC.connectDB import connectDB
import Accas.IO.writer as generator
Editeur de jdc 5C
"""
- def __init__ (self,appliEficas,fichier = None, jdc=None, QWParent=None, units = None, include=0):
+ def __init__ (self,appliEficas,fichier = None, jdc=None, QWParent=None, include=0):
#------------------------------------------------------------------------------------------------
debug = 0
self.jdcSelection=self._newJDC(texte=texte)
self.jdcSelection.analyse()
if debug : print (self.jdcSelection.etapes)
- self.jdcSelectionItem = Objecttreeitem.makeObjecttreeitem( self, "nom", self.jdcSelection )
+ self.jdcSelectionItem = objecttreeitem.makeObjecttreeitem( self, "nom", self.jdcSelection )
if self.jdcSelectionItem :
self.treeJdcSelection = browser.JDCTree( self.jdcSelectionItem, self )
if debug : print (self.treeJdcSelection)
if debug : print ('texte newJDC' , texte)
self.jdcLabels=self._newJDC(texte=texte)
self.jdcLabels.analyse()
- jdcLabelsItem = Objecttreeitem.makeObjecttreeitem( self, "nom", self.jdcLabels )
+ jdcLabelsItem = objecttreeitem.makeObjecttreeitem( self, "nom", self.jdcLabels )
if jdcLabelsItem :
treeJdcLabels = browser.JDCTree( jdcLabelsItem, self )
widgetLabels = treeJdcLabels.racine.children[0].fenetre
super().__init__(code=code, salome=salome, multi=multi, langue=langue, versionCode=versionCode, GUIPath=GUIPath)
self.withXSD = True
self.GUIPath = GUIPath
- self.editorManager.newEditor()
+ self.editorManager.getEditor()
def connecterSignaux(self) :
+++ /dev/null
-# -*- coding: utf-8 -*-
-# 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
-#
-"""
-"""
-from builtins import str
-from builtins import object
-import types, os, sys
-from copy import copy, deepcopy
-from uuid import uuid1
-
-# import du chargeur de composants
-from InterfaceGUI.common.comploader import makeObjecttreeitem
-from Accas.accessor import CONNECTOR
-from Accas.extensions.eficas_translation import tr
-from Accas.extensions.eficas_exception import EficasException
-
-from reprlib import Repr
-
-myrepr = Repr()
-myrepr.maxstring = 100
-myrepr.maxother = 100
-
-
-class TreeItem(object):
-
- """Abstract class representing tree items.
-
- Methods should typically be overridden, otherwise a default action
- is used.
-
- """
-
- # itemNode est une factory qui doit retourner un objet de la classe Node
- # ou derive de cette classe.
- # Le widget arbre utilisera cet objet comme noeud associe au tree item.
- # Par defaut, utilise la classe Node de base
- # La signature de la factory est la suivante :
- # itemNode(treeOrNode,item,command,rmenu)
- # ou treeOrNode est le noeud parent, item est l'item associe
- # command est une fonction python appelee sur selection graphique
- # du noeud et rmenu est une fonction python appelee sur click droit sur le noeud
- itemNode = None
-
- def __init__(self):
- """Constructor. Do whatever you need to do."""
-
- def getText(self):
- """Return text string to display."""
-
- def getLabelText(self):
- """Return label text string to display in front of text (if any)."""
-
- expandable = None
-
- def _isExpandable(self):
- if self.expandable is None:
- self.expandable = self.isExpandable()
- return self.expandable
-
- def isExpandable(self):
- """Return whether there are subitems."""
- return 1
-
- def _getSubList(self):
- """Do not override! Called by TreeNode."""
- if not self.isExpandable():
- return []
- sublist = self.getSubList()
- if not sublist:
- self.expandable = 0
- return sublist
-
- def IsEditable(self):
- """Return whether the item's text may be edited."""
- pass
-
- def SetText(self, text):
- """Change the item's text (if it is editable)."""
- pass
-
- def getIconName(self):
- """Return name of icon to be displayed normally."""
- pass
-
- def getSelectedIconName(self):
- """Return name of icon to be displayed when selected."""
- pass
-
- def getSubList(self):
- """Return list of items forming sublist."""
- pass
-
- def onDoubleClick(self):
- """Called on a double-click on the item."""
- pass
-
-
-class Delegate(object):
- def __init__(self, delegate=None):
- self.object = delegate
- self.__cache = {}
-
- def setDelegate(self, delegate):
- self.resetcache()
- self.object = delegate
-
- def getDelegate(self):
- return self.object
-
- def __getattr__(self, name):
- attr = getattr(self.object, name) # May raise AttributeError
- setattr(self, name, attr)
- self.__cache[name] = attr
- return attr
-
- def resetcache(self):
- for key in list(self.__cache.keys()):
- try:
- delattr(self, key)
- except AttributeError:
- pass
- self.__cache.clear()
-
- def cachereport(self):
- keys = list(self.__cache.keys())
- keys.sort()
- # print keys
-
-
-class ObjectTreeItem(TreeItem, Delegate):
- def __init__(self, appliEficas, labeltext, object, setFunction=None):
- self.labeltext = labeltext
- self.appliEficas = appliEficas
- # L'objet delegue est stocke dans l'attribut object
- # L'objet associe a l'item est stocke dans l'attribut _object
- # Il peut etre obtenu par appel a la methode getObject
- # Attention : le delegue peut etre different de l'objet associe (MCLIST)
- # Dans le cas d'une MCListe de longueur 1, l'objet associe est la MCListe
- # et l'objet delegue est le MCFACT (object = _object.data[0])
- Delegate.__init__(self, object)
- # On cache l'objet initial (pour destruction eventuelle
- # ulterieure)
- self._object = object
- self.setFunction = setFunction
- self.expandable = 1
- self.sublist = []
- self.init()
-
-
- # La partie suivante ne sert que pour le Web
- # on met le meme id au noeud et a l objet
- # utile pour les MCList
- if hasattr(object, "idUnique"):
- self.idUnique = object.idUnique
- else:
- self.idUnique = uuid1().hex
-
- if self._object.nature == "MCList" and len(self._object.data) == 1:
- # pour les suppressions on met le meme id a l objet et a la liste
- self._object.data[0].idUnique = self.idUnique
- self._object.idUnique = self._object.data[0].idUnique
- if hasattr(self.appliEficas, "dicoIdNode"):
- self.appliEficas.dicoIdNode[self._object.data[0].idUnique] = self
- self.idUnique = 0
- return
-
- self._object.idUnique = self.idUnique
- if hasattr(self.appliEficas, "dicoIdNode") and self.idUnique:
- self.appliEficas.dicoIdNode[self.idUnique] = self
-
- def init(self):
- return
-
- def getObject(self):
- return self._object
-
- def connect(self, channel, callable, args):
- """Connecte la fonction callable (avec arguments args) a l'item self sur le
- canal channel
- """
- # print self,channel,callable,args
- CONNECTOR.Connect(self._object, channel, callable, args)
- CONNECTOR.Connect(self.object, channel, callable, args)
-
- def copy(self):
- """
- Cree un item copie de self
- """
- object = self._object.copy()
- appliEficas = copy(self.appliEficas)
- labeltext = copy(self.labeltext)
- fonction = deepcopy(self.setFunction)
- item = makeObjecttreeitem(appliEficas, labeltext, object, fonction)
- return item
-
- def isActif(self):
- if hasattr(self.object, "actif"):
- return self.object.actif
- else:
- return 1
-
- def update(self, item):
- """
- Met a jour l'item courant a partir d'un autre item passe en argument
- Ne fait rien par defaut
- """
- pass
-
- def getLabelText(self):
- """Retourne 3 valeurs :
- - le texte a afficher dans le noeud representant l'item
- - la fonte dans laquelle afficher ce texte
- - la couleur du texte
- """
- # None --> fonte et couleur par defaut
- return tr(self.labeltext), None, None
-
- def getNature(self):
- """
- Retourne la nature de l'item et de l'objet
- """
- return self.object.nature
-
- def getRegles(self):
- """retourne les regles de l'objet pointe par self"""
- return self.object.getRegles()
-
- def getListeMcPresents(self):
- """Retourne la liste des mots-cles fils de l'objet pointe par self"""
- return self.object.listeMcPresents()
-
- def getVal(self):
- """Retourne le nom de la valeur de l'objet pointe par self dans le cas
- ou celle-ci est un objet (ASSD)"""
- return self.object.getVal()
-
- def get_definition(self):
- """
- Retourne l'objet definition de l'objet pointe par self
- """
- return self.object.definition
-
- def getListeMcOrdonnee(self, liste, dico):
- """retourne la liste ordonnee (suivant le catalogue) brute des mots-cles
- d'une entite composee dont le chemin complet est donne sous forme
- d'une liste du type :ETAPE + MCFACT ou MCBLOC + ...
- il faut encore rearranger cette liste (certains mots-cles deja
- presents ne doivent plus etre proposes, regles ...)"""
- return self.object.getListeMcOrdonnee(liste, dico)
-
- def getListeMcOrdonneeBrute(self, liste, dico):
- """
- retourne la liste ordonnee (suivant le catalogue) BRUTE des mots-cles
- d'une entite composee dont le chemin complet est donne sous forme
- d'une liste du type :ETAPE + MCFACT ou MCBLOC + ...
- """
- return self.object.getListeMcOrdonneeBrute(liste, dico)
-
- def getGenealogie(self):
- """
- Retourne la liste des noms des ascendants (noms de MCSIMP,MCFACT,MCBLOC ou ETAPE)
- de l'objet pointe par self
- """
- return self.object.getGenealogie()
-
- def getIndexChild(self, nom_fils):
- """
- Retourne l'index dans la liste des fils de self du nouveau fils de nom nom_fils
- Necessaire pour savoir a quelle position dans la liste des fils il faut ajouter
- le nouveau mot-cle
- """
- return self.object.getIndexChild(nom_fils)
-
- def getIndexChild_old(self, nom_fils):
- """
- Retourne l'index dans la liste des fils de self du nouveau fils de nom nom_fils
- Necessaire pour savoir a quelle position dans la liste des fils il faut ajouter
- le nouveau mot-cle
- """
- liste_noms_mc_ordonnee = self.getListeMcOrdonneeBrute(
- self.getGenealogie(), self.getJdc().dicoCataOrdonne
- )
- liste_noms_mc_presents = self.object.listeMcPresents()
- l = []
- for nom in liste_noms_mc_ordonnee:
- if nom in liste_noms_mc_presents or nom == nom_fils:
- l.append(nom)
- # l contient les anciens mots-cles + le nouveau dans l'ordre
- return l.index(nom_fils)
-
- def appendChild(self, name, pos=None):
- """
- Permet d'ajouter un item fils a self
- """
- if pos == "first":
- index = 0
- elif pos == "last":
- index = len(self.listeMcPresents())
- elif type(pos) == int:
- # la position est fixee
- index = pos
- # elif type(pos) == types.InstanceType:
- elif type(pos) == object:
- # pos est un item. Il faut inserer name apres pos
- index = self.getIndex(pos) + 1
- # elif type(name) == types.InstanceType:
- elif type(name) == object:
- index = self.getIndexChild(name.nom)
- else:
- index = self.getIndexChild(name)
- return self.addobject(name, index)
-
- def appendBrother(self, name, pos="after"):
- """
- Permet d'ajouter un frere a self
- par defaut on l'ajoute apres self
- """
- index = self._object.parent.getIndex(self.getObject())
- if pos == "before":
- index = index
- elif pos == "after":
- index = index + 1
- else:
- print((tr("%d n'est pas un index valide pour appendBrother", pos)))
- return
- return self.parent.addobject(name, index)
-
- def getCopieObjet(self):
- """Retourne une copie de l'objet pointe par self"""
- return self.object.copy()
-
- def getPosition(self):
- """Retourne la valeur de l'attribut position de l'objet pointe par self"""
- definition = self.get_definition()
- try:
- return getattr(definition, "position")
- except AttributeError:
- return "local"
-
- def getNom(self):
- """Retourne le nom de l'objet pointe par self"""
- return self.object.nom
-
- def getJdc(self):
- """Retourne le jdc auquel appartient l'objet pointe par self"""
- return self.object.jdc
-
- def getValeur(self):
- """Retourne la valeur de l'objet pointe par self"""
- return self.object.valeur
-
- def getCr(self):
- """Retourne le compte-rendu CR de self"""
- return self.object.report()
-
- def getObjetCommentarise(self):
- """
- Cette methode retourne un objet commentarise
- representatif de self.object
- --> a surcharger par les differents items
- """
- raise EficasException(
- "MESSAGE AU DEVELOPPEUR : il faut \
- surcharger la methode getObjetCommentarise() \
- pour la classe %s",
- self.__class__.__name__,
- )
-
- def isValid(self):
- """Retourne 1 si l'objet pointe par self est valide, 0 sinon"""
- return self.object.isValid()
-
- def isCopiable(self):
- """
- Retourne 1 si l'objet est copiable, 0 sinon
- Par defaut retourne 0
- """
- return 0
-
- def getMcPresents(self):
- """Retourne le dictionnaire des mots-cles presents de l'objet pointe par self"""
- return self.object.dictMcPresents()
-
- def verifConditionRegles(self, l_mc_presents):
- return self.object.verifConditionRegles(l_mc_presents)
-
- def getFr(self):
- """Retourne le fr de l'objet pointe par self"""
- try:
- return self.object.getFr()
- except:
- return ""
-
- def getDocu(self):
- """Retourne la cle de doc de l'objet pointe par self"""
- return self.object.getDocu()
-
- def setValeur(self, new_valeur):
- """Remplace la valeur de l'objet pointe par self par new_valeur"""
- return self.object.setValeur(new_valeur)
-
- def getText(self):
- return myrepr.repr(self.object)
-
- def getIconName(self):
- if not self.isExpandable():
- return "python"
-
- def IsEditable(self):
- return self.setFunction is not None
-
- def SetText(self, text):
- try:
- value = eval(text)
- self.setFunction(value)
- except:
- pass
-
- def isExpandable(self):
- return 1
-
- def getSubList(self):
- keys = dir(self.object)
- sublist = []
- for key in keys:
- try:
- value = getattr(self.object, key)
- except AttributeError:
- continue
- item = makeObjecttreeitem(
- self.appliEficas,
- str(key) + " =",
- value,
- lambda value, key=key, object=self.object: setattr(object, key, value),
- )
- sublist.append(item)
- return sublist
-
- # a piori inutile PN 06 11 17
- # def wait_fichier_init(self):
- """ Retourne 1 si l'object pointe par self attend un fichier d'initialisation
- (ex: macros POURSUITE et INCLUDE de Code_Aster), 0 SINON """
-
- # return self.object.definition.fichier_ini
-
- def makeObjecttreeitem(self, appliEficas, labeltext, object, setFunction=None):
- """
- Cette methode, globale pour les objets de type item, permet de construire et de retourner un objet
- de type item associe a l'object passe en argument.
- """
- return makeObjecttreeitem(appliEficas, labeltext, object, setFunction)
-
- # def __del__(self):
- # print "__del__",self
-
-
-class AtomicObjectTreeItem(ObjectTreeItem):
- def isExpandable(self):
- return 0
-
-
-class SequenceTreeItem(ObjectTreeItem):
- def isExpandable(self):
- return len(self._object) > 0
-
- def __len__(self):
- return len(self._object)
-
- def keys(self):
- return list(range(len(self._object)))
-
- def getIconName(self):
- if self._object.isValid():
- return "ast-green-los"
- elif self._object.isOblig():
- return "ast-red-los"
- else:
- return "ast-yel-los"
-
- def ajoutPossible(self):
- return self._object.ajoutPossible()
-
- def getIndex(self, child):
- """Retourne le numero de child dans la liste des enfants de self"""
- return self._object.getIndex(child.getObject())
-
- def getText(self):
- return " "
-
- def addItem(self, obj, pos):
- self._object.insert(pos, obj)
- item = self.makeObjecttreeitem(self.appliEficas, obj.nom + ":", obj)
- return item
-
- def suppItem(self, item):
- try:
- self._object.remove(item.getObject())
- # la liste peut etre retournee vide !
- message = "Mot-clef " + item.getObject().nom + " supprime"
- self.appliEficas.afficheMessages(message)
- return 1
- except:
- return 0
-
- def getSubList(self):
- isublist = iter(self.sublist)
- liste = self._object.data
- iliste = iter(liste)
- self.sublist = []
-
- while 1:
- old_obj = obj = None
- for item in isublist:
- old_obj = item.getObject()
- if old_obj in liste:
- break
-
- for obj in iliste:
- if obj is old_obj:
- break
-
- # nouvel objet : on cree un nouvel item
- def setFunction(value, object=obj):
- object = value
-
- it = self.makeObjecttreeitem(
- self.appliEficas, obj.nom + " : ", obj, setFunction
- )
- self.sublist.append(it)
- if old_obj is None and obj is None:
- break
- if old_obj is obj:
- self.sublist.append(item)
- return self.sublist
--- /dev/null
+# -*- coding: utf-8 -*-
+# 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
+#
+"""
+"""
+from builtins import str
+from builtins import object
+import types, os, sys
+from copy import copy, deepcopy
+from uuid import uuid1
+
+# import du chargeur de composants
+from InterfaceGUI.common.comploader import makeObjecttreeitem
+from Accas.accessor import CONNECTOR
+from Accas.extensions.eficas_translation import tr
+from Accas.extensions.eficas_exception import EficasException
+
+from reprlib import Repr
+
+myrepr = Repr()
+myrepr.maxstring = 100
+myrepr.maxother = 100
+
+
+class TreeItem(object):
+
+ """Abstract class representing tree items.
+
+ Methods should typically be overridden, otherwise a default action
+ is used.
+
+ """
+
+ # itemNode est une factory qui doit retourner un objet de la classe Node
+ # ou derive de cette classe.
+ # Le widget arbre utilisera cet objet comme noeud associe au tree item.
+ # Par defaut, utilise la classe Node de base
+ # La signature de la factory est la suivante :
+ # itemNode(treeOrNode,item,command,rmenu)
+ # ou treeOrNode est le noeud parent, item est l'item associe
+ # command est une fonction python appelee sur selection graphique
+ # du noeud et rmenu est une fonction python appelee sur click droit sur le noeud
+ itemNode = None
+
+ def __init__(self):
+ """Constructor. Do whatever you need to do."""
+
+ def getText(self):
+ """Return text string to display."""
+
+ def getLabelText(self):
+ """Return label text string to display in front of text (if any)."""
+
+ expandable = None
+
+ def _isExpandable(self):
+ if self.expandable is None:
+ self.expandable = self.isExpandable()
+ return self.expandable
+
+ def isExpandable(self):
+ """Return whether there are subitems."""
+ return 1
+
+ def _getSubList(self):
+ """Do not override! Called by TreeNode."""
+ if not self.isExpandable():
+ return []
+ sublist = self.getSubList()
+ if not sublist:
+ self.expandable = 0
+ return sublist
+
+ def IsEditable(self):
+ """Return whether the item's text may be edited."""
+ pass
+
+ def SetText(self, text):
+ """Change the item's text (if it is editable)."""
+ pass
+
+ def getIconName(self):
+ """Return name of icon to be displayed normally."""
+ pass
+
+ def getSelectedIconName(self):
+ """Return name of icon to be displayed when selected."""
+ pass
+
+ def getSubList(self):
+ """Return list of items forming sublist."""
+ pass
+
+ def onDoubleClick(self):
+ """Called on a double-click on the item."""
+ pass
+
+
+class Delegate(object):
+ def __init__(self, delegate=None):
+ self.object = delegate
+ self.__cache = {}
+
+ def setDelegate(self, delegate):
+ self.resetcache()
+ self.object = delegate
+
+ def getDelegate(self):
+ return self.object
+
+ def __getattr__(self, name):
+ attr = getattr(self.object, name) # May raise AttributeError
+ setattr(self, name, attr)
+ self.__cache[name] = attr
+ return attr
+
+ def resetcache(self):
+ for key in list(self.__cache.keys()):
+ try:
+ delattr(self, key)
+ except AttributeError:
+ pass
+ self.__cache.clear()
+
+ def cachereport(self):
+ keys = list(self.__cache.keys())
+ keys.sort()
+ # print keys
+
+
+class ObjectTreeItem(TreeItem, Delegate):
+ def __init__(self, appliEficas, labeltext, object, setFunction=None):
+ self.labeltext = labeltext
+ self.appliEficas = appliEficas
+ # L'objet delegue est stocke dans l'attribut object
+ # L'objet associe a l'item est stocke dans l'attribut _object
+ # Il peut etre obtenu par appel a la methode getObject
+ # Attention : le delegue peut etre different de l'objet associe (MCLIST)
+ # Dans le cas d'une MCListe de longueur 1, l'objet associe est la MCListe
+ # et l'objet delegue est le MCFACT (object = _object.data[0])
+ Delegate.__init__(self, object)
+ # On cache l'objet initial (pour destruction eventuelle
+ # ulterieure)
+ self._object = object
+ self.setFunction = setFunction
+ self.expandable = 1
+ self.sublist = []
+ self.init()
+
+
+ # La partie suivante ne sert que pour le Web
+ # on met le meme id au noeud et a l objet
+ # utile pour les MCList
+ if hasattr(object, "idUnique"):
+ self.idUnique = object.idUnique
+ else:
+ self.idUnique = uuid1().hex
+
+ if self._object.nature == "MCList" and len(self._object.data) == 1:
+ # pour les suppressions on met le meme id a l objet et a la liste
+ self._object.data[0].idUnique = self.idUnique
+ self._object.idUnique = self._object.data[0].idUnique
+ if hasattr(self.appliEficas, "dicoIdNode"):
+ self.appliEficas.dicoIdNode[self._object.data[0].idUnique] = self
+ self.idUnique = 0
+ return
+
+ self._object.idUnique = self.idUnique
+ if hasattr(self.appliEficas, "dicoIdNode") and self.idUnique:
+ self.appliEficas.dicoIdNode[self.idUnique] = self
+
+ def init(self):
+ return
+
+ def getObject(self):
+ return self._object
+
+ def connect(self, channel, callable, args):
+ """Connecte la fonction callable (avec arguments args) a l'item self sur le
+ canal channel
+ """
+ # print self,channel,callable,args
+ CONNECTOR.Connect(self._object, channel, callable, args)
+ CONNECTOR.Connect(self.object, channel, callable, args)
+
+ def copy(self):
+ """
+ Cree un item copie de self
+ """
+ object = self._object.copy()
+ appliEficas = copy(self.appliEficas)
+ labeltext = copy(self.labeltext)
+ fonction = deepcopy(self.setFunction)
+ item = makeObjecttreeitem(appliEficas, labeltext, object, fonction)
+ return item
+
+ def isActif(self):
+ if hasattr(self.object, "actif"):
+ return self.object.actif
+ else:
+ return 1
+
+ def update(self, item):
+ """
+ Met a jour l'item courant a partir d'un autre item passe en argument
+ Ne fait rien par defaut
+ """
+ pass
+
+ def getLabelText(self):
+ """Retourne 3 valeurs :
+ - le texte a afficher dans le noeud representant l'item
+ - la fonte dans laquelle afficher ce texte
+ - la couleur du texte
+ """
+ # None --> fonte et couleur par defaut
+ return tr(self.labeltext), None, None
+
+ def getNature(self):
+ """
+ Retourne la nature de l'item et de l'objet
+ """
+ return self.object.nature
+
+ def getRegles(self):
+ """retourne les regles de l'objet pointe par self"""
+ return self.object.getRegles()
+
+ def getListeMcPresents(self):
+ """Retourne la liste des mots-cles fils de l'objet pointe par self"""
+ return self.object.listeMcPresents()
+
+ def getVal(self):
+ """Retourne le nom de la valeur de l'objet pointe par self dans le cas
+ ou celle-ci est un objet (ASSD)"""
+ return self.object.getVal()
+
+ def get_definition(self):
+ """
+ Retourne l'objet definition de l'objet pointe par self
+ """
+ return self.object.definition
+
+ def getListeMcOrdonnee(self, liste, dico):
+ """retourne la liste ordonnee (suivant le catalogue) brute des mots-cles
+ d'une entite composee dont le chemin complet est donne sous forme
+ d'une liste du type :ETAPE + MCFACT ou MCBLOC + ...
+ il faut encore rearranger cette liste (certains mots-cles deja
+ presents ne doivent plus etre proposes, regles ...)"""
+ return self.object.getListeMcOrdonnee(liste, dico)
+
+ def getListeMcOrdonneeBrute(self, liste, dico):
+ """
+ retourne la liste ordonnee (suivant le catalogue) BRUTE des mots-cles
+ d'une entite composee dont le chemin complet est donne sous forme
+ d'une liste du type :ETAPE + MCFACT ou MCBLOC + ...
+ """
+ return self.object.getListeMcOrdonneeBrute(liste, dico)
+
+ def getGenealogie(self):
+ """
+ Retourne la liste des noms des ascendants (noms de MCSIMP,MCFACT,MCBLOC ou ETAPE)
+ de l'objet pointe par self
+ """
+ return self.object.getGenealogie()
+
+ def getIndexChild(self, nom_fils):
+ """
+ Retourne l'index dans la liste des fils de self du nouveau fils de nom nom_fils
+ Necessaire pour savoir a quelle position dans la liste des fils il faut ajouter
+ le nouveau mot-cle
+ """
+ return self.object.getIndexChild(nom_fils)
+
+ def getIndexChild_old(self, nom_fils):
+ """
+ Retourne l'index dans la liste des fils de self du nouveau fils de nom nom_fils
+ Necessaire pour savoir a quelle position dans la liste des fils il faut ajouter
+ le nouveau mot-cle
+ """
+ liste_noms_mc_ordonnee = self.getListeMcOrdonneeBrute(
+ self.getGenealogie(), self.getJdc().dicoCataOrdonne
+ )
+ liste_noms_mc_presents = self.object.listeMcPresents()
+ l = []
+ for nom in liste_noms_mc_ordonnee:
+ if nom in liste_noms_mc_presents or nom == nom_fils:
+ l.append(nom)
+ # l contient les anciens mots-cles + le nouveau dans l'ordre
+ return l.index(nom_fils)
+
+ def appendChild(self, name, pos=None):
+ """
+ Permet d'ajouter un item fils a self
+ """
+ if pos == "first":
+ index = 0
+ elif pos == "last":
+ index = len(self.listeMcPresents())
+ elif type(pos) == int:
+ # la position est fixee
+ index = pos
+ # elif type(pos) == types.InstanceType:
+ elif type(pos) == object:
+ # pos est un item. Il faut inserer name apres pos
+ index = self.getIndex(pos) + 1
+ # elif type(name) == types.InstanceType:
+ elif type(name) == object:
+ index = self.getIndexChild(name.nom)
+ else:
+ index = self.getIndexChild(name)
+ return self.addobject(name, index)
+
+ def appendBrother(self, name, pos="after"):
+ """
+ Permet d'ajouter un frere a self
+ par defaut on l'ajoute apres self
+ """
+ index = self._object.parent.getIndex(self.getObject())
+ if pos == "before":
+ index = index
+ elif pos == "after":
+ index = index + 1
+ else:
+ print((tr("%d n'est pas un index valide pour appendBrother", pos)))
+ return
+ return self.parent.addobject(name, index)
+
+ def getCopieObjet(self):
+ """Retourne une copie de l'objet pointe par self"""
+ return self.object.copy()
+
+ def getPosition(self):
+ """Retourne la valeur de l'attribut position de l'objet pointe par self"""
+ definition = self.get_definition()
+ try:
+ return getattr(definition, "position")
+ except AttributeError:
+ return "local"
+
+ def getNom(self):
+ """Retourne le nom de l'objet pointe par self"""
+ return self.object.nom
+
+ def getJdc(self):
+ """Retourne le jdc auquel appartient l'objet pointe par self"""
+ return self.object.jdc
+
+ def getValeur(self):
+ """Retourne la valeur de l'objet pointe par self"""
+ return self.object.valeur
+
+ def getCr(self):
+ """Retourne le compte-rendu CR de self"""
+ return self.object.report()
+
+ def getObjetCommentarise(self):
+ """
+ Cette methode retourne un objet commentarise
+ representatif de self.object
+ --> a surcharger par les differents items
+ """
+ raise EficasException(
+ "MESSAGE AU DEVELOPPEUR : il faut \
+ surcharger la methode getObjetCommentarise() \
+ pour la classe %s",
+ self.__class__.__name__,
+ )
+
+ def isValid(self):
+ """Retourne 1 si l'objet pointe par self est valide, 0 sinon"""
+ return self.object.isValid()
+
+ def isCopiable(self):
+ """
+ Retourne 1 si l'objet est copiable, 0 sinon
+ Par defaut retourne 0
+ """
+ return 0
+
+ def getMcPresents(self):
+ """Retourne le dictionnaire des mots-cles presents de l'objet pointe par self"""
+ return self.object.dictMcPresents()
+
+ def verifConditionRegles(self, l_mc_presents):
+ return self.object.verifConditionRegles(l_mc_presents)
+
+ def getFr(self):
+ """Retourne le fr de l'objet pointe par self"""
+ try:
+ return self.object.getFr()
+ except:
+ return ""
+
+ def getDocu(self):
+ """Retourne la cle de doc de l'objet pointe par self"""
+ return self.object.getDocu()
+
+ def setValeur(self, new_valeur):
+ """Remplace la valeur de l'objet pointe par self par new_valeur"""
+ return self.object.setValeur(new_valeur)
+
+ def getText(self):
+ return myrepr.repr(self.object)
+
+ def getIconName(self):
+ if not self.isExpandable():
+ return "python"
+
+ def IsEditable(self):
+ return self.setFunction is not None
+
+ def SetText(self, text):
+ try:
+ value = eval(text)
+ self.setFunction(value)
+ except:
+ pass
+
+ def isExpandable(self):
+ return 1
+
+ def getSubList(self):
+ keys = dir(self.object)
+ sublist = []
+ for key in keys:
+ try:
+ value = getattr(self.object, key)
+ except AttributeError:
+ continue
+ item = makeObjecttreeitem(
+ self.appliEficas,
+ str(key) + " =",
+ value,
+ lambda value, key=key, object=self.object: setattr(object, key, value),
+ )
+ sublist.append(item)
+ return sublist
+
+ # a piori inutile PN 06 11 17
+ # def wait_fichier_init(self):
+ """ Retourne 1 si l'object pointe par self attend un fichier d'initialisation
+ (ex: macros POURSUITE et INCLUDE de Code_Aster), 0 SINON """
+
+ # return self.object.definition.fichier_ini
+
+ def makeObjecttreeitem(self, appliEficas, labeltext, object, setFunction=None):
+ """
+ Cette methode, globale pour les objets de type item, permet de construire et de retourner un objet
+ de type item associe a l'object passe en argument.
+ """
+ return makeObjecttreeitem(appliEficas, labeltext, object, setFunction)
+
+ # def __del__(self):
+ # print "__del__",self
+
+
+class AtomicObjectTreeItem(ObjectTreeItem):
+ def isExpandable(self):
+ return 0
+
+
+class SequenceTreeItem(ObjectTreeItem):
+ def isExpandable(self):
+ return len(self._object) > 0
+
+ def __len__(self):
+ return len(self._object)
+
+ def keys(self):
+ return list(range(len(self._object)))
+
+ def getIconName(self):
+ if self._object.isValid():
+ return "ast-green-los"
+ elif self._object.isOblig():
+ return "ast-red-los"
+ else:
+ return "ast-yel-los"
+
+ def ajoutPossible(self):
+ return self._object.ajoutPossible()
+
+ def getIndex(self, child):
+ """Retourne le numero de child dans la liste des enfants de self"""
+ return self._object.getIndex(child.getObject())
+
+ def getText(self):
+ return " "
+
+ def addItem(self, obj, pos):
+ self._object.insert(pos, obj)
+ item = self.makeObjecttreeitem(self.appliEficas, obj.nom + ":", obj)
+ return item
+
+ def suppItem(self, item):
+ try:
+ self._object.remove(item.getObject())
+ # la liste peut etre retournee vide !
+ message = "Mot-clef " + item.getObject().nom + " supprime"
+ self.appliEficas.afficheMessages(message)
+ return 1
+ except:
+ return 0
+
+ def getSubList(self):
+ isublist = iter(self.sublist)
+ liste = self._object.data
+ iliste = iter(liste)
+ self.sublist = []
+
+ while 1:
+ old_obj = obj = None
+ for item in isublist:
+ old_obj = item.getObject()
+ if old_obj in liste:
+ break
+
+ for obj in iliste:
+ if obj is old_obj:
+ break
+
+ # nouvel objet : on cree un nouvel item
+ def setFunction(value, object=obj):
+ object = value
+
+ it = self.makeObjecttreeitem(
+ self.appliEficas, obj.nom + " : ", obj, setFunction
+ )
+ self.sublist.append(it)
+ if old_obj is None and obj is None:
+ break
+ if old_obj is obj:
+ self.sublist.append(item)
+ return self.sublist
validite,commentaire=self.politique.recordValeur(nouvelleValeurFormat)
if commentaire != "" :
if validite : self.editor.afficheCommentaire(commentaire)
- else : self.editor.afficheInfos(commentaire,'red')
+ else : self.editor.afficheMessage(commentaire,'red')
self.inSaisieValeur=False
self.setValide()
try:
nouvelleValeur = str(self.lineEditVal.text())
except UnicodeEncodeError as e:
- self.editor.afficheInfos("pb d encoding", Qt.red)
+ self.editor.afficheMessage("pb d encoding", Qt.red)
validite, commentaire = self.politique.recordValeur(None)
self.lineEditVal.setText("")
self.setValide()
if self.node.item.definition.validators != None:
if self.node.item.definition.validators.verifItem(nouvelleValeur) != 1:
commentaire = self.node.item.definition.validators.infoErreurItem()
- self.editor.afficheInfos(commentaire, Qt.red)
+ self.editor.afficheMessage(commentaire, Qt.red)
self.inSaisieValeur = False
return
validite, commentaire = self.politique.recordValeur(nouvelleValeurFormat)
if commentaire != "":
if validite: self.editor.afficheCommentaire(commentaire)
- else: self.editor.afficheInfos(commentaire, 'red')
+ else: self.editor.afficheMessage(commentaire, 'red')
self.inSaisieValeur = False
self.setValide()
commentaire = tr(
"Veuillez entrer le complexe sous forme aster ou sous forme python"
)
- self.editor.afficheInfos(commentaire)
+ self.editor.afficheMessage(commentaire)
return listeValeurs, 0
else: # ce n'est pas un tuple a la mode aster
# coding: utf-8
#!/usr/bin/env python3
import sys
-from accasConnecteur import AccasConnecteur
code='Essai'
#code=None
app.register_blueprint(sse, url_prefix='/stream')
### Eficas Connector
-def createConnecteur(app):
- monConnecteur=AccasConnecteur(code, langue='ang',appWeb=app)
- return monConnecteur
+def createWebAppli(app):
+ import os
+ sys.path.append(os.path.join(os.path.abspath(os.path.dirname(__file__)),'..'))
+ from Editeur.eficas_go import getEficas
+ eficasAppli=getEficas(code, langue='ang',GUIPath= 'Web',appWeb=app)
+ return eficasAppli
-monConnecteur=createConnecteur(app)
+
+eficasAppli=createWebAppli(app)
debug=1
if debug :
+ eficasEditeur=eficasAppli.getEditor()
print ('les commandes dans le catalogue')
print ('_______________________________')
- print (monConnecteur.getListeCommandes())
+ print (eficasEditeur.getListeCommandes())
def fromConnecteur(maFonction,*args,**kwargs):
fnct=globals()[maFonction]
#TODO: Câbler la sélection du catalogue avant d'activer les appels suivants
# car si la page Web n'est pas rendue et que le connecteur génère une erreur... boom !
-def afficheInfos(txt, couleur): #TODO: RENAME TO ... displayWarning
- print ('Flask/afficheInfos: ', txt, couleur)
- # sse.publish( {'txt':txt, 'color':couleur, 'messageClass':"alert-warning" ,'message': "Hello from afficheInfos!"},
+def afficheMessage(txt, couleur): #TODO: RENAME TO ... displayWarning
+ print ('Flask/afficheMessage: ', txt, couleur)
+ # sse.publish( {'txt':txt, 'color':couleur, 'messageClass':"alert-warning" ,'message': "Hello from afficheMessage!"},
# type='displayMessage')
def afficheAlerte(titre, message): #TODO: RENAME TO ... displayDanger
id=req['id'];value=req['value']
# id, value = req.values() # Dangereux correspondance implicite
value = str(value) #On peut écrire Pi
- rId,message,changeDone = monConnecteur.changeValeur(id,value);
+ rId,message,changeDone = eficasEditeur.changeValeur(id,value);
assert(rId==id)
#changeDone = True
print ("changeDone : ",changeDone)
# Ne pas recuperer et ne pas renvoyer le noeud dans le cas du SIMP
# (le changeDone et l''ancienne valeur ds la WebApp suffit
- node = monConnecteur.getDicoForFancy(monConnecteur.monEditeur.getNodeById(id))
+ node = eficasEditeur.getDicoForFancy(eficasEditeur.getNodeById(id))
print("Flask/updateSimp node : ",node)
# return jsonify([myTreeDico])
print(req['id'])
id=req['id'];sdnom=req['sdnom']
sdnom = str(sdnom) #On peut écrire Pi
- changeDone,message = monConnecteur.updateSDName(id,sdnom);
+ changeDone,message = eficasEditeur.updateSDName(id,sdnom);
#changeDone = True
print ("changeDone : ",changeDone)
# Print the dictionary
print("/removeNode ",req);print("/removeNode ",req['id']);
id = req['id'];
- ret,message = monConnecteur.suppNode(id);
+ ret,message = eficasEditeur.suppNode(id);
print ("/removeNode : ret : ",ret," message : ",message)
return make_response(json.dumps( {'ret':ret, 'message':message} ))
print(__file__+"/appendChild : ",req);
id=req['id'];name=req['name'];pos=req['pos'];
# id, value = req.values() # Dangereux correspondance implicite
- #rId,message,changeDone = monConnecteur.appendChild(id,name,pos);
- newId = monConnecteur.appendChild(id,name,pos);
+ #rId,message,changeDone = eficasEditeur.appendChild(id,name,pos);
+ newId = eficasEditeur.appendChild(id,name,pos);
print (__file__+"/appendChild : newId : ",newId);
return make_response(json.dumps( {'id':newId} ))
@app.route('/')
def index():
-
- monConnecteur.litFichierComm('../WebTest/web_tres_simple_avec_2Fact.comm')
- #monConnecteur.litFichierComm('../WebTest/edg_REP1300_FULL_PN.comm')
- myFancyTreeDico=monConnecteur.getDicoForFancy(monConnecteur.monEditeur.tree.racine)
-
+#PN decider de ce qu on appelle
+# Lecture du cata
+# Lecture du fichier
+ #eficasEditeur = eficasAppli.litFichierComm('../Codes/WebTest/web_tres_simple_avec_2Fact.comm')
+ #eficasAppli.litFichierComm('../WebTest/edg_REP1300_FULL_PN.comm')
+
+ eficasEditeur = eficasAppli.openFile('../Codes/WebTest/web_tres_simple_avec_2Fact.comm')
+ if not(eficasEditeur) :
+ return render_template('commandes_2.html',
+ titre='Pb a la lecture',
+ listeCommandes = [],
+ tree= None
+ )
+ myFancyTreeDico=eficasEditeur.getDicoForFancy(eficasEditeur.tree.racine)
myFancyTreeJS=json.dumps([myFancyTreeDico],indent=4) #TODO : remove indent if not DEBUG
print("---- myFancyTreeDico ----")
return render_template('commandes_2.html',
titre=code,
- listeCommandes = monConnecteur.getListeCommandes(),
+ listeCommandes = eficasEditeur.getListeCommandes(),
tree=myFancyTreeJS,
# tree=tree4Fancy,
)
